1、什么是描述符？
描述符是Python新式类的关键点之一，它为对象属性提供强大的API，你可以认为描述符是表示对象属性的一个代理。当需要属性时，可根据你遇到的情况，通过描述符进行访问他（摘自Python核心编程）。
2、类属性和实例属性
2.1 属性：__dict__
作用：字典类型，存放本对象的属性，key(键)即为属性名，value(值)即为属性的值，形式为{attr_key : attr_value}。
__dict__是对象的默认属性，所以每个类对象和实例化对象都有这个属性。
对象属性的访问顺序：
（1）实例对象/类对象的属于描述符的属性
（2）实例属性
（3）类属性
（3）父类属性
（4）__getattr__()方法
2.2 实例属性的调用顺序
作用：查找类对象或者实例对象的属性（也就是用于获取对象的__dict__属性中的值）
这三个魔法方法的调用顺序如下：
如果 obj = Clz(), 那么obj.attr 顺序如下：
（1）如果“attr”出现在Clz的__dict__中， 且attr是data descriptor， 那么调用其__get__方法
（2）如果“attr”出现在obj的__dict__中， 那么直接返回 obj.__dict__['attr']
（3）如果“attr”出现在Clz的__dict__中
（3.1）如果attr是non-data descriptor，那么调用其__get__方法
（3.2）否则，返回__dict__['attr']
（4）如果Clz有__getattr__方法，调用__getattr__方法
（5）抛出AttributeError
实际上还是上面那个调用顺序。只是结合描述符进行了一些补充关于描述符的补充
3 Descriptor 的定义
描述符本质上是一个类属性，实现描述符的类被称为描述符类。
其中只实现了__set__()方法的被当做方法描述符，或者是非数据描述符。
那些同时实现了__set__()和__get__()方法的类被称作数据描述符。
而魔法方法__get__(), __set__(), __delete__() 就用于定义和调用类属性 __dict__
__get__(self, object, type) # 用于得到一个属性的值
__set__(self, obj, val) # 用于为一个属性赋值
__delete__(self, obj) # 删除某个属性时被调用，但很少用到
3.1 描述符的定义和调用初体验
# 描述符类的定义
class MyDescriptor(object):
def __init__(self, value):
self.value = value
# 描述符value的访问
def __get__(self, instance, owner):
return self.value
# 描述符value的定义
def __set__(self, instance, value):
self.value = value
class MyClass(object):
mydescriptor = MyDescriptor(5)
# 在MyClass类中创建一个描述符mydescriptor，重申一下，这是一个类属性。
# 同时可以看到，mydescriptor不仅仅是MyClass类的一个类属性，同时还是MyDescriptor的一个实例对象。
# 这样就将一个类的类属性定义成了另一个类的实例对象。
if __name__ == '__main__':
print (MyClass.mydescriptor) # 输出为 5
发现访问 MyClass 的 mydescriptor 属性时，调用了描述符的__get__()方法，访问了描述符类的实例属性value.
这就达到了描述符的作用：可以改变了类对象属性的访问。
调用原理：对于类属性描述符，如果解析器发现属性x是一个描述符的话，在内部通过
type.__getattribute__()（访问属性时无条件调用，最先调用），它能把Class.x转换成Class.__dict__[‘x’].__get__(None, Class)来访问
4、描述符与普通属性的区别
上面简单说了几个定义，接下来我们来解决一些实际使用中的细节问题。
4.1 首先我们看一下普通的属性调用
class Test(object):
cls_val = 1
def __init__(self, ins_val):
self.ins_val = ins_val
>>> t=Test(10)
>>> Test.__dict__
{'__module__': '__main__',
'__init__': <function Test.__init__ at 0x03975150>,
'__dict__': <attribute '__dict__' of 'Test' objects>,
'__weakref__': <attribute '__weakref__' of 'Test' objects>,
'__doc__': None,
'cls_val': 1, }
>>> t.__dict__
{'ins_val': 10}
# 没有写在__init__中的类属性在实例化时是不会在实例的__doc__中的。
# 注意，这里并不是说实例t没有属性cls_val。t.cls_val依旧为1。
# ------------------------------------- -------------------------------------
>>> t.cls_val = 20
>>> Test.__dict__
{'__module__': '__main__',
'__init__': <function Test.__init__ at 0x035D5150>,
'__dict__': <attribute '__dict__' of 'Test' objects>,
'__weakref__': <attribute '__weakref__' of 'Test' objects>,
'__doc__': None,
'cls_val': 1, }
>>> t.__dict__
{'ins_val': 10, 'cls_val': 20}
# 更改实例t的属性cls_val，并不影响类Test的类属性cls_val
# ------------------------------------- -------------------------------------
>>> Test.cls_val = 30
>>> Test.__dict__
{'__module__': '__main__',
'__init__': <function Test.__init__ at 0x035D5150>,
'__dict__': <attribute '__dict__' of 'Test' objects>,
'__weakref__': <attribute '__weakref__' of 'Test' objects>,
'__doc__': None,
'cls_val': 30, }
>>> t.__dict__
{'ins_val': 10, 'cls_val': 20}
# 更改了类Test的属性cls_val的值，由于实例在修改类属性之前生成，所以修改类的属性不会影响到实例的属性
以上这段代码证明：
在实例化结束之后，类属性和实例属性互不影响。
4.2 下面我们看看__get__()方法的调用过程
class Desc(object):
def __init__(self, value):
self.value = value
def __get__(self, instance, owner):
print("...__get__...")
print("self : ", self)
print("instance : ", instance)
print("owner : ", owner)
return self.value
def __set__(self, instance, value):
print('...__set__...')
print("self : ", self)
print("instance : ", instance)
print("value : ", value)
self.value = value
class TestDesc(object):
desc = Desc(666)
# 以下为测试代码
testdesc = TestDesc()
print('testdesc.desc:%s' % testdesc.desc)
print('-' * 40)
print('TestDesc.desc:%s' % TestDesc.desc)
print()
print('=' * 40)
print()
testdesc.desc = 888
print('-' * 40)
print('testdesc.desc:%s' % testdesc.desc)
print('-' * 40)
print('TestDesc.desc:%s' % TestDesc.desc)
# 以下为输出结果
...__get__...
self : <__main__.Desc object at 0x038C2290>
instance : <__main__.TestDesc object at 0x038C22F0>
owner : <class '__main__.TestDesc'>
testdesc.desc:666
----------------------------------------
...__get__...
self : <__main__.Desc object at 0x038C2290>
instance : None
owner : <class '__main__.TestDesc'>
TestDesc.desc:666
========================================
...__set__...
self : <__main__.Desc object at 0x038C2290>
instance : <__main__.TestDesc object at 0x038C22F0>
value : 888
----------------------------------------
...__get__...
self : <__main__.Desc object at 0x038C2290>
instance : <__main__.TestDesc object at 0x038C22F0>
owner : <class '__main__.TestDesc'>
testdesc.desc:888
----------------------------------------
...__get__...
self : <__main__.Desc object at 0x038C2290>
instance : None
owner : <class '__main__.TestDesc'>
TestDesc.desc:888
以上代码说明：
1. 调用实例属性和调用类属性调到的是同一个对象，实际上他们都是由描述符类调用的。
2. 不管是类对象的类属性还是实例对象的实例属性，其实际属性都是描述符的实例对象。
3. 被描述的类属性在被实例化时是被实例对象继承的，示例中testdesc.desc和TestDesc.desc有相同的值，而且修改实例属性testdesc.desc会影响到类属性TestDesc.desc。
4.3 描述符是不能定义成实例属性的
# coding=utf-8
class Descriptor(object):
def __init__(self, value):
self.value = value
def __get__(self, instance, owner):
print ("访问属性")
return self.value
def __set__(self, instance, value):
print ("设置属性值")
self.value = value
class TestDesc(object):
classdesc = Descriptor(888)
def __init__(self):
self.insdesc = Descriptor(666)
# 以下为测试代码
testdesc = TestDesc()
print(TestDesc.classdesc)
print(testdesc.classdesc)
print(testdesc.insdesc)
# 以下为输出结果
访问属性
888
访问属性
888
<__main__.Descriptor object at 0x0000025041A64940>
可以看到，实例对象testdesc的 实例属性insdesc 并没有调用__get__()方法，只是说他是一个Descriptor对象。
这是因为当访问实例描述符对象时，obj.__getattribute__()会将myclass.desc转换为type(myclass).__dict__['desc'].__get__(myclass, type(myclass))，即到类属性中去寻找desc，并调用他的__get__()方法。而Myclass类中没有desc属性，所以无法访调用到__get__方法.
描述符是一个类属性，必须定义在类的层次上, 而不能单纯的定义为对象属性。
4. python的property方法
通过使用 property()，可以轻松地为任意属性创建可用的描述符。
property内建函数有四个参数：property(fget=None, fset=None, fdel=None, doc=None)。
这四个参数都接受函数类型
class PropertyDesc(object):
def __init__(self):
self.__name = ''
def fget(self):
print ("Getting: %s" % self.__name)
return self.__name
def fset(self, value):
self.__name = value
print ("Setting: %s" % value)
def fdel(self):
print ("Deleting: %s" % self.__name)
del self.__name
name = property(fget, fset, fdel, "I'm the property.")
if __name__ == '__main__':
pro = PropertyDesc()
pro.name = "hellokitty"
print(pro.name)
del pro.name
# 以下为输出结果
Setting: hellokitty
Getting: hellokitty
hellokitty
Deleting: hellokitty
当然也可以使用装饰器的方式实现以上内容：
class PropertyDesc(object):
def __init__(self):
self._name = ''
@property
def name(self):
print ("Getting: %s" % self._name)
return self._name
@name.setter
def name(self, value):
print ("Setting: %s" % value)
self._name = value
@name.deleter
def name(self):
print ("Deleting: %s" %self._name)
del self._name
if __name__ == '__main__':
pro = PropertyDesc()
pro.name = "hello world"
print(pro.name)
del pro.name
# 以下为输出内容
Setting: hello world
Getting: hello world
hello world
Deleting: hello world