阅读前提 ：建议先读完上篇和中篇。下篇会假设你已经理解描述符协议、数据/非数据描述符的优先级差异、以及
__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 等价实现。我们逐行拆开：
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 实例访问。
python
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 现象观察
python
class D:
def f(self):
return self
print(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三个关键观察：
D.f是函数对象，不绑定任何东西。d.f是绑定方法，它"记住"了d这个实例。d.f()不需要你手动传d，它自动把d作为self塞进去了。
这个"绑定"机制，完全由描述符实现。
3.2 函数对象的秘密：__get__
每一个 Python 函数（function 类型）在底层都定义了一个 __get__ 方法。因此，函数对象本身就是一个非数据描述符 ------它只定义了 __get__，没有 __set__ 或 __delete__。
官方文档给出了这个机制的核心逻辑：
python
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 等价实现：
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 为什么函数是非数据描述符？
函数是非数据描述符，所以实例字典可以覆盖它。这就是为什么下面的代码能工作：
python
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）。
python
class E:
@staticmethod
def f(x):
return x * 10
print(E.f(3)) # 30
print(E().f(3)) # 30 ------ 完全一样！staticmethod 的描述符实现非常简单------它根本不做任何绑定，原样返回底层函数：
python
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()：
python
class F:
@classmethod
def f(cls, x):
return cls.__name__, x
print(F.f(3)) # ('F', 3)
print(F().f(3)) # ('F', 3) ------ 实例调用也传的是类！classmethod 的描述符实现同样简洁，只是把绑定的目标从"实例"换成了"类"：
python
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 来说明这个机制的实战价值：
python
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__ 返回值 |
调用时的第一个参数 |
|---|---|---|---|
| 普通函数 | 非数据描述符 | MethodType(func, obj) |
obj（实例）→ 即 self |
| staticmethod | 非数据描述符 | func（原函数） |
无自动绑定 |
| classmethod | 非数据描述符 | MethodType(func, cls) |
cls（类） |
三种都是非数据描述符，区别只在于 __get__ 返回时绑定了什么。Python 没有为每种方法类型写一套独立的机制，而是复用同一个描述符协议 ，只在 __get__ 的返回值上做文章。这就是 Python 设计哲学中"一种明显的方式去做一件事"的体现。
五、属性查找的完整决策链
了解了描述符的实现，我们还要理解描述符在什么时候被调用 。这涉及到 Python 属性查找的完整机制。官方文档给出了 object.__getattribute__ 的纯 Python 等价实现。我们逐行拆开：
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 default
def 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__ 的参数是：
python
descr.__get__(obj, type(obj)) # obj 不为 None通过类访问：Cls.attr
类访问走的是 type.__getattribute__()。如果被调用的是描述符，传给 __get__ 的参数是：
python
descr.__get__(None, Cls) # 第一个参数是 None这就是为什么 D.f 返回原始函数而 d.f 返回绑定方法------函数描述符的 __get__ 检查 if obj is None，在类访问时直接返回 self，在实例访问时才返回 MethodType(self, obj)。
通过 super() 访问：super(A, obj).m
super() 是最复杂的一种。它的查找逻辑是：
- 找到
obj.__class__.__mro__中A的下一个父类B。 - 在
B的类字典里查找m。 - 如果
m是描述符，调用B.__dict__['m'].__get__(obj, A)。 - 如果不是描述符，直接返回值。
注意传给 __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"的分水岭。
感谢阅读。