如何将类型的 `__init__` 或 `__new__` 绑定到其他类实例？

Question

我试图使用 Python 内置的 setattr 为类设置类型属性。我已经在类型中声明了__new__ 和__init__ 方法，以查看它们的参数是什么，令人惊讶的是，它们并没有被绑定到接收类实例。我已经阅读了有关setattr 和描述符的Python 文档，并且我在解释器中执行了一些测试，但我还没有找到将类型的__new__ 或__init__ 方法绑定到类实例的方法。

这是我一直在玩弄的代码片段：

T = type("T", (object,), {"__new__": lambda cls: print(f"T.__new__: {cls}") or object.__new__(cls), "__init__": lambda self: print(f"T.__init__: {self}")})

T()
# T.__new__: <class '__main__.T'>
# T.__init__: <__main__.T object at 0x7f970b667c10>
# <__main__.T object at 0x7f970b667c10>

class A:
    pass

setattr(A, "T", T)

A.T()
# T.__new__: <class '__main__.T'>
# T.__init__: <__main__.T object at 0x7f970b6675e0>
# <__main__.T object at 0x7f970b6675e0>

A().T()
# T.__new__: <class '__main__.T'>
# T.__init__: <__main__.T object at 0x7f970b667ee0>
# <__main__.T object at 0x7f970b667ee0> 

基本上我想知道如何让 T 在 __new__ 或 __init__ 方法中接收 A 的实例。我相信我没有完全理解 setattr 的实际工作原理，并且我在滥用它，或者完成此行为的方式与 setattr 根本无关。

PS.：将 T 声明为常规类不会改变任何事情，而声明 T::__get__ 也不会改变任何事情。

Answer 1

setattr 函数只是一种以编程方式执行普通赋值操作的方法。您拨打setattr(A, "T", T) 与拨打A.T = T 完全相同。它并不能帮助您实现您想要的，即在 A（或者可能在 A 实例中）查找类 T 时具有绑定行为。

虽然您可以创建一个元类，使您声明为A 类的属性的T 类型成为描述符，但更简单的方法可能是编写@987654329 的方法@ 返回 T 类的实例，但实际上不是类本身。

class T:
    def __init__(self, a):
        self.a = a

class A:
    def make_T(self):
        return T(self)

现在您可以执行A().make_T()，您将获得一个T 实例，该实例作为__init__ 方法的参数传递给A 实例。如果您愿意，您甚至可以将 make_T 重命名为 T，它大部分会像您对嵌套类的预期一样工作。这并不完全相同，因为您不能在其他上下文中将A.T 用作类，例如isinstance 检查。使用像 make_T 这样的名称会更清楚一点，它是工厂方法，而不是类本身。

如果您确实需要将类 T 放在 A 内，这里是元类方法：

class BindingInnerClass(type):
    def __get__(cls, obj, owner=None):
        if obj is None:
            return cls

        class BoundSubclass(cls):
            if cls.__new__ is not object.__new__:
                def __new__(subcls, *args, **kwargs):
                    return super().__new__(subcls, obj, *args, **kwargs)

            if cls.__init__ is not object.__init__:
                def __init__(self, *args, **kwargs):
                    super().__init__(obj, *args, **kwargs)

        setattr(obj, cls.__name__,  BoundSubclass)
        return BoundSubclass

class A:
    class T(metaclass=BindingInnerClass):
        def __init__(self, a):  # the metaclass will also work if you define __new__
            self.a = a

a = A()
t = a.T()
print(a, t.a) # prints the same object twice
print(isinstance(t, a.T), isinstance(t, A.T), isinstance(t, A().T)) # True True False

如果您希望能够阅读和维护它，那么该元类比代码真正应该的要复杂和微妙得多。它为您查找原始类的每个A 实例创建T 的子类。在某些情况下，这可能会非常令人困惑（例如示例代码中的最后一个 isinstance 签入）！

这里有一些微妙之处：我们需要选择创建 __init__ 和 __new__ 中的哪一个，因为如果我们无条件地创建两者，如果 T 没有将它们都定义为将obj 作为位置参数。使用朴素绑定（方法的方式），您最终会得到可能无限数量的类，因为您将为每次查找创建一个新的子类（a.T 每次都是不同的类）。为避免这种情况，我使用setattr 缓存子类（让我们回到原点！）。

我强烈建议不要对任何严肃的代码使用这种设计。这种类架构真的很臭，试图强迫 Python 设计成更自然地适合其他编程语言的设计，其中内部类是很正常的事情。几乎可以肯定没有必要以这种方式设计类，可能会有一个稍微修改的设计，这对 Python 的类模型来说更自然。帮自己（以及将来需要阅读您的代码的任何人）一个巨大的帮助，找出更好的设计是什么，而不是使用一个非常难以理解或修改的元类怪物。