本文转载自:http://python.jobbole.com/85176/
Python 黑魔法—描述器（descriptor）
Python黑魔法，前面已经介绍了两个魔法，装饰器和迭代器，通常还有个生成器。生成器固然也是一个很优雅的魔法。生成器更像是函数的行为。而连接类行为和函数行为的时候，还有一个描述器魔法，也称之为描述符。
我们不止一次说过，Python的优雅，很大程度在于如何设计成优雅的API。黑魔法则是一大利器。或者说Python的优雅很大程度上是建立在这些魔法巧技基础上。
何谓描述器
当定义迭代器的时候，描述是实现迭代协议的对象，即实现__iter__方法的对象。同理，所谓描述器，即实现了描述符协议，即__get__, __set__, 和 __delete__方法的对象。
单看定义，还是比较抽象的。talk is cheap。看代码吧：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
class WebFramework(object): def __init__(self, name='Flask'): self.name = name
def __get__(self, instance, owner): return self.name
def __set__(self, instance, value): self.name = value
class PythonSite(object):
webframework = WebFramework()
In [1]: PythonSite.webframework Out[1]: 'Flask'
In [2]: PythonSite.webframework = 'Tornado'
In [3]: PythonSite.webframework Out[3]: 'Tornado' |
定义了一个类WebFramework，它实现了描述符协议__get__和__set__，该对象（类也是对象，一切都是对象）即成为了一个描述器。同时实现__get__和__set__的称之为资料描述器（data descriptor）。仅仅实现__get__的则为非描述器。两者的差别是相对于实例的字典的优先级。
如果实例字典中有与描述器同名的属性，如果描述器是资料描述器，优先使用资料描述器，如果是非资料描述器，优先使用字典中的属性。
描述器的调用
对于这类魔法，其调用方法往往不是直接使用的。例如装饰器需要用 @ 符号调用。迭代器通常在迭代过程，或者使用 next 方法调用。描述器则比较简单，对象属性的时候会调用。
| 1 2 3 4 |
In [15]: webframework = WebFramework()
In [16]: webframework.__get__(webframework, WebFramework) Out[16]: 'Flask' |
描述器与对象属性
OOP的理论中，类的成员变量包括属性和方法。那么在Python里什么是属性？修改上面的PythonSite类如下：
| 1 2 3 4 5 6 7 8 |
class PythonSite(object):
webframework = WebFramework()
version = 0.01
def __init__(self, site): self.site = site |
这里增加了一个version的类属性，以及一个实例属性site。分别查看一下类和实例对象的属性：
XHTML
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
In [1]: pysite = PythonSite('ghost')
In [2]: vars(PythonSite).items() Out[2]: [('__module__', '__main__'), ('version', 0.01), ('__dict__', <attribute '__dict__' of 'PythonSite' objects>), ('webframework', <__main__.WebFramework at 0x10d55be90>), ('__weakref__', <attribute '__weakref__' of 'PythonSite' objects>), ('__doc__', None), ('__init__', <function __main__.__init__>)]
In [3]: vars(pysite) Out[3]: {'site': 'ghost'} In [4]: PythonSite.__dict__ Out[4]: <dictproxy {'__dict__': <attribute '__dict__' of 'PythonSite' objects>, '__doc__': None, '__init__': <function __main__.__init__>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'PythonSite' objects>, 'version': 0.01, 'webframework': <__main__.WebFramework at 0x10d55be90>}> |
vars方法用于查看对象的属性，等价于对象的__dict__内容。从上面的显示结果，可以看到类PythonSite和实例pysite的属性差别在于前者有 webframework，version两个属性，以及 __init__方法，后者仅有一个site属性。
类与实例的属性
类属性可以使用对象和类访问，多个实例对象共享一个类变量。但是只有类才能修改。
| 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 |
In [6]: pysite1 = PythonSite('ghost')
In [7]: pysite2 = PythonSite('admin')
In [8]: PythonSite.version Out[8]: 0.01
In [9]: pysite1.version Out[9]: 0.01
In [10]: pysite2.version Out[10]: 0.01
In [11]: pysite1.version is pysite2.version Out[11]: True
In [12]: pysite1.version = 'pysite1'
In [13]: vars(pysite1) Out[13]: {'site': 'ghost', 'version': 'pysite1'}
In [14]: vars(pysite2) Out[14]: {'site': 'admin'}
In [15]: PythonSite.version = 0.02
In [16]: pysite1.version Out[16]: 'pysite1'
In [17]: pysite2.version Out[17]: 0.02 |
正如上面的代码显示，两个实例对象都可以访问version类属性，并且是同一个类属性。当pysite1修改了version，实际上是给自己添加了一个version属性。类属性并没有被改变。当PythonSite改变了version属性的时候，pysite2的该属性也对应被改变。
属性访问的原理与描述器
知道了属性访问的结果。这个结果都是基于Python的描述器实现的。通常，类或者实例通过.操作符访问属性。例如pysite1.site和pysite1.version的访问。先访问对象的__dict__，如果没有再访问类（或父类，元类除外）的__dict__。如果最后这个__dict__的对象是一个描述器，则会调用描述器的__get__方法。
XHTML
| 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 |
In [21]: pysite1.site Out[21]: 'ghost'
In [22]: pysite1.__dict__['site'] Out[22]: 'ghost'
In [23]: pysite2.version Out[23]: 0.02
In [24]: pysite2.__dict__['version'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-24-73ef6aeba259> in <module>() ----> 1 pysite2.__dict__['version']
KeyError: 'version'
In [25]: type(pysite2).__dict__['version'] Out[25]: 0.02
In [32]: type(pysite1).__dict__['webframework'] Out[32]: <__main__.WebFramework at 0x103426e90>
In [38]: type(pysite1).__dict__['webframework'].__get__(None, PythonSite) Out[38]: 'Flask' |
实例方法，类方法，静态方法与描述器
调用描述器的时候，实际上会调用object.__getattribute__()。这取决于调用描述其器的是对象还是类，如果是对象obj.x，则会调用type(obj).__dict__['x'].__get__(obj, type(obj))。如果是类，class.x， 则会调用type(class).__dict__['x'].__get__(None, type(class)。
这样说还是比较抽象，下面来分析Python的方法，静态方法和类方法。把PythonSite重构一下：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
class PythonSite(object): webframework = WebFramework()
version = 0.01
def __init__(self, site): self.site = site
def get_site(self): return self.site
@classmethod def get_version(cls): return cls.version
@staticmethod def find_version(): return PythonSite.version |
类方法，@classmethod装饰器
先看类方法，类方法使用@classmethod装饰器定义。经过该装饰器的方法是一个描述器。类和实例都可以调用类方法：
XHTML
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
In [1]: ps = PythonSite('ghost')
In [2]: ps.get_version Out[2]: <bound method type.get_version of <class '__main__.PythonSite'>>
In [3]: ps.get_version() Out[3]: 0.01
In [4]: PythonSite.get_version Out[4]: <bound method type.get_version of <class '__main__.PythonSite'>>
In [5]: PythonSite.get_version() Out[5]: 0.01 |
get_version 是一个bound方法。下面再看下ps.get_version这个调用，会先查找它·的__dict__是否有get_version这个属性，如果没有，则查找其类。
XHTML
| 1 2 3 4 5 6 7 8 9 10 11 |
In [6]: vars(ps) Out[6]: {'site': 'ghost'}
In [7]: type(ps).__dict__['get_version'] Out[7]: <classmethod at 0x108952e18>
In [8]: type(ps).__dict__['get_version'].__get__(ps, type(ps)) Out[8]: <bound method type.get_version of <class '__main__.PythonSite'>>
In [9]: type(ps).__dict__['get_version'].__get__(ps, type(ps)) == ps.get_version Out[9]: True |
并且vars(ps)中，__dict__并没有get_version这个属性，依据描述器协议，将会调用type(ps).__dict__['get_version']描述器的__get__方法，因为ps是实例，因此object.__getattribute__()会这样调用__get__(obj, type(obj))。
现在再看类方法的调用:
XHTML
| 1 2 3 4 5 6 7 8 |
In [10]: PythonSite.__dict__['get_version'] Out[10]: <classmethod at 0x108952e18>
In [11]: PythonSite.__dict__['get_version'].__get__(None, PythonSite) Out[11]: <bound method type.get_version of <class '__main__.PythonSite'>>
In [12]: PythonSite.__dict__['get_version'].__get__(None, PythonSite) == PythonSite.get_version Out[12]: True |
因为这次调用get_version的是一个类对象，而不是实例对象，因此object.__getattribute__()会这样调用__get__(None, Class)。
静态方法，@staticmethod
实例和类也可以调用静态方法：
XHTML
| 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 |
In [13]: ps.find_version Out[13]: <function __main__.find_version>
In [14]: ps.find_version() Out[14]: 0.01
In [15]: vars(ps) Out[15]: {'site': 'ghost'}
In [16]: type(ps).__dict__['find_version'] Out[16]: <staticmethod at 0x108952d70>
In [17]: type(ps).__dict__['find_version'].__get__(ps, type(ps)) Out[17]: <function __main__.find_version>
In [18]: type(ps).__dict__['find_version'].__get__(ps, type(ps)) == ps.find_version Out[18]: True
In [19]: PythonSite.find_version() Out[19]: 0.01
In [20]: PythonSite.find_version Out[20]: <function __main__.find_version>
In [21]: type(ps).__dict__['find_version'].__get__(None, type(ps)) Out[21]: <function __main__.find_version>
In [22]: type(ps).__dict__['find_version'].__get__(None, type(ps)) == PythonSite.find_version Out[22]: True |
和类方法差别不大，他们的主要差别是在类方法内部的时候，类方法可以有cls的类引用，静态访问则没有，如果静态方法想使用类变量，只能硬编码类名。
实例方法
实例方法最为复杂，是专门属于实例的，使用类调用的时候，会是一个unbound方法。
XHTML
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
In [2]: ps.get_site Out[2]: <bound method PythonSite.get_site of <__main__.PythonSite object at 0x1054ae2d0>>
In [3]: ps.get_site() Out[3]: 'ghost'
In [4]: type(ps).__dict__['get_site'] Out[4]: <function __main__.get_site>
In [5]: type(ps).__dict__['get_site'].__get__(ps, type(ps)) Out[5]: <bound method PythonSite.get_site of <__main__.PythonSite object at 0x1054ae2d0>>
In [6]: type(ps).__dict__['get_site'].__get__(ps, type(ps)) == ps.get_site Out[6]: True |
一切工作正常，实例方法也是类的一个属性，但是对于类，描述器使其变成了unbound方法：
XHTML
| 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 |
In [7]: PythonSite.get_site Out[7]: <unbound method PythonSite.get_site>
In [8]: PythonSite.get_site() --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-8-99c7d7607137> in <module>() ----> 1 PythonSite.get_site()
TypeError: unbound method get_site() must be called with PythonSite instance as first argument (got nothing instead)
In [9]: PythonSite.get_site(ps) Out[9]: 'ghost'
In [10]: PythonSite.__dict__['get_site'] Out[10]: <function __main__.get_site>
In [11]: PythonSite.__dict__['get_site'].__get__(None, PythonSite) Out[11]: <unbound method PythonSite.get_site>
In [12]: PythonSite.__dict__['get_site'].__get__(None, PythonSite) == PythonSite.get_site Out[12]: True
In [14]: PythonSite.__dict__['get_site'].__get__(ps, PythonSite) Out[14]: <bound method PythonSite.get_site of <__main__.PythonSite object at 0x1054ae2d0>>
In [15]: PythonSite.__dict__['get_site'].__get__(ps, PythonSite)() Out[15]: 'ghost' |
由此可见，类不能直接调用实例方法，除非在描述器手动绑定一个类实例。因为使用类对象调用描述器的时候，__get__的第一个参数是None，想要成功调用，需要把这个参数替换为实例ps，这个过程就是对方法的bound过程。
描述器的应用
描述器的作用主要在方法和属性的定义上。既然我们可以重新描述类的属性，那么这个魔法就可以改变类的一些行为。最简单的应用则是可以配合装饰器，写一个类属性的缓存。Flask的作者写了一个werkzeug网络工具库，里面就使用描述器的特性，实现了一个缓存器。
| 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 |
class _Missing(object): def __repr__(self): return 'no value'
def __reduce__(self): return '_missing'
_missing = _Missing()
class cached_property(object): def __init__(self, func, name=None, doc=None): self.__name__ = name or func.__name__ self.__module__ = func.__module__ self.__doc__ = doc or func.__doc__ self.func = func
def __get__(self, obj, type=None): if obj is None: return self value = obj.__dict__.get(self.__name__, _missing) if value is _missing: value = self.func(obj) obj.__dict__[self.__name__] = value return value
class Foo(object): @cached_property def foo(self): print 'first calculate' result = 'this is result' return result
f = Foo()
print f.foo # first calculate this is result print f.foo # this is result |
运行结果可见，first calculate只在第一次调用时候被计算之后就把结果缓存起来了。这样的好处是在网络编程中，对HTTP协议的解析，通常会把HTTP的header解析成python的一个字典，而在视图函数的时候，可能不知一次的访问这个header，因此把这个header使用描述器缓存起来，可以减少多余的解析。
描述器在python的应用十分广泛，通常是配合装饰器一起使用。强大的魔法来自强大的责任。描述器还可以用来实现ORM中对sql语句的”预编译”。恰当的使用描述器，可以让自己的Python代码更优雅。