本文深入探讨了python描述符机制中一个常见的陷阱：当描述符管理的属性名与实例内部存储该值的属性名相同时，可能导致无限递归。文章通过具体代码示例，详细解释了这种冲突的产生原因，并提供了两种有效的解决方案：使用内部私有属性名或直接调用`object.__setattr__`绕过描述符协议，以确保属性访问的正确性和效率。
Python描述符简介
Python描述符（Descriptor）是一种强大的协议，允许我们自定义类属性的访问、修改和删除行为。它通过在类中定义特殊方法 __get__、__set__ 和 __delete__ 来实现。当一个类属性被定义为一个描述符实例时，对该属性的访问操作（如 obj.attr 或 obj.attr = value）将不再直接操作实例的 __dict__，而是通过调用描述符实例中对应的方法来完成。
描述符的典型应用场景包括：
- 数据验证： 在设置属性值时进行类型检查、范围检查等。
- 延迟计算： 属性值在首次访问时才进行计算。
- 日志记录： 记录属性的访问和修改操作。
- 缓存： 缓存属性的计算结果。
描述符与实例属性同名导致的递归问题
在使用描述符时，一个常见的陷阱是描述符内部用于存储实际值的属性名与外部暴露给用户的属性名发生冲突。这通常会导致无限递归。
考虑以下一个简单的日志记录年龄访问的描述符示例：
立即学习“Python免费学习笔记（深入）”；
import logging
logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(name)s:%(message)s')
class LoggedAgeAccess:
"""一个记录年龄访问日志的描述符"""
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 尝试从实例的内部属性 '_age' 获取值
value = obj._age
logging.info('Accessing age: %r', value)
return value
def __set__(self, obj, value):
# 尝试将值存储到实例的内部属性 '_age'
logging.info('Updating age to: %r', 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(f"Mary's attributes: {vars(mary)}") # {'name': 'Mary M', '_age': 30}
mary.birthday()
print(f"Mary's current age: {mary.age}")在上述代码中，LoggedAgeAccess 描述符通过 obj._age 来存储和获取 Person 实例的实际年龄值。当 Person 类的 __init__ 方法中执行 self.age = age 时，它会触发 LoggedAgeAccess 描述符的 __set__ 方法。在 __set__ 方法内部，obj._age = value 这行代码直接操作了 Person 实例的 __dict__，将值存储到名为 _age 的属性中。由于 _age 并非描述符所管理的属性名（即不是 age），因此不会再次触发描述符协议，从而避免了递归。
输出示例：
INFO:root:Updating age to: 30
Mary's attributes: {'name': 'Mary M', '_age': 30}
INFO:root:Accessing age: 30
INFO:root:Updating age to: 31
INFO:root:Accessing age: 31
Mary's current age: 31导致无限递归的错误实践
现在，假设我们修改 LoggedAgeAccess 描述符，使其在 __get__ 和 __set__ 方法内部直接使用 obj.age 来存储和获取值：
import logging
logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(name)s:%(message)s')
class LoggedAgeAccessBroken:
"""一个会导致无限递归的描述符示例"""
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 错误：这里访问 obj.age 会再次触发描述符的 __get__ 方法
value = obj.age
logging.info('Accessing age: %r', value)
return value
def __set__(self, obj, value):
# 错误：这里设置 obj.age 会再次触发描述符的 __set__ 方法
logging.info('Updating age to: %r', value)
obj.age = value
class PersonBroken:
age = LoggedAgeAccessBroken()
def __init__(self, name, age):
self.name = name
self.age = age # 尝试调用 LoggedAgeAccessBroken.__set__()当我们尝试创建 PersonBroken 实例时：
# 尝试运行此代码将导致无限递归
# john = PersonBroken('John D', 25)执行 john = PersonBroken('John D', 25) 时，PersonBroken.__init__ 中的 self.age = age 会触发 LoggedAgeAccessBroken 的 __set__ 方法。然而，在 __set__ 方法内部，obj.age = value 这一行代码又会再次触发 LoggedAgeAccessBroken 的 __set__ 方法。如此往复，形成一个无限递归，最终导致 RecursionError。
根本原因在于： 当一个类（如 Person）定义了一个描述符（如 LoggedAgeAccess）作为其属性（如 age）时，任何通过 obj.age 形式对该属性的访问或赋值，都会首先通过描述符协议进行处理，即调用描述符的 __get__ 或 __set__ 方法。如果在描述符的这些方法内部，又再次以 obj.age 的形式进行访问或赋值，就会再次触发描述符协议，从而导致无限循环。
解决方案
解决这种无限递归问题主要有两种策略：
1. 使用不同的内部属性名（推荐）
这是最常见且推荐的做法。描述符在内部存储实际值时，使用一个与外部暴露属性名不同的名字。通常，我们会使用带下划线的前缀（如 _age）来表示这是一个内部私有属性，避免与描述符管理的公共属性名冲突。
import logging
logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(name)s:%(message)s')
class LoggedAgeAccess:
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 从实例的 __dict__ 中直接获取 _age 属性，绕过描述符协议
value = obj.__dict__.get('_age')
logging.info('Accessing age: %r', value)
return value
def __set__(self, obj, value):
logging.info('Updating age to: %r', value)
# 直接设置实例的 __dict__ 中的 _age 属性，绕过描述符协议
obj.__dict__['_age'] = value
class Person:
age = LoggedAgeAccess()
def __init__(self, name, age):
self.name = name
self.age = age # 正常调用 LoggedAgeAccess.__set__()
# 示例
charlie = Person('Charlie B', 40)
print(f"Charlie's attributes: {vars(charlie)}")
print(f"Charlie's age: {charlie.age}")在上述代码中，obj.__dict__.get('_age') 和 obj.__dict__['_age'] = value 直接操作了实例的 __dict__，完全绕过了描述符协议，因此不会引发递归。
2. 使用 object.__setattr__ 和 object.__getattr__
另一种方法是利用 object 基类提供的 __setattr__ 和 __getattr__ 方法。这些方法允许你在不触发描述符协议的情况下，直接设置或获取对象的属性。
import logging
logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(name)s:%(message)s')
class LoggedAgeAccessDirect:
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 使用 object.__getattribute__ 获取实际值，避免再次触发描述符
# 注意：这里需要知道属性的实际名称，或者通过描述符的初始化传递
# 为了演示，我们假设描述符知道它管理的属性名是 'age'
try:
value = object.__getattribute__(obj, '_age_internal') # 假设内部存储名为 _age_internal
except AttributeError:
value = None # 或者抛出错误，取决于需求
logging.info('Accessing age (direct): %r', value)
return value
def __set__(self, obj, value):
logging.info('Updating age (direct) to: %r', value)
# 使用 object.__setattr__ 直接设置属性，避免再次触发描述符
object.__setattr__(obj, '_age_internal', value) # 假设内部存储名为 _age_internal
class PersonDirect:
age = LoggedAgeAccessDirect()
def __init__(self, name, age):
self.name = name
self.age = age
# 示例
diana = PersonDirect('Diana P', 28)
print(f"Diana's attributes: {vars(diana)}")
print(f"Diana's age: {diana.age}")这种方法在描述符内部需要一个明确的内部存储名称（例如 _age_internal），并且在 __get__ 和 __set__ 中通过 object.__getattribute__ 和 object.__setattr__ 来操作这个内部名称。这提供了更细粒度的控制，但对于简单的场景，直接操作 obj.__dict__ 或使用带下划线的属性名通常更简洁。
注意事项与总结
- 理解描述符协议： 任何对拥有描述符的属性的访问（obj.attr）或赋值（obj.attr = value）都会首先触发描述符的相应方法。
- 避免自引用： 在描述符的 __get__ 和 __set__ 方法内部，切勿再次使用 obj.descriptor_name 来访问或设置值，否则会陷入无限递归。
-
内部存储策略：
- 推荐： 使用一个与描述符管理的属性名不同的内部私有属性名（如 _attribute_name）来存储实际值。
- 替代： 直接操作 obj.__dict__ 或使用 object.__setattr__ 和 object.__getattribute__ 来绕过描述符协议。
- 描述符实例的名称： 描述符实例本身在类定义中的名称（例如 Person.age = LoggedAgeAccess() 中的 age）与导致递归的实例属性名称是同一个。这个名称是描述符协议查找的入口点。
通过遵循这些原则，可以有效地利用Python描述符的强大功能，同时避免常见的递归陷阱，构建出健壮且可维护的代码。
