Python中包含了許多內建的語言特性，它們使得程式碼簡潔且易於理解。這些特性包括列表/集合/字典推導式，屬性（property）、以及裝飾器（decorator）。對於大部分特性來說，這些“中級”的語言特性有著完善的文件，並且易於學習。
但是這裡有個例外，那就是描述符。至少對於我來說，描述符是Python語言核心中困擾我時間最長的一個特性。這裡有幾點原因如下：
- 有關描述符的官方文件相當難懂，而且沒有包含優秀的示例告訴你為什麼需要編寫描述符（我得為Raymond Hettinger辯護一下，他寫的其他主題的Python文章和視訊對我的幫助還是非常大的）
- 編寫描述符的語法顯得有些怪異
- 自定義描述符可能是Python中用的最少的特性，因此你很難在開源專案中找到優秀的示例
但是一旦你理解了之後，描述符的確還是有它的應用價值的。這篇文章告訴你描述符可以用來做什麼，以及為什麼應該引起你的注意。
一句話概括：描述符就是可重用的屬性
在這裡我要告訴你：從根本上講，描述符就是可以重複使用的屬性。也就是說，描述符可以讓你編寫這樣的程式碼：
|
1 2 3 4 |
f = Foo() b = f.bar f.bar = c del f.bar |
而在直譯器執行上述程式碼時，當發現你試圖訪問屬性（b = f.bar）、對屬性賦值（f.bar = c）或者刪除一個例項變數的屬性（del f.bar）時，就會去呼叫自定義的方法。
讓我們先來解釋一下為什麼把對函式的呼叫偽裝成對屬性的訪問是大有好處的。
property——把函式呼叫偽裝成對屬性的訪問
想象一下你正在編寫管理電影資訊的程式碼。你最後寫好的Movie類可能看上去是這樣的：
|
1 2 3 4 5 6 7 8 9 10 |
class Movie(object): def __init__(self, title, rating, runtime, budget, gross): self.title = title self.rating = rating self.runtime = runtime self.budget = budget self.gross = gross def profit(self): return self.gross - self.budget |
你開始在專案的其他地方使用這個類，但是之後你意識到：如果不小心給電影打了負分怎麼辦？你覺得這是錯誤的行為，希望Movie類可以阻止這個錯誤。 你首先想到的辦法是將Movie類修改為這樣：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class Movie(object): def __init__(self, title, rating, runtime, budget, gross): self.title = title self.rating = rating self.runtime = runtime self.gross = gross if budget < 0: raise ValueError("Negative value not allowed: %s" % budget) self.budget = budget def profit(self): return self.gross - self.budget |
但這行不通。因為其他部分的程式碼都是直接通過Movie.budget來賦值的——這個新修改的類只會在__init__方法中捕獲錯誤的資料，但對於已經存在的類例項就無能為力了。如果有人試著執行m.budget = -100，那麼誰也沒法阻止。作為一個Python程式設計師同時也是電影迷，你該怎麼辦？
幸運的是，Python的property解決了這個問題。如果你從未見過property的用法，下面是一個示例：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
class Movie(object): def __init__(self, title, rating, runtime, budget, gross): self._budget = None self.title = title self.rating = rating self.runtime = runtime self.gross = gross self.budget = budget @property def budget(self): return self._budget @budget.setter def budget(self, value): if value < 0: raise ValueError("Negative value not allowed: %s" % value) self._budget = value def profit(self): return self.gross - self.budget m = Movie('Casablanca', 97, 102, 964000, 1300000) print m.budget # calls m.budget(), returns result try: m.budget = -100 # calls budget.setter(-100), and raises ValueError except ValueError: print "Woops. Not allowed" 964000 Woops. Not allowed |
我們用@property裝飾器指定了一個getter方法，用@budget.setter裝飾器指定了一個setter方法。當我們這麼做時，每當有人試著訪問budget屬性，Python就會自動呼叫相應的getter/setter方法。比方說，當遇到m.budget = value這樣的程式碼時就會自動呼叫budget.setter。
花點時間來欣賞一下Python這麼做是多麼的優雅：如果沒有property，我們將不得不把所有的例項屬性隱藏起來，提供大量顯式的類似get_budget和set_budget方法。像這樣編寫類的話，使用起來就會不斷的去呼叫這些getter/setter方法，這看起來就像臃腫的Java程式碼一樣。更糟的是，如果我們不採用這種編碼風格，直接對例項屬性進行訪問。那麼稍後就沒法以清晰的方式增加對非負數的條件檢查——我們不得不重新建立set_budget方法，然後搜尋整個工程中的原始碼，將m.budget = value這樣的程式碼替換為m.set_budget(value)。太蛋疼了！！
因此，property讓我們將自定義的程式碼同變數的訪問/設定聯絡在了一起，同時為你的類保持一個簡單的訪問屬性的介面。幹得漂亮！
property的不足
對property來說，最大的缺點就是它們不能重複使用。舉個例子，假設你想為rating，runtime和gross這些欄位也新增非負檢查。下面是修改過的新類：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
class Movie(object): def __init__(self, title, rating, runtime, budget, gross): self._rating = None self._runtime = None self._budget = None self._gross = None self.title = title self.rating = rating self.runtime = runtime self.gross = gross self.budget = budget #nice @property def budget(self): return self._budget @budget.setter def budget(self, value): if value < 0: raise ValueError("Negative value not allowed: %s" % value) self._budget = value #ok @property def rating(self): return self._rating @rating.setter def rating(self, value): if value < 0: raise ValueError("Negative value not allowed: %s" % value) self._rating = value #uhh... @property def runtime(self): return self._runtime @runtime.setter def runtime(self, value): if value < 0: raise ValueError("Negative value not allowed: %s" % value) self._runtime = value #is this forever? @property def gross(self): return self._gross @gross.setter def gross(self, value): if value < 0: raise ValueError("Negative value not allowed: %s" % value) self._gross = value def profit(self): return self.gross - self.budget |
可以看到程式碼增加了不少，但重複的邏輯也出現了不少。雖然property可以讓類從外部看起來介面整潔漂亮，但是卻做不到內部同樣整潔漂亮。
描述符登場（最終的大殺器）
這就是描述符所解決的問題。描述符是property的升級版，允許你為重複的property邏輯編寫單獨的類來處理。下面的示例展示了描述符是如何工作的（現在還不必擔心NonNegative類的實現）：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
from weakref import WeakKeyDictionary class NonNegative(object): """A descriptor that forbids negative values""" def __init__(self, default): self.default = default self.data = WeakKeyDictionary() def __get__(self, instance, owner): # we get here when someone calls x.d, and d is a NonNegative instance # instance = x # owner = type(x) return self.data.get(instance, self.default) def __set__(self, instance, value): # we get here when someone calls x.d = val, and d is a NonNegative instance # instance = x # value = val if value < 0: raise ValueError("Negative value not allowed: %s" % value) self.data[instance] = value class Movie(object): #always put descriptors at the class-level rating = NonNegative(0) runtime = NonNegative(0) budget = NonNegative(0) gross = NonNegative(0) def __init__(self, title, rating, runtime, budget, gross): self.title = title self.rating = rating self.runtime = runtime self.budget = budget self.gross = gross def profit(self): return self.gross - self.budget m = Movie('Casablanca', 97, 102, 964000, 1300000) print m.budget # calls Movie.budget.__get__(m, Movie) m.rating = 100 # calls Movie.budget.__set__(m, 100) try: m.rating = -1 # calls Movie.budget.__set__(m, -100) except ValueError: print "Woops, negative value" 964000 Woops, negative value |
這裡引入了一些新的語法，我們一條條的來看：
NonNegative是一個描述符物件，因為它定義了__get__，__set__或__delete__方法。
Movie類現在看起來非常清晰。我們在類的層面上建立了4個描述符，把它們當做普通的例項屬性。顯然，描述符在這裡為我們做非負檢查。
訪問描述符
當直譯器遇到print m.buget時，它就會把budget當作一個帶有__get__ 方法的描述符，呼叫Movie.budget.__get__方法並將方法的返回值列印出來，而不是直接傳遞m.budget來列印。這和你訪問一個property相似，Python自動呼叫一個方法，同時返回結果。
__get__接收2個引數：一個是點號左邊的例項物件（在這裡，就是m.budget中的m），另一個是這個例項的型別（Movie）。在一些Python文件中，Movie被稱作描述符的所有者（owner）。如果我們需要訪問Movie.budget，Python將會呼叫Movie.budget.__get__(None, Movie)。可以看到，第一個引數要麼是所有者的例項，要麼是None。這些輸入引數可能看起來很怪，但是這裡它們告訴了你描述符屬於哪個物件的一部分。當我們看到NonNegative類的實現時這一切就合情合理了。
對描述符賦值
當直譯器看到m.rating = 100時，Python識別出rating是一個帶有__set__方法的描述符，於是就呼叫Movie.rating.__set__(m, 100)。和__get__一樣，__set__的第一個引數是點號左邊的類例項（m.rating = 100中的m）。第二個引數是所賦的值（100）。
刪除描述符
為了說明的完整，這裡提一下刪除。如果你呼叫del m.budget，Python就會呼叫Movie.budget.__delete__(m)。
NonNegative類是如何工作的？
帶著前面的困惑，我們終於要揭示NonNegative類是如何工作的了。每個NonNegative的例項都維護著一個字典，其中儲存著所有者例項和對應資料的對映關係。當我們呼叫m.budget時，__get__方法會查詢與m相關聯的資料，並返回這個結果（如果這個值不存在，則會返回一個預設值）。__set__採用的方式相同，但是這裡會包含額外的非負檢查。我們使用WeakKeyDictionary來取代普通的字典以防止記憶體洩露——我們可不想僅僅因為它在描述符的字典中就讓一個無用 的例項一直存活著。
使用描述符會有一點彆扭。因為它們作用於類的層次上，每一個類例項都共享同一個描述符。這就意味著對不同的例項物件而言，描述符不得不手動地管理 不同的狀態，同時需要顯式的將類例項作為第一個引數準確傳遞給__get__、__set__以及__delete__方法。
我希望這個例子解釋清楚了描述符可以用來做什麼——它們提供了一種方法將property的邏輯隔離到單獨的類中來處理。如果你發現自己正在不同的property之間重複著相同的邏輯，那麼本文也許會成為一個線索供你思考為何用描述符重構程式碼是值得一試的。
祕訣和陷阱
把描述符放在類的層次上（class level）
為了讓描述符能夠正常工作，它們必須定義在類的層次上。如果你不這麼做，那麼Python無法自動為你呼叫__get__和__set__方法。
|
1 2 3 4 5 6 7 8 9 |
class Broken(object): y = NonNegative(5) def __init__(self): self.x = NonNegative(0) # NOT a good descriptor b = Broken() print "X is %s, Y is %s" % (b.x, b.y) X is <__main__.NonNegative object at 0x10432c250>, Y is 5 |
可以看到，訪問類層次上的描述符y可以自動呼叫__get__。但是訪問例項層次上的描述符x只會返回描述符本身，真是魔法一般的存在啊。
確保例項的資料只屬於例項本身
你可能會像這樣編寫NonNegative描述符：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
class BrokenNonNegative(object): def __init__(self, default): self.value = default def __get__(self, instance, owner): return self.value def __set__(self, instance, value): if value < 0: raise ValueError("Negative value not allowed: %s" % value) self.value = value class Foo(object): bar = BrokenNonNegative(5) f = Foo() try: f.bar = -1 except ValueError: print "Caught the invalid assignment" Caught the invalid assignment |
這麼做看起來似乎能正常工作。但這裡的問題就在於所有Foo的例項都共享相同的bar，這會產生一些令人痛苦的結果：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class Foo(object): bar = BrokenNonNegative(5) f = Foo() g = Foo() print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) print "Setting f.bar to 10" f.bar = 10 print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) #ouch f.bar is 5 g.bar is 5 Setting f.bar to 10 f.bar is 10 g.bar is 10 |
這就是為什麼我們要在NonNegative中使用資料字典的原因。__get__和__set__的第一個引數告訴我們需要關心哪一個例項。NonNegative使用這個引數作為字典的key，為每一個Foo例項單獨儲存一份資料。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Foo(object): bar = NonNegative(5) f = Foo() g = Foo() print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) print "Setting f.bar to 10" f.bar = 10 print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) #better f.bar is 5 g.bar is 5 Setting f.bar to 10 f.bar is 10 g.bar is 5 |
這就是描述符最令人感到彆扭的地方（坦白的說，我不理解為什麼Python不讓你在例項的層次上定義描述符，並且總是需要將實際的處理分發給__get__和__set__。這麼做行不通一定是有原因的）
注意不可雜湊的描述符所有者
NonNegative類使用了一個字典來單獨儲存專屬於例項的資料。這個一般來說是沒問題的，除非你用到了不可雜湊（unhashable）的物件：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
class MoProblems(list): #you can't use lists as dictionary keys x = NonNegative(5) m = MoProblems() print m.x # womp womp --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-8-dd73b177bd8d> in <module>() 3 4 m = MoProblems() ----> 5 print m.x # womp womp <ipython-input-3-6671804ce5d5> in __get__(self, instance, owner) 9 # instance = x 10 # owner = type(x) ---> 11 return self.data.get(instance, self.default) 12 13 def __set__(self, instance, value): TypeError: unhashable type: 'MoProblems' |
因為MoProblems的例項（list的子類）是不可雜湊的，因此它們不能為MoProblems.x用做資料字典的key。有一些方法可以規避這個問題，但是都不完美。最好的方法可能就是給你的描述符加標籤了。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
class Descriptor(object): def __init__(self, label): self.label = label def __get__(self, instance, owner): print '__get__', instance, owner return instance.__dict__.get(self.label) def __set__(self, instance, value): print '__set__' instance.__dict__[self.label] = value class Foo(list): x = Descriptor('x') y = Descriptor('y') f = Foo() f.x = 5 print f.x __set__ __get__ [] <class '__main__.Foo'> 5 |
這種方法依賴於Python的方法解析順序（即，MRO）。我們給Foo中的每個描述符加上一個標籤名，名稱和我們賦值給描述符的變數名相同，比如x = Descriptor(‘x’)。之後，描述符將特定於例項的資料儲存在f.__dict__[‘x’]中。這個字典條目通常是當我們請求f.x時Python給出的返回值。然而，由於Foo.x 是一個描述符，Python不能正常的使用f.__dict__[‘x’]，但是描述符可以安全的在這裡儲存資料。只是要記住，不要在別的地方也給這個描述符新增標籤。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Foo(object): x = Descriptor('y') f = Foo() f.x = 5 print f.x f.y = 4 #oh no! print f.x __set__ __get__ <__main__.Foo object at 0x10432c810> <class '__main__.Foo'> 5 __get__ <__main__.Foo object at 0x10432c810> <class '__main__.Foo'> 4 |
我不喜歡這種方式，因為這樣的程式碼很脆弱也有很多微妙之處。但這個方法的確很普遍，可以用在不可雜湊的所有者類上。David Beazley在他的書中用到了這個方法。
在元類中使用帶標籤的描述符
由於描述符的標籤名和賦給它的變數名相同，所以有人使用元類來自動處理這個簿記（bookkeeping）任務。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
class Descriptor(object): def __init__(self): #notice we aren't setting the label here self.label = None def __get__(self, instance, owner): print '__get__. Label = %s' % self.label return instance.__dict__.get(self.label, None) def __set__(self, instance, value): print '__set__' instance.__dict__[self.label] = value class DescriptorOwner(type): def __new__(cls, name, bases, attrs): # find all descriptors, auto-set their labels for n, v in attrs.items(): if isinstance(v, Descriptor): v.label = n return super(DescriptorOwner, cls).__new__(cls, name, bases, attrs) class Foo(object): __metaclass__ = DescriptorOwner x = Descriptor() f = Foo() f.x = 10 print f.x __set__ __get__. Label = x 10 |
我不會去解釋有關元類的細節——參考文獻中David Beazley已經在他的文章中解釋的很清楚了。 需要指出的是元類自動的為描述符新增標籤，並且和賦給描述符的變數名字相匹配。
儘管這樣解決了描述符的標籤和變數名不一致的問題，但是卻引入了複雜的元類。雖然我很懷疑，但是你可以自行判斷這麼做是否值得。
訪問描述符的方法
描述符僅僅是類，也許你想要為它們增加一些方法。舉個例子，描述符是一個用來回撥property的很好的手段。比如我們想要一個類的某個部分的狀態發生變化時就立刻通知我們。下面的大部分程式碼是用來做這個的：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
class CallbackProperty(object): """A property that will alert observers when upon updates""" def __init__(self, default=None): self.data = WeakKeyDictionary() self.default = default self.callbacks = WeakKeyDictionary() def __get__(self, instance, owner): return self.data.get(instance, self.default) def __set__(self, instance, value): for callback in self.callbacks.get(instance, []): # alert callback function of new value callback(value) self.data[instance] = value def add_callback(self, instance, callback): """Add a new function to call everytime the descriptor updates""" #but how do we get here?!?! if instance not in self.callbacks: self.callbacks[instance] = [] self.callbacks[instance].append(callback) class BankAccount(object): balance = CallbackProperty(0) def low_balance_warning(value): if value < 100: print "You are poor" ba = BankAccount() # will not work -- try it #ba.balance.add_callback(ba, low_balance_warning) |
這是一個很有吸引力的模式——我們可以自定義回撥函式用來響應一個類中的狀態變化，而且完全無需修改這個類的程式碼。這樣做可真是替人分憂解難呀。現在，我們所要做的就是呼叫ba.balance.add_callback(ba, low_balance_warning)，以使得每次balance變化時low_balance_warning都會被呼叫。
但是我們是如何做到的呢？當我們試圖訪問它們時，描述符總是會呼叫__get__。就好像add_callback方法是無法觸及的一樣！其實關鍵在於利用了一種特殊的情況，即，當從類的層次訪問時，__get__方法的第一個引數是None。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
class CallbackProperty(object): """A property that will alert observers when upon updates""" def __init__(self, default=None): self.data = WeakKeyDictionary() self.default = default self.callbacks = WeakKeyDictionary() def __get__(self, instance, owner): if instance is None: return self return self.data.get(instance, self.default) def __set__(self, instance, value): for callback in self.callbacks.get(instance, []): # alert callback function of new value callback(value) self.data[instance] = value def add_callback(self, instance, callback): """Add a new function to call everytime the descriptor within instance updates""" if instance not in self.callbacks: self.callbacks[instance] = [] self.callbacks[instance].append(callback) class BankAccount(object): balance = CallbackProperty(0) def low_balance_warning(value): if value < 100: print "You are now poor" ba = BankAccount() BankAccount.balance.add_callback(ba, low_balance_warning) ba.balance = 5000 print "Balance is %s" % ba.balance ba.balance = 99 print "Balance is %s" % ba.balance Balance is 5000 You are now poor Balance is 99 |
結語
希望你現在對描述符是什麼和它們的適用場景有了一個認識。前進吧騷年！
參考文獻
- Encapsulation With Descriptors by Luciano Ramalho
- Python 3 Metaprogramming by David Beazley
- Python’s class development toolkit by Raymond Hettinger