Python中创建嵌套类实例时如何隐式保留外部类对象引用？

下面提供几种无需显式传递外部类对象，就能让嵌套类实例持有外部类对象引用的实现方式：

方案一：使用描述符装饰内部类 #

通过自定义描述符，在外部类实例访问内部类时，动态生成绑定了外部实例的内部类子类，自动注入外部引用：

class BoundInner:
    def __init__(self, inner_cls):
        self.inner_cls = inner_cls

    def __get__(self, instance, owner):
        # 类级别访问时返回原始内部类
        if instance is None:
            return self.inner_cls
        # 实例级别访问时，返回绑定外部实例的子类
        class BoundInnerSubclass(self.inner_cls):
            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self._parent = instance
        return BoundInnerSubclass

class OuterClass:
    @BoundInner
    class InnerClass:
        def get_parent_link(self):
            return self._parent

# 测试
parent_obj = OuterClass()
child_obj = parent_obj.InnerClass()
print(child_obj.get_parent_link() is parent_obj)  # 输出: True

原理 #

• BoundInner是实现了__get__方法的描述符，当外部类实例访问InnerClass时，会触发该方法。
• 此时会动态创建一个继承自原InnerClass的子类，其__init__方法会自动将外部实例赋值给内部实例的_parent属性。

方案二：重写外部类的__getattribute__方法 #

通过拦截外部类实例的属性访问，对内部类进行动态绑定：

class OuterClass:
    class InnerClass:
        def get_parent_link(self):
            return self._parent

    def __getattribute__(self, name):
        attr_val = super().__getattribute__(name)
        # 仅处理内部类的访问请求
        if name == "InnerClass" and isinstance(attr_val, type):
            outer_instance = self
            # 动态创建绑定外部实例的内部类
            bound_inner = type(
                f"Bound{attr_val.__name__}",
                (attr_val,),
                {
                    "__init__": lambda self, *args, **kwargs: (
                        super(type(self), self).__init__(*args, **kwargs),
                        setattr(self, "_parent", outer_instance)
                    )
                }
            )
            return bound_inner
        return attr_val

# 测试
parent_obj = OuterClass()
child_obj = parent_obj.InnerClass()
print(child_obj.get_parent_link() is parent_obj)  # 输出: True

原理 #

• __getattribute__会拦截所有外部类实例的属性访问，当检测到访问InnerClass时，动态生成一个绑定了当前外部实例的内部类变体。
• 新生成的类在实例化时，会自动将外部实例赋值给内部实例的_parent属性。

方案三：使用元类批量处理内部类 #

如果外部类有多个内部类，使用元类可以一次性完成所有内部类的绑定逻辑：

class InnerBindingMeta(type):
    def __new__(cls, class_name, bases, namespace):
        # 遍历命名空间中的所有内部类，统一包装成描述符
        for attr_name, attr in namespace.items():
            if isinstance(attr, type):
                namespace[attr_name] = BoundInner(attr)
        return super().__new__(cls, class_name, bases, namespace)

# 复用方案一中的BoundInner描述符
class BoundInner:
    def __init__(self, inner_cls):
        self.inner_cls = inner_cls

    def __get__(self, instance, owner):
        if instance is None:
            return self.inner_cls
        class BoundInnerSubclass(self.inner_cls):
            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self._parent = instance
        return BoundInnerSubclass

class OuterClass(metaclass=InnerBindingMeta):
    class InnerClass:
        def get_parent_link(self):
            return self._parent

    class AnotherInner:
        def get_outer_instance(self):
            return self._parent

# 测试
parent_obj = OuterClass()
child1 = parent_obj.InnerClass()
child2 = parent_obj.AnotherInner()
print(child1.get_parent_link() is parent_obj)  # 输出: True
print(child2.get_outer_instance() is parent_obj)  # 输出: True

原理 #

• 元类InnerBindingMeta在创建外部类时，会自动遍历并包装所有内部类为BoundInner描述符。
• 后续访问任意内部类时，都会自动绑定外部实例，无需逐个装饰。

内容的提问来源于stack exchange，提问作者Japan Manul