在 python 中賦值語句總是建立物件的引用值，而不是複製物件。因此，python 變數更像是指標，而不是資料儲存區域

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

首先來看個問題

在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沒有賦值，只有引用，上面這個操作相當於建立了一個引用自身的結構，所以導致了無限迴圈。

下面這個例子可以幫助理解：

首先執行

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] = 8
a[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] = 8
a[1][1] = 9

Python變數作用域

可變物件 & 不可變物件

在Python中，物件分為兩種：可變物件和不可變物件，不可變物件包括int，float，long，str，tuple等，可變物件包括list，set，dict等。需要注意的是：這裡說的不可變指的是值的不可變。對於不可變型別的變數，如果要更改變數，則會建立一個新值，把變數繫結到新值上，而舊值如果沒有被引用就等待垃圾回收。另外，不可變的型別可以計算hash值，作為字典的key。可變型別資料對物件操作的時候，不需要再在其他地方申請記憶體，只需要在此物件後面連續申請(+/-)即可，也就是它的記憶體地址會保持不變，但區域會變長或者變短。

>>> a = 'a1'
>>> id(a)
140364890935624
>>> a = 'b1'
>>> id(a)
140364890935680

可以看出重新賦值之後，變數a的記憶體地址已經變了。 'a1'是str型別，不可變，所以賦值操作知識重新建立了str型別的 'a2'物件，然後將變數a指向了它。

>>> a_list = [1,2,3]
>>> id(a_list)
140364890927496
>>> a_list.append(4)
>>> id(a_list)
140364890927496

list重新賦值之後，變數a_list的記憶體地址並未改變，由於[1, 2, 3]是可變的，append操作只是改變了其value，變數a_list指向沒有變。

函式值傳遞

例子1：

>>> def func_int(a):
...     a += 4
...
>>> t = 0
>>> func_int(t)
>>> print(t)
0

例子2：

>>> def func_list(a_list):
...     a_list[0] = 4
...
>>> t_list = [1,2,3]
>>> func_list(t_list)
>>> print(t_list)
[4, 2, 3]

第一個例子看起來像是傳值，而第二個例子確實傳引用。其實，解釋這個問題也非常容易，主要是因為可變物件和不可變物件的原因：對於可變物件，物件的操作不會重建物件，而對於不可變物件，每一次操作就重建新的物件。

在函式引數傳遞的時候，Python其實就是把引數裡傳入的變數對應的物件的引用依次賦值給對應的函式內部變數。參照上面的例子來說明更容易理解，func_int中的區域性變數"a"其實是全部變數"t"所指向物件的另一個引用，由於整數物件是不可變的，所以當func_int對變數"a"進行修改的時候，實際上是將區域性變數"a"指向到了整數物件"1"。所以很明顯，func_list修改的是一個可變的物件，區域性變數"a"和全域性變數"t_list"指向的還是同一個物件。

本文轉載於：https://www.cnblogs.com/jiangzhaowei/p/5740913.html