Python中包含了許多內(nèi)建的語(yǔ)言特性，它們使得代碼簡(jiǎn)潔且易于理解。這些特性包括列表/集合/字典推導(dǎo)式，屬性（property）、以及裝飾器（decorator）。對(duì)于大部分特性來(lái)說(shuō)，這些“中級(jí)”的語(yǔ)言特性有著完善的文檔，并且易于學(xué)習(xí)。

但是這里有個(gè)例外，那就是描述符。至少對(duì)于我來(lái)說(shuō)，描述符是Python語(yǔ)言核心中困擾我時(shí)間最長(zhǎng)的一個(gè)特性。這里有幾點(diǎn)原因如下：

有關(guān)描述符的官方文檔相當(dāng)難懂，而且沒(méi)有包含優(yōu)秀的示例告訴你為什么需要編寫(xiě)描述符（我得為Raymond Hettinger辯護(hù)一下，他寫(xiě)的其他主題的Python文章和視頻對(duì)我的幫助還是非常大的）

編寫(xiě)描述符的語(yǔ)法顯得有些怪異

自定義描述符可能是Python中用的最少的特性，因此你很難在開(kāi)源項(xiàng)目中找到優(yōu)秀的示例

但是一旦你理解了之后，描述符的確還是有它的應(yīng)用價(jià)值的。這篇文章告訴你描述符可以用來(lái)做什么，以及為什么應(yīng)該引起你的注意。

一句話概括：描述符就是可重用的屬性

在這里我要告訴你：從根本上講，描述符就是可以重復(fù)使用的屬性。也就是說(shuō)，描述符可以讓你編寫(xiě)這樣的代碼：

f = Foo() b = f.bar f.bar = c del f.bar

而在解釋器執(zhí)行上述代碼時(shí)，當(dāng)發(fā)現(xiàn)你試圖訪問(wèn)屬性（b = f.bar）、對(duì)屬性賦值（f.bar = c）或者刪除一個(gè)實(shí)例變量的屬性（del f.bar）時(shí)，就會(huì)去調(diào)用自定義的方法。

讓我們先來(lái)解釋一下為什么把對(duì)函數(shù)的調(diào)用偽裝成對(duì)屬性的訪問(wèn)是大有好處的。

property——把函數(shù)調(diào)用偽裝成對(duì)屬性的訪問(wèn)

想象一下你正在編寫(xiě)管理電影信息的代碼。你最后寫(xiě)好的Movie類(lèi)可能看上去是這樣的：

class Movie(object):def __init__(self, title, rating, runtime, budget, gross):self.title = titleself.rating = ratingself.runtime = runtimeself.budget = budgetself.gross = grossdef profit(self):return self.gross - self.budget

你開(kāi)始在項(xiàng)目的其他地方使用這個(gè)類(lèi)，但是之后你意識(shí)到：如果不小心給電影打了負(fù)分怎么辦？你覺(jué)得這是錯(cuò)誤的行為，希望Movie類(lèi)可以阻止這個(gè)錯(cuò)誤。 你首先想到的辦法是將Movie類(lèi)修改為這樣：

class Movie(object):def __init__(self, title, rating, runtime, budget, gross):self.title = titleself.rating = ratingself.runtime = runtimeself.gross = grossif budget < 0:raise ValueError("Negative value not allowed: %s" % budget)self.budget = budgetdef profit(self):return self.gross - self.budget

但這行不通。因?yàn)槠渌糠值拇a都是直接通過(guò)Movie.budget來(lái)賦值的——這個(gè)新修改的類(lèi)只會(huì)在__init__方法中捕獲錯(cuò)誤的數(shù)據(jù)，但對(duì)于已 經(jīng)存在的類(lèi)實(shí)例就無(wú)能為力了。如果有人試著運(yùn)行m.budget = -100，那么誰(shuí)也沒(méi)法阻止。作為一個(gè)Python程序員同時(shí)也是電影迷，你該怎么辦？

幸運(yùn)的是，Python的property解決了這個(gè)問(wèn)題。如果你從未見(jiàn)過(guò)property的用法，下面是一個(gè)示例：

class Movie(object):def __init__(self, title, rating, runtime, budget, gross):self._budget = Noneself.title = titleself.rating = ratingself.runtime = runtimeself.gross = grossself.budget = budget@propertydef budget(self):return self._budget@budget.setterdef budget(self, value):if value < 0:raise ValueError("Negative value not allowed: %s" % value)self._budget = valuedef profit(self):return self.gross - self.budgetm = 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裝飾器指定了一個(gè)getter方法，用@budget.setter裝飾器指定了一個(gè)setter方法。當(dāng)我們這么做時(shí)，每當(dāng)有 人試著訪問(wèn)budget屬性，Python就會(huì)自動(dòng)調(diào)用相應(yīng)的getter/setter方法。比方說(shuō)，當(dāng)遇到m.budget = value這樣的代碼時(shí)就會(huì)自動(dòng)調(diào)用budget.setter。

花點(diǎn)時(shí)間來(lái)欣賞一下Python這么做是多么的優(yōu)雅：如果沒(méi)有property，我們將不得不把所有的實(shí)例屬性隱藏起來(lái)，提供大量顯式的類(lèi)似 get_budget和set_budget方法。像這樣編寫(xiě)類(lèi)的話，使用起來(lái)就會(huì)不斷的去調(diào)用這些getter/setter方法，這看起來(lái)就像臃腫的 Java代碼一樣。更糟的是，如果我們不采用這種編碼風(fēng)格，直接對(duì)實(shí)例屬性進(jìn)行訪問(wèn)。那么稍后就沒(méi)法以清晰的方式增加對(duì)非負(fù)數(shù)的條件檢查——我們不得不重 新創(chuàng)建set_budget方法，然后搜索整個(gè)工程中的源代碼，將m.budget = value這樣的代碼替換為m.set_budget(value)。太蛋疼了！！

因此，property讓我們將自定義的代碼同變量的訪問(wèn)/設(shè)定聯(lián)系在了一起，同時(shí)為你的類(lèi)保持一個(gè)簡(jiǎn)單的訪問(wèn)屬性的接口。干得漂亮！

property的不足

對(duì)property來(lái)說(shuō)，最大的缺點(diǎn)就是它們不能重復(fù)使用。舉個(gè)例子，假設(shè)你想為rating，runtime和gross這些字段也添加非負(fù)檢查。下面是修改過(guò)的新類(lèi)：

class Movie(object):def __init__(self, title, rating, runtime, budget, gross):self._rating = Noneself._runtime = Noneself._budget = Noneself._gross = Noneself.title = titleself.rating = ratingself.runtime = runtimeself.gross = grossself.budget = budget#nice @propertydef budget(self):return self._budget@budget.setterdef budget(self, value):if value < 0:raise ValueError("Negative value not allowed: %s" % value)self._budget = value#ok @propertydef rating(self):return self._rating@rating.setterdef rating(self, value):if value < 0:raise ValueError("Negative value not allowed: %s" % value)self._rating = value#uhh... @propertydef runtime(self):return self._runtime@runtime.setterdef runtime(self, value):if value < 0:raise ValueError("Negative value not allowed: %s" % value)self._runtime = value #is this forever? @propertydef gross(self):return self._gross@gross.setterdef 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

可以看到代碼增加了不少，但重復(fù)的邏輯也出現(xiàn)了不少。雖然property可以讓類(lèi)從外部看起來(lái)接口整潔漂亮，但是卻做不到內(nèi)部同樣整潔漂亮。

描述符登場(chǎng)（最終的大殺器）

這就是描述符所解決的問(wèn)題。描述符是property的升級(jí)版，允許你為重復(fù)的property邏輯編寫(xiě)單獨(dú)的類(lèi)來(lái)處理。下面的示例展示了描述符是如何工作的（現(xiàn)在還不必?fù)?dān)心NonNegative類(lèi)的實(shí)現(xiàn)）：

from weakref import WeakKeyDictionaryclass NonNegative(object):"""A descriptor that forbids negative values"""def __init__(self, default):self.default = defaultself.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 = valif value < 0:raise ValueError("Negative value not allowed: %s" % value)self.data[instance] = valueclass Movie(object):#always put descriptors at the class-levelrating = NonNegative(0)runtime = NonNegative(0)budget = NonNegative(0)gross = NonNegative(0)def __init__(self, title, rating, runtime, budget, gross):self.title = titleself.rating = ratingself.runtime = runtimeself.budget = budgetself.gross = grossdef profit(self):return self.gross - self.budgetm = 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

這里引入了一些新的語(yǔ)法，我們一條條的來(lái)看：

NonNegative是一個(gè)描述符對(duì)象，因?yàn)樗x了__get__，__set__或__delete__方法。

Movie類(lèi)現(xiàn)在看起來(lái)非常清晰。我們?cè)陬?lèi)的層面上創(chuàng)建了4個(gè)描述符，把它們當(dāng)做普通的實(shí)例屬性。顯然，描述符在這里為我們做非負(fù)檢查。

訪問(wèn)描述符

當(dāng)解釋器遇到print m.buget時(shí)，它就會(huì)把budget當(dāng)作一個(gè)帶有__get__ 方法的描述符，調(diào)用Movie.budget.__get__方法并將方法的返回值打印出來(lái)，而不是直接傳遞m.budget來(lái)打印。這和你訪問(wèn)一個(gè) property相似，Python自動(dòng)調(diào)用一個(gè)方法，同時(shí)返回結(jié)果。

__get__接收2個(gè)參數(shù)：一個(gè)是點(diǎn)號(hào)左邊的實(shí)例對(duì)象（在這里，就是m.budget中的m），另一個(gè)是這個(gè)實(shí)例的類(lèi)型（Movie）。在一些Python文檔中，Movie 被稱(chēng)作描述符的所有者（owner）。如果我們需要訪問(wèn)Movie.budget，Python將會(huì)調(diào)用 Movie.budget.__get__(None, Movie)。可以看到，第一個(gè)參數(shù)要么是所有者的實(shí)例，要么是None。這些輸入?yún)?shù)可能看起來(lái)很怪，但是這里它們告訴了你描述符屬于哪個(gè)對(duì)象的一部 分。當(dāng)我們看到NonNegative類(lèi)的實(shí)現(xiàn)時(shí)這一切就合情合理了。

對(duì)描述符賦值

當(dāng)解釋器看到m.rating = 100時(shí)，Python識(shí)別出rating是一個(gè)帶有__set__方法的描述符，于是就調(diào)用Movie.rating.__set__(m, 100)。和__get__一樣，__set__的第一個(gè)參數(shù)是點(diǎn)號(hào)左邊的類(lèi)實(shí)例（m.rating = 100中的m）。第二個(gè)參數(shù)是所賦的值（100）。

刪除描述符

為了說(shuō)明的完整，這里提一下刪除。如果你調(diào)用del m.budget，Python就會(huì)調(diào)用Movie.budget.__delete__(m)。

NonNegative類(lèi)是如何工作的？

帶著前面的困惑，我們終于要揭示NonNegative類(lèi)是如何工作的了。每個(gè)NonNegative的實(shí)例都維護(hù)著一個(gè)字典，其中保存著所有者實(shí) 例和對(duì)應(yīng)數(shù)據(jù)的映射關(guān)系。當(dāng)我們調(diào)用m.budget時(shí)，__get__方法會(huì)查找與m相關(guān)聯(lián)的數(shù)據(jù)，并返回這個(gè)結(jié)果（如果這個(gè)值不存在，則會(huì)返回一個(gè)默 認(rèn)值）。__set__采用的方式相同，但是這里會(huì)包含額外的非負(fù)檢查。我們使用WeakKeyDictionary來(lái)取代普通的字典以防止內(nèi)存泄露—— 我們可不想僅僅因?yàn)樗诿枋龇淖值渲芯妥屢粋€(gè)無(wú)用?的實(shí)例一直存活著。

使用描述符會(huì)有一點(diǎn)別扭。因?yàn)樗鼈冏饔糜陬?lèi)的層次上，每一個(gè)類(lèi)實(shí)例都共享同一個(gè)描述符。這就意味著對(duì)不同的實(shí)例對(duì)象而言，描述符不得不手動(dòng)地管理?不同的狀態(tài)，同時(shí)需要顯式的將類(lèi)實(shí)例作為第一個(gè)參數(shù)準(zhǔn)確傳遞給__get__、__set__以及__delete__方法。

我希望這個(gè)例子解釋清楚了描述符可以用來(lái)做什么——它們提供了一種方法將property的邏輯隔離到單獨(dú)的類(lèi)中來(lái)處理。如果你發(fā)現(xiàn)自己正在不同的property之間重復(fù)著相同的邏輯，那么本文也許會(huì)成為一個(gè)線索供你思考為何用描述符重構(gòu)代碼是值得一試的。

秘訣和陷阱

把描述符放在類(lèi)的層次上（class level）

為了讓描述符能夠正常工作，它們必須定義在類(lèi)的層次上。如果你不這么做，那么Python無(wú)法自動(dòng)為你調(diào)用__get__和__set__方法。

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

可以看到，訪問(wèn)類(lèi)層次上的描述符y可以自動(dòng)調(diào)用__get__。但是訪問(wèn)實(shí)例層次上的描述符x只會(huì)返回描述符本身，真是魔法一般的存在啊。

確保實(shí)例的數(shù)據(jù)只屬于實(shí)例本身?

你可能會(huì)像這樣編寫(xiě)NonNegative描述符：

class BrokenNonNegative(object):def __init__(self, default):self.value = defaultdef __get__(self, instance, owner):return self.valuedef __set__(self, instance, value):if value < 0:raise ValueError("Negative value not allowed: %s" % value)self.value = valueclass Foo(object):bar = BrokenNonNegative(5)f = Foo() try:f.bar = -1 except ValueError:print "Caught the invalid assignment"Caught the invalid assignment

這么做看起來(lái)似乎能正常工作。但這里的問(wèn)題就在于所有Foo的實(shí)例都共享相同的bar，這會(huì)產(chǎn)生一些令人痛苦的結(jié)果：

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中使用數(shù)據(jù)字典的原因。__get__和__set__的第一個(gè)參數(shù)告訴我們需要關(guān)心哪一個(gè)實(shí)例。NonNegative使用這個(gè)參數(shù)作為字典的key，為每一個(gè)Foo實(shí)例單獨(dú)保存一份數(shù)據(jù)。

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

這就是描述符最令人感到別扭的地方（坦白的說(shuō)，我不理解為什么Python不讓你在實(shí)例的層次上定義描述符，并且總是需要將實(shí)際的處理分發(fā)給__get__和__set__。這么做行不通一定是有原因的）

注意不可哈希的描述符所有者

NonNegative類(lèi)使用了一個(gè)字典來(lái)單獨(dú)保存專(zhuān)屬于實(shí)例的數(shù)據(jù)。這個(gè)一般來(lái)說(shuō)是沒(méi)問(wèn)題的，除非你用到了不可哈希（unhashable）的對(duì)象：

class MoProblems(list): #you can't use lists as dictionary keysx = NonNegative(5)m = MoProblems() print m.x # womp womp--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-8-dd73b177bd8d> in <module>()34 m = MoProblems() ----> 5 print m.x # womp womp<ipython-input-3-6671804ce5d5> in __get__(self, instance, owner)9 # instance = x10 # owner = type(x) ---> 11 return self.data.get(instance, self.default)1213 def __set__(self, instance, value):TypeError: unhashable type: 'MoProblems'

因?yàn)镸oProblems的實(shí)例（list的子類(lèi)）是不可哈希的，因此它們不能為MoProblems.x用做數(shù)據(jù)字典的key。有一些方法可以規(guī)避這個(gè)問(wèn)題，但是都不完美。最好的方法可能就是給你的描述符加標(biāo)簽了。

class Descriptor(object):def __init__(self, label):self.label = labeldef __get__(self, instance, owner):print '__get__', instance, ownerreturn instance.__dict__.get(self.label)def __set__(self, instance, value):print '__set__'instance.__dict__[self.label] = valueclass 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中的每個(gè)描述符加上一個(gè)標(biāo)簽名，名稱(chēng)和我們賦值給描述符的變量名相同，比如x = Descriptor(‘x’)。之后，描述符將特定于實(shí)例的數(shù)據(jù)保存在f.__dict__['x']中。這個(gè)字典條目通常是當(dāng)我們請(qǐng)求f.x時(shí) Python給出的返回值。然而，由于Foo.x 是一個(gè)描述符，Python不能正常的使用f.__dict__[‘x’]，但是描述符可以安全的在這里存儲(chǔ)數(shù)據(jù)。只是要記住，不要在別的地方也給這個(gè)描 述符添加標(biāo)簽。

class Foo(object):x = Descriptor('y')f = Foo() f.x = 5 print f.xf.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

我不喜歡這種方式，因?yàn)檫@樣的代碼很脆弱也有很多微妙之處。但這個(gè)方法的確很普遍，可以用在不可哈希的所有者類(lèi)上。David Beazley在他的書(shū)中用到了這個(gè)方法。

在元類(lèi)中使用帶標(biāo)簽的描述符

由于描述符的標(biāo)簽名和賦給它的變量名相同，所以有人使用元類(lèi)來(lái)自動(dòng)處理這個(gè)簿記（bookkeeping）任務(wù)。

class Descriptor(object):def __init__(self):#notice we aren't setting the label hereself.label = Nonedef __get__(self, instance, owner):print '__get__. Label = %s' % self.labelreturn instance.__dict__.get(self.label, None)def __set__(self, instance, value):print '__set__'instance.__dict__[self.label] = valueclass DescriptorOwner(type):def __new__(cls, name, bases, attrs):# find all descriptors, auto-set their labelsfor n, v in attrs.items():if isinstance(v, Descriptor):v.label = nreturn super(DescriptorOwner, cls).__new__(cls, name, bases, attrs)class Foo(object):__metaclass__ = DescriptorOwnerx = Descriptor()f = Foo() f.x = 10 print f.x__set__ __get__. Label = x 10

我不會(huì)去解釋有關(guān)元類(lèi)的細(xì)節(jié)——參考文獻(xiàn)中David Beazley已經(jīng)在他的文章中解釋的很清楚了。?需要指出的是元類(lèi)自動(dòng)的為描述符添加標(biāo)簽，并且和賦給描述符的變量名字相匹配。

盡管這樣解決了描述符的標(biāo)簽和變量名不一致的問(wèn)題，但是卻引入了復(fù)雜的元類(lèi)。雖然我很懷疑，但是你可以自行判斷這么做是否值得。

訪問(wèn)描述符的方法

描述符僅僅是類(lèi)，也許你想要為它們?cè)黾右恍┓椒āＥe個(gè)例子，描述符是一個(gè)用來(lái)回調(diào)property的很好的手段。比如我們想要一個(gè)類(lèi)的某個(gè)部分的狀態(tài)發(fā)生變化時(shí)就立刻通知我們。下面的大部分代碼是用來(lái)做這個(gè)的：

class CallbackProperty(object):"""A property that will alert observers when upon updates"""def __init__(self, default=None):self.data = WeakKeyDictionary()self.default = defaultself.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] = valuedef 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)

這是一個(gè)很有吸引力的模式——我們可以自定義回調(diào)函數(shù)用來(lái)響應(yīng)一個(gè)類(lèi)中的狀態(tài)變化，而且完全無(wú)需修改這個(gè)類(lèi)的代碼。這樣做可真是替人分憂解難呀。現(xiàn)在，我 們所要做的就是調(diào)用ba.balance.add_callback(ba, low_balance_warning)，以使得每次balance變化時(shí)low_balance_warning都會(huì)被調(diào)用。

但是我們是如何做到的呢？當(dāng)我們?cè)噲D訪問(wèn)它們時(shí)，描述符總是會(huì)調(diào)用__get__。就好像add_callback方法是無(wú)法觸及的一樣！其實(shí)關(guān)鍵在于利用了一種特殊的情況，即，當(dāng)從類(lèi)的層次訪問(wèn)時(shí)，__get__方法的第一個(gè)參數(shù)是None。

class CallbackProperty(object):"""A property that will alert observers when upon updates"""def __init__(self, default=None):self.data = WeakKeyDictionary()self.default = defaultself.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] = valuedef 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

?

轉(zhuǎn)載于:https://www.cnblogs.com/JohnABC/p/5685672.html

總結(jié)

以上是生活随笔為你收集整理的Python-描述符的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。