21、描述器：Descriptors
1）描述器的表现
用到三个魔术方法。__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(B.x.a1) #A init a1
b = B()
print(b.x.a1) # B init a1
执行顺序是：第一个print执行类A的 第二个print执行的是类B。
class A:
def __init__(self):
self.a1 = 'a1'
print('A init')
def __get__(self, instance, owner):
print('{}{}{}'.format(self,instance,owner))
class B:
x = A()
def __init__(self):
print('B init')
# print(B.x.a1) # 会抛出错误，属性异常
#
# b = B()
# print(b.x.a1) #会抛出错误，属性异常
出现错误的原因是：类A中定义get方法，那么类A就是描述器，报错的原因是和类A中的get方法的返回有关系。
get方法return返回值后：
class A:
def __init__(self):
self.a1 = 'a1'
print('A init')
def __get__(self, instance, owner):
print('{}{}{}'.format(self,instance,owner))
return self
class B:
x = A()
def __init__(self):
print('B init')
print(B.x.a1)
b = B()
print(b.x.a1)
A init
<__main__.A object at 0x00000090E02F2F60>None<class '__main__.B'>
a1
B init
<__main__.A object at 0x00000090E02F2F60><__main__.B object at 0x00000090E02F9518><class '__main__.B'>
a1
查看是否除了类属性以外，实例的属性是否可以触发get方法呢?
class A:
def __init__(self):
self.a1 = 'a1'
print('A init')
def __get__(self, instance, owner):
print('{}{}{}'.format(self,instance,owner))
return self
class B:
x = A()
def __init__(self):
print('B init')
self.b = A()
print(B.x.a1)
b = B()
print(b.x.a1)
print(b.b)
总结：所以只有类属性是类的实例才可以。
2）描述器定义
描述器是一个类的类属性是另一个类的实例，另一个类中实现了set、delete和get方法之一。
有两个类A，B，类A中实现set和get的属性方法。类B中的一个属性为类A。
用一个类来增强另一个类的功能。
练习：模仿property描述器
class Property:
def __init__(self,fget,fset = None):
self.fget = fget
self.fset = fset
def __get__(self, instance, owner):
if instance is not None:
return self.fget(instance)
return self
def __set__(self, instance, value):
print(self,instance,value)
if callable(self.fset):
self.fset(instance,value)
else:
raise AttributeError
def setter(self,fn):
self.fset = fn
return self
class A:
def __init__(self,data):
self._data = data
@Property #data = Property(data) #实例化
def data(self):
return self._data
@data.setter #data是Property的实例了 project.setter(data)
def data(self,value): #通过data.setter,提取参数，给fset. data等价于 = self
self._data = value #data = Property(data)
a = A(100)
print(a.data) #data>>值 <<函数（self）
a.data = 200
描述器定义：
描述器必须是类属性，Python中，一个类实现了__get__ 、__set__、__delete__三个任意一个方法都称为描述器。
仅仅实现__get__ 非数据描述器。non-data descriptor
实现__get__ 和__set__ 就是数据描述器。data descriptor
如果一个类的类属性设置为描述器，那么他被称为owner属主。
3）属性的访问顺序
非数据描述器，首先查找的是自己本身的字典。
数据描述器，首先查找的是类的字典。
class A:
def __init__(self):
self.a1 = 'a1'
print('A init')
def __get__(self, instance, owner):
print('{}{}{}'.format(self,instance,owner))
return self
class B:
x = A()
def __init__(self):
print('B init')
self.x = 'b.x'
print(B.x.a1)
b = B()
print(b.x.a1) #会抛出错误，属性异常
b.x访问到了实例的属性，而不是描述器。
修改代码，为类A增加__set__方法。
class A:
def __init__(self):
self.a1 = 'a1'
print('A init')
def __get__(self, instance, owner):
print('{}{}{}'.format(self,instance,owner))
return self
def __set__(self, instance, value):
print('{}{}{}'.format(self,instance,value))
self.data = value
class B:
x = A()
def __init__(self):
print('B init')
self.x = 'b.x'
print(B.x.a1)
b = B()
print(b.x)
print(b.x.a1)
A init
<__main__.A object at 0x0000006AD6EC9588>None<class '__main__.B'>
a1
B init
<__main__.A object at 0x0000006AD6EC9588><__main__.B object at 0x0000006AD6EC95F8>b.x
<__main__.A object at 0x0000006AD6EC9588><__main__.B object at 0x0000006AD6EC95F8><class '__main__.B'>
<__main__.A object at 0x0000006AD6EC9588>
<__main__.A object at 0x0000006AD6EC9588><__main__.B object at 0x0000006AD6EC95F8><class '__main__.B'>
a1
返回变成了a1，访问到了描述器的数据。
属性查找顺序：
实例的 __dict__ 优先于非数据描述器。
数据描述器优先于实例的 __dict__
4）本质（进阶）
不是因为数据描述器优先级高，而是把实例的属性从__dict__ 中去除掉了，数据访问的顺序还是按照原来的顺序执行。
5）Python中的描述器应用
描述器在Python中应用广泛，Python的方法（包括staticmethod（）和classmethod（））都实现为非数据描述器，因此，实例重新定义和覆盖方法，允许单个实例获取与同一类的其他实例不同的行为。
****实现装饰器staticmethod和classmethod。
from functools import partial
class StaticMethod:
def __init__(self,fn):
self.fn = fn
def __get__(self, instance, owner):
return self.fn
class ClassMethod:
def __init__(self,fn):
self.fn = fn
def __get__(self, instance, cls):
return partial(self.fn,cls)
class A:
@StaticMethod #s_meth = StaticMethod(s_meth)
def s_meth():
print('static method')
@ClassMethod
def c_meth(cls):
print('{}class method'.format(cls))
A.s_meth()
A.c_meth()
6）对实例的数据进行校验。
class Person:
def __init__(self,name:str,age:int):
params = ((name,str),(age,int))#利用二元组判断
if not self.checkdata(params)： #如果不为真，就抛出异常
raise TypeError
self.name = name
self.age = age
def checkdata(self,params):
for p,t in params:
if not isinstance(p,t):
return False
return True
(1)描述器方式：
class Check:
def __init__(self,name,type):
self.name = name
self.type = type
def __set__(self, instance, value):
if not isinstance(value,self.type):#如果值和要求的类型不一致，则抛出异常，如果是则按照字典对应key和value值。
raise TypeError(value)
instance.__dict__[self.name] = value
def __get__(self, instance, owner):
if instance is not None:#如果对象不为空，返回的实例对象的字典名称对应的值，如果为空，则是返回实例本身。
return instance.__dict__[self.name]
return self
class Person:
name = Check('name',str)
age = Check('age',int)
def __init__(self,name:str,age:int):
self.name = name
self.age = age
Person('tom',20)
Person('tom','20')
（2）利用装饰器
class Check:
def __init__(self,name,type):
self.name = name
self.type = type
def __set__(self, instance, value):
if not isinstance(value,self.type):
raise TypeError(value)
instance.__dict__[self.name] = value
def __get__(self, instance, owner):
if instance is not None:
return instance.__dict__[self.name]
return self
import inspect
def typeassert(cls):
params = inspect.signature(cls).parameters #获取签名
print(params)
for name,param in params.items():
print(param.name,param.annotation)
if param.annotation != param.empty:#设置的属性不为空，检查是否和设置的属性一致。
setattr(cls,name,Check(name,param.annotation))
return cls
@typeassert
class Person:
# name = Check('name',str)
# age = Check('age',int)
def __init__(self,name:str,age:int):
self.name = name
self.age = age
def __repr__(self):
return '{}is{}'.format(self.name,self.age)
p1 = Person('tom',20)
print(p1)
（3）封装成为类
class Check:
def __init__(self,name,type):
self.name = name
self.type = type
def __set__(self, instance, value):
if not isinstance(value,self.type):
raise TypeError(value)
instance.__dict__[self.name] = value
def __get__(self, instance, owner):
if instance is not None:
return instance.__dict__[self.name]
return self
import inspect
class typeassert #定义为一个类
# def typeassert(cls):
def __init__(self,cls):
self.cls = cls
params = inspect.signature(self.cls).parameters
print(params)
for name,param in params.items():
print(param.name,param.annotation)
if param.annotation != param.empty:
setattr(cls,name,Check(name,param.annotation))
print(self.cls.__dict__)
def __call__(self, name, age): #构建可调用对象。
p = self.cls(name,age) #重新构建一个新的Person对象。
return p
@typeassert
class Person:
# name = Check('name',str)
# age = Check('age',int)
def __init__(self,name:str,age:int):
self.name = name
self.age = age
def __repr__(self):
return '{}is{}'.format(self.name,self.age)
p1 = Person('tom',20)
print(p1)
7）练习题，模仿property装饰器。
class Property:
def __init__(self,fget,fset):
self.fget = fset
self.fset = fset
def __get__(self, instance, owner):
if instance in not None:
return self.fget(instance)
return self
def __set__(self, instance, value):
self.fset(instance,value)
def setter(self,fn):
self.fset = fn
return self
class A:
def __init__(self,data):
self._data = data
@Property #data = Property(data)
def data(self):
return self._data
@data.setter
def data(self,value):
self._data = value