深入探究Python中變量的拷貝和作用域問題

 　　這篇文章主要介紹了Python中變量的拷貝和作用域問題,包括一些賦值、引用問題,以及相關函數在Python2和3版本之間的不同,需要的朋友可以參考下

　　在 python 中賦值語句總是建立對象的引用值，而不是復制對象。因此，python 變量更像是指針，而不是數據存儲區域，

　　這點和大多數 OO 語言類似吧，比如 C++、java 等 ~

　　1、先來看個問題吧：

　　在Python中，令values=[0,1,2];values[1]=values,為何結果是[0,[...],2]?

　　?

1 2 3 4 >>> values = [0, 1, 2] >>> values[1] = values >>> values [0, [...], 2]

　　我預想應當是

　　?

1 [0, [0, 1, 2], 2]

　　但結果卻為何要賦值無限次?

　　可以說 Python 沒有賦值，只有引用。你這樣相當於創建了一個引用自身的結構，所以導致了無限循環。為了理解這個問題，有個基本概念需要搞清楚。

　　Python 沒有「變量」，我們平時所說的變量其實只是「標簽」，是引用。

　　執行

　　?

1 values = [0, 1, 2]

　　的時候，Python 做的事情是首先創建一個列表對象 [0, 1, 2]，然後給它貼上名為 values 的標簽。如果隨後又執行

　　?

1 values = [3, 4, 5]

　　的話，Python 做的事情是創建另一個列表對象 [3, 4, 5]，然後把剛才那張名為 values 的標簽從前面的 [0, 1, 2] 對象上撕下來，重新貼到 [3, 4, 5] 這個對象上。

　　至始至終，並沒有一個叫做 values 的列表對象容器存在，Python 也沒有把任何對象的值復制進 values 去。過程如圖所示：

　　執行

　　?

1 values[1] = values

　　的時候，Python 做的事情則是把 values 這個標簽所引用的列表對象的第二個元素指向 values 所引用的列表對象本身。執行完畢後，values 標簽還是指向原來那個對象，只不過那個對象的結構發生了變化，從之前的列表 [0, 1, 2] 變成了 [0, ?, 2]，而這個 ? 則是指向那個對象本身的一個引用。如圖所示：

　　要達到你所需要的效果，即得到 [0, [0, 1, 2], 2] 這個對象，你不能直接將 values[1] 指向 values 引用的對象本身，而是需要吧 [0, 1, 2] 這個對象「復制」一遍，得到一個新對象，再將 values[1] 指向這個復制後的對象。Python 裡面復制對象的操作因對象類型而異，復制列表 values 的操作是

　　values[:] #生成對象的拷貝或者是復制序列，不再是引用和共享變量，但此法只能頂層復制

　　所以你需要執行

　　?

1 values[1] = values[:]

　　Python 做的事情是，先 dereference 得到 values 所指向的對象 [0, 1, 2]，然後執行 [0, 1, 2][:] 復制操作得到一個新的對象，內容也是 [0, 1, 2]，然後將 values 所指向的列表對象的第二個元素指向這個復制二來的列表對象，最終 values 指向的對象是 [0, [0, 1, 2], 2]。過程如圖所示：

　　往更深處說，values[:] 復制操作是所謂的「淺復制」(shallow copy)，當列表對象有嵌套的時候也會產生出乎意料的錯誤，比如

　　?

1 2 3 4 a = [0, [1, 2], 3] b = a[:] a[0] = 8 a[1][1] = 9

　　問：此時 a 和 b 分別是多少?

　　正確答案是 a 為 [8, [1, 9], 3]，b 為 [0, [1, 9], 3]。發現沒?b 的第二個元素也被改變了。想想是為什麼?不明白的話看下圖

　　正確的復制嵌套元素的方法是進行「深復制」(deep copy)，方法是

　　?

1 2 3 4 5 6 import copy   a = [0, [1, 2], 3] b = copy.deepcopy(a) a[0] = 8 a[1][1] = 9

　　2、引用 VS 拷貝：

　　(1)沒有限制條件的分片表達式(L[:])能夠復制序列，但此法只能淺層復制。

　　(2)字典 copy 方法，D.copy() 能夠復制字典，但此法只能淺層復制

　　(3)有些內置函數，例如 list，能夠生成拷貝 list(L)

　　(4)copy 標准庫模塊能夠生成完整拷貝：deepcopy 本質上是遞歸 copy

　　(5)對於不可變對象和可變對象來說，淺復制都是復制的引用，只是因為復制不變對象和復制不變對象的引用是等效的(因為對象不可變，當改變時會新建對象重新賦值)。所以看起來淺復制只復制不可變對象(整數，實數，字符串等)，對於可變對象，淺復制其實是創建了一個對於該對象的引用，也就是說只是給同一個對象貼上了另一個標簽而已。

　　?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 L = [1, 2, 3] D = {'a':1, 'b':2} A = L[:] B = D.copy() print "L, D" print L, D print "A, B" print A, B print "--------------------" A[1] = 'NI' B['c'] = 'spam' print "L, D" print L, D print "A, B" print A, B     L, D [1, 2, 3] {'a': 1, 'b': 2} A, B [1, 2, 3] {'a': 1, 'b': 2} -------------------- L, D [1, 2, 3] {'a': 1, 'b': 2} A, B [1, 'NI', 3] {'a': 1, 'c': 'spam', 'b': 2}

　　3、增強賦值以及共享引用：

　　x = x + y，x 出現兩次，必須執行兩次，性能不好，合並必須新建對象 x，然後復制兩個列表合並

　　屬於復制/拷貝

　　x += y，x 只出現一次，也只會計算一次，性能好，不生成新對象，只在內存塊末尾增加元素。

　　當 x、y 為list時， += 會自動調用 extend 方法進行合並運算，in-place change。

　　屬於共享引用

　　?

1 2 3 4 5 6 7 8 9 10 11 12 13