(转)Python描述符（descriptor）解密

2014-03-28

声明：
本文转载自极客范，原文链接：http://www.geekfan.net/7862/，转载请注明。

Python中包含了许多内建的语言特性，它们使得代码简洁且易于理解。这些特性包括列表/集合/字典推导式，属性（property）、以及装饰器（decorator）。对于大部分特性来说，这些“中级”的语言特性有着完善的文档，并且易于学习。

但是这里有个例外，那就是描述符。至少对于我来说，描述符是Python语言核心中困扰我时间最长的一个特性。这里有几点原因如下：

• 有关描述符的官方文档相当难懂，而且没有包含优秀的示例告诉你为什么需要编写描述符（我得为Raymond Hettinger辩护一下，他写的其他主题的Python文章和视频对我的帮助还是非常大的）
• 编写描述符的语法显得有些怪异
• 自定义描述符可能是Python中用的最少的特性，因此你很难在开源项目中找到优秀的示例

但是一旦你理解了之后，描述符的确还是有它的应用价值的。这篇文章告诉你描述符可以用来做什么，以及为什么应该引起你的注意。

一句话概括：描述符就是可重用的属性

在这里我要告诉你：从根本上讲，描述符就是可以重复使用的属性。也就是说，描述符可以让你编写这样的代码：

1. f = Foo()
2. b = f.bar
3. f.bar = c
4. del f.bar

而在解释器执行上述代码时，当发现你试图访问属性（b = f.bar）、对属性赋值（f.bar = c）或者删除一个实例变量的属性（del f.bar）时，就会去调用自定义的方法。

让我们先来解释一下为什么把对函数的调用伪装成对属性的访问是大有好处的。

property——把函数调用伪装成对属性的访问

想象一下你正在编写管理电影信息的代码。你最后写好的Movie类可能看上去是这样的：

1. class Movie(object):
2. def __init__(self, title, rating, runtime, budget, gross):
3. self.title = title
4. self.rating = rating
5. self.runtime = runtime
6. self.budget = budget
7. self.gross = gross
9. def profit(self):
10. return self.gross - self.budget

你开始在项目的其他地方使用这个类，但是之后你意识到：如果不小心给电影打了负分怎么办？你觉得这是错误的行为，希望Movie类可以阻止这个错误。 你首先想到的办法是将Movie类修改为这样：

1. class Movie(object):
2. def __init__(self, title, rating, runtime, budget, gross):
3. self.title = title
4. self.rating = rating
5. self.runtime = runtime
6. self.gross = gross
7. if budget < 0:
8. raise ValueError("Negative value not allowed: %s" % budget)
9. self.budget = budget
11. def profit(self):
12. return self.gross - self.budget

但这行不通。因为其他部分的代码都是直接通过Movie.budget来赋值的——这个新修改的类只会在__init__方法中捕获错误的数据，但对于已经存在的类实例就无能为力了。如果有人试着运行m.budget = -100，那么谁也没法阻止。作为一个Python程序员同时也是电影迷，你该怎么办？

幸运的是，Python的property解决了这个问题。如果你从未见过property的用法，下面是一个示例：

1. class Movie(object):
2. def __init__(self, title, rating, runtime, budget, gross):
3. self._budget = None
5. self.title = title
6. self.rating = rating
7. self.runtime = runtime
8. self.gross = gross
9. self.budget = budget
11. @property
12. def budget(self):
13. return self._budget
15. @budget.setter
16. def budget(self, value):
17. if value < 0:
18. raise ValueError("Negative value not allowed: %s" % value)
19. self._budget = value
21. def profit(self):
22. return self.gross - self.budget
24. m = Movie('Casablanca', 97, 102, 964000, 1300000)
25. print m.budget # calls m.budget(), returns result
26. try:
27. m.budget = -100 # calls budget.setter(-100), and raises ValueError
28. except ValueError:
29. print "Woops. Not allowed"
31. 964000
32. 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. class Movie(object):
2. def __init__(self, title, rating, runtime, budget, gross):
3. self._rating = None
4. self._runtime = None
5. self._budget = None
6. self._gross = None
8. self.title = title
9. self.rating = rating
10. self.runtime = runtime
11. self.gross = gross
12. self.budget = budget
14. #nice
15. @property
16. def budget(self):
17. return self._budget
19. @budget.setter
20. def budget(self, value):
21. if value < 0:
22. raise ValueError("Negative value not allowed: %s" % value)
23. self._budget = value
25. #ok
26. @property
27. def rating(self):
28. return self._rating
30. @rating.setter
31. def rating(self, value):
32. if value < 0:
33. raise ValueError("Negative value not allowed: %s" % value)
34. self._rating = value
36. #uhh...
37. @property
38. def runtime(self):
39. return self._runtime
41. @runtime.setter
42. def runtime(self, value):
43. if value < 0:
44. raise ValueError("Negative value not allowed: %s" % value)
45. self._runtime = value
47. #is this forever?
48. @property
49. def gross(self):
50. return self._gross
52. @gross.setter
53. def gross(self, value):
54. if value < 0:
55. raise ValueError("Negative value not allowed: %s" % value)
56. self._gross = value
58. def profit(self):
59. return self.gross - self.budget

可以看到代码增加了不少，但重复的逻辑也出现了不少。虽然property可以让类从外部看起来接口整洁漂亮，但是却做不到内部同样整洁漂亮。

描述符登场（最终的大杀器）

这就是描述符所解决的问题。描述符是property的升级版，允许你为重复的property逻辑编写单独的类来处理。下面的示例展示了描述符是如何工作的（现在还不必担心NonNegative类的实现）：

1. from weakref import WeakKeyDictionary
3. class NonNegative(object):
4. """A descriptor that forbids negative values"""
5. def __init__(self, default):
6. self.default = default
7. self.data = WeakKeyDictionary()
9. def __get__(self, instance, owner):
10. # we get here when someone calls x.d, and d is a NonNegative instance
11. # instance = x
12. # owner = type(x)
13. return self.data.get(instance, self.default)
15. def __set__(self, instance, value):
16. # we get here when someone calls x.d = val, and d is a NonNegative instance
17. # instance = x
18. # value = val
19. if value < 0:
20. raise ValueError("Negative value not allowed: %s" % value)
21. self.data[instance] = value
23. class Movie(object):
25. #always put descriptors at the class-level
26. rating = NonNegative(0)
27. runtime = NonNegative(0)
28. budget = NonNegative(0)
29. gross = NonNegative(0)
31. def __init__(self, title, rating, runtime, budget, gross):
32. self.title = title
33. self.rating = rating
34. self.runtime = runtime
35. self.budget = budget
36. self.gross = gross
38. def profit(self):
39. return self.gross - self.budget
41. m = Movie('Casablanca', 97, 102, 964000, 1300000)
42. print m.budget # calls Movie.budget.__get__(m, Movie)
43. m.rating = 100 # calls Movie.budget.__set__(m, 100)
44. try:
45. m.rating = -1 # calls Movie.budget.__set__(m, -100)
46. except ValueError:
47. print "Woops, negative value"
49. 964000
50. 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. class Broken(object):
2. y = NonNegative(5)
3. def __init__(self):
4. self.x = NonNegative(0) # NOT a good descriptor
6. b = Broken()
7. print "X is %s, Y is %s" % (b.x, b.y)
9. X is <__main__.NonNegative object at 0x10432c250>, Y is 5

可以看到，访问类层次上的描述符y可以自动调用__get__。但是访问实例层次上的描述符x只会返回描述符本身，真是魔法一般的存在啊。

确保实例的数据只属于实例本身

你可能会像这样编写NonNegative描述符：

1. class BrokenNonNegative(object):
2. def __init__(self, default):
3. self.value = default
5. def __get__(self, instance, owner):
6. return self.value
8. def __set__(self, instance, value):
9. if value < 0:
10. raise ValueError("Negative value not allowed: %s" % value)
11. self.value = value
13. class Foo(object):
14. bar = BrokenNonNegative(5)
16. f = Foo()
17. try:
18. f.bar = -1
19. except ValueError:
20. print "Caught the invalid assignment"
22. Caught the invalid assignment

这么做看起来似乎能正常工作。但这里的问题就在于所有Foo的实例都共享相同的bar，这会产生一些令人痛苦的结果：

1. class Foo(object):
2. bar = BrokenNonNegative(5)
4. f = Foo()
5. g = Foo()
7. print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar)
8. print "Setting f.bar to 10"
9. f.bar = 10
10. print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) #ouch
11. f.bar is 5
12. g.bar is 5
13. Setting f.bar to 10
14. f.bar is 10
15. g.bar is 10

这就是为什么我们要在NonNegative中使用数据字典的原因。__get__和__set__的第一个参数告诉我们需要关心哪一个实例。NonNegative使用这个参数作为字典的key，为每一个Foo实例单独保存一份数据。

1. class Foo(object):
2. bar = NonNegative(5)
4. f = Foo()
5. g = Foo()
6. print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar)
7. print "Setting f.bar to 10"
8. f.bar = 10
9. print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) #better
10. f.bar is 5
11. g.bar is 5
12. Setting f.bar to 10
13. f.bar is 10
14. g.bar is 5

这就是描述符最令人感到别扭的地方（坦白的说，我不理解为什么Python不让你在实例的层次上定义描述符，并且总是需要将实际的处理分发给__get__和__set__。这么做行不通一定是有原因的）

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

NonNegative类使用了一个字典来单独保存专属于实例的数据。这个一般来说是没问题的，除非你用到了不可哈希（unhashable）的对象：

1. class MoProblems(list): #you can't use lists as dictionary keys
2. x = NonNegative(5)
4. m = MoProblems()
5. print m.x # womp womp
7. ---------------------------------------------------------------------------
8. TypeError Traceback (most recent call last)
9. <ipython-input-8-dd73b177bd8d> in <module>()
10. 3
11. 4 m = MoProblems()
12. ----> 5 print m.x # womp womp
14. <ipython-input-3-6671804ce5d5> in __get__(self, instance, owner)
15. 9 # instance = x
16. 10 # owner = type(x)
17. ---> 11 return self.data.get(instance, self.default)
18. 12
19. 13 def __set__(self, instance, value):
21. TypeError: unhashable type: 'MoProblems'

因为MoProblems的实例（list的子类）是不可哈希的，因此它们不能为MoProblems.x用做数据字典的key。有一些方法可以规避这个问题，但是都不完美。最好的方法可能就是给你的描述符加标签了。

1. class Descriptor(object):
3. def __init__(self, label):
4. self.label = label
6. def __get__(self, instance, owner):
7. print '__get__', instance, owner
8. return instance.__dict__.get(self.label)
10. def __set__(self, instance, value):
11. print '__set__'
12. instance.__dict__[self.label] = value
14. class Foo(list):
15. x = Descriptor('x')
16. y = Descriptor('y')
18. f = Foo()
19. f.x = 5
20. print f.x
22. __set__
23. __get__ [] <class '__main__.Foo'>
24. 5

这种方法依赖于Python的方法解析顺序（即，MRO）。我们给Foo中的每个描述符加上一个标签名，名称和我们赋值给描述符的变量名相同，比如x = Descriptor(‘x’)。之后，描述符将特定于实例的数据保存在f.__dict__[‘x’]中。这个字典条目通常是当我们请求f.x时Python给出的返回值。然而，由于Foo.x 是一个描述符，Python不能正常的使用f.__dict__[‘x’]，但是描述符可以安全的在这里存储数据。只是要记住，不要在别的地方也给这个描述符添加标签。

1. class Foo(object):
2. x = Descriptor('y')
4. f = Foo()
5. f.x = 5
6. print f.x
8. f.y = 4 #oh no!
9. print f.x
10. __set__
11. __get__ <__main__.Foo object at 0x10432c810> <class '__main__.Foo'>
12. 5
13. __get__ <__main__.Foo object at 0x10432c810> <class '__main__.Foo'>
14. 4

我不喜欢这种方式，因为这样的代码很脆弱也有很多微妙之处。但这个方法的确很普遍，可以用在不可哈希的所有者类上。David Beazley在他的书中用到了这个方法。

在元类中使用带标签的描述符

由于描述符的标签名和赋给它的变量名相同，所以有人使用元类来自动处理这个簿记（bookkeeping）任务。

1. class Descriptor(object):
2. def __init__(self):
3. #notice we aren't setting the label here
4. self.label = None
6. def __get__(self, instance, owner):
7. print '__get__. Label = %s' % self.label
8. return instance.__dict__.get(self.label, None)
10. def __set__(self, instance, value):
11. print '__set__'
12. instance.__dict__[self.label] = value
14. class DescriptorOwner(type):
15. def __new__(cls, name, bases, attrs):
16. # find all descriptors, auto-set their labels
17. for n, v in attrs.items():
18. if isinstance(v, Descriptor):
19. v.label = n
20. return super(DescriptorOwner, cls).__new__(cls, name, bases, attrs)
22. class Foo(object):
23. __metaclass__ = DescriptorOwner
24. x = Descriptor()
26. f = Foo()
27. f.x = 10
28. print f.x
30. __set__
31. __get__. Label = x
32. 10

我不会去解释有关元类的细节——参考文献中David Beazley已经在他的文章中解释的很清楚了。 需要指出的是元类自动的为描述符添加标签，并且和赋给描述符的变量名字相匹配。

尽管这样解决了描述符的标签和变量名不一致的问题，但是却引入了复杂的元类。虽然我很怀疑，但是你可以自行判断这么做是否值得。

访问描述符的方法

描述符仅仅是类，也许你想要为它们增加一些方法。举个例子，描述符是一个用来回调property的很好的手段。比如我们想要一个类的某个部分的状态发生变化时就立刻通知我们。下面的大部分代码是用来做这个的：

1. class CallbackProperty(object):
2. """A property that will alert observers when upon updates"""
3. def __init__(self, default=None):
4. self.data = WeakKeyDictionary()
5. self.default = default
6. self.callbacks = WeakKeyDictionary()
8. def __get__(self, instance, owner):
9. return self.data.get(instance, self.default)
11. def __set__(self, instance, value):
12. for callback in self.callbacks.get(instance, []):
13. # alert callback function of new value
14. callback(value)
15. self.data[instance] = value
17. def add_callback(self, instance, callback):
18. """Add a new function to call everytime the descriptor updates"""
19. #but how do we get here?!?!
20. if instance not in self.callbacks:
21. self.callbacks[instance] = []
22. self.callbacks[instance].append(callback)
24. class BankAccount(object):
25. balance = CallbackProperty(0)
27. def low_balance_warning(value):
28. if value < 100:
29. print "You are poor"
31. ba = BankAccount()
33. # will not work -- try it
34. #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. class CallbackProperty(object):
2. """A property that will alert observers when upon updates"""
3. def __init__(self, default=None):
4. self.data = WeakKeyDictionary()
5. self.default = default
6. self.callbacks = WeakKeyDictionary()
8. def __get__(self, instance, owner):
9. if instance is None:
10. return self
11. return self.data.get(instance, self.default)
13. def __set__(self, instance, value):
14. for callback in self.callbacks.get(instance, []):
15. # alert callback function of new value
16. callback(value)
17. self.data[instance] = value
19. def add_callback(self, instance, callback):
20. """Add a new function to call everytime the descriptor within instance updates"""
21. if instance not in self.callbacks:
22. self.callbacks[instance] = []
23. self.callbacks[instance].append(callback)
25. class BankAccount(object):
26. balance = CallbackProperty(0)
28. def low_balance_warning(value):
29. if value < 100:
30. print "You are now poor"
32. ba = BankAccount()
33. BankAccount.balance.add_callback(ba, low_balance_warning)
35. ba.balance = 5000
36. print "Balance is %s" % ba.balance
37. ba.balance = 99
38. print "Balance is %s" % ba.balance
39. Balance is 5000
40. You are now poor
41. Balance is 99

结语

希望你现在对描述符是什么和它们的适用场景有了一个认识。前进吧骚年！