python描述符(descriptor)、属性(property)、函数（类）装饰器原理实例详解

 1、前言

      Python的描述符是接触到Python核心编程中一个比较难以理解的内容，自己在学习的过程中也遇到过很多的疑惑，通过google和阅读源码，现将自己的理解和心得记录下来，也为正在为了该问题苦恼的朋友提供一个思考问题的参考，由于个人能力有限，文中如有笔误、逻辑错误甚至概念性错误，还请提出并指正。注：本文所有测试代码使用Python 3.4版本

      本文为自己整理和原创，如有转载，请注明出处。

2、什么是描述符

      Python 2.2 引进了 Python 描述符，同时还引进了一些新的样式类，但是它们并没有得到广泛使用。Python 描述符是一种创建托管属性的方法。描述符具有诸多优点，诸如：保护属性不受修改、属性类型检查和自动更新某个依赖属性的值等。

      说的通俗一点，从表现形式来看，一个类如果实现了__get__,__set__,__del__方法(三个方法不一定要全部都实现)，并且该类的实例对象是另一个类的类属性，那么这个实例就是一个描述符。__get__,__set__,__del__的具体声明如下：

      __get__(self, instance, owner)
      __set__(self, instance, value)
      __delete__(self, instance)

其中：
      __get__ 用于访问属性。它返回属性的值，或者在所请求的属性不存在的情况下出现 AttributeError 异常。类似于javabean中的get。
      __set__ 将在属性分配操作中调用。不会返回任何内容。类似于javabean中的set。
      __delete__ 控制删除操作。不会返回内容。

 注意：

      只实现__get__方法的对象是非数据描述符，意味着在初始化之后它们只能被读取。而同时实现__get__和__set__的对象是数据描述符，意味着这种属性是可读写的。   

3、为什么需要描述符

      因为Python是一个动态类型解释性语言，不像C/C++等静态编译型语言，数据类型在编译时便可以进行验证，而Python中必须添加额外的类型检查逻辑代码才能做到这一点，这就是描述符的初衷。比如，有一个测试类Test，其具有一个类属性name。

1 class Test(object):
2      name = None

      正常情况下，name的值(其实应该是对象,name是引用)都应该是字符串，但是因为Python是动态类型语言，即使执行Test.name = 3，解释器也不会有任何异常。当然可以想到解决办法，就是提供一个get，set方法来统一读写name，读写前添加安全验证逻辑。代码如下：

 1 class test(object):
 2     name = None
 3     @classmethod
 4     def get_name(cls):
 5         return cls.name
 6     @classmethod
 7     def set_name(cls,val):
 8         if  isinstance(val,str):
 9             cls.name = val
10         else:
11             raise TypeError("Must be an string")

      虽然以上代码勉强可以实现对属性赋值的类型检查，但是会导致类型定义的臃肿和逻辑的混乱。从OOP思想来看，只有属性自己最清楚自己的类型，而不是它所在的类，因此如果能将类型检查的逻辑根植于属性内部，那么就可以完美的解决这个问题，而描述符就是这样的利器。

      为name属性定义一个(数据)描述符类，其实现了__get__和__set__方法，代码如下：

 1 class name_des(object):
 2     def __init__(self):
 3         self.__name = None
 4     def  __get__(self, instance, owner):
 5         print('call __get__')
 6         return self.__name
 7     def  __set__(self, instance, value):
 8         print('call __set__')
 9         if  isinstance(value,str):
10             self.__name = value
11         else:
12             raise TypeError("Must be an string")

      测试类如下：

1 class test(object):
2     name = name_des()

      测试代码及输出结果如下：

>>> t = test()
>>> t.name
call __get__
>>> t.name = 3
call __set__
Traceback (most recent call last):
  File "<pyshell#99>", line 1, in <module>
    t.name = 3
  File "<pyshell#94>", line 12, in __set__
    raise TypeError("Must be an string")
TypeError: Must be an string
>>> t.name = 'my name is chenyang'
call __set__
>>> t.name
call __get__
'my name is chenyang'
>>> 

     从打印的输出信息可以看到，当使用实例访问name属性(即执行t.name)时，便会调用描述符的__get__方法(注意__get__中添加的打印语句)。当使用实例对name属性进行赋值操作时(即t.name = 'my name is chenyang.')，从打印出的'call set'可以看到描述符的__set__方法被调用。熟悉Python的都知道，如果name是一个普通类属性(即不是数据描述符)，那么执行t.name = 'my name is chenyang.'时，将动态产生一个实例属性，再次执行t.name读取属性时，此时读取的属性为实例属性，而不是之前的类属性(这涉及到一个属性查找优先级的问题，下文会提到)。

     至此，可以发现描述符的作用和优势，以弥补Python动态类型的缺点。

4、属性查找的优先级　　

当使用实例对象访问属性时，都会调用__getattribute__内建函数，__getattribute__查找属性的优先级如下：

1、类属性
2、数据描述符
3、实例属性
4、非数据描述符
5、__getattr__()

       由于__getattribute__是实例查找属性的入口，因此有必要探究其实现过程，其逻辑伪代码(带注释说明)如下：

 1 __getattribute__伪代码：
 2    __getattribute__(property) logic:
 3   #先在类(包括父类、祖先类)的__dict__属性中查找描述符
 4   descripter = find first descripter in class and bases's dict(property)
 5   if descripter:#如果找到属性并且是数据描述符，就直接调用该数据描述符的__get__方法并将结果返回
 6       return descripter.__get__(instance, instance.__class__)
 7   else:#如果没有找到或者不是数据描述符，就去实例的__dict__属性中查找属性，如果找到了就直接返回这个属性值
 8       if value in instance.__dict__
 9           return value
10       #程序执行到这里，说明没有数据描述符和实例属性，则在类(父类、祖先类)的__dict__属性中查找非数据描述符
11       value = find first value in class and bases's dict(property)
12       if value is a function:#如果找到了并且这个属性是一个函数，就返回绑定后的函数
13          return bounded function(value)
14       else:#否则就直接返回这个属性值
15          return value
16  #程序执行到这里说明没有找到该属性，引发异常，__getattr__函数会被调用
17  raise AttributeNotFundedException

       同样的，当对属性进行赋值操作的时候，内建函数__setattr__也会被调用，其伪代码如下：

1 __setattr__伪代码：
2  __setattr__(property, value)logic:
3  #先在类(包括父类、祖先类)的__dict__属性中查找描述符
4  descripter = find first descripter in class and bases's dict(property)
5  if descripter:#如果找到了且是数据描述符，就调用描述符的__set__方法
6      descripter.__set__(instance, value)
7  else:#否则就是给实例属性赋值
8      instance.__dict__[property] = value

      记住__getattribute__查找属性的优先级顺序，并且理解__getattribute__、__setattr__的实现逻辑(还包括__getattr__的调用时机)后，就可以很容易搞懂为什么有些类属性无法被实例属性覆盖(隐藏)、通过实例访问一个属性的时候到底访问的是类属性还是实例属性，为此，我专门写了一个综合测试实例，代码见本文最后。

5、装饰器

     如果想在不修改源代码的基础上扩充现有函数和类的功能，装饰器是一个不错的选择（类还可以通过派生的方式），下面分别介绍函数和类的装饰器。

函数装饰器：

     假设有如下函数：

1 class myfun():
2      print('myfun called.')

     如果想在不修改myfun函数源码的前提下，使之调用前后打印'before called'和'after called'，则可以定义一个简单的函数装饰器，如下：

1 def myecho(fun):
2      def return_fun():
3             print('before called.')
4             fun()
5             print('after called.')
6      return return_fun

     使用装饰器对myfun函数就行功能增强：

1 @myecho
2 def myfun():
3       print('myfun called.')

     调用myfun(执行myfun()相当于myecho(fun)())，得到如下输出：

before called.
myfun called.
after called.

      装饰器可以带参数，比如定义一个日志功能的装饰器，代码如下：

1 def log(header,footer):#相当于在无参装饰器外套一层参数
2     def log_to_return(fun):#这里接受被装饰的函数
3         def return_fun(*args,**kargs):
4             print(header)
5             fun(*args,**kargs)
6             print(footer)
7         return return_fun
8     return log_to_return

      使用有参函数装饰器对say函数进行功能增强：

1 @log('日志输出开始','结束日志输出')
2 def say(message):
3     print(message)

      执行say('my name is chenyang.')，输出结果如下：

日志输出开始
my name is chenyang.
结束日志输出

类装饰器：

      类装饰器和函数装饰器原理相似，带参数的类装饰器示例代码如下：

1 def drinkable(message):
2     def drinkable_to_return(cls):
3         def drink(self):
4             print('i can drink',message)
5         cls.drink = drink #类属性也可以动态修改
6         return cls
7     return drinkable_to_return

     测试类：

1 @drinkable('water')
2 class test(object):
3     pass

     执行测试：

1   t = test()
2   t.drink()

     结果如下：

i can drink water

6、自定义staticmethod和classmethod

     一旦了解了描述符和装饰器的基本知识，自定义staticmethod和classmethod就变得非常容易，以下提供参考代码:

 1 #定义一个非数据描述符
 2 class myStaticObject(object):
 3     def __init__(self,fun):
 4         self.fun = fun
 5     def __get__(self,instance,owner):
 6         print('call myStaticObject __get__')
 7         return self.fun
 8 #无参的函数装饰器，返回的是非数据描述符对象
 9 def my_static_method(fun):
10     return myStaticObject(fun)
11 #定义一个非数据描述符
12 class myClassObject(object):
13     def __init__(self,fun):
14         self.fun = fun
15     def __get__(self,instance,owner):
16         print('call myClassObject __get__')
17         def class_method(*args,**kargs):
18             return self.fun(owner,*args,**kargs)
19         return class_method
20 #无参的函数装饰器，返回的是非数据描述符对象
21 def my_class_method(fun):
22     return myClassObject(fun)

       测试类如下：

1 class test(object):
2     @my_static_method
3     def my_static_fun():
4         print('my_static_fun')
5     @my_class_method
6     def my_class_fun(cls):
7         print('my_class_fun')

      测试代码：

>>> test.my_static_fun()
call myStaticObject __get__
my_static_fun
>>> test.my_class_fun()
call myClassObject __get__
my_class_fun
>>> 

7、property

      本文前面提到过使用定义类的方式使用描述符，但是如果每次为了一个属性都单独定义一个类，有时将变得得不偿失。为此，python提供了一个轻量级的数据描述符协议函数Property()，其使用装饰器的模式，可以将类方法当成属性来访问。它的标准定义是:

      property(fget=None,fset=None,fdel=None,doc=None) 

      前面3个参数都是未绑定的方法，所以它们事实上可以是任意的类成员函数，分别对应于数据描述符的中的__get__，__set__，__del__方法，所以它们之间会有一个内部的与数据描述符的映射。

      property有两种使用方式，一种是函数模式，一种是装饰器模式。

      函数模式代码如下:

 1 class test(object):  
 2     def __init__(self):  
 3         self._x = None  
 4     def getx(self):  
 5         print("get x")  
 6         return self._x  
 7     def setx(self, value):  
 8         print("set x")  
 9         self._x = value  
10     def delx(self):  
11         print("del x")  
12         del self._x  
13     x = property(getx, setx, delx, "I'm the 'x' property.") 

      如果要使用property函数，首先定义class的时候必须是object的子类(新式类)。通过property的定义，当获取成员x的值时，就会调用getx函数，当给成员x赋值时，就会调用setx函数，当删除x时，就会调用delx函数。使用属性的好处就是因为在调用函数，可以做一些检查。如果没有严格的要求，直接使用实例属性可能更方便。

      此处省略测试代码。

      装饰器模式代码如下：

 1 class test(object):
 2 　def __init__(self):
 3 　　self.__x=None
 4 　
 5 　@property
 6 　def x(self):
 7 　　return self.__x
 8 　@x.setter
 9 　def x(self,value):
10 　　self.__x=value
11 　@x.deleter
12 　def x(self):
13 　　del self.__x

      注意：三个函数的名字(也就是将来要访问的属性名)必须一致。

      使用property可以非常容易的实现属性的读写控制，如果想要属性只读，则只需要提供getter方法，如下:

 1 class test(object):
 2 　def __init__(self):
 3 　　self.__x=None
 4 　
 5 　@property
 6 　def x(self):
 7 　　return self.__x

       前文说过，只实现get函数的描述符是非数据描述符，根据属性查找的优先级，非属性优先级是可以被实例属性覆盖(隐藏)的，但是执行如下代码:

>>> t=test()
>>> t.x
>>> t.x = 3
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    t.x = 3
AttributeError: can't set attribute

     从错误信息中可以看出，执行t.x=3的时候并不是动态产生一个实例属性，也就是说x并不是非数据描述符，那么原因是什么呢？其实原因就在property，虽然表面上看属性x只设置了get方法，但是其实property是一个同时实现了__get__,__set__,__del__方法的类(是一个数据描述符)，因此，使用property生成的属性其实是一个数据描述符！

      使用python模拟的property代码如下，可以看到，上面的“AttributeError: can't set attribute”异常其实是在property中的__set__函数中引发的，因为用户没有设置fset(为None)：

 1 class Property(object):
 2     "Emulate PyProperty_Type() in Objects/descrobject.c"
 3 
 4     def __init__(self, fget=None, fset=None, fdel=None, doc=None):
 5         self.fget = fget
 6         self.fset = fset
 7         self.fdel = fdel
 8         if doc is None and fget is not None:
 9             doc = fget.__doc__
10         self.__doc__ = doc
11 
12     def __get__(self, obj, objtype=None):
13         if obj is None:
14             return self
15         if self.fget is None:
16             raise AttributeError("unreadable attribute")
17         return self.fget(obj)
18 
19     def __set__(self, obj, value):
20         if self.fset is None:
21             raise AttributeError("can't set attribute")
22         self.fset(obj, value)
23 
24     def __delete__(self, obj):
25         if self.fdel is None:
26             raise AttributeError("can't delete attribute")
27         self.fdel(obj)
28 
29     def getter(self, fget):
30         return type(self)(fget, self.fset, self.fdel, self.__doc__)
31     def setter(self, fset):
32         return type(self)(self.fget, fset, self.fdel, self.__doc__)
33     def deleter(self, fdel):
34         return type(self)(self.fget, self.fset, fdel, self.__doc__)

7、综合测试实例

      以下测试代码，结合了前文的知识点和测试代码，集中测试了描述符、property、装饰器等。并且重写了内建函数__getattribute__、__setattr__、__getattr__，增加了打印语句用以测试这些内建函数的调用时机。每一条测试结构都在相应的测试语句下用多行注释括起来。

  1 #带参数函数装饰器
  2 def log(header,footer):#相当于在无参装饰器外套一层参数
  3     def log_to_return(fun):#这里接受被装饰的函数
  4         def return_fun(*args,**kargs):
  5             print(header)
  6             fun(*args,**kargs)
  7             print(footer)
  8         return return_fun
  9     return log_to_return
 10 
 11 #带参数类型装饰器
 12 def flyable(message):
 13     def flyable_to_return(cls):
 14         def fly(self):
 15             print(message)
 16         cls.fly = fly #类属性也可以动态修改
 17         return cls
 18     return flyable_to_return
 19 
 20 #say(meaasge) ==> log(parms)(say)(message)
 21 @log('日志输出开始','结束日志输出')
 22 def say(message):
 23     print(message)
 24 
 25 #定义一个非数据描述符
 26 class myStaticObject(object):
 27     def __init__(self,fun):
 28         self.fun = fun
 29     def __get__(self,instance,owner):
 30         print('call myStaticObject __get__')
 31         return self.fun
 32 #无参的函数装饰器，返回的是非数据描述符对象
 33 def my_static_method(fun):
 34     return myStaticObject(fun)
 35 #定义一个非数据描述符
 36 class myClassObject(object):
 37     def __init__(self,fun):
 38         self.fun = fun
 39     def __get__(self,instance,owner):
 40         print('call myClassObject __get__')
 41         def class_method(*args,**kargs):
 42             return self.fun(owner,*args,**kargs)
 43         return class_method
 44 #无参的函数装饰器，返回的是非数据描述符对象
 45 def my_class_method(fun):
 46     return myClassObject(fun)
 47 
 48 #非数据描述符
 49 class des1(object):
 50     def __init__(self,name=None):
 51         self.__name = name
 52     def __get__(self,obj,typ=None):
 53         print('call des1.__get__')
 54         return self.__name
 55 #数据描述符
 56 class des2(object):
 57     def __init__(self,name=None):
 58         self.__name = name
 59     def __get__(self,obj,typ=None):
 60         print('call des2.__get__')
 61         return self.__name
 62     def __set__(self,obj,val):
 63         print('call des2.__set__,val is %s' % (val))
 64         self.__name = val
 65 #测试类
 66 @flyable("这是一个测试类")
 67 class test(object):
 68     def __init__(self,name='test',age=0,sex='man'):
 69         self.__name = name
 70         self.__age = age
 71         self.__sex = sex
 72 #---------------------覆盖默认的内建方法
 73     def __getattribute__(self, name):
 74         print("start call __getattribute__")
 75         return  super(test, self).__getattribute__(name)
 76     def __setattr__(self, name, value):
 77         print("before __setattr__")
 78         super(test, self).__setattr__(name, value)
 79         print("after __setattr__")
 80     def __getattr__(self,attr):
 81         print("start call __getattr__")
 82         return attr
 83         #此处可以使用getattr()内建函数对包装对象进行授权    
 84     def __str__(self):
 85         return str('name is %s,age is %d,sex is %s' % (self.__name,self.__age,self.__sex))
 86     __repr__ = __str__ 
 87 #-----------------------
 88     d1 = des1('chenyang')     #非数据描述符，可以被实例属性覆盖
 89     d2 = des2('pengmingyao')  #数据描述符，不能被实例属性覆盖
 90     def d3(self):             #普通函数，为了验证函数(包括函数、静态/类方法)都是非数据描述符，可悲实例属性覆盖
 91         print('i am a function')
 92 #------------------------
 93     def get_name(self):
 94         print('call test.get_name')
 95         return self.__name
 96     def set_name(self,val):
 97         print('call test.set_name')
 98         self.__name = val
 99     name_proxy = property(get_name,set_name)#数据描述符，不能被实例属性覆盖，property本身就是一个描述符类
100 
101     def get_age(self):       
102         print('call test.get_age')
103         return self.__age
104     age_proxy = property(get_age) #非数据描述符，但是也不能被实例属性覆盖
105 #----------------------
106     @property 
107     def sex_proxy(self):
108         print("call get sex")
109         return self.__sex
110     @sex_proxy.setter  #如果没有setter装饰，那么sex_proxy也是只读的，实例属性也无法覆盖，同property
111     def sex_proxy(self,val):
112         print("call set sex")
113         self.__sex = val
114 #---------------------
115     @my_static_method #相当于my_static_fun = my_static_method(my_static_fun)  就是非数据描述符
116     def my_static_fun():
117         print('my_static_fun')
118     @my_class_method
119     def my_class_fun(cls):
120         print('my_class_fun')
121 
122 #主函数
123 if __name__ == "__main__":
124     say("函数装饰器测试")
125     '''
126     日志输出开始
127     函数装饰器测试
128     结束日志输出
129     '''
130     t=test( )  #创建测试类的实例对象
131     '''
132     before __setattr__    
133     after __setattr__
134     before __setattr__
135     after __setattr__
136     before __setattr__
137     after __setattr__
138     '''
139     print(str(t)) #验证__str__内建函数
140     '''
141     start call __getattribute__
142     start call __getattribute__
143     start call __getattribute__
144     name is test,age is 0,sex is man
145     '''
146     print(repr(t))#验证__repr__内建函数
147     '''
148     start call __getattribute__
149     start call __getattribute__
150     start call __getattribute__
151     name is test,age is 0,sex is man
152     '''
153     t.fly()       #验证类装饰器
154     '''
155     start call __getattribute__
156     这是一个测试类
157     '''
158     t.my_static_fun()#验证自定义静态方法
159     '''
160     start call __getattribute__
161     call myStaticObject __get__
162     my_static_fun
163     '''
164     t.my_class_fun()#验证自定义类方法
165     '''
166     start call __getattribute__
167     call myClassObject __get__
168     my_class_fun
169     '''
170     #以下为属性获取
171     t.d1
172     '''
173     start call __getattribute__
174     call des1.__get__
175     '''
176     t.d2
177     '''
178     start call __getattribute__
179     call des2.__get__
180     '''
181     t.d3()
182     '''
183     start call __getattribute__
184     i am a function
185     '''
186     t.name_proxy
187     '''
188     start call __getattribute__
189     call test.get_name
190     start call __getattribute__
191     '''
192     t.age_proxy
193     '''
194     start call __getattribute__
195     call test.get_age
196     start call __getattribute__
197     '''
198     t.sex_proxy
199     '''
200     start call __getattribute__
201     call get sex
202     start call __getattribute__
203     '''
204     t.xyz #测试访问不存在的属性，会调用__getattr__
205     '''
206     start call __getattribute__
207     start call __getattr__
208     '''
209     #测试属性写
210     t.d1 = 3  #由于类属性d1是非数据描述符，因此这里将动态产生实例属性d1
211     '''
212     before __setattr__
213     after __setattr__
214     '''
215     t.d1      #由于实例属性的优先级比非数据描述符优先级高，因此此处访问的是实例属性
216     '''
217     start call __getattribute__
218     '''
219     t.d2 = 'modefied'
220     '''
221     before __setattr__
222     call des2.__set__,val is modefied
223     after __setattr__
224     '''
225     t.d2   
226     '''
227     start call __getattribute__
228     call des2.__get__
229     '''
230     t.d3 = 'not a function' 
231     '''
232     before __setattr__
233     after __setattr__
234     '''
235     t.d3  #因为函数是非数据描述符，因此被实例属性覆盖 236     '''
237     start call __getattribute__
238     '''
239     t.name_proxy = 'modified'
240     '''
241     before __setattr__
242     call test.set_name
243     before __setattr__
244     after __setattr__
245     after __setattr__
246     '''
247     t.sex_proxy = 'women'
248     '''
249     before __setattr__
250     call set sex
251     before __setattr__
252     after __setattr__
253     after __setattr__
254     '''
255     t.age_proxy = 3  #age_proxy是只读的     
256     '''
257     before __setattr__
258     Traceback (most recent call last):
259       File "test.py", line 191, in <module>
260        t.age_proxy = 3
261       File "test.py", line 121, in __setattr__
262        super(test, self).__setattr__(name, value)
263     AttributeError: can't set attribute
264     '''