深入探究Python中變數的拷貝和範圍問題

在 python 中指派陳述式總是建立對象的引用值，而不是複製對象。因此，python 變數更像是指標，而不是資料存放區地區，

這點和大多數 OO 語言類似吧，比如 C++、java 等 ~
1、先來看個問題吧：

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

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

我預想應當是

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

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

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

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

執行

values = [0, 1, 2]

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

values = [3, 4, 5]

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

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

執行

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[:] #產生對象的拷貝或者是複製序列，不再是引用和共用變數，但此法只能頂層複製

所以你需要執行

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)，當列表對象有嵌套的時候也會產生出乎意料的錯誤，比如

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

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

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

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

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

2、引用 VS 拷貝：

（1）沒有限制條件的分區運算式（L[:]）能夠複製序列，但此法只能淺層複製。

（2）字典 copy 方法，D.copy() 能夠複製字典，但此法只能淺層複製

（3）有些內建函數，例如 list，能夠產生拷貝 list(L)

（4）copy 標準庫模組能夠產生完整拷貝：deepcopy 本質上是遞迴 copy

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

L = [1, 2, 3]D = {'a':1, 'b':2}A = L[:]B = D.copy()print "L, D"print L, Dprint "A, B"print A, Bprint "--------------------"A[1] = 'NI'B['c'] = 'spam'print "L, D"print L, Dprint "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。

屬於共用引用

L = [1, 2]M = LL = L + [3, 4]print L, Mprint "-------------------"L = [1, 2]M = LL += [3, 4]print L, M  [1, 2, 3, 4] [1, 2]-------------------[1, 2, 3, 4] [1, 2, 3, 4]

4、python 從2.x 到3.x，語句變函數引發的變數範圍問題

先看段代碼：

def test():  a = False  exec ("a = True")  print ("a = ", a)test() b = Falseexec ("b = True")print ("b = ", b)

在 python 2.x 和 3.x 下 你會發現他們的結果不一樣：

2.x：a = Trueb = True 3.x：a = Falseb = True

這是為什麼呢？

因為 3.x 中 exec 由語句變成函數了，而在函數中變數預設都是局部的，也就是說

你所見到的兩個 a，是兩個不同的變數，分別處於不同的命名空間中，而不會衝突。

具體參考 《learning python》P331-P332

知道原因了，我們可以這麼改改：

def test():  a = False  ldict = locals()  exec("a=True",globals(),ldict)  a = ldict['a']  print(a) test() b = Falseexec("b = True", globals())print("b = ", b)

這個問題在 stackoverflow 上已經有人問了，而且 python 官方也有人報了 bug。。。

具體連結在下面：

http://stackoverflow.com/questions/7668724/variables-declared-in-execed-code-dont-become-local-in-python-3-documentatio

http://bugs.python.org/issue4831

http://stackoverflow.com/questions/1463306/how-does-exec-work-with-locals

