本文深入探讨了python描述符在使用过程中，当描述符内部用于存储实例数据的属性名与描述符在类上绑定的属性名相同时，为何会导致无限递归的问题。文章详细解释了python描述符协议的工作原理，并通过代码示例演示了这一陷阱及其背后的机制，最终提供了避免此问题的最佳实践和解决方案，强调了使用不同属性名进行内部存储的重要性。
理解Python描述符与属性访问机制
Python描述符（Descriptor）是一种强大的元编程工具，它允许我们自定义类属性的访问、赋值和删除行为。通过实现特殊方法 __get__、__set__ 和 __delete__，描述符可以拦截对其所属类实例属性的访问操作。当一个类属性被赋值为一个描述符实例时，对该属性的访问将不再直接操作实例的 __dict__，而是通过调用描述符的相应方法来完成。
例如，一个典型的描述符结构如下：
import logging
logging.basicConfig(level=logging.INFO)
class LoggedAccess:
def __init__(self, storage_name):
self.storage_name = storage_name
def __get__(self, obj, objtype=None):
if obj is None:
return self # Return the descriptor itself if accessed via class
value = getattr(obj, self.storage_name)
logging.info('Accessing %r giving %r', self.storage_name, value)
return value
def __set__(self, obj, value):
logging.info('Updating %r to %r', self.storage_name, value)
setattr(obj, self.storage_name, value)
class Person:
# 假设我们想要管理 'age' 属性
# descriptor_age = LoggedAccess('_age') # 正确做法，内部存储名为 '_age'
def __init__(self, name, age):
self.name = name
# self.age = age # 这将调用描述符的 __set__ 方法在这个例子中，LoggedAccess 是一个描述符。当它被绑定到 Person 类的一个属性上时（例如 age = LoggedAccess('_age')），每次对 person_instance.age 的访问或赋值，都会触发 LoggedAccess 实例的 __get__ 或 __set__ 方法。
同名属性引发的无限递归陷阱
问题出现在描述符内部用于实际存储数据的属性名与描述符在类上被绑定的属性名相同时。让我们看一个导致无限递归的错误示例：
立即学习“Python免费学习笔记（深入）”；
import logging
logging.basicConfig(level=logging.INFO)
class LoggedAgeAccessBroken:
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 错误：这里试图访问 obj.age，但 obj.age 已经被描述符管理
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，这将再次调用本 __set__ 方法
obj.age = value
class Person:
age = LoggedAgeAccessBroken() # 描述符实例，管理 'age' 属性
def __init__(self, name, age):
self.name = name
self.age = age # 第一次调用 LoggedAgeAccessBroken.__set__()
def birthday(self):
self.age += 1当我们尝试创建 Person 类的实例并赋值 age 属性时：
mary = Person('Mary M', 30)
# 预期输出：无限循环的 INFO:root:Updating 'age' to 30运行上述代码，会观察到 __set__ 方法的日志信息不断输出，最终导致栈溢出错误。
为什么会发生无限递归？
核心原因在于Python的属性查找机制和描述符协议。当在 Person 类的实例 mary 上执行 mary.age = 30 时：
- Python发现 Person 类上有一个名为 age 的属性，并且它是一个描述符（LoggedAgeAccessBroken 的实例）。
- Python调用 LoggedAgeAccessBroken 实例的 __set__(mary, 30) 方法。
- 在 __set__ 方法内部，代码执行 obj.age = value（即 mary.age = 30）。
- 此时，Python再次发现 Person 类上有一个名为 age 的属性，并且它是一个描述符。
- Python再次调用 LoggedAgeAccessBroken 实例的 __set__(mary, 30) 方法。
- 这个过程无限循环，直到系统资源耗尽。
简而言之，obj.age = value 这行代码本身就会触发描述符协议，导致 __set__ 方法的递归调用。
解决方案：使用不同的内部存储名称
为了避免这种无限递归，描述符必须将实际的数据存储在实例的 __dict__ 中，并且使用的属性名要与描述符在类上绑定的属性名不同。通常，我们会使用一个带下划线的前缀（例如 _age）来表示这是描述符的内部存储属性。
以下是修正后的描述符实现：
import logging
logging.basicConfig(level=logging.INFO)
class LoggedAgeAccessCorrect:
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 从实例的内部属性 '_age' 获取值
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)
# 将值存储到实例的内部属性 '_age'
obj._age = value
class Person:
age = LoggedAgeAccessCorrect() # 描述符实例，管理 'age' 属性
def __init__(self, name, age):
self.name = name
self.age = age # 调用 LoggedAgeAccessCorrect.__set__()
def birthday(self):
self.age += 1 # 调用 __get__() 和 __set__()
# 运行修正后的代码
mary = Person('Mary M', 30)
print(vars(mary))
mary.birthday()
print(vars(mary))输出：
INFO:root:Updating 'age' to 30
{'name': 'Mary M', '_age': 30}
INFO:root:Accessing 'age' giving 30
INFO:root:Updating 'age' to 31
{'name': 'Mary M', '_age': 31}现在，代码按预期工作。当 LoggedAgeAccessCorrect.__set__ 方法执行 obj._age = value 时，它直接操作了实例 mary 的 __dict__，为 mary 对象创建或更新了一个名为 _age 的属性。因为 _age 不是一个描述符，所以这个赋值操作不会再次触发描述符协议，从而避免了递归。同样，obj._age 的读取操作也不会触发描述符。
总结与最佳实践
- 明确职责分离：描述符的主要职责是管理对特定属性的访问逻辑，而不是直接存储数据。数据本身应该存储在实例的 __dict__ 中。
- 使用不同的内部存储名称：在描述符的 __get__ 和 __set__ 方法中，用于在实例上实际存储和检索数据的属性名，必须与描述符在类上绑定的属性名不同。
- 命名约定：通常，我们会使用一个以下划线 _ 开头的属性名（例如 _value 或 _age）作为描述符的内部存储名称，这是一种约定俗成的做法，表示这是一个内部使用的属性。
- 理解描述符协议：深入理解Python的属性查找顺序和描述符协议是正确使用描述符的关键。当访问 obj.attribute 时，Python会优先检查 attribute 是否为描述符，如果是，则调用描述符的方法；否则，才会查找 obj.__dict__。
通过遵循这些原则，我们可以有效地利用Python描述符的强大功能，实现更灵活、更可控的属性管理。
