描述器 Descriptors

描述器的表现

用到3个魔术方法: __get__() 、 __set__() 、 __delete__()

方法签名如下

object.__get__(self, instance, owner)

object.__set__(self, instance, value)

object.__delete__(self, instance)

self 指代当前实例，调用者

instance 是owner的实例

owner 是属性的所属的类

请思考下面程序的执行流程是什么？

class A:
    def __init__(self):
        self.a1 = 'a1'
        print('A.init')
class B:
    x = A()
    def __init__(self):
        print('B.init')
print('-'*20)
print(B.x.a1)
print('='*20)
b = B()
print(b.x.a1)
# 运行结果
A.init
--------------------
a1
====================
B.init
a1

可以看出执行的先后顺序吧？

类加载的时候，类变量需要先生成，而类B的x属性是类A的实例，所以类A先初始化，所以打印A.init。 然后执行到打印B.x.a1。

然后实例化并初始化B的实例b。

打印b.x.a1，会查找类属性b.x，指向A的实例，所以返回A实例的属性a1的值。

描述器定义

Python中，一个类实现了 __get__ 、 __set__ 、 __delete__ 三个方法中的任何一个方法，就是描述器。实现这 三个中的某些方法，就支持了描述器协议。

仅实现了 __get__ ，就是非数据描述符 non-data descriptor

实现了 __get__ 、 __set__ 就是数据描述符 data descriptor

如果一个类的类属性设置为描述器实例，那么它被称为owner属主。

当该类的该类属性被查找、设置、删除时，就会调用描述器相应的方法。

属性的访问顺序

为上例中的类B增加实例属性x

class A:
    def __init__(self):
        self.a1 = 'a1'
        print('A.init')
    def __get__(self, instance, owner):
        print("A.__get__ {} {} {}".format(self, instance, owner))
        return self
class B:
    x = A()
    def __init__(self):
        print('B.init')
        self.x = 'b.x' # 增加实例属性x
print('-'*20)
print(B.x)
print(B.x.a1)
print('='*20)
b = B()
print(b.x)
print(b.x.a1) # AttributeError: 'str' object has no attribute 'a1'

类A只实现了__get__()方法，b.x访问到了实例的属性，而不是描述器。

继续修改代码，为类A增加 __set__ 方法。

class A:
    def __init__(self):
        self.a1 = 'a1'
        print('A.init')
    def __get__(self, instance, owner):
        print("A.__get__ {} {} {}".format(self, instance, owner))
        return self
    def __set__(self, instance, value):
        print('A.__set__ {} {} {}'.format(self, instance, value))
        self.data = value
class B:
    x = A()
    def __init__(self):
        print('B.init')
        self.x = 'b.x' # 增加实例属性x
print('-'*20)
print(B.x)
print(B.x.a1)
print('='*20)
b = B()
print(b.x) # 返回什么
print(b.x.a1) # 返回什么
print(b.x.data) # 返回什么？

所有的b.x就会访问描述器的get()方法，代码中返回的self就是描述器实例，它的实例字典中就保存着a1和data 属性，可以打印b.x.dict就可以看到这些属性。

属性查找顺序

实例的 dict 优先于 非数据描述器

数据描述器 优先于 实例的 dict

__delete__ 方法有同样的效果，有了这个方法，也是数据描述器。

尝试着增加下面的2行代码，看看字典的变化

b.x = 500

B.x = 600

b.x = 500，这是调用数据描述器的 set 方法，或调用非数据描述器的实例覆盖。

B.x = 600，赋值即定义，这是覆盖类属性。把描述器给替换了。

Python中的描述器

描述器在Python中应用非常广泛。

Python的方法（包括staticmethod()和classmethod()）都实现为非数据描述器。因此，实例可以重新定义和覆盖 方法。这允许单个实例获取与同一类的其他实例不同的行为。

property()函数实现为一个数据描述器。因此，实例不能覆盖属性的行为。

class A:
    @classmethod
    def foo(cls): # 非数据描述器
        pass
    @staticmethod # 非数据描述器
    def bar():
        pass
    @property # 数据描述器
    def z(self):
        return 5
    def getfoo(self): # 非数据描述器
        return self.foo
    def __init__(self): # 非数据描述器
        self.foo = 100
        self.bar = 200
    #self.z = 300
a = A()
print(a.__dict__)
print(A.__dict__)

foo、bar都可以在实例中覆盖，但是z不可以。

新增方法

3.6新增描述器方法 __set_name__ ，它在属主类构建的时候就会调用。

 class A:
    def init(self):
    print('A init')
    def get(self, instance, owner):
        print(1, self, instance, owner)
    return self
    def set_name(self, owner, name):
        print(2, self, owner, name)
        self.name = name
 class B:
 x = A() # 类属性创建时调用描述器的set_name方法 print('-' * 30)
 print(B().x)