Python中嵌套类如何隐式获取父对象引用

class OuterClass:
    def __init__(self, name="Outer"):
        self.name = name

    class InnerClass:
        def __init__(self, parent_obj, value="Inner"):
            self.parent = parent_obj
            self.value = value

        def get_parent_info(self):
            return f"Inner instance '{self.value}' belongs to Outer instance '{self.parent.name}'"

parent_obj = OuterClass()
child_obj = parent_obj.InnerClass(parent_obj) # 显式传递父对象
print(child_obj.get_parent_info())

import functools

class InjectParent(type):
    """
    一个元类，用于在类创建时修改其__init__方法，使其能够接受一个'parent'参数。
    同时，它作为一个描述符，在通过实例访问时，将该实例作为'parent'参数预绑定到构造函数。
    """
    def __new__(cls, name, bases, ns):
        # 捕获用户定义的__init__方法（如果存在）
        user_init = ns.get("__init__")

        def __init__(self, parent=None, *args, **kwargs):
            """
            新的__init__方法，自动接收一个parent参数。
            """
            self.parent = parent # 将父对象引用存储在实例中
            if user_init:
                # 如果用户定义了__init__，则调用它，但不传递parent参数
                user_init(self, *args, **kwargs)

        # 创建新类，并用我们修改后的__init__替换原有的__init__
        return super().__new__(cls, name, bases, {**ns, "__init__":__init__})

    def __get__(self, obj, objtype=None):
        """
        当类作为描述符被访问时调用。
        如果通过实例（如parent.Inner）访问，obj将是该实例。
        此时返回一个偏函数，将obj（即父实例）作为parent参数预绑定。
        如果通过类（如Outer.Inner）访问，obj将是None，直接返回类本身。
        """
        if obj is None:
            # 通过类访问时，返回类本身
            return self
        # 通过实例访问时，返回一个偏函数，将当前实例作为parent参数绑定
        return functools.partial(self, obj)

class Outer:
    def __init__(self, id_val="OuterID"):
        self.id_val = id_val

    # Inner类使用InjectParent作为元类
    class Inner(metaclass=InjectParent):
        def __init__(self, custom_name="DefaultInner"):
            # 注意：这里的__init__不再需要显式接收parent参数，
            # 它会由元类修改后的__init__来处理
            self.custom_name = custom_name
            print(f"Inner instance '{self.custom_name}' created.")
            if self.parent:
                print(f"Parent reference found: {self.parent.id_val}")
            else:
                print("No parent reference found.")

# 示例用法
print("--- 通过父实例创建子实例 ---")
parent_instance = Outer(id_val="MyOuterInstance")
# 访问 parent_instance.Inner 时，InjectParent.__get__ 被调用，
# 返回 functools.partial(Inner, parent_instance)
# 随后调用 () 时，parent_instance 被作为 parent 参数传递给 Inner 的构造函数
child_instance = parent_instance.Inner(custom_name="MyChild")

assert child_instance.parent is parent_instance
print(f"Child's parent is indeed parent_instance: {child_instance.parent.id_val}")

print("\n--- 直接通过外部类创建子实例 ---")
# 访问 Outer.Inner 时，InjectParent.__get__ 的 obj 为 None，直接返回 Inner 类
orphan_instance = Outer.Inner(custom_name="OrphanChild")
assert orphan_instance.parent is None
print(f"Orphan's parent is None: {orphan_instance.parent}")