Python描述符(下):内置机制揭秘

阅读前提：建议先读完上篇和中篇。下篇会假设你已经理解描述符协议、数据/非数据描述符的优先级差异、以及 __set_name__ 的用法。

一、同一个协议

如果你认真读完了中篇的验证器框架，你现在应该已经有了一种模糊的感觉：

“我写的 Validator 类，干的活好像和 property 有点像？”

这个感觉是对的。而且它比"有点像"要深刻得多。在 Python 里，property、staticmethod、classmethod，以及你每天随手写的 def f(self) 自动变成的绑定方法——这些看似完全不同的东西，底层实现全都指向同一个协议：描述符。

官方文档在最后一部分给出了这个终极揭秘：

“描述器协议很简单，但它提供了令人兴奋的可能性。有几个用例非常通用，以至于它们已预先打包到内置工具中。属性、绑定方法、静态方法、类方法和 __slots__ 均基于描述器协议。”

本篇的目标非常具体：用纯 Python 代码把 property()、staticmethod()、classmethod()、以及函数为什么能变成绑定方法全部重写一遍。你会发现——你完全看得懂。因为上篇和中篇教给你的知识，已经足够让你理解 Python 最核心的内部设计。

二、property()：一个内置的数据描述符

property 的签名是 property(fget=None, fset=None, fdel=None, doc=None)。@property 装饰器本质上就是调用 Property(fget)，只传了 getter，其余三个为 None。

property 在底层就是一个数据描述符——它定义了 __get__ 和 __set__，所以当你访问 c.x 时，Python 走的是描述符调用路径，而不是直接去字典里抓值。

官方文档给出了 property 的纯 Python 等价实现。我们逐行拆开：

class Property:    """模拟内置 property() 的核心逻辑。"""    def __init__(self, fget=None, fset=None, fdel=None, doc=None):        self.fget = fget        self.fset = fset        self.fdel = fdel        if doc is None and fget is not None:            doc = fget.__doc__        self.__doc__ = doc    def __set_name__(self, owner, name):        self.__name__ = name    def __get__(self, obj, objtype=None):        if obj is None:            return self          # 类访问：返回 property 对象本身        if self.fget is None:            raise AttributeError        return self.fget(obj)  # 调用用户传入的 getter    def __set__(self, obj, value):        if self.fset is None:            raise AttributeError(f"property '{self.__name__}' has no setter")        self.fset(obj, value)    def __delete__(self, obj):        if self.fdel is None:            raise AttributeError(f"property '{self.__name__}' has no deleter")        self.fdel(obj)    def getter(self, fget):        return type(self)(fget, self.fset, self.fdel, self.__doc__)    def setter(self, fset):        return type(self)(self.fget, fset, self.fdel, self.__doc__)    def deleter(self, fdel):        return type(self)(self.fget, self.fset, fdel, self.__doc__)

逐行解析关键点：

__set_name__：记录属性名，用于报错时给出更清晰的提示。

__get__ 的 if obj is None：类访问 vs 实例访问。

print(C.x)    # 返回 Property 对象本身（因为 obj 为 None）print(c.x)    # 调用 self.fget(c)，返回 self._x

__set__ 抛 AttributeError：只读的秘密。如果你只写了 @property 但没写 @x.setter，self.fset 就是 None。当有人执行 c.x = 1 时，__set__ 被触发，发现没有 setter，抛出 AttributeError。这就是 property 实现只读属性的全部机制——和我们上篇写的 ReadOnly 描述符一模一样。

@x.setter 的本质：替换，不是修改。@x.setter 调用 Property.setter(fset)，返回一个新的 Property 实例，替换掉旧的。不是"给已有的 property 添加了一个 setter"，而是"创建了一个全新的 property，然后覆盖了旧的"。

官方文档对 property 的使用场景给出了精准说明：

“当用户接口已授权直接访问属性，但后续的变化要求通过方法来干预时，内置的 property() 就能派上用场。”

“例如，一个电子表格类可以通过 Cell('b10').value 授予对单元格值的访问权限。对程序的后续改进要求每次访问都要重新计算单元格；但是，程序员不希望影响直接访问该属性的现有客户端代码。解决方案是将对 value 属性的访问包装在属性数据描述器中。”

这就是 property 存在的理由：向后兼容。用户代码一直写 cell.value，后来需求变了，你不需要让用户改成 cell.get_value()，只需要在内部加一个 @property 把 value 包装起来，对用户完全透明。

三、函数为什么变成绑定方法：非数据描述符的完美应用

这是 Python 对象模型中最精巧的设计之一。我们来回答一个你可能问过自己但从未深究的问题：

为什么 self 会自动出现在方法调用的第一个参数位置？

3.1 现象观察

class D:    def f(self):        return selfprint(D.f)        # <function D.f at 0x...>  —— 类访问：是函数d = D()print(d.f)        # <bound method D.f of <...>>  —— 实例访问：是绑定方法print(d.f())      # <__main__.D object ...>  —— 调用时 self 自动传了 d

三个关键观察：

1. D.f
    是函数对象，不绑定任何东西。
2. d.f
    是绑定方法，它"记住"了 d 这个实例。
3. d.f()
    不需要你手动传 d，它自动把 d 作为 self 塞进去了。

这个"绑定"机制，完全由描述符实现。

3.2 函数对象的秘密：__get__

每一个 Python 函数（function 类型）在底层都定义了一个 __get__ 方法。因此，函数对象本身就是一个非数据描述符——它只定义了 __get__，没有 __set__ 或 __delete__。

官方文档给出了这个机制的核心逻辑：

class Function:    """模拟函数对象的描述符行为。"""    def __get__(self, obj, objtype=None):        if obj is None:            return self          # 类访问：返回函数本身        return MethodType(self, obj)  # 实例访问：返回绑定方法

就这么简单！if obj is None 对应类访问，返回原函数；否则返回 MethodType(self, obj)，也就是一个绑定方法对象。

3.3 绑定方法是什么？

MethodType 在 Python 标准库里真实存在，位于 types 模块。它的工作方式官方文档也给了纯 Python 等价实现：

class MethodType:    """模拟绑定方法：把原始函数和实例绑定在一起。"""    def __init__(self, func, obj):        self.__func__ = func      # 原始函数对象（如 D.f）        self.__self__ = obj       # 绑定的实例（如 d）    def __call__(self, *args, **kwargs):        func = self.__func__        obj = self.__self__        return func(obj, *args, **kwargs)  # 自动把实例塞到第一个参数

就是这么朴素的设计：

• __init__
  ：存下原始函数和实例。
• __call__
  ：调用时，把实例 obj 插到 args 最前面，再调用原始函数。

所以你写 d.f() 时，Python 实际执行的是 D.f(d)。那个神秘的 self，就这么光明正大地被描述符机制塞了进去。

3.4 为什么函数是非数据描述符？

函数是非数据描述符，所以实例字典可以覆盖它。这就是为什么下面的代码能工作：

d = D()d.f = 'not a method'print(d.f)        # 'not a method'

因为函数没有 __set__，它是非数据描述符。d.f = '...' 把值塞进了 d.__dict__，下次访问 d.f 时，Python 的查找规则是"实例字典优先于非数据描述符"，所以直接返回字符串，不再调用函数的 __get__。而 D.f 仍然返回原始函数，因为类访问根本不查实例字典。

这个设计的巧妙之处在于：它给了程序员一个"逃生舱"。如果你真的需要临时覆盖某个方法（比如在单元测试里 mock），可以直接在实例上赋值，不需要修改类定义。这是非数据描述符的"低优先级"带来的灵活性。

四、staticmethod 和 classmethod：两个特殊的非数据描述符

@staticmethod 和 @classmethod 看起来是两个独立的魔法，但它们的底层实现和函数绑定方法共享着同一套描述符协议。只是它们对 __get__ 的返回值做了不同的处理。

4.1 staticmethod：取消绑定，让类和实例访问完全一致

@staticmethod 的使用场景是：一个方法在概念上属于某个类，但它不需要访问实例（self）也不需要访问类（cls）。

class E:    @staticmethod    def f(x):        return x * 10print(E.f(3))     # 30print(E().f(3))   # 30  —— 完全一样！

staticmethod 的描述符实现非常简单——它根本不做任何绑定，原样返回底层函数：

class StaticMethod:    """模拟 @staticmethod。"""    def __init__(self, f):        self.f = f    def __get__(self, obj, objtype=None):        return self.f  # 无论类访问还是实例访问，都返回原函数

官方文档对此的描述是：

“静态方法返回底层函数，不做任何更改。调用 c.f 或 C.f 等效于通过 object.__getattribute__(c, 'f') 或 object.__getattribute__(C, 'f') 查找。这样该函数就可以从对象或类中进行相同的访问。”

4.2 classmethod：绑定类，而不是实例

@classmethod 的使用场景是：方法需要知道它属于哪个类，但不需要具体的实例。最典型的例子是 dict.fromkeys()：

class F:    @classmethod    def f(cls, x):        return cls.__name__, xprint(F.f(3))      # ('F', 3)print(F().f(3))    # ('F', 3)  —— 实例调用也传的是类！

classmethod 的描述符实现同样简洁，只是把绑定的目标从"实例"换成了"类"：

class ClassMethod:    """模拟 @classmethod。"""    def __init__(self, f):        self.f = f    def __get__(self, obj, cls=None):        if cls is None:            cls = type(obj)        return MethodType(self.f, cls)  # 绑定的是 cls（类），不是 obj（实例）

注意和函数描述符的区别：

• 函数描述符：MethodType(self, obj) —— 绑定实例。
• 类方法描述符：MethodType(self.f, cls) —— 绑定类。

所以当你调用 F().f(3) 时，cls 是 F，MethodType 在调用时会把 F 作为第一个参数 cls 传入。这就是为什么类方法里第一个参数叫 cls——和实例方法里叫 self 是同一个机制，只是绑定的对象不同。

官方文档给出了一个纯 Python 版的 dict.fromkeys 来说明这个机制的实战价值：

class Dict(dict):    @classmethod    def fromkeys(cls, iterable, value=None):        d = cls()          # 调用 cls() 而不是硬编码 dict()        for key in iterable:            d[key] = value        return d

关键点在 d = cls()：因为 fromkeys 是类方法，cls 可以是 Dict 本身，也可以是 Dict 的任何子类。这样返回的实例类型总是和调用方一致，不会因为硬编码 dict() 而丢失子类的行为。这是类方法最经典的用途之一：

“类方法的一种用途是创建备用类构造函数。”

4.3 三种方法的本质对比

现在把三种方法类型放在一张表里，看清它们的统一性：

三种都是非数据描述符，区别只在于 __get__ 返回时绑定了什么。Python 没有为每种方法类型写一套独立的机制，而是复用同一个描述符协议，只在 __get__ 的返回值上做文章。这就是 Python 设计哲学中"一种明显的方式去做一件事"的体现。

五、属性查找的完整决策链

了解了描述符的实现，我们还要理解描述符在什么时候被调用。这涉及到 Python 属性查找的完整机制。官方文档给出了 object.__getattribute__ 的纯 Python 等价实现。我们逐行拆开：

def find_name_in_mro(cls, name, default):    """模拟 CPython 中的 _PyType_Lookup()。"""    for base in cls.__mro__:        if name in vars(base):            return vars(base)[name]    return defaultdef object_getattribute(obj, name):    """模拟 PyObject_GenericGetAttr()。这是 obj.attr 的底层逻辑！"""    null = object()    objtype = type(obj)    # 第一步：在类及 MRO 中查找属性    cls_var = find_name_in_mro(objtype, name, null)    # 第二步：检查这个类属性是不是描述符（有没有 __get__）    descr_get = getattr(type(cls_var), '__get__', null)    if descr_get is not null:        # 第三步 A：如果它是数据描述符（有 __set__ 或 __delete__），        # 直接调用它，优先级最高！实例字典被完全忽略。        if (hasattr(type(cls_var), '__set__')             or hasattr(type(cls_var), '__delete__')):            return descr_get(cls_var, obj, objtype)    # 第四步：检查实例字典    if hasattr(obj, '__dict__') and name in vars(obj):        return vars(obj)[name]  # 实例属性优先于非数据描述符    # 第五步：如果它是非数据描述符（只有 __get__），调用它    if descr_get is not null:        return descr_get(cls_var, obj, objtype)    # 第六步：如果只是一个普通类属性，原样返回    if cls_var is not null:        return cls_var    # 第七步：全都没找到，抛 AttributeError    raise AttributeError(name)

这段代码虽然只有二十几行，但它就是 Python 属性访问的宪法。逐段理解：

• 第一步
  ：在类及 MRO 中查找。父类中的描述符也会被正确继承和触发。
• 第二步
  ：getattr(type(cls_var), '__get__', null) 检查 cls_var 的类型有没有定义 __get__。
• 第三步 A
  ：数据描述符永远压制实例字典。无论 obj.__dict__ 里有没有同名属性，都听它的。
• 第四步
  ：如果数据描述符检测没通过，Python 才来看实例字典。这就是非数据描述符被实例字典覆盖的原因。
• 第五步
  ：如果类属性有 __get__ 但没有 __set__/__delete__，而且实例字典里也没有，才调用它。这就是函数变成绑定方法的环节。
• 第六步
  ：普通类属性，直接返回。

关于 __getattr__，官方文档做了重要说明：

“注意，在 __getattribute__() 代码中没有 __getattr__() 钩子。这就是为什么直接调用 __getattribute__() 或用 super().__getattribute__ 会彻底绕过 __getattr__()。”

__getattr__ 是 getattr() 函数的兜底机制：当 __getattribute__ 抛出 AttributeError 时，getattr() 捕获这个异常，然后检查有没有定义 __getattr__，如果有就调用它。所以 __getattr__ 是在查找失败后才被调用的，不是查找过程的一部分。

六、三种访问路径的差异

同一个属性，通过三种不同的方式访问时，描述符的调用细节是不一样的。

通过实例访问：obj.attr

调用 type(obj).__getattribute__(obj, 'attr')，即上面详细拆解的 object_getattribute 逻辑。如果被调用的是描述符，传给 __get__ 的参数是：

descr.__get__(obj, type(obj))  # obj 不为 None

通过类访问：Cls.attr

类访问走的是 type.__getattribute__()。如果被调用的是描述符，传给 __get__ 的参数是：

descr.__get__(None, Cls)  # 第一个参数是 None

这就是为什么 D.f 返回原始函数而 d.f 返回绑定方法——函数描述符的 __get__ 检查 if obj is None，在类访问时直接返回 self，在实例访问时才返回 MethodType(self, obj)。

通过 super() 访问：super(A, obj).m

super() 是最复杂的一种。它的查找逻辑是：

1. 找到 obj.__class__.__mro__ 中 A 的下一个父类B。
2. 在 B 的类字典里查找 m。
3. 如果 m 是描述符，调用 B.__dict__['m'].__get__(obj, A)。
4. 如果不是描述符，直接返回值。

注意传给 __get__ 的第二个参数不是 type(obj)，而是 A（即你在 super() 里显式写出的那个类）。这个设计保证了方法解析的正确性，尤其是在多重继承的钻石结构中。

“类似 super(A, obj).m 形式的点分查找将在 obj.__class__.__mro__ 中搜索紧接在 A 之后的基类 B，然后返回 B.__dict__['m'].__get__(obj, A)。如果 m 不是描述器，则直接返回其值。”

七、属性查找决策链（流程图）

以下是 obj.attr 查找流程的完整图示。图中的每一个节点都对应 object.__getattribute__ 中的一行逻辑：

这张图就是 Python 属性查找的全部真相。property、method、staticmethod、classmethod，乃至你自己写的任何描述符，都是这张决策链上的不同节点。搞懂了这张图，你再回头看今天写的 Validator 框架，会恍然大悟：原来你早就在用 Python 最核心的设计哲学了。

八、总结：你已经站在门槛上了

走完三篇系列，你现在能够：

• 理解 property 不是魔法，而是一个你完全能自己写的数据描述符。
• 理解 self 不是编译器的特殊优待，而是函数描述符通过 MethodType 绑定进去的。
• 理解 classmethod 和 staticmethod 不是两套独立机制，而是对 __get__ 返回值的不同处理。
• 理解实例属性为什么能覆盖方法名（非数据描述符的低优先级），以及 property 为什么不能被覆盖（数据描述符的高优先级）。
• 理解 Django ORM、SQLAlchemy、甚至 Python 的 __slots__，底层都在用同一个描述符协议做不同的事。

更重要的是，你获得了一个元编程的视角：当你看到某个库用声明式语法（name = StringField(max_length=100)）实现了看似魔法的效果时，你的第一反应不再是"这库好复杂"，而是"这大概是描述符，让我看看它的 __set_name__ 和 __set__ 干了什么"。

这种直觉，是区分"能写 Python 代码"和"真正理解 Python"的分水岭。

感谢阅读。

本文核心概念与引用语句均忠实于 Python 官方中文文档 描述器指南。所有代码示例均经过 Python 3 实际运行验证。 被覆盖（数据描述符的高优先级）。

• 理解 Django ORM、SQLAlchemy、甚至 Python 的 __slots__，底层都在用同一个描述符协议做不同的事。

更重要的是，你获得了一个元编程的视角：当你看到某个库用声明式语法（name = StringField(max_length=100)）实现了看似魔法的效果时，你的第一反应不再是"这库好复杂"，而是"这大概是描述符，让我看看它的 __set_name__ 和 __set__ 干了什么"。

这种直觉，是区分"能写 Python 代码"和"真正理解 Python"的分水岭。