Python中的Descriptor描述符学习教程
Descriptor是什么？简而言之，Descriptor是用来定制访问类或实例的成员的一种协议。额。。好吧，一句话是说不清楚的。下面先介绍一下Python中成员变量的定义和使用。
我们知道，在Python中定义类成员和C/C++相比得到的结果具有很大的差别。如下面的定义：
classCclass
{
intI;
voidfunc();
};
Cclassc;
在上面的定义中，C++定义了一个类型，所有该类型的对象都包含有一个成员整数i和函数func；而Python则创建了一个名为Pclass、类型（__class__）为type（详情请参见MetaClass，Python中一切皆为对象，类型也不例外）的对象，然后再创建一个名为p、类型为Pclass的对象。如下所示：
In[71]:type(pclass) Out[71]:<type'type'> In[72]:p=pclass() In[73]:type(p) Out[73]:<class'__main__.pclass'>
p和Pclass各自包含了一些成员，如下所示：
1p.__class__p.__init__p.__sizeof__
2p.__delattr__p.__module__p.__str__
3p.__dict__p.__new__p.__subclasshook__
4p.__doc__p.__reduce__p.__weakref__
5p.__format__p.__reduce_ex__p.f
6p.__getattribute__p.__repr__p.i
7p.__hash__p.__setattr__
其中，带有双下划线的成员为特殊成员，或者可以称之为固定成员（和__slots__定义的成员类似），这些成员变量的值可以被改变，但不能被删除（del）。其中，__class__变量为对象所属的类型，__doc__为对象的文档字符串。有一个特殊成员值得注意：__dict__,该字典中保存了对象的自定义变量。相信大家在初学Python对于其中对象可以任意增加删除成员变量的能力感到惊讶，其实这个功能的玄机就在于__dict__成员中（注意type的__dict__为dictproxy类型）：
In[10]:p.x=2
In[11]:p.__dict__
Out[11]:{'x':2}
通过上面的演示可以很清楚地看出：Python将对象的自定义成员以键值对的形式保存到__dict__字典中，而前面提到的类型定义只是这种情况的语法糖而已，即上面的类型定义等价于以下形式的定义：
ClassPclass(object):pass Pclass.i=1 Pclass.f=lambdax:x
访问成员变量时，Python也是从__dict__字典中取出变量名对应的值，如下形式的两种访问形式是等价的——在Descriptor被引入之前：
p.i p.__dict__['i']
Descriptor的引入即将改变上面的规则，且看下文分解。
定义：DescriptorProtocol
Descriptor如何改变对象成员的访问规则呢？根据计算机理论中“绝大多数软件问题都可以用增加一个中间层的方式解决”这一名言，我们需要为对象访问提供一个中间层，而非直接访问所需的对象。实现这一中间层的方式是定义Descriptor协议。Descriptor的定义很简单，如果一个类包含以下三个方法（之一），则可以称之为一个Descriptor：
1.object.__get__(self,instance,owner)
成员被访问时调用，instance为成员所属的对象、owner为instance所属的类型
2.object.__set__(self,instance,value)
成员被赋值时调用
3.0object.__delete__(self,instance)
成员被删除时调用
如果我们需要改变一个对象在其它对象中的访问规则，需要将其定义成Descriptor，之后在对该成员进行访问时将调用该Descriptor的相应函数。下面是一个使用Descriptor改变访问规则的例子：
classMyDescriptor(object):
def__init__(self,x):
self.x=x
def__get__(self,instance,owner):
print'getfromdescriptor'
returnself.x
def__set__(self,instance,value):
print'setfromdescriptor'
self.x=value
def__delete__(self,instance)
print'delfromdescriptor,thevalis',self.x
classC(object):
d=MyDescriptor('hello'）
>>C.d
getfromdescriptor
>>c=C()
>>c.d
getfromdescriptor
>>c.d=1
setfromdescriptor
>>delc.d
delfromdescriptor,thevalis1
从例子中可以看出：当我们对对象成员进行引用（Reference）、赋值（Assign）和删除（Dereference）操作时，如果对象成员为一个Descriptor，则这些操作将执行该Descriptor对象的相应成员函数。以上约定即为Descriptor协议。
obj.name背后的魔法
引入了Descriptor之后，Python对于对象成员访问的规则是怎样的呢？在回答这一问题之前，需要对Descriptor进行简单的划分：
Overriding或Data：对象同时提供了__get__和__set__方法
Nonoverriding或Non-Data：对象仅提供了__get__方法
(__del__方法表示自己被忽略了，很伤心～）
下面是从一个类对象中访问其成员（如C.name）的规则：
如果“name”在C.__dict__能找到，C.name将访问C.__dict__['name']，假设为v。如果v是一个Descriptor，则返回type(v).__get__(v,None,C)，否则直接返回v；
如果“name”不在C.__dict__中，则向上查找C的父类，根据MRO（MethodResolutionOrder）对C的父类重复第一步；
还是没有找到“name”，抛出AttributeError异常。
从一个类实例对象中访问其成员（如x.name，type(x)为C）要稍微复杂一些：
如果“name”能在C（或C的父类）中找到，且其值v为一个OverridingDescriptor，则返回type(v).__get__(v,x,C)的值；
否则，如果“name”能在x.__dict__中找到，则返回x.__dict__['name']的值；
如果“name”仍未找到，则执行类对象成员的查找规则；
如果C定义了__getattr__函数，则调用该函数；否则抛出AttributeError异常。
成员赋值的查找规则与访问规则类似，但还是有一点区别：对类成员执行赋值操作时将直接设置C.__dict__中的值，而不会调用Descriptor的__set__函数。
以上面的代码为例，当访问C.d时，Python将在C.__dict__中找到d，并且发现d是一个Descriptor，因此将调用d.__get__(None,C)；当访问c.d时，Python首先查找C，并且在其中发现d的定义，且d为一个OverridingDescriptor，因此执行d.__get__(c,C)。
前面介绍了Descriptor的一些细节，那么Descriptor的作用是什么呢？在Python中，Descriptor主要用来实现一些Python本身的功能，如类方法调用、staticmethod和Property等。下面将对这些使用Descriptor进行类方法调用的实现进行介绍。
Bound&UnboundMethod
在python中，函数是第一级的对象，即其本质与其它对象相同，差别在于函数对象是callable对象，即对于函数对象f，可以用语法f()来调用函数。上面提到的对象成员访问规则，对于函数来说是完全一样的。Python在实现成员函数调用时obj.f()时，会执行一下两个步骤：
根据对象成员访问规则获取函数对象；
用函数对象执行函数调用；
为了验证上述过程，我们可以执行以下代码：
ClassC(object): deff(self): pass >>fun=C.f UnboundMethod >>fun() >>c=C() >>fun=c.f BoundMethod >>fun()
我们可以看到C.f和c.f返回了instancemethod类型的对象，这两个对象也是可调用的，但是却不是我们本以为的func对象。那么instancemethod对象和func对象之间具有什么关联呢？
func类型：func类型为Python中原始的函数对象类型，即deff():pass将定义一个func类型的对象f；
instancemethod：func的一个wrapper，如果类方法没有绑定到对象，则该instancemethod为一个UnboundMethod，对UnboundMethod的调用将导致TypeError错误；如果类方法绑定到了对象，则该instancemethod为一个BoundMethod，对BoundMethod的调用不许要指定self参数的值。
如果查看UnboundMethod对象和BoundMethod对象的成员，我们可以发现它们都包含了一下三个成员：im_func、im_self和im_class。其中im_func为所封装的func对象，im_self则为所绑定对象的值，而im_class则为定义该函数的类对象。由此我们可以知道，Python会根据不同的情况返回函数的不同wrapper，当通过类对象访问函数时，返回的是名为UnboundMethod对象的Wrapper，而通过类实例访问函数是，返回的则是绑定了该实例的名为BoundMethod对象的Wrapper。
现在是Descriptor大显身手的时候了。
Python中将func定义为一个OverridingDescriptor，在其__get__方法中构造一个instancemethod对象，并根据被访问函数被访问的情况设置im_func、im_self和im_class成员。在instancemethod实例被调用时，则根据im_func和im_self来完成真正的函数调用。演示这一过程的代码如下：
Classinstancemethod(object): def__call__(self,*args): ifself.im_self==None: raise'unbounderror' returnself.im_func(self.im_self,*args) def__init__(self,im_self,im_func,im_class): self.im_self=im_self self.im_func=im_func self.im_class=im_class classfunc(object): ... def__get__(self,instance,owner): returninstancemethod(instance,self,owner) def__set__(self,instance,value): pass ...
一个小问题的解决
分享一下刚遇到的一个小问题，我有一段类似于这样的python代码：
#coding:utf-8
classA(object):
@property
def_value(self):
#raiseAttributeError("test")
return{"v":"Thisisatest."}
def__getattr__(self,key):
print"__getattr__:",key
returnself._value[key]
if__name__=='__main__':
a=A()
printa.v
运行后可以得到正确的结果
__getattr__:v Thisisatest.
但是注意，如果把
#raiseAttributeError("test")
这行的注释去掉的话，即在_value方法里面抛出AttributeError异常，事情就会变得有些奇怪。程序运行的时候并不会抛出异常，而是会进入一个无限递归：
File"attr_test.py",line12,in__getattr__ returnself._value[key] File"attr_test.py",line12,in__getattr__ returnself._value[key] RuntimeError:maximumrecursiondepthexceededwhilecallingaPythonobject
通过多方查找后发现是property装饰器的问题，property实际上是一个descriptor。在pythondoc中可以发现这样的文字：
object.__get__(self,instance,owner)
Calledtogettheattributeoftheownerclass(classattributeaccess)orofaninstanceofthatclass(instanceattributeaccess).ownerisalwaystheownerclass,whileinstanceistheinstancethattheattributewasaccessedthrough,orNonewhentheattributeisaccessedthroughtheowner.Thismethodshouldreturnthe(computed)attributevalueorraiseanAttributeErrorexception.
这样当用户访问._value时，抛出了AttributeError从而调用了__getattr__方法去尝试获取。这样程序就变成了无限递归。
这个问题看上去不复杂，但是当你的_value方法是比较隐晦的抛出AttributeError的话，调试起来就会比较困难了。
小结
Descriptor是访问对象成员时的一个中间层，为我们提供了自定义对象成员访问的方式。通过对Descriptor的探索，对原来的一些看似神秘的概念顿时有种豁然开朗的感觉：
类方法调用：编译器并没有为其提供专门的语法规则，而是使用Descriptor返回instancemethod来封装func，从而实现类似obj.func()的调用方式；
staticmethod：decorator将创建一个StaticMethod并在其中保存func对象，StaticMethod是一个Descriptor，其__get__函数中返回前面所保存的func对象；
Property：创建一个Property对象，在其__get__、__set__和__delete__方法中分别执行构造对象是传入的fget、fset、和fdel函数。现在知道为什么Property只提供这三个函数作为参数么。。
最后一个问题是，Python引入Descriptor之后的性能会不会有影响？性能影响是必须的：每次访问成员时的查找规则，之后再调用Descriptor的__get__函数，如果是方法调用的话之后才是执行真正的函数调用。每次访问对象成员时都要经历以上过程，对Python的性能应该会有较大的影响。但是，在Python的世界，貌似Pythonic才是被关注的重点，性能神马的就别提了。。