變量不是盒子
在示例所示的交互式控制臺中，無法使用“變量是盒子”做解釋。圖說明了在 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之間選擇
== 運算符比較 兩個對象的值 （對象中保存的數據），而 i s 比較對象的標識 。通常，我們關注的是值，而不是標識，因此 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])
>>> 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)
>>> 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
>>> 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
以上這篇基于Python對象引用、可變性和垃圾回收詳解就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持腳本之家。
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
