Python 中的元类：需要澄清的几个问题

Question

在与元类崩溃之后，我深入研究了 Python 中的元编程主题，恕我直言，我有几个问题在可用文档中没有明确回答。

1. 在元类中同时使用 __new__ 和 __init__ 时，它们的参数必须定义相同吗？
2. 在元类中定义类 __init__ 的最有效方法是什么？
3. 有没有办法在元类中引用类实例（通常是self）？

Answer 1

1. 同时使用__new__和__init__时
   在元类中，它们的参数必须
   定义相同吗？

   我认为Alex Martelli解释了
   最简洁地说：

   类名(Base1,Base2): <>
       __metaclass__==合适的_metaclass
   

   表示

   Name =suitable_metaclass('Name', (Base1,Base2), <>)
   

   所以别再想了
   合适的元类作为元类
   暂时将其视为
   班级。每当你看到

   suitable_metaclass('名称', (Base1,Base2), <>)
   

   它告诉你
   合适的_metaclass的__new__
   方法必须有签名
   类似的东西

   def __new__(metacls, 名称, 基数, dct)
   

   和一个 __init__ 方法，例如

   def __init__(cls, 名称, 基数, dct)
   

   因此签名并不完全相同，但它们仅在第一个参数上有所不同。

2. 最有效的定义方式是什么
   元类中的类 __init__？

   高效是什么意思？这是
   不需要定义__init__
   除非你愿意。

3. 有没有办法引用类
   实例（通常是自身）
   元类？

   不，您不需要这样做。
   任何取决于班级的事情
   实例应在
   类定义，而不是在
   元类。

Answer 2

对于 1：any 类的 __init__ 和 __new__ 必须接受相同的参数，因为它们将使用相同的参数进行调用。 __new__ 通常会接受更多它忽略的参数（例如 object.__new__ 接受任何参数并忽略它们），因此 __new__ 不会'在继承过程中不必重写，但通常只有在根本没有 __new__ 时才这样做。

这在这里不是问题，因为正如前面所说，元类总是使用相同的参数集来调用，因此您不会遇到麻烦。至少有论据。但是，如果您要修改传递给父类的参数，则需要同时修改它们。

对于2：您通常不会在元类中定义类__init__。您可以编写一个包装器并在元类的 __new__ 或 __init__ 中替换该类的 __init__，也可以重新定义 元类上的 __call__ 。如果您使用继承，前者会表现得很奇怪。

import functools

class A(type):
    def __call__(cls, *args, **kwargs):
        r = super(A, cls).__call__(*args, **kwargs)
        print "%s was instantiated" % (cls.__name__, )
        print "the new instance is %r" % (r, )
        return r


class B(type):
    def __init__(cls, name, bases, dct):
        super(B, cls).__init__(name, bases, dct)
        if '__init__' not in dct:
            return
        old_init = dct['__init__']
        @functools.wraps(old_init)
        def __init__(self, *args, **kwargs):
            old_init(self, *args, **kwargs)
            print "%s (%s) was instantiated" % (type(self).__name__, cls.__name__)
            print "the new instance is %r" % (self, )
        cls.__init__ = __init__


class T1:
    __metaclass__ = A

class T2:
    __metaclass__ = B
    def __init__(self): 
        pass

class T3(T2):
    def __init__(self):
        super(T3, self).__init__()

调用它的结果：

>>> T1()
T1 was instantiated
the new instance is <__main__.T1 object at 0x7f502c104290>
<__main__.T1 object at 0x7f502c104290>
>>> T2()
T2 (T2) was instantiated
the new instance is <__main__.T2 object at 0x7f502c0f7ed0>
<__main__.T2 object at 0x7f502c0f7ed0>
>>> T3()
T3 (T2) was instantiated
the new instance is <__main__.T3 object at 0x7f502c104290>
T3 (T3) was instantiated
the new instance is <__main__.T3 object at 0x7f502c104290>
<__main__.T3 object at 0x7f502c104290>

对于 3：是的，来自 __call__，如上所示。