引入
描述符是 Python 语言中一个强大的特性，它隐藏在编程语言的底层，为许多神奇的魔法提供了便利。
假设你需要一个学生类，来记录考试的分数。简单写如下：
classStudent:def__init__(self, name, math):self.name = nameself.math = math
但是稍后发现分数为负值或者大于100是不合理的，上面的代码对输入参数没有任何检查。如下：
>>> stu = Student("a", -90)>>> stu.math-90
于是修改代码做限制：
classStudent:def__init__(self, name, math):self.name = nameif math < 0or math > 100:raise ValueError('math score must >= 0 and < 100')self.math = math
但这样也没解决问题，因为分数虽然在初始化时不能为负，但后续修改时还是可以输入非法值：
>>> stu = Student("a", 90)>>> stu.math90>>> stu.math = -100>>> stu.math-100
为了解决以上问题，可以使用 @property。代码如下：
classStudent:def__init__(self, name, math):self.name = nameself._math = math @propertydefmath(self):# self.math 取值returnself._math @math.setterdefmath(self, value):# self.math 赋值if value < 0or value > 100:raise ValueError('math score must >= 0 and < 100')self._math = value
简单来说就是 @property 接管了对 math 属性的直接访问，而是将对应的取值赋值转交给 @property 封装的方法。
虽然 @property 已经表现得比较完美了，但是它最大的问题是不能重用。如果要同时保存其他课程的成绩，这个类就会变成这样：
classStudent:def__init__(self, name, math, chinese, english):self.name = nameself._math = mathself._chinese = chineseself._english = english @propertydefmath(self):returnself._math @math.setterdefmath(self, value):if0 <= value <= 100:self._math = valueelse:raise ValueError("Valid value must be in [0, 100]") @propertydefchinese(self):returnself._chinese @chinese.setterdefchinese(self, value):if0 <= value <= 100:self._chinese = valueelse:raise ValueError("Valid value must be in [0, 100]") @propertydefenglish(self):returnself._english @english.setterdefenglish(self, value):if0 <= value <= 100:self._english = valueelse:raise ValueError("Valid value must be in [0, 100]")
虽然外部调用时依然简洁，但掩盖不了类内部的臃肿。
描述符就可以很好的解决上面的代码重用问题。
什么是描述符
描述符，一个实现了描述符协议的类就是一个描述符。
什么描述符协议：在类里实现了 __get__()、__set__()、__delete__() 其中至少一个方法。
__get__：用于访问属性。它返回属性的值，若属性不存在、不合法等都可以抛出对应的异常。
__set__：将在属性分配操作中调用。不会返回任何内容。
__delete__：控制删除操作。不会返回内容。
__get__ 方法中有三个参数：
self：描述符实例
instance：描述符所附加的对象的实例
owner：描述符所附加的对象的类型
__set__ 方法中也有三个参数：
self：描述符实例
instance：描述符所附加的对象的实例
value：当前准备赋的值
__delete__ 方法中有两个参数：
self：描述符实例
instance：描述符所附加的对象的实例
前面的例子中，我们把分数抽象为描述符，代码改为如下：
classScore:def__init__(self, name):self.name = namedef__set__(self, instance, value):ifnotisinstance(value, int):raise TypeError('Score must be integer')ifnot0 <= value <= 100:raise ValueError('Valid value must be in [0, 100]') instance.__dict__[self.name] = valuedef__get__(self, instance, owner):return instance.__dict__.get(self.name, 0)def__delete__(self, instance):del instance.__dict__[self.name]classStudent: math = Score('math') chinese = Score('chinese') english = Score('english')def__init__(self, name, math, chinese, english):self.name = nameself.math = mathself.chinese = chineseself.english = englishdef__repr__(self):return"<Student: {}, math:{}, chinese: {}, english:{}>".format(self.name, self.math, self.chinese, self.english )
当从 Student 的实例访问 math、chinese、english 这三个属性的时候，都会经过 Score 类里的三个特殊的方法。这里的 Score 避免了使用 Property 出现大量的代码无法复用的尴尬。
描述符给我们带来的编码上的便利，它在实现保护属性不受修改、属性类型检查的基本功能，同时有大大提高代码的复用率。
描述符可以用一句话概括：描述符是可重用的属性，它把函数调用伪装成对属性的访问。
描述符类型
描述符分两种：
数据描述器和非数据描述器的区别在于：它们相对于实例的字典的优先级不同。
如果实例字典中有与描述符同名的属性，如果描述符是数据描述符，优先使用数据描述符，如果是非数据描述符，优先使用字典中的属性。
看下面一个例子：
# 数据描述符classDataDes:def__init__(self, default=0):self._score = defaultdef__set__(self, instance, value):self._score = valuedef__get__(self, instance, owner):print("访问数据描述符里的 __get__")returnself._score# 非数据描述符classNoDataDes:def__init__(self, default=0):self._score = defaultdef__get__(self, instance, owner):print("访问非数据描述符里的 __get__")returnself._scoreclassStudent: math = DataDes(0) chinese = NoDataDes(0)def__init__(self, name, math, chinese):self.name = nameself.math = mathself.chinese = chinesedef__getattribute__(self, item):print("调用 __getattribute__")returnsuper().__getattribute__(item)def__repr__(self):return"<Student: {}, math:{}, chinese: {}>".format(self.name, self.math, self.chinese )
上面例子中，math 是数据描述符，而 chinese 是非数据描述符。从下面的验证中，可以看出，当实例属性和数据描述符同名时，会优先访问数据描述符（如下面的 math），而当实例属性和非数据描述符同名时，会优先访问实例属性（__getattribute__）。
>>> std = Student('xm', 88, 99)>>>>>> std.math调用 __getattribute__访问数据描述符里的 __get__88>>> std.chinese调用 __getattribute__99
当访问对象的某个属性时，其查找链简单来说就是：
首先在对应的数据描述符中查找此属性。
如果失败，则在对象的 __dict__ 中查找此属性。
如果失败，则在非数据描述符中查找此属性。
如果失败，再去别的地方查找。（本文就不展开了）
共享陷阱
描述符有一个非常迷惑人的特性：在同一个类中每个描述符仅实例化一次，也就是说所有实例共享该描述符实例。
看下面一个例子：
classNonNegative:"""检查输入值不能为负"""def__get__(self, instance, owner=None):returnself.valuedef__set__(self, instance, value):if value < 0:raise ValueError('score must >= 0')# 数据被绑定在描述符实例上# 由于描述符实例是共享的# 因此数据也只有一份被共享self.value = valueclassScore: math = NonNegative()def__init__(self, math):self.math = mathscore_1 = Score(10)score_2 = Score(20)# 所有对象共享同一个描述符实例print(score_1.math, score_2.math)# 输出: 20 20score_1.math = 30print(score_1.math, score_2.math)# 输出: 30 30
修改某个实例的值后，所有实例跟着一起改变了。这通常不是你想要的结果。
要破除这种共享状态，比较好的解决方式是将数据绑定到使用描述符的对象实例上，就像开头的例子所做的那样：
classNonNegative:"""检查输入值不能为负"""def__init__(self, name):self.name = namedef__get__(self, instance, owner=None):return instance.__dict__.get(self.name)def__set__(self, instance, value):if value < 0:raise ValueError(f'{self.name} score must >= 0')# 数据被绑定在描述符附加的对象上# 因此保持了对象之间的数据隔离 instance.__dict__[self.name] = valueclassScore: math = NonNegative('math')def__init__(self, math):self.math = math
唯一有些不爽的是，为了给数据属性规定一个名字，在定义描述符的时候 NonNegative('math') 还得传递 math 这个名字进去，有点多此一举。
幸好 Python 3.6 为描述符引入了 __set_name__ 方法，现在你可以这样：
classNonNegative:# 注意这里# __init__ 也没有了def__set_name__(self, owner, name):self.name = namedef__get__(self, instance, owner=None):return instance.__dict__.get(self.name)def__set__(self, instance, value):if value < 0:raise ValueError(f'{self.name} score must >= 0') instance.__dict__[self.name] = valueclassScore:# NonNegative() 不需要带参数以规定属性名了 math = NonNegative()def__init__(self, math):self.math = math
应用场景
验证器
用描述符实现一个规范的验证器。
首先定义一个仅具有基础功能的验证器抽象基类：
from abc import ABC, abstractmethodclassValidator(ABC):"""验证器抽象基类"""def__set_name__(self, owner, name):self.private_name = '_' + namedef__get__(self, instance, owner=None):returngetattr(instance, self.private_name)def__set__(self, instance, value):self.validate(value)setattr(instance, self.private_name, value) @abstractmethoddefvalidate(self, value):pass
Validator 描述符类定义了 validate 方法，用于子类覆写以执行具体的验证逻辑。__get__ 和 __set__ 表明这是类是数据描述符。
写好这个基类，接下来就可以写实际用到的验证器子类了。
比如写两个子类：
classOneOf(Validator):"""字符串单选验证器"""def__init__(self, *options):self.options = set(options)defvalidate(self, value):if value notinself.options:raise ValueError(f'Expected {value!r} to be one of {self.options!r}')classNumber(Validator):"""数值类型验证器"""defvalidate(self, value):ifnotisinstance(value, (int, float)):raise TypeError(f'Expected {value!r} to be an int or float')
OneOf 用于确保输入值为固定的某种类型。Number 用于确保输入值必须为数值型。它们均以 Validator 为父类，并实现了 validate 方法。
像这样使用它们：
classComponent: kind = OneOf('wood', 'metal', 'plastic') quantity = Number()def__init__(self, kind, quantity):self.kind = kindself.quantity = quantity
实际操作试试效果：
>>> Component('abc', 100)Traceback (most recent call last): ...ValueError: Expected 'abc' to be one of {'metal', 'plastic', 'wood'}>>> Component('wood', 'notNum')Traceback (most recent call last): ...TypeError: Expected 'notNum' to be an intorfloat>>> c = Component('wood', 100)>>> c<__main__.Component object at 0x...>
再试试赋值：
>>> c = Component('wood', 100)>>> c.kind = 'abc'ValueError: Expected 'abc' to be one of {'metal', 'plastic', 'wood'}>>> c.kind'wood'>>> c.kind = 'metal'>>> c.kind'metal'>>> c.quantity = 'haha'TypeError: Expected 'haha' to be an int or float>>> c.quantity = 20>>> c.quantity20
很顺利的实现了验证器的功能。
ORM
利用元类和描述符实现 ORM 的功能。
import numbersclassField:passclassCharField(Field):# 数据描述符# 好处在于可以在各方法中校验传入值的合理性def__init__(self, col_name, max_length):if col_name isNoneornotisinstance(col_name, str):raise ValueError("col_name must be given as str")if max_length isNoneornotisinstance(max_length, numbers.Integral):raise ValueError("max_length must be given as int")self._col_name = col_nameself._max_length = max_lengthdef__get__(self, instance, owner):return instance.fields[self._col_name]def__set__(self, instance, value):# 这里如果 col_name 和数据描述符对应的名字一样的话，如 name=CharField(col_name="name", 10)# 用 setattr(instance, self._col_name, value) 即 user.name=value 会再次进入此 __set__ 方法，导致无限递归 instance.fields[self._col_name] = valueclassIntField(Field):def__init__(self, col_name, min_length, max_length):self._col_name = col_nameself._min_length = min_lengthself._max_length = max_lengthdef__get__(self, instance, owner):return instance.fields[self._col_name]def__set__(self, instance, value):if value isNoneor (notisinstance(value, numbers.Integral)):raise ValueError("value must be given as int") instance.fields[self._col_name] = valueclassModelMetaClass(type):# 元类：这个类主要用来实例化我们定义的 Model 的时候，提前做一些事def__new__(cls, cls_name, base_class, attrs):if cls_name == "Model":returnsuper().__new__(cls, cls_name, base_class, attrs) fields = {}for k, v in attrs.items():ifisinstance(v, Field): fields[k] = v attrs["fields"] = fields _meta = {} attrs_meta = attrs.get("Meta", None)if attrs_meta isnotNoneandisinstance(attrs_meta, type): _meta["tb_name"] = getattr(attrs_meta, "tb_name", cls_name)del attrs["Meta"]else: _meta["tb_name"] = cls_name.lower() attrs["_meta"] = _metareturnsuper().__new__(cls, cls_name, base_class, attrs)classModel(metaclass=ModelMetaClass):# 这个类用来把类属性设置为实例属性def__init__(self, **kwargs):self.fields = {}for k, v in kwargs.items():setattr(self, k, v)classUser(Model): name = CharField(col_name="name", max_length=10) sex = CharField(col_name="sex", max_length=1) age = IntField(col_name="age", min_length=1, max_length=10)classMeta: tb_name = "User"classCompany(Model): name = CharField(col_name="name", max_length=10) address = CharField(col_name="address", max_length=1)if __name__ == "__main__": user = User(name="boy1", age=5, sex="男") user1 = User(name="girl1", age=6, sex="女") company = Company(name="com", address="China")print(User.__dict__)print(user.__dict__)print(user1.__dict__)print(Company.__dict__)print(company.__dict__)
