本文深入探讨了python描述符在使用过程中可能遇到的一个常见陷阱：当描述符管理的实例属性与描述符本身在类中定义的名称相同时，会导致无限递归。文章通过详细的代码示例，解释了描述符协议的工作原理，揭示了递归发生的原因，并提供了使用不同内部属性名来规避此问题的最佳实践，旨在帮助开发者正确理解和应用python描述符。
理解Python描述符与属性访问
Python描述符是一种强大的机制，允许开发者自定义类属性的访问、设置和删除行为。通过实现__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:
"""使用LoggedAgeAccess描述符管理年龄属性的类。"""
age = LoggedAgeAccess() # 描述符实例，管理'age'属性
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)) # 查看实例的__dict__
# 输出:
# INFO:root:Updating 'age' to 30
# {'name': 'Mary M', '_age': 30}在这个示例中，LoggedAgeAccess是一个描述符，它被赋值给了Person类的age属性。当Person实例的age属性被访问或设置时，实际上会调用LoggedAgeAccess的__get__或__set__方法。注意到在LoggedAgeAccess内部，它使用obj._age来实际存储和检索年龄值。这种做法是关键，它避免了与描述符本身的名称冲突。
命名冲突引发的无限递归
现在，假设我们修改LoggedAgeAccess描述符，使其在内部也使用obj.age来存储和检索数据，而不是obj._age。
立即学习“Python免费学习笔记（深入）”；
import logging
logging.basicConfig(level=logging.INFO)
class LoggedAgeAccessConflicting:
"""一个有命名冲突的描述符示例。"""
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):
logging.info('Updating %r to %r', 'age', value)
# 尝试将值设置到 obj.age
# 这将再次触发描述符协议，导致递归调用__set__
obj.age = value
class PersonConflicting:
"""使用有命名冲突的描述符管理年龄属性的类。"""
age = LoggedAgeAccessConflicting() # 描述符实例
def __init__(self, name, age):
self.name = name
self.age = age # 尝试调用LoggedAgeAccessConflicting.__set__()
# 尝试运行此代码将导致无限递归
# mary_bad = PersonConflicting('Mary B', 30)
# print(vars(mary_bad))当我们尝试创建PersonConflicting的实例并设置其age属性时，例如self.age = age，会发生什么？
- PersonConflicting类的__init__方法中执行 self.age = age。
- Python检测到PersonConflicting.age是一个描述符（LoggedAgeAccessConflicting的实例）。
- 于是，Python调用LoggedAgeAccessConflicting的__set__方法，传入self（即mary_bad实例）和age值。
- 在LoggedAgeAccessConflicting.__set__方法内部，执行 obj.age = value。
- 此时，obj是mary_bad实例，obj.age = value再次触发描述符协议。
- Python再次检测到PersonConflicting.age是一个描述符。
- Python再次调用LoggedAgeAccessConflicting的__set__方法，传入obj和value。
- 这个过程无限重复，导致栈溢出或程序崩溃。日志中会看到Updating 'age' to ...的无限循环输出。
为什么会发生递归？描述符协议解析
问题的根源在于Python的属性访问机制，即描述符协议。当通过obj.attribute访问或设置属性时，Python会按照特定的顺序查找属性：
- 实例字典 (obj.__dict__): 首先在实例的__dict__中查找attribute。
-
类字典 (type(obj).__dict__): 如果实例字典中没有找到，Python会在类的__dict__中查找attribute。
- 如果找到一个数据描述符（定义了__get__和__set__），则调用其__get__或__set__方法。
- 如果找到一个非数据描述符（只定义了__get__），则调用其__get__方法。
- 如果找到一个普通方法或非描述符，则直接返回。
- 继承链: 如果在当前类中未找到，则沿着MRO（Method Resolution Order）查找父类。
在我们的冲突示例中：
- 当执行obj.age = value时，Python首先查找obj.__dict__。
- 如果obj.__dict__中没有age，它会查找type(obj).__dict__（即PersonConflicting.__dict__）。
- 在PersonConflicting.__dict__中，它找到了age = LoggedAgeAccessConflicting()，这是一个数据描述符。
- 因此，Python调用LoggedAgeAccessConflicting.__set__。
- 在__set__内部，再次执行obj.age = value，这个过程又重新开始，形成无限递归。
解决方案：使用不同的内部属性名
解决这个问题的关键是确保描述符在内部存储数据时，不会再次触发自身的描述符协议。最常见且推荐的方法是使用一个不同的、通常带有前缀（如_）的属性名来存储实际数据，这个属性名不会被描述符自身管理。
class LoggedAgeAccessCorrect:
"""正确的描述符实现，使用内部属性名。"""
def __get__(self, obj, objtype=None):
if obj is None:
return self
# 从实例的 __dict__ 中直接获取 _age
# 这不会触发描述符协议
value = obj.__dict__['_age']
logging.info('Accessing %r giving %r', 'age', value)
return value
def __set__(self, obj, value):
logging.info('Updating %r to %r', 'age', value)
# 将值直接存储到实例的 __dict__ 中
# 这不会触发描述符协议
obj.__dict__['_age'] = value
class PersonCorrect:
"""使用正确描述符的类。"""
age = LoggedAgeAccessCorrect()
def __init__(self, name, age):
self.name = name
self.age = age # 调用LoggedAgeAccessCorrect.__set__()
mary_correct = PersonCorrect('Mary C', 30)
print(vars(mary_correct))
# 输出:
# INFO:root:Updating 'age' to 30
# {'name': 'Mary C', '_age': 30}在LoggedAgeAccessCorrect中，我们使用obj.__dict__['_age']来直接访问实例的底层字典。这样，当__set__或__get__方法内部需要存储或检索值时，它会直接操作实例的__dict__，而不会再次触发age描述符的协议，从而避免了递归。
另一种常见的写法是直接使用obj._age = value（如最初的例子所示）。这种方式之所以有效，是因为_age不是描述符age的名称，所以obj._age不会触发LoggedAgeAccessCorrect描述符，而是作为普通的实例属性被存储在obj.__dict__中。
注意事项与最佳实践
- 选择内部属性名: 通常，描述符会选择一个与描述符名称不同的内部属性名来存储实际数据，例如在Person类中描述符名为age，内部存储名为_age。这种命名约定（前缀_）表明这是一个内部实现细节，不应直接从外部访问。
- 直接访问 __dict__: 在描述符内部，如果需要确保不触发任何描述符协议，直接通过obj.__dict__['attribute_name']访问实例字典是明确且安全的做法。
- 描述符实例的名称: 描述符实例在类中的名称（例如Person.age中的age）是外部代码用来访问该属性的名称。而描述符内部用来存储数据的名称（例如_age）是描述符的私有实现细节。两者必须不同，以避免递归。
- 无描述符时的行为: 如果一个属性名在实例__dict__中存在，Python将优先使用它，而不会触发类中同名的描述符。这是描述符协议的一个重要部分，也是为什么obj._age = value能正常工作的原因——_age首先在obj.__dict__中被找到并设置，不涉及描述符。
总结
Python描述符是实现高级属性管理和元编程的强大工具。然而，理解其工作原理，特别是属性查找和描述符协议的交互至关重要。当描述符管理的属性名与其在类中声明的名称相同时，会陷入无限递归的陷阱。通过在描述符内部使用不同的、通常带有前缀的属性名来存储实际数据，可以有效规避这一问题，确保描述符的正确和安全使用。掌握这一机制对于编写健壮和高效的Python代码至关重要。
