Python描述符中属性名称冲突导致无限递归的解析与实践

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

Python描述符中属性名称冲突导致无限递归的解析与实践

2025-11-10

浏览次数：次

返回列表

Python描述符中属性名称冲突导致无限递归的解析与实践

本文深入探讨了python描述符在使用过程中，当描述符内部用于存储数据的属性名与外部管理属性名相同时，为何会导致无限递归的问题。通过剖析描述符协议的调用机制，揭示了这种命名冲突如何触发`__set__`方法的循环调用。文章提供了清晰的代码示例，并强调了使用不同内部属性名（如加前缀`_`）来安全实现描述符的关键实践，旨在帮助开发者避免此类常见陷阱，提升代码的健壮性。

Python 描述符与属性管理

Python 描述符（Descriptor）是一种强大的机制，允许开发者自定义对象属性的访问、修改和删除行为。它通过实现特殊方法 __get__、__set__ 和 __delete__ 来工作。当一个类属性被赋值为一个描述符实例时，对该类实例上同名属性的访问就会被描述符的方法所拦截。

例如，我们可以创建一个描述符来记录属性的访问和修改日志：

import logging

logging.basicConfig(level=logging.INFO)

class LoggedAgeAccess:
    """
    一个记录年龄属性访问和修改的描述符。
    它将实际的年龄值存储在拥有者对象的 _age 属性中。
    """
    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() # 将 LoggedAgeAccess 实例作为 Person 类的 age 属性

    def __init__(self, name, age):
        self.name = name
        self.age = age # 调用描述符的 __set__ 方法

    def birthday(self):
        self.age += 1 # 调用描述符的 __get__ 和 __set__ 方法

在上述示例中，LoggedAgeAccess 描述符管理 Person 类的 age 属性。它将实际的年龄值存储在 Person 实例的 _age 属性中。当我们创建 Person 实例并设置 age 时，LoggedAgeAccess.__set__ 方法会被调用；当我们访问 age 时，LoggedAgeAccess.__get__ 方法会被调用。

mary = Person('Mary M', 30)
# 输出: INFO:root:Updating 'age' to 30
print(vars(mary))
# 输出: {'name': 'Mary M', '_age': 30}

可以看到，age 属性通过描述符被管理，实际的数据存储在 _age 中，避免了命名冲突。

命名冲突引发的无限递归

然而，如果我们在描述符内部使用与外部管理属性相同的名称来存储数据，就会导致一个常见的陷阱——无限递归。

考虑以下修改后的 LoggedAgeAccess 描述符，它尝试将值存储在 obj.age 而不是 obj._age 中：

class LoggedAgeAccessBroken:
    """
    一个错误的描述符实现，将导致无限递归。
    它尝试将实际的年龄值存储在拥有者对象的 age 属性中。
    """
    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 PersonBroken:
    age = LoggedAgeAccessBroken() # 将 LoggedAgeAccessBroken 实例作为 PersonBroken 类的 age 属性

    def __init__(self, name, age):
        self.name = name
        self.age = age # 尝试调用描述符的 __set__ 方法

当我们尝试使用 PersonBroken 类时：

# mary_broken = PersonBroken('Mary B', 30)

程序会陷入一个无限循环，不断输出 INFO:root:Updating 'age' to 30，最终可能导致栈溢出错误。

Yaara

使用AI生成一流的文案广告，电子邮件，网站，列表，博客，故事和更多…

95 查看详情 Yaara

无限递归的机制解析

这个无限递归的根本原因在于 Python 的描述符协议。当一个类的属性（例如 PersonBroken.age）是一个描述符实例时，对该类的实例属性（例如 mary_broken.age）的访问或设置，都会首先通过描述符协议进行处理。

具体来说：

当执行 self.age = age （在 PersonBroken.__init__ 中）时，Python 解释器发现 PersonBroken.age 是一个描述符。
于是，它会调用 LoggedAgeAccessBroken.__set__(self, age)。
进入 LoggedAgeAccessBroken.__set__ 方法内部，执行 obj.age = value。
此时，obj 实际上就是 mary_broken 实例。对 mary_broken.age 的赋值操作，再次触发了描述符协议。
解释器再次发现 PersonBroken.age 是一个描述符，于是再次调用 LoggedAgeAccessBroken.__set__(obj, value)。
这个过程无限重复，形成递归调用，直到系统资源耗尽。

同样的问题也存在于 __get__ 方法中。如果 __get__ 方法内部尝试访问 obj.age，也会再次触发描述符的 __get__ 方法，导致无限递归。

解决方案与最佳实践

解决这个问题的关键在于，描述符内部用于存储实际数据的属性名，必须与描述符所管理的外部属性名不同。通常的做法是，在拥有者对象上使用一个带前缀（如 _ 或 __）的私有属性名来存储数据。

正确的实现方式

回到最初的正确示例，LoggedAgeAccess 描述符通过 obj._age 来存储和访问数据，从而避免了与外部 age 属性的冲突。

import logging

logging.basicConfig(level=logging.INFO)

class LoggedAgeAccess:
    """
    正确的描述符实现，使用不同的内部属性名来存储数据。
    """
    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 = LoggedAgeAccess()

    def __init__(self, name, age):
        self.name = name
        self.age = age # 正常调用描述符的 __set__ 方法

    def birthday(self):
        self.age += 1 # 正常调用描述符的 __get__ 和 __set__ 方法

其他存储方式

除了在拥有者对象上使用不同的私有属性名外，描述符还可以使用其他方式来存储数据，例如：

直接在描述符实例上存储（不常见，因为描述符通常是类属性，所有实例共享）：如果描述符是每个实例独有的，可以在 __set__ 中存储到 self.value。
使用 obj.__dict__ 直接操作实例字典：通过 obj.__dict__['age'] = value 可以绕过描述符协议，直接在实例的字典中设置或获取值。这在某些高级场景下很有用，但通常不如使用 _age 这种约定俗成的私有属性名直观。
使用 weakref.WeakKeyDictionary 或 weakref.WeakValueDictionary：对于需要存储大量实例特定数据的描述符，可以使用弱引用字典来避免内存泄漏。

注意事项

命名约定：在 Python 中，以单个下划线 _ 开头的属性通常表示“受保护”或“内部使用”，提醒开发者不应直接访问。双下划线 __ 开头的属性会触发名称改编（name mangling），使其在外部更难访问。
理解描述符协议：深入理解 __get__、__set__ 和 __delete__ 方法的调用时机和参数是正确使用描述符的关键。
避免循环引用：在设计复杂的描述符时，要注意避免可能导致内存泄漏的循环引用。

总结

Python 描述符是实现高级属性管理和元编程的强大工具。然而，在使用它们时，必须注意避免内部存储属性与外部管理属性同名的问题，这会导致无限递归。通过在拥有者对象上使用不同的、通常是带前缀的私有属性名来存储实际数据，可以有效地解决这一问题，确保描述符的正确和安全运行。掌握这一关键概念，将帮助开发者编写更健壮、更符合 Python 惯例的代码。

以上就是Python描述符中属性名称冲突导致无限递归的解析与实践的详细内容，更多请关注其它相关文章！

# 它将 # 武昌推广营销方案 # 北海营销推广费用高吗知乎 # 企业技术开发网站建设 # 巩义网站建设小程序 # 莆田seo优化文案 # 厦门培训网站建设 # SEO优化执行 # 金鹰营销推广部王丽娜 # 苏州如何建设网站流程 # SEO妍(公园敏京 # 法会 # 运算符 # python # 显存 # 下划线 # 就会 # 这一 # 当我们 # 是一个 # 递归 # asic # 栈 # 工具 # access