python描述符在管理类属性访问时，若其内部用于存储实例值的属性名与描述符在类上定义的名称相同，将导致无限递归。本文深入解析了这一机制，通过示例代码演示了命名冲突如何引发无限循环，并提供了使用不同内部属性名的解决方案，以确保描述符的正确行为并避免递归调用。
Python描述符机制概览
Python描述符（Descriptor）是一种强大的协议，允许我们自定义类属性的访问、修改和删除行为。它通过在描述符类中实现__get__、__set__和__delete__方法来工作。当一个描述符实例被放置在另一个类的类属性上时，对该类实例上同名属性的访问就会被描述符协议拦截。
例如，我们可以创建一个记录属性访问日志的描述符：
import logging
logging.basicConfig(level=logging.INFO)
class LoggedAgeAccess:
"""一个记录年龄属性访问日志的描述符。"""
def __get__(self, obj, objtype=None):
if obj is None:
return self # 访问类属性时返回描述符本身
# 从实例的内部存储中获取值
value = obj._age
logging.info('Accessing %r giving %r', 'age', value)
return value
def __set__(self, obj, value):
# 将值存储到实例的内部属性中
logging.info('Updating %r to %r', 'age', value)
obj._age = value
class Person:
"""使用描述符管理年龄属性的类。"""
age = LoggedAgeAccess() # 描述符实例
def __init__(self, name, age):
self.name = name
self.age = age # 调用 LoggedAgeAccess.__set__()
def birthday(self):
self.age += 1 # 调用 LoggedAgeAccess.__get__() 和 __set__()
# 正常运行示例
mary = Person('Mary M', 30)
print(vars(mary))上述代码的输出如下：
INFO:root:Updating 'age' to 30
{'name': 'Mary M', '_age': 30}在这个例子中，LoggedAgeAccess 描述符将 age 属性的实际值存储在 Person 实例的 _age 属性中。当 mary.age = 30 发生时，LoggedAgeAccess.__set__ 方法被调用，它将值赋给 mary._age。同样，当访问 mary.age 时，LoggedAgeAccess.__get__ 方法被调用，它从 mary._age 中取值。这种方式避免了与描述符本身的名称 age 产生冲突。
立即学习“Python免费学习笔记（深入）”；
命名冲突导致的无限递归
现在，考虑如果我们将描述符内部用于存储值的属性名也设置为 age，会发生什么：
import logging
logging.basicConfig(level=logging.INFO)
class LoggedAgeAccessInfinite:
"""一个有命名冲突的描述符，会导致无限递归。"""
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 尝试从 obj.age 获取值，这将再次触发描述符的 __get__
value = obj.age
logging.info('Accessing %r giving %r', 'age', value)
return value
def __set__(self, obj, value):
# 尝试将值赋给 obj.age，这将再次触发描述符的 __set__
logging.info('Updating %r to %r', 'age', value)
obj.age = value # !!! 导致无限递归 !!!
class PersonWithConflict:
"""使用有命名冲突的描述符的类。"""
age = LoggedAgeAccessInfinite() # 描述符实例
def __init__(self, name, age):
self.name = name
self.age = age # 调用 LoggedAgeAccessInfinite.__set__()当我们尝试创建 PersonWithConflict 实例时：
# 运行以下代码将导致无限递归
# mary_conflict = PersonWithConflict('Mary C', 30) 程序会陷入一个无限循环，不断输出 INFO:root:Updating 'age' to 30，直到达到递归深度限制或内存耗尽。
递归发生的原因
这个无限递归的根本原因在于 Python 的属性查找机制。当我们在 PersonWithConflict 实例上执行 obj.age = value 时：
- Python 发现 PersonWithConflict 类上有一个名为 age 的描述符 (LoggedAgeAccessInfinite 实例)。
- 因此，它会调用该描述符的 __set__ 方法，即 LoggedAgeAccessInfinite.__set__(obj, value)。
- 在 LoggedAgeAccessInfinite.__set__ 方法内部，我们又执行了 obj.age = value。
- 这个 obj.age = value 表达式再次触发了描述符协议，导致 LoggedAgeAccessInfinite.__set__ 方法被递归调用。
- 这个过程无限重复，形成递归循环。
简而言之，描述符的 __set__ 和 __get__ 方法本身通过 obj.attribute_name 来访问实例属性时，如果 attribute_name 正是描述符在类上注册的名称，就会再次触发描述符协议，从而导致无限递归。
解决方案：使用不同的内部属性名
为了避免这种递归，描述符必须将实际的数据存储在实例的另一个属性名下，这个属性名不应该与描述符在类上的名称相同。通常，我们会使用一个以下划线开头的“私有”名称（例如 _age），或者直接操作实例的 __dict__ 字典。
以下是正确的实现方式：
import logging
logging.basicConfig(level=logging.INFO)
class LoggedAgeAccessCorrect:
"""正确实现，避免命名冲突的描述符。"""
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 从实例的 __dict__ 中获取实际存储的值
# 或者使用一个不同的属性名，如 obj._age
value = obj.__dict__['age'] # 直接访问实例字典
logging.info('Accessing %r giving %r', 'age', value)
return value
def __set__(self, obj, value):
# 将值存储到实例的 __dict__ 中
# 或者使用一个不同的属性名，如 obj._age = value
logging.info('Updating %r to %r', 'age', value)
obj.__dict__['age'] = value # 直接修改实例字典
class PersonCorrect:
"""使用正确描述符的类。"""
age = LoggedAgeAccessCorrect()
def __init__(self, name, age):
self.name = name
self.age = age # 调用 LoggedAgeAccessCorrect.__set__()
# 验证正确性
person_correct = PersonCorrect('Alice', 25)
print(vars(person_correct))
person_correct.birthday() # 假设 PersonCorrect 也有 birthday 方法
print(vars(person_correct))输出如下：
INFO:root:Updating 'age' to 25
{'name': 'Alice', 'age': 25}
INFO:root:Accessing 'age' giving 25
INFO:root:Updating 'age' to 26
{'name': 'Alice', 'age': 26}在这个修正后的版本中，LoggedAgeAccessCorrect 描述符直接通过 obj.__dict__['age'] 来访问和修改实例的底层字典。这样做的好处是，obj.__dict__['age'] 不会触发描述符协议，因为它直接操作字典，绕过了属性查找机制。
另一种更常见的做法是，在描述符内部使用一个与描述符名称不同的“私有”属性名（如 _age）来存储实际值，就像第一个示例那样。这种方法更具可读性，并且避免了直接操作 __dict__。
注意事项与最佳实践
- 避免命名冲突：这是核心原则。描述符内部用于存储值的属性名（例如 _age 或 __dict__['age']）必须与描述符在类上声明的名称（例如 age）不同。
- 理解属性查找顺序：Python 在查找属性时，会优先检查类上是否有描述符。如果存在，描述符协议就会被激活。只有当没有描述符或者描述符的 __get__ 方法返回 NotImplemented 时，才会去查找实例的 __dict__。
- 使用 property 简化：对于简单的属性管理（如验证、转换），Python 内置的 property 装饰器通常是更好的选择，因为它在内部实现了描述符协议，并自动处理了命名冲突的问题。只有当需要更复杂的行为（例如动态创建属性、管理多个相关属性、或者需要访问描述符实例本身）时，才需要手动创建描述符。
- 清晰的内部命名：为了代码的可读性和可维护性，建议在描述符内部使用一个带有前缀（如 _ 或 __）的属性名来存储实际值，以明确区分这是描述符的内部存储。
总结
Python描述符提供了一种强大的方式来控制属性访问，但正确使用它需要深入理解其工作原理。当在描述符的 __get__ 或 __set__ 方法中访问或设置实例属性时，务必确保所使用的属性名不会再次触发该描述符本身。通过使用不同的内部属性名（例如 _attribute_name）或直接操作实例的 __dict__，可以有效避免命名冲突导致的无限递归，确保描述符功能的正确实现。
