基于Python對象引用、可變性和垃圾回收詳解

更新時間：2017年08月21日 08:20:58 投稿：jingxian

下面小編就為大家?guī)硪黄赑ython對象引用、可變性和垃圾回收詳解。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

變量不是盒子

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

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

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

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

注意：

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

標識、相等性和別名

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 綁定另一個具有相同內(nèi)容的對象

alex 與 charles 比較的結(jié)果是相等，但 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 的對象內(nèi)容一樣，比較兩個對象，結(jié)果相等，這是因為 dict 類的 __eq__ 方法就是這樣實現(xiàn)的，但它們是不同的對象。這是 Python 說明標識不同的方式：a is notb。

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

在==和is之間選擇

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

x is None

否定的寫法

x is not None

元組的相對不可變性

元組與多數(shù) Python 集合（列表、字典、集，等等）一樣，保存的是對象的引用。如果引用的元素是可變的，即便元組本身不可變，元素依然可變。也就是說，元組的不可變性其實是指 tuple 數(shù)據(jù)結(jié)構(gòu)的物理內(nèi)容（即保存的引用）不可變，與引用的對象無關(guān)。

>>> 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

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

默認做淺復制

復制列表（或多數(shù)內(nèi)置的可變集合）最簡單的方式是使用內(nèi)置的類型構(gòu)造方法。例如：

>>> 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)網(wǎng)站中，看看動畫效果

l1 = [3, [66, 55, 44], (7, 8, 9)]
l2 = list(l1)    #淺復制了l1
l1.append(100)    #l1列表在尾部添加數(shù)值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 的淺復制副本

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

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

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

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)

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

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))  #查看三個對象的內(nèi)存地址

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

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

以上代碼執(zhí)行的結(jié)果為：

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

循環(huán)引用：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]]

函數(shù)的參數(shù)作為引用時

Python 唯一支持的參數(shù)傳遞模式是共享傳參（call by sharing）。多數(shù)面向?qū)ο笳Z言都采用這一模式，包括 Ruby、Smalltalk 和 Java（Java 的引用類型是這樣，基本類型按值傳參）。共享傳參指函數(shù)的各個形式參數(shù)獲得實參中各個引用的副本。也就是說，函數(shù)內(nèi)部的形參是實參的別名。

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

>>> 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))

數(shù)字x沒有變化，列表a變了，元祖t沒變化

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

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

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

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)

以上代碼執(zhí)行的結(jié)果為：

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

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

防御可變參數(shù)

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

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

TwilightBus 實例與客戶共享乘客列表，這會產(chǎn)生意料之外的結(jié)果。在分析實現(xiàn)之前，我們先從客戶的角度看看 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)  #會修改構(gòu)造放的列表，也就是會修改外部的數(shù)據(jù)

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

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

以上代碼執(zhí)行的結(jié)果為：

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

解決方案，不直接引用外部的basketball_team，而是在內(nèi)部創(chuàng)建一個副本，類似于下面的這種

>>> 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的副本，不會因為本身列表的變化而受影響，在上面的 🌰 中，只需要在構(gòu)造函數(shù)中創(chuàng)建一個副本即可(self.passengers=list(passengers))

del和垃圾回收

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

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

弱引用

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

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

弱引用是可調(diào)用的對象，返回的是被引用的對象；如果所指對象不存在了，返回 None

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

以上這篇基于Python對象引用、可變性和垃圾回收詳解就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: