嘗試解決以下問題，然后檢查以下答案。

提示：所有問題都有共同點，因此在解決其余問題之前檢查第一個問題的解決方案可以減輕挑戰。

[[329422]]

問題1

假設我們有幾個變量：

x = 1 
y = 2 
l = [x, y] 
x += 5 
a = [1] 
b = [2] 
s = [a, b] 
a.append(5) 

l和s的打印結果是什么?

跳到解決方案

問題2

讓我們定義一個簡單的函數：

def f(x, s=set()): 
s.add(x) print(s) 

如果您決定，將會發生什么：

>>f(7)  
>>f(6, {4, 5})  
>>f(2)  
？ 

跳到解決方案

問題3

讓我們定義兩個簡單的函數：

def f(): 
    l = [1] 
    def inner(x): 
        l.append(x) 
        return l 
    return inner 
def g(): 
    y = 1 
    def inner(x): 
        y += x 
        return y 
    return inner 

以下命令將產生什么結果?

>>ff_inner = f() 
>>print(f_inner(2)) 
>>gg_inner = g() 
>>print(g_inner(2)) 

跳到解決方案

您對自己的回答有多自信? 讓我們看看您是否正確。

解決問題1

>>print(l) 
 
[1, 2] 
 
>>print(s) 
 
[[1, 5], [2]] 

為什么第二個列表對第一個元素a.append(5)的更改有反應，但是第一個列表完全忽略x + = 5的類似變化?

解決問題2

讓我們看看發生了什么：

>>f(7){7}  
>>f(6, {4, 5}){4, 5, 6}  
>>f(2){2, 7} 

等待，最后輸出不是{2}嗎?

解決問題3

輸出將是以下內容：

>>ff_inner = f()  
>>print(f_inner(2))[1, 2]  
>>gg_inner = g()  
>>print(g_inner(2))  
UnboundLocalError: local variable 'y' referenced before assignment 

為什么g_inner(2)不輸出3? f()的內部函數如何記住其外部范圍，而g()的內部函數卻不記得呢? 它們實際上是相同的!

說明

如果我告訴您這些怪異的行為與Python中可變對象和不可變對象之間的區別有關怎么辦?

諸如列表，集合或字典之類的可變對象可以在適當位置進行更改(變異)。 不變的對象(如整數，字符串和元組)不能—此類對象的"更改"會導致創建新對象。

問題1的說明

x = 1 
y = 2 
l = [x, y] 
x += 5 
a = [1] 
b = [2] 
s = [a, b] 
a.append(5) 
>>print(l) 
[1, 2] 
>>print(s) 
[[1, 5], [2]] 

由于x是不可變的，因此操作x + = 5不會更改原始對象，而是創建一個新對象。 列表的第一個元素仍指向原始對象，因此其值保持不變。

對于可變對象a，a.append(5)更改原始對象，因此list s"看到"更改。

問題2的解釋

def f(x, s=set()): 
    s.add(x) 
    print(s) 
>>f(7) 
{7} 
>>f(6, {4, 5}) 
{4, 5, 6} 
>>f(2) 
{2, 7} 

前兩個輸出完全有意義：首先將值7添加到默認空集中，得到{7}，然后將值6添加到一組{4，5}中，得到{4，5，6 }。

但是隨后發生了一件奇怪的事情：將值2添加到默認的空集而不是添加到{7}的集。 為什么? 可選參數s的默認值僅被評估一次-僅在第一次調用s期間將被初始化為空集。 由于s在調用f(7)之后是可變的，因此就地進行了修改。 第二個調用f(6，{4，5})不會影響默認參數-提供的集合{4，5}將其遮蔽，換句話說，{4，5}是一個不同的變量。 第三次調用f(2)使用的是與第一次調用相同的s變量，但是s未作為空集重新初始化-使用了其先前的值{7}。

這就是為什么您不應該使用可變的默認參數的原因。 在這種情況下，應按以下方式修改功能：

def f(x, s=None): 
    if s is None: 
        s = set() 
    s.add(x) 
    print(s) 

問題3的解釋

def f(): 
    l = [1] 
    def inner(x): 
        l.append(x) 
        return l 
    return inner 
def g(): 
    y = 1 
    def inner(x): 
        y += x 
        return y 
    return inner 
>>ff_inner = f() 
>>print(f_inner(2)) 
[1, 2] 
>>gg_inner = g() 
>>print(g_inner(2)) 
UnboundLocalError: local variable ‘y’ referenced before assignment 

在這個問題中，我們處理閉包-內部函數記住定義時它們的封閉名稱空間的外觀。 或至少應該如此-第二個功能保持撲克面孔，就像從未聽說過其外部作用域一樣。

這是為什么? 當我們執行l.append(x)時，在定義時創建的可變對象被修改，但是變量l仍然指向內存中的相同地址。 但是，嘗試更改第二個函數y + = x中的不可變變量會導致y指向內存中與以前不同的地址-原始y將不再被記住，因此導致UnboundLocalError。

結論

Python中可變對象與不可變對象之間的區別非常重要。 請注意這一點，以避免出現本文所述的奇怪行為。 特別是：

• 不要使用可變的默認參數。
• 不要嘗試在內部函數中更改不可變的閉包變量。
• 請隨意分享其他示例，這些示例可能是由于您在響應中誤用了可變的和不變的對象而導致的潛在問題。