Python 對象引用、可變性和垃圾回收

變量不是盒子 

　　在示例所示的交互式控制台中，無法使用“變量是盒子”做解釋。圖說明了在 Python 中為什么不能使用盒子比喻，而便利貼則指出了變量的正確工作方式。

　   變量 a 和 b 引用同一個列表，而不是那個列表的副本

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]

如果把變量想象為盒子，那么無法解釋 Python 中的賦值；應該把變量視作便利貼，這樣示例中的行為就好解釋了

 

 注意：

　　對引用式變量來說，說把變量分配給對象更合理，反過來說就有問題。畢竟，對象在賦值之前就創建了

 

標識、相等性和別名

　　Lewis Carroll 是 Charles Lutwidge Dodgson 教授的筆名。Carroll 先生指的就是 Dodgson 教授，二者是同一個人。🌰 用 Python 表達了這個概念。

charles 和 lewis 指代同一個對象

>>> lewis = charles
>>> lewis is charles
True
>>> id(lewis), id(charles)
(4303312648, 4303312648)
>>> lewis['balance'] = 950
>>> charles
{'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}

　　然而，假如有冒充者（姑且叫他 Alexander Pedachenko 博士）生於 1832年，聲稱他是 Charles L. Dodgson。這個冒充者的證件可能一樣，但是Pedachenko 博士不是 Dodgson 教授。這種情況如圖

 

charles 和 lewis 綁定同一個對象，alex 綁定另一個具有相同內容的對象

alex 與 charles 比較的結果是相等，但 alex 不是charles

>>> lewis
{'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}
>>> alex = {'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}
>>> lewis == alex
True
>>> alex is not lewis
True

　　alex 指代的對象與賦值給 lewis 的對象內容一樣，比較兩個對象，結果相等，這是因為 dict 類的 __eq__ 方法就是這樣實現的，但它們是不同的對象。這是 Python 說明標識不同的方式：a is notb。

　　示例體現了別名。在那段代碼中，lewis 和 charles 是別名，即兩個變量綁定同一個對象。而 alex 不是 charles 的別名，因為二者綁定的是不同的對象。alex 和 charles 綁定的對象具有相同的值（== 比較的就是值），但是它們的標識不同。

在==和is之間選擇

　　== 運算符比較兩個對象的值（對象中保存的數據），而 is 比較對象的標識。通常，我們關注的是值，而不是標識，因此 Python 代碼中 == 出現的頻率比 is 高。然而，在變量和單例值之間比較時，應該使用 is。目前，最常使用 is檢查變量綁定的值是不是 None。下面是推薦的寫法：

x is None

否定的寫法

x is not None

元組的相對不可變性 

　　元組與多數 Python 集合（列表、字典、集，等等）一樣，保存的是對象的引用。 如果引用的元素是可變的，即便元組本身不可變，元素依然可變。也就是說，元組的不可變性其實是指 tuple 數據結構的物理內容（即保存的引用）不可變，與引用的對象無關。 

>>> t1 = (1, 2, [30, 40])
>>> t2 = (1, 2, [30, 40])
>>> t1 == t2
True
>>> id(t1[-1])
4316861320
>>> t1[-1].append(1000)
>>> t1
(1, 2, [30, 40, 1000])
>>> t1 == t2
False

 🌰  表明，元組的值會隨着引用的可變對象的變化而變。元組中不可變的是元素的標識。

 

默認做淺復制

　　復制列表（或多數內置的可變集合）最簡單的方式是使用內置的類型構造方法。例如：

>>> l1 = [3, [55, 44], (7, 8, 9)]
>>> l2 = list(l1)
>>> l3 = l1[:]
>>> l2
[3, [55, 44], (7, 8, 9)]
>>> l3
[3, [55, 44], (7, 8, 9)]
>>> l1 == l2 == l3
True
>>> l2 is l1
False
>>> l3 is l1
False

為一個包含另一個列表的列表做淺復制；把這段代碼復制粘貼到 Python Tutor (http://www.pythontutor.com)網站中，看看動畫效果

l1 = [3, [66, 55, 44], (7, 8, 9)]
l2 = list(l1)               #淺復制了l1
l1.append(100)              #l1列表在尾部添加數值100
l1[1].remove(55)            #移除列表中第1個索引的值
print('l1:', l1)
print('l2:', l2)
l2[1] += [33, 22]           #l2列表中第1個索引做列表拼接
l2[2] += (10, 11)           #l2列表中的第2個索引做元祖拼接
print('l1:', l1)
print('l2:', l2)

l2 是 l1 的淺復制副本

為任意對象做深復制和淺復制 

　　淺復制沒什么問題，但有時我們需要的是深復制（即副本不共享內部對象的引用）。copy 模塊提供的 deepcopy 和 copy 函數能為任意對象做深復制和淺復制。

🌰  校車乘客在途中上車和下車

class Bus:

    def __init__(self, passengers=None):
        if passengers is None:
            self.passengers = []
        else:
            self.passengers = list(passengers)

    def pick(self, name):
        self.passengers.append(name)

    def drop(self, name):
        self.passengers.remove(name)

我們將創建一個 Bus 實例（bus1）和兩個副本，一個是淺復制副本（bus2），另一個是深復制副本（bus3），看看在 bus1 有學生下車后會發生什么。

from copy import copy, deepcopy

bus1 = Bus(['Alice', 'Bill', 'Claire', 'David'])
bus2 = copy(bus1)                       #bus2淺復制的bus1
bus3 = deepcopy(bus1)                   #bus3深復制了bus1
print(id(bus1), id(bus2), id(bus3))     #查看三個對象的內存地址

bus1.drop('Bill')                       #bus1的車上Bill下車了
print('bus2:', bus2.passengers)         #wtf....bus2中的Bill也沒有了，見鬼了！
print(id(bus1.passengers), id(bus2.passengers), id(bus3.passengers))    #審查 passengers 屬性后發現，bus1和bus2共享同一個列表對象，因為 bus2 是 bus1 的淺復制副本

print('bus3:', bus3.passengers)         #bus3是bus1 的深復制副本，因此它的 passengers 屬性指代另一個列表

以上代碼執行的結果為：

4324829840 4324830176 4324830736
bus2: ['Alice', 'Claire', 'David']
4324861256 4324861256 4324849608
bus3: ['Alice', 'Bill', 'Claire', 'David']

循環引用：b 引用 a，然后追加到 a 中；deepcopy 會想辦法復制 a

>>> a = [10, 20]
>>> b = [a, 30]
>>> a.append(b)
>>> a
[10, 20, [[...], 30]]
>>> from copy import deepcopy
>>> c = deepcopy(a)
>>> c
[10, 20, [[...], 30]]

 

函數的參數作為引用時

 　　Python 唯一支持的參數傳遞模式是共享傳參（call by sharing）。多數面向對象語言都采用這一模式，包括 Ruby、Smalltalk 和 Java（Java 的引用類型是這樣，基本類型按值傳參）。共享傳參指函數的各個形式參數獲得實參中各個引用的副本。也就是說，函數內部的形參是實參的別名。

函數可能會修改接收到的任何可變對象

>>> def f(a, b):
...     a += b
...     return a
... 
>>> x = 1
>>> y = 2
>>> f(x, y)
3
>>> x, y
(1, 2)
>>> a = [1, 2]
>>> b = [3, 4]
>>> f(a, b)
[1, 2, 3, 4]
>>> a, b
([1, 2, 3, 4], [3, 4])
>>> t = (10, 20)
>>> u = (30, 40)
>>> f(t, u)
(10, 20, 30, 40)
>>> t, u
((10, 20), (30, 40))

數字x沒有變化，列表a變了，元祖t沒變化

不要使用可變類型作為參數的默認值

　　可選參數可以有默認值，這是 Python 函數定義的一個很棒的特性，這樣我們的 API 在進化的同時能保證向后兼容。然而，我們應該避免使用可變的對象作為參數的默認值。

一個簡單的類，說明可變默認值的危險

class HauntedBus:
    '''
    備受折磨的幽靈車
    '''

    def __init__(self, passengers=[]):
        self.passengers = passengers

    def pick(self, name):
        self.passengers.append(name)

    def drop(self, name):
        self.passengers.remove(name)


bus1 = HauntedBus(['Alice', 'Bill'])
print('bus1上的乘客：', bus1.passengers)
bus1.pick('Charlie')            #bus1上來一名乘客Charile
bus1.drop('Alice')              #bus1下去一名乘客Alice
print('bus1上的乘客：', bus1.passengers)          #打印bus1上的乘客

bus2 = HauntedBus()             #實例化bus2
bus2.pick('Carrie')             #bus2上來一名課程Carrie
print('bus2上的乘客：', bus2.passengers)

bus3 = HauntedBus()
print('bus3上的乘客：', bus3.passengers)
bus3.pick('Dave')
print('bus2上的乘客：', bus2.passengers)        #登錄到bus3上的乘客Dava跑到了bus2上面

print('bus2是否為bus3的對象：', bus2.passengers is bus3.passengers)
print('bus1上的乘客：', bus1.passengers)

以上代碼執行的結果為：

bus1上的乘客： ['Alice', 'Bill']
bus1上的乘客： ['Bill', 'Charlie']
bus2上的乘客： ['Carrie']
bus3上的乘客： ['Carrie']
bus2上的乘客： ['Carrie', 'Dave']
bus2是否為bus3的對象： True
bus1上的乘客： ['Bill', 'Charlie']

　　實例化 HauntedBus 時，如果傳入乘客，會按預期運作。但是不為 HauntedBus 指定乘客的話，奇怪的事就發生了，這是因為 self.passengers 變成了 passengers 參數默認值的別名。出現這個問題的根源是，默認值在定義函數時計算（通常在加載模塊時），因此默認值變成了函數對象的屬性。因此，如果默認值是可變對象，而且修改了它的值，那么后續的函數調用都會受到影響。

 防御可變參數

　　如果定義的函數接收可變參數，應該謹慎考慮調用方是否期望修改傳入的參數。

　　例如，如果函數接收一個字典，而且在處理的過程中要修改它，那么這個副作用要不要體現到函數外部？具體情況具體分析。這其實需要函數的編寫者和調用方達成共識。

　　TwilightBus 實例與客戶共享乘客列表，這會產生意料之外的結果。在分析實現之前，我們先從客戶的角度看看 TwilightBus 類是如何工作的。

 🌰 從 TwilightBus 下車后，乘客消失了

class TwilightBus:
    """讓乘客銷聲匿跡的校車"""

    def __init__(self, passengers=None):
        if passengers is None:
            self.passengers = passengers
        else:
            self.passengers = passengers    #這個地方就需要注意了,這里傳遞的是引用的別名

    def pick(self, name):
        self.passengers.append(name)        #會修改構造放的列表，也就是會修改外部的數據

    def drop(self, name):
        self.passengers.remove(name)        #會修改構造放的列表，也就是會修改外部的數據

basketball_team = ['Sue', 'Tina', 'Maya', 'Diana', 'Pat']
bus = TwilightBus(basketball_team)
bus.drop('Tina')        #bus中乘客Tina下去了
bus.drop('Pat')         #bus中課程Pat下去了

print(basketball_team)  #wtf....為毛線的basketball的里面這兩個人也木有了~~MMP

以上代碼執行的結果為： 

['Sue', 'Maya', 'Diana']

解決方案，不直接引用外部的basketball_team，而是在內部創建一個副本，類似於下面的這種 🌰 

>>> a = [1, 2, 3]
>>> b = a
>>> c = list(a)
>>> b.append(10)
>>> a
[1, 2, 3, 10]
>>> b
[1, 2, 3, 10]
>>> c
[1, 2, 3]

c是a的副本，不會因為本身列表的變化而受影響，在上面的 🌰 中，只需要在構造函數中創建一個副本即可(self.passengers=list(passengers))

 

del和垃圾回收

　　del 語句刪除名稱，而不是對象。del 命令可能會導致對象被當作垃圾回收，但是僅當刪除的變量保存的是對象的最后一個引用，或者無法得到對象時。 重新綁定也可能會導致對象的引用數量歸零，導致對象被銷毀。

>>> import weakref
>>> s1 = {1, 2, 3}　　　　　　　　　　　　　　　　
>>> s2 = s1　　　　　　　　　　　　　　　　　　　　　#s1和s2是別名，指向同一個集合
>>> def bye():　　　　　　　　　　　　　　　　　　　#這個函數一定不能是要銷毀的對象的綁定方法，否則會有一個指向對象的引用
...     print('Gone with the wind...')　　　　
... 
>>> ender = weakref.finalize(s1, bye)　　　　　#在s1引用的對象上注冊bye回調　　　　　
>>> ender.alive　　　　　　　　　　　　　　　　　　#調用finalize對象之前，.alive屬性的值為True
True
>>> del s1　　　　　　　　　　　　　　　　　　　　　#del不刪除對象，而是刪除對象的引用
>>> ender.alive
True
>>> s2 = 'spam'　　　　　　　　　　　　　　　　　 #重新綁定最后一個引用s2，讓{1, 2, 3}無法獲取，對象唄銷毀了，調用bye回調，ender.alive的值編程了False
Gone with the wind...
>>> ender.alive
False

 

弱引用

　　正是因為有引用，對象才會在內存中存在。當對象的引用數量歸零后，垃圾回收程序會把對象銷毀。但是，有時需要引用對象，而不讓對象存在的時間超過所需時間。這經常用在緩存中。

　　弱引用不會增加對象的引用數量。引用的目標對象稱為所指對象（referent）。因此我們說，弱引用不會妨礙所指對象被當作垃圾回收。

🌰 弱引用是可調用的對象，返回的是被引用的對象；如果所指對象不存在了，返回 None

>>> import weakref
>>> a_set = {0, 1}　　　　
>>> wref = weakref.ref(a_set)　　　　　　　　　　　　　　　　　　#創建弱引用對象wref，下一行審查它
>>> wref
<weakref at 0x101ce03b8; to 'set' at 0x101cd8d68>
>>> wref()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#調用wref()返回的是被引用的對象，{0, 1}。因為這是控制台會話，所以{0, 1}會綁定給_變量
{0, 1}
>>> a_set = {2, 3, 4}　　　　　　　　　　　　　　　　　　　　　　 #a_set不在指代{0， 1}集合，因此集合的引用數量減少了，但是_變量仍然指代它
>>> wref()　　　　　　　　　　　　　　　　　　　　　　　　　　　　  #調用wref()已經返回了{0， 1}
{0, 1}
>>> wref() is None　　　　　　　　　　　　　　　　　　　　　　　　#計算這個表達式時，{0， 1}存在，因此wref()不是None，但是，隨后_綁定到結果值False，現在{0，1}沒有強引用
False
>>> wref() is None　　　　　　　　　　　　　　　　　　　　　　　　#因為{0， 1}對象不存在了，所以wref()返回了None
True