Python 的描述符 descriptor詳解

Python 在 2.2 版本中引入了descriptor（描述符）功能，也正是基於這個功能實現了新式類(new-styel class)的物件模型，同時解決了之前版本中經典類 (classic class) 系統中出現的多重繼承中的 MRO(Method Resolution Order) 問題，另外還引入了一些新的概念，比如 classmethod, staticmethod, super, Property 等。因此理解 descriptor 有助於更好地瞭解 Python 的運行機制。

那麼什麼是 descriptor 呢？

簡而言之：descriptor 就是一類實現了__get__(), __set__(), __delete__()方法的對象。

Orz...如果你瞬間頓悟了，那麼請收下我的膝蓋；
O_o!...如果似懂非懂,那麼恭喜你！說明你潛力很大,咱們可以繼續挖掘：

引言

對於陌生的事物，一個具體的栗子是最好的學習方式，首先來看這樣一個問題：假設我們給一次數學考試建立一個類，用於記錄每個學生的學號、數學成績、以及提供一個用於判斷是否通過考試的check 函數：

class MathScore():    def __init__(self, std_id, score):    self.std_id = std_id    self.score = score  def check(self):    if self.score >= 60:      return 'pass'    else:      return 'failed'      

很簡單一個樣本，看起來啟動並執行不錯：

xiaoming = MathScore(10, 90)xiaoming.scoreOut[3]: 90xiaoming.std_idOut[4]: 10xiaoming.check()Out[5]: 'pass'

但是會有一個問題，比如手一抖錄入了一個負分數，那麼他就得悲劇的掛了：

xiaoming = MathScore(10, -90)xiaoming.scoreOut[8]: -90xiaoming.check()Out[9]: 'failed'

這顯然是一個嚴重的問題，怎麼能讓一個數學 90+ 的孩子掛科呢，於是乎一個簡單粗暴的方法就誕生了：

class MathScore():    def __init__(self, std_id, score):    self.std_id = std_id    if score < 0:      raise ValueError("Score can't be negative number!")    self.score = score  def check(self):    if self.score >= 60:      return 'pass'    else:      return 'failed'          

上面再類的初始化函數中增加了負數判斷，雖然不夠優雅，甚至有點拙劣，但這在執行個體初始化時確實工作的不錯：

xiaoming = MathScore(10, -90)Traceback (most recent call last): File "", line 1, in   xiaoming = MathScore(10, -90) File "C:/Users/xu_zh/.spyder2-py3/temp.py", line 14, in __init__  raise ValueError("Score can't be negative number!")ValueError: Score can't be negative number!

OK, 但我們還無法阻止執行個體對 score 的賦值操作，畢竟修改成績也是常有的事：

xiaoming = MathScore(10, 90)xiaoming = -10  # 無法判斷出錯誤

對於大多數童鞋，這個問題 so easy 的啦：將 score 變為私人，從而禁止 xiaoming.score 這樣的直接調用，增加一個 get_score 和 set_score 用於讀寫：

class MathScore():    def __init__(self, std_id, score):    self.std_id = std_id    if score < 0:      raise ValueError("Score can't be negative number!")    self.__score = score  def check(self):    if self.__score >= 60:      return 'pass'    else:      return 'failed'            def get_score(self):    return self.__score    def set_score(self, value):    if value < 0:      raise ValueError("Score can't be negative number!")    self.__score = value

這確實是種常見的解決方案，但是不得不說這簡直醜爆了：

調用成績再也不能使用 xiaoming.score 這樣自然的方式，需要使用 xiaoming.get_score() ，這看起來像口吃在說話！
還有那反人類的底線和括弧...那應該只出現在電腦之間竊竊私語之中...
賦值也無法使用 xiaoming.score = 80， 而需使用 xiaoming.set_score(80)， 這對數學老師來說，太 TM 不自然了 !!!

作為一門簡潔優雅的程式設計語言，Python 是不會坐視不管的，於是其給出了 Property 類：

Property 類

先不管 Property 是啥，咱先看看它是如何簡潔優雅的解決上面這個問題的：

class MathScore():    def __init__(self, std_id, score):    self.std_id = std_id    if score < 0:      raise ValueError("Score can't be negative number!")    self.__score = score  def check(self):    if self.__score >= 60:      return 'pass'    else:      return 'failed'            def __get_score__(self):    return self.__score    def __set_score__(self, value):    if value < 0:      raise ValueError("Score can't be negative number!")    self.__score = value      score = property(__get_score__, __set_score__)

與上段代碼相比，主要是在最後一句執行個體化了一個 property 執行個體，並取名為 score， 這個時候，我們就能如此自然的對 instance.__score 進行讀寫了：

xiaoming = MathScore(10, 90)xiaoming.scoreOut[30]: 90xiaoming.score = 80xiaoming.scoreOut[32]: 80xiaoming.score = -90Traceback (most recent call last): File "", line 1, in   xiaoming.score = -90 File "C:/Users/xu_zh/.spyder2-py3/temp.py", line 28, in __set_score__  raise ValueError("Score can't be negative number!")ValueError: Score can't be negative number!

WOW~~一切工作正常！
嗯，那麼問題來了：它是怎麼工作的呢？
先看下 property 的參數：

class property(fget=None, fset=None, fdel=None, doc=None) #拷貝自 Python 官方文檔
它的工作方式：

執行個體化 property 執行個體（我知道這是句廢話）；
調用 property 執行個體（比如xiaoming.score）會直接調用 fget，並由 fget 返回相應值；
對 property 執行個體進行賦值操作（xiaoming.score = 80）則會調用 fset，並由 fset 定義完成相應操作；
刪除 property 執行個體（del xiaoming），則會調用 fdel 實現該執行個體的刪除；
doc 則是該 property 執行個體的字元說明；
fget/fset/fdel/doc 需自訂，如果只設定了fget，則該執行個體為唯讀對象；
這看起來和本篇開頭所說的 descriptor 的功能非常相似，讓我們回顧一下 descriptor：

“descriptor 就是一類實現了__get__(), __set__(), __delete__()方法的對象。”

@~@ 如果你這次又秒懂了，那麼請再次收下我的膝蓋 Orz...

另外，Property 還有個裝飾器文法糖 @property，其所實現的功能與 property() 完全一樣：

class MathScore():    def __init__(self, std_id, score):    self.std_id = std_id    if score < 0:      raise ValueError("Score can't be negative number!")    self.__score = score  def check(self):    if self.__score >= 60:      return 'pass'    else:      return 'failed'          @property    def score(self):    return self.__score    @score.setter  def score(self, value):  #注意方法名稱要與上面一致，否則會失效    if value < 0:      raise ValueError("Score can't be negative number!")    self.__score = value

我們知道了 property 執行個體的工作方式了，那麼問題又來了：它是怎麼實現的？
事實上 Property 確實是基於 descriptor 而實現的，下面進入我們的正題 descriptor 吧！

descriptor 描述符

照樣先不管 descriptor 是啥，咱們還是先看栗子，對於上面 Property 實現的功能，我們可以通過自訂的 descriptor 來實現：

class NonNegative():    def __init__(self):    pass  def __get__(self, ist, cls):    return 'descriptor get: ' + str(ist.__score ) #這裡加上字元描述便於看清調用  def __set__(self, ist, value):    if value < 0:      raise ValueError("Score can't be negative number!")    print('descriptor set:', value)    ist.__score = value    class MathScore():    score = NonNegative()    def __init__(self, std_id, score):    self.std_id = std_id    if score < 0:      raise ValueError("Score can't be negative number!")    self.__score = score      def check(self):    if self.__score >= 60:      return 'pass'    else:      return 'failed'      

我們新定義了一個 NonNegative 類，並在其內實現了__get__、__set__方法，然後在 MathScore 類中執行個體化了一個 NonNegative 的執行個體 score，注意！！！重要的事情說三遍：score 執行個體是 MathScore 的類屬性！！！類屬性！！！類屬性！！！這個 Mathscore.score 屬性同上面 Property 的 score 執行個體的功能是一樣的，只不過 Mathscore.score 調用的 get、set 並不定義在 Mathscore 內，而是定義在 NonNegative 類中，而 NonNegative 類就是一個 descriptor 對象！

納尼？ NonNegative 類的定義中可沒見到半個 “descriptor” 的字樣，怎麼就成了 descriptor 對象？？？

淡定！ 重要的事情這裡只說一遍：任何實現 __get__，__set__ 或 __delete__ 方法中一至多個的類，就是 descriptor 對象。所以 NonNegative 自然是一個 descriptor 對象。

那麼 descriptor 對象與普通類比有什麼特別之處呢？ 先不急，來看看上端代碼的效果：

xiaoming = MathScore(10, 90)xiaoming.scoreOut[67]: 'descriptor get: 90'xiaoming.score = 80descriptor set: 80wangerma = MathScore(11, 70)wangerma.scoreOut[70]: 'descriptor get: 70'wangerma.score = 60Out[70]: descriptor set: 60wangerma.scoreOut[73]: 'descriptor get: 60'xiaoming.scoreOut[74]: 'descriptor get: 80'xiaoming.score = -90ValueError: Score can't be negative number!

可以發現，MathScore.score 雖然是一個類屬性，但它卻可以通過執行個體的進行賦值，且面對不同的 MathScore 執行個體 xiaoming、wangerma 的賦值和調用，並不會產生衝突！因此看起來似乎更類似於 MathScore 的執行個體屬性，但與執行個體屬性不同的是它並不通過 MathScore 執行個體的讀寫方法操作值，而總是通過 NonNegative 執行個體的 __get__ 和 __set__ 對值進行操作，那麼它是怎麼做到這點的？

注意看 __get__、__set__ 的參數

def __get__(self, ist, cls): #self：descriptor 執行個體本身（如 Math.score），ist：調用 score 的執行個體（如 xiaoming）,cls：descriptor 執行個體所在的類（如MathScore）
...

def __set__(self, ist, value): #score 就是通過這些傳入的 ist 、cls 參數，實現對 MathScore 及其具體執行個體屬性的調用和改寫的
...
OK, 現在我們基本搞清了 descriptor 執行個體是如何?對宿主類的執行個體屬性進行類比的。事實上 Property 執行個體的實現方式與上面的 NonNegative 執行個體類似。那麼我們既然有了 Propery，為什麼還要去自訂 descriptor 呢？

答案在於：更加逼真的類比執行個體屬性（想想 MathScore.__init__裡面那噁心的判斷語句），還有最重要的是：代碼重用！！！

簡而言之：通過單個 descriptor 對象，可以更加逼真的類比執行個體屬性，並且可以實現對宿主類執行個體的多個執行個體屬性進行操作。

O.O! 如果你又秒懂了，那麼你可以直接跳到下面寫評論了...

看個栗子：假如不僅要判斷學生的分數是否為負數，而且還要判學生的學號是否為負值，使用 property 的實現方式是這樣子的：

class MathScore():    def __init__(self, std_id, score):    if std_id < 0:      raise ValueError("Can't be negative number!")    self.__std_id = std_id    if score < 0:      raise ValueError("Can't be negative number!")    self.__score = score  def check(self):    if self.__score >= 60:      return 'pass'    else:      return 'failed'          @property    def score(self):    return self.__score    @score.setter  def score(self, value):    if value < 0:      raise ValueError("Can't be negative number!")    self.__score = value    @property  def std_id(self):    return self.__std_id  @std_id.setter  def std_id(self, idnum):    if idnum < 0:      raise ValueError("Can't be negative nmuber!")    self.__std_id = idnum

Property 執行個體最大的問題是：

無法影響宿主類執行個體的初始化，所以咱必須在__init__ 加上那醜惡的 if ...
單個 Property 執行個體僅能針對宿主類執行個體的單個屬性，如果需要對多個屬性進行控制，則必須定義多個 Property 執行個體， 這真是太蛋疼了！
但是自訂 descriptor 可以很好的解決這個問題，看下實現：

class NonNegative():    def __init__(self):    self.dic = dict()  def __get__(self, ist, cls):    print('Description get', ist)    return self.dic[ist]  def __set__(self, ist, value):    print('Description set', ist, value)    if value < 0:      raise ValueError("Can't be negative number!")    self.dic[ist] = value    class MathScore():    score = NonNegative()    std_id = NonNegative()      def __init__(self, std_id, score):    #這裡並未建立執行個體屬性 std_id 和 score, 而是調用 MathScore.std_id 和 MathScore.score        self.std_id = std_id    self.score = score       def check(self):    if self.score >= 60:      return 'pass'    else:      return 'failed'   

哈哈~！ MathScore.__init__ 內終於沒了 if ，代碼也比上面的簡潔不少，但是功能一個不少，且執行個體之間不會相互影響：

事實上，MathScore 多個執行個體的同一個屬性，都是通過單個 MathScore 類的相應類屬性（也即 NonNegative 執行個體）操作的，這同 property 一致，但它又是怎麼克服 Property 的兩個不足的呢？秘訣有三個：

Property 執行個體本質上是藉助類屬性，變向對執行個體屬性進行操作，而 NonNegative 執行個體則是完全通過類屬性類比執行個體屬性，因此執行個體屬性其實根本不存在；

NonNegative 執行個體使用字典記錄每個 MathScore 執行個體及其對應的屬性值，其中 key 為 MathScore 執行個體名：比如 score 執行個體就是使用 dic = {‘Zhangsan':50, ‘Lisi':90} 記錄每個執行個體對應的 score 值，從而確保可以實現對 MathScore 執行個體屬性的類比；
MathScore 通過在__init__內直接調用類屬性，從而實現對執行個體屬性初始化賦值的類比，而 Property 則不可能，因為 Property 執行個體（也即MathScore的類屬性）是真實的操作 MathScore 執行個體傳入的執行個體屬性以達到目的，但如果在初始化程式中傳入的不是執行個體屬性，而是類屬性（也即 Property 執行個體本身），則會陷入無限遞迴（PS：想一下如果將前一個property 執行個體實現中的self.__score 改成這裡的 self.score 會發生什麼）。

這三點看的似懂非懂，沒關係，來個比喻：

每個 descriptor 執行個體（MathScore.score 和 MathScore.std_id）都是類範圍裡的一個籃子，籃子裡放著寫著每個 MathScore 執行個體名字的盒子（‘zhangsan'，'lisi‘），同一個籃子裡的盒子只記錄同樣屬性的值（比如score籃子裡的盒子只記錄分數值），當 MathScore 的執行個體對相應屬性進行操作時，則找到對應的籃子，取出標有該執行個體名字的盒子，並對其進行操作。

因此，執行個體對應的屬性，壓根不在執行個體自己的範圍內，而是在類範圍的籃子裡，只不過我們可以通過 xiaoming.score 這樣的方式進行操作而已，所以其實際的調用的邏輯是這樣的：右側的執行個體分別通過紅線和黑線對score和std_id 進行操作，他們首先通過類調用相應的類屬性，然後類屬性通過對應的 descriptor 執行個體範圍對操作進行處理，並返回給類屬性相應結果，最後讓執行個體感知到。

看到這裡，很多童鞋可能不淡定了，因為大家都知道在 Python 中採取 xiaoming.score = 10 這樣的賦值方式，如果 xiaoming 沒有 score 這樣的執行個體屬性，必定會自動建立該執行個體屬性，怎麼會去調用 MathScore 的 score 呢？

首先，要鼓掌！！！ 給想到這點的童鞋點贊！！！其實上面在說 Property 的時候這個問題就產生了。

其次，Python 為了實現 discriptor 確實對屬性的調用順序做出了相應的調整，這些將會“Python 的 descriptor（下）”中介紹。

