什么是描述符

描述符，是一个类，定义了另一个类的属性的访问方式，即一个类可以将属性管理委托给另一个类

特别注意：必须把描述符定义成这个类的类属性，不能为定义到构造函数中

描述符协议

描述符类基于三种特殊方法组成了描述符协议： set(self, instance, value)：为一个属性赋值时触发(仅对实例起作用) 调用此方法以设置 instance 指定的所有者类的实例的属性为新值 value。

get(self, instance, owner=None)：调用一个属性时触发(访问owner类或owner类实例对应属性) 调用此方法以获取所有者类的属性或该类的实例的属性（类属性访问/类实例属性访问） 可选的参数owner参数是所有者类, instance是用来访问属性的实例 owner：描述符对象所绑定的类 instance：假如用实例来访问描述符属性，该参数值为实例对象，如果通过类访问，该值为None

delete(self, instance)：删除一个属性时触发 调用此方法以删除 instance 指定的所有者类的实例的属性

使用描述符

最常见的方式是把它的实例对象设置为其他类(常被称为owner类)的属性

实现语法

其中，类中实现了get()和set()的描述符称为数据描述符，只实现了get()的被称为非数据描述符

  1. class M:
  2.     def __init__(self, x=1):
  3.         self.x = x
  5.     def __get__(self, instance, owner):
  6.         print("调用__get__方法")
  7.         return self.x
  9.     def __set__(self, instance, value):
  10.         print("调用__set__方法")
  11.         self.x = value
  14. class AA:
  15.     m = M(x=2) # 类属性m被M()代理
  16. if __name__ == '__main__':
  17.     a = AA()
  18.     print(a.m)
  19.     a.m = 30
  20.     print(a.m)
  21.  -------------------------
  22. #调用__get__方法
  23. #2
  24. #调用__set__方法
  25. #调用__get__方法
  26. #30

由上例子可得，如果一个类中的某个属性有数据描述符，那么每次查找这个属性都会调用描述符的get()这个方法并返回其值，每次对这个属性进行赋值，都会调用描述符的set()方法

通过类、实例访问描述符

  1. class Descriptor(object):
  3.     def __get__(self, instance, owner=None):
  4.         print(f"Call __get__, instance: {instance}, owner: {owner}")
  5.         # 当不是通过实例访问时，直接返回描述符对象
  6.         if not instance:
  7.             print(f"instance not exists, return {self}")
  8.             return self
  9.         return 'test descriptor'
  12. class Foo:
  13.     bar = Descriptor()
  15. """通过类访问描述符"""
  16. # Call __get__, instance: None, owner: <class '__main__.Foo'>
  17. # instance not exists, return <__main__.Descriptor object at 0x7fa610adc5f8>
  18. Foo.bar
  20. """类实例访问描述符"""
  21. # Call __get__, instance: <__main__.Foo object at 0x7fa610adc630>, owner: <class '__main__.Foo'>
  22. Foo().bar

应用场景

实例1-1

  1. class Students:
  2.     def __init__(self, name, math, chinese):
  3.         self._chinese = chinese
  4.         self._math = math
  5.         self.name = name
  7.     @property
  8.     def math(self):
  9.         return self._math
  11.     @math.setter
  12.     def math(self, value):
  13.         if 0 <= value <= 100:
  14.             self._math = value
  15.         else:
  16.             raise ValueError("valid error!")
  18.     @property
  19.     def chinese(self):
  20.         return self._chinese
  22.     @chinese.setter
  23.     def chinese(self, value):
  24.         if 0 <= value <= 100:
  25.             self._chinese = value
  26.         else:
  27.             raise ValueError("valid error!")
  30. if __name__ == '__main__':
  31.     std = Students("zaygee", '33', '67')
  32.     print(std.name)
  33.     print(std.math)
  34. ---------------------------------
  35. #zaygee
  36. #33
  37. #67

上面的例子类中两个类属性：math、chinese，都使用了property对属性的合法性进行了有效控制，就是代码太冗余了
当我们使用描述符对上面的例子进行重写

  1. class Score:
  2.     def __init__(self, default=0):
  3.         self._score = default
  5.     def __set__(self, instance, value):
  6.         if not isinstance(value, int):
  7.             raise TypeError("sccore error！")
  8.         if not 0 <= value <= 100:
  9.             raise ValueError("valid error!")
  10.         self._score = value
  12.     def __get__(self, instance, owner):
  13.         return self._score
  15.     def __delete__(self):
  16.         del self._score
  19. class Students:
  21.     math = Score(0)
  22.     chinese = Score(0)
  24.     def __init__(self, name, math, chinese):
  25.         self._chinese = chinese
  26.         self._math = math
  27.         self.name = name
  29. if __name__ == '__main__':
  30.     std = Students("zaygee", '33', '67')
  31.     print(std.name)
  32.     print(std.math)
  33.     print(std.chinese)
  35. ----------------------------------
  36. #zaygee
  37. #33
  38. #67

应用场景-解决所有实例共享描述符

以上例子中，因为math其实是类变量，所以创建多个实例访问math其实是相当于访问类变量，会造成创建多个实例共享了描述符的情况，可以修改将变量的访问作用于instance上，使得实例之间类变量访问的隔离性

  1. class Score:
  3.     def __init__(self, subject):
  4.         self.name = subject
  6.     def __get__(self, instance, owner):
  7.         print("Call __get__ func")
  8.         # 变量的访问直接作用于instance上
  9.         return instance.__dict__[self.name]
  11.     def __set__(self, instance, value):
  12.         if 0<= value <= 100:
  13.             # 变量的设置也是一样作用于instance上
  14.             instance.__dict__[self.name] = value
  15.         else:
  16.             raise ValueError

应用场景-一个类定义多个描述符覆盖问题

可通过使用 **set_name(self, owner, name)** 方法解决此问题 owner: 描述符对象当前绑定的类 name: 描述符所绑定的属性名称

  1. class Descriptor(object):
  3.     def __init__(self, min_value: int = 0, max_value: int = 0):
  4.         self.min_value = min_value
  5.         self.max_value =  max_value
  9.     def __get__(self, instance, owner=None):
  10.         print(f"Call __get__, instance: {instance}, owner: {owner}")
  11.         # 当不是通过实例访问时，直接返回描述符对象
  12.         if not instance:
  13.             print(f"instance not exists, return {self}")
  14.             return self
  15.         return instance.__dict__.get('field')
  18.     def __set__(self, instance, value):
  19.         value = self._validate_value(value)
  20.         instance.__dict__['field'] = value
  23.     def _validate_value(self, value):
  25.         try:
  26.             value = int(value)
  29.         except (KeyError, ValueError):
  30.             raise ValueError('Value is not a valid integer!')
  32.         if not self.min_value < value < self.max_value:
  33.                 raise ValueError("not self.min_value < value < self.max_value")
  35.         return value
  38. class Foo:
  39.     bar = Descriptor(min_value=0, max_value=3)
  40.     bar2 = Descriptor(min_value=0, max_value=4)
  43. # Call __get__, instance: <__main__.Foo object at 0x7fa610adc630>, owner: <class '__main__.Foo'>
  44. r = Foo()
  45. r.bar = 2
  46. # Call __get__, instance: <__main__.Foo object at 0x7f1c8ce5c7f0>, owner: <class '__main__.Foo'>
  47. # 2
  48. print(r.bar)
  49. # Call __get__, instance: <__main__.Foo object at 0x7f1c8ce5c7f0>, owner: <class '__main__.Foo'>
  50. # 2
  51. print(r.bar2)
  53. """
  54. 上面Foo类的bar、bar2都使用了Descriptor描述符，但是两个字段出现了相互覆盖的情况，可通过__set_name__ 方法解决
  55. """
  57. class Descriptor(object):
  59.     def __init__(self, min_value: int = 0, max_value: int = 0):
  60.         self.min_value = min_value
  61.         self.max_value =  max_value
  64.     def __set_name__(self, owner, name):
  65.         # 将绑定属性名保存在描述符对象中
  66.         # 对于bar = Descriptor(min_value=0, max_value=3)，name就是 "bar"了
  67.         print(f"Call __set_name__ fun ,owner: {owner}, name: {name}")
  68.         self._name = name
  70.     def __get__(self, instance, owner=None):
  71.         print(f"Call __get__, instance: {instance}, owner: {owner}")
  72.         # 当不是通过实例访问时，直接返回描述符对象
  73.         if not instance:
  74.             print(f"instance not exists, return {self}")
  75.             return self
  76.         return instance.__dict__.get(self._name)
  79.     def __set__(self, instance, value):
  80.         value = self._validate_value(value)
  81.         instance.__dict__[self._name] = value
  84.     def _validate_value(self, value):
  86.         try:
  87.             value = int(value)
  90.         except (KeyError, ValueError):
  91.             raise ValueError('Value is not a valid integer!')
  93.         if not self.min_value < value < self.max_value:
  94.                 raise ValueError("not self.min_value < value < self.max_value")
  96.         return value
  99. class Foo:
  100.     bar = Descriptor(min_value=0, max_value=3)
  101.     bar2 = Descriptor(min_value=0, max_value=4)
  103. # Call __set_name__ fun ,owner: <class '__main__.Foo'>, name: bar
  104. # Call __set_name__ fun ,owner: <class '__main__.Foo'>, name: bar2
  105. # Call __get__, instance: <__main__.Foo object at 0x7fa610adc630>, owner: <class '__main__.Foo'>
  106. r = Foo()
  107. r.bar = 2
  108. # Call __get__, instance: <__main__.Foo object at 0x7f1c8ce5c7f0>, owner: <class '__main__.Foo'>
  109. # 2
  110. print(r.bar)
  111. # Call __get__, instance: <__main__.Foo object at 0x7f1c8ce5c7f0>, owner: <class '__main__.Foo'>
  112. # None
  113. print(r.bar2)

实例1-2：以下类.属性调用方式，会报错：AttributeError: ‘NoneType’ object has no attribute ‘dict‘
原因：类去操作属性，会传None给instance
解决方法：if instance is None:return self

  1. class Str:
  2.     def __init__(self, name):
  3.         self.name = name
  5.     def __get__(self, instance, owner):
  6.         print("__get__-->", instance, owner)
  7.         return instance.__dict__[self.name]
  9.     def __set__(self, instance, value):
  10.         print('__set__-->', instance, value)
  11.         instance.__dict__[self.name] = value
  13.     def __delete__(self, instance):
  14.         print('__delete__-->', instance)
  15.         instance.__dict__.pop(self.name)
  18. class People:
  19.     name = Str('name')
  21.     def __init__(self, name, age, salary):
  22.         self.name = name
  23.         self.age = age
  24.         self.salary = salary
  27. print(People.name)
  28. -----------------
  29. #    return instance.__dict__[self.name]
  30. #AttributeError: 'NoneType' object has no attribute '__dict__'
  31. #__get__--> None <class '__main__.People'>

描述符拓展

https://blog.csdn.net/qq_27825451/category_9282212.html

描述符是python中复杂属性访问的基础，它在内部被用于实现property、方法、类方法、静态方法和super类型

调用优先级：类属性>数据描述符>实例属性>非数据描述符>找不到的属性触发getattr()

数据描述符和非数据描述符的区别

两者最大的区别主要体现在 所绑定实例的属性存取优先级上 对于非数据描述符，可直接用 instance.attr = xxx，在实例级别重写描述符属性attr，让其读取逻辑不受get方法控制。 对于数据描述符，数据描述符所定义的属性存储逻辑比实例属性优先级高，无法直接重写修改