可行的方法

更新2：基于行为，下面调用了M0.__call__，肯定是因为在CPython源码的builtin__build_class函数（Python/bltinmodule.c）中这一行代码的副作用。

为了定义一个具有元类的类，我们像往常一样调用元类的__prepare__、__new__和__init__方法。 这创建了一个类——在下面的示例中，是名称为Meta的类——它是可调用的，但其内部的PyFunction_GET_CODE插槽不是指向其自己的__call__，而是指向其元类的__call__。 因此，如果我们调用Meta()（元类对象），我们就会调用M0.__call__：

print("call Meta")
print("Meta returns:", Meta('name', (), {}))
print("finished calling Meta")

输出结果：

call Meta
M0 __call__: mmcls=, args=('name', (), {}), kwargs={}
Meta __new__: mcs=, name='name', bases=(), attrs={}, kwargs={}
Meta __init__: mcs=, name='name', bases=(), attrs={}, kwargs={}
Meta returns: 
finished calling Meta

换句话说，我们可以看到，Meta的行为类似于type，但它（神奇地、缺乏非常好的文档）调用了M0.__call__。这毫无疑问是因为在类的类型中查找__call__，而不是在类的实例中查找（事实上，除了我们正在创建的这个实例之外，根本就没有实例）。实际上，这是一般情况：它是基于在Meta的类型上调用__call__，而Meta的类型是M0，所以会发生这种情况：

print("type(Meta) =", type(Meta))

输出结果：

type(Meta) = 

这就解释了这个问题的来源。（我仍然认为这应该在文档中强调，并且文档也应该描述元类类型的约束 - 这些是在Lib/types.py中的_calculate_winner和C代码中在Objects/typeobject.c的_PyType_CalculateMetaclass中实施的。）

我不知道你的图表来自何处，但它是错误的。 更新：实际上你可以为你的元类创建一个元类，请参见jsbueno的回答。我已经更新了下面的示例。新的句子/文本加粗，除了最后一节中描述的我对显然缺乏文档的困惑。

你现有的元类代码至少有一个错误。 最重要的是，它的__prepare__需要是一个类方法。此外，还可以参见使用元类的__call__方法而不是__new__？和PEP 3115。 使用元-元-类，您的元类需要拥有自己的元类，而不是一个基类。

Chris's answer 包含了正确的定义。但是，在元类方法参数和类方法参数之间存在一些不幸的不对称性，我将在下面进行说明。

还有一件可能有帮助的事情是，请注意，在创建任何类B实例之前，元类__prepare__方法被调用：当定义class B本身时会被调用。为了说明这一点，这里是一个纠正过的元类和类。我还添加了几个更多的例子。我还添加了一个元元类，基于jsbueno的答案。我找不到关于这个的正式Python文档，但我已经更新了下面的输出。

class M0(type):
    def __call__(mmcls, *args, **kwargs):
        print("M0 __call__: mmcls={!r}, "
              "args={!r}, kwargs={!r}".format(mmcls, args, kwargs))
        return super().__call__(*args, **kwargs)
class Meta(type, metaclass=M0):
    def __call__(cls, *args, **kwargs):
        print("Meta __call__: cls={!r}, "
              "args={!r}, kwargs={!r}".format(cls, args, kwargs))
        return super().__call__(*args, **kwargs)
    def __new__(mcs, name, bases, attrs, **kwargs):
        print("Meta __new__: mcs={!r}, name={!r}, bases={!r}, "
              "attrs={!r}, kwargs={!r}".format(mcs, name, bases, attrs, kwargs))
        return super().__new__(mcs, name, bases, attrs)
    def __init__(mcs, name, bases, attrs, **kwargs):
        print("Meta __init__: mcs={!r}, name={!r}, bases={!r}, "
              "attrs={!r}, kwargs={!r}".format(mcs, name, bases, attrs, kwargs))
        super().__init__(name, bases, attrs, **kwargs)
    @classmethod
    def __prepare__(cls, name, bases, **kwargs):
        print("Meta __prepare__: name={!r}, "
              "bases={!r}, kwargs={!r}".format(name, bases, kwargs))
        return {}
print("about to create class A")
class A(metaclass=Meta): pass
print("finished creating class A")
print("about to create class B")
class B(A, metaclass=Meta, foo=3):
    @staticmethod
    def __new__(cls, *args, **kwargs):
        print("B __new__: cls={!r}, "
              "args={!r}, kwargs={!r}".format(cls, args, kwargs))
        return super().__new__(cls)
    def __init__(self, *args, **kwargs):
        print("B __init__: args={!r}, kwargs={!r}, ".format(args, kwargs))
print("finished creating class B")
print("about to create instance b = B()")
b = B('hello', bar=7)
print("finished creating instance b")

现在，让我们观察当我运行它时会发生什么，并分开每个部分：

$ python3.6 meta.py
about to create class A
Meta __prepare__: name='A', bases=(), kwargs={}
M0 __call__: mmcls=, args=('A', (), {'__module__': '__main__', '__qualname__': 'A'}), kwargs={}
Meta __new__: mcs=, name='A', bases=(), attrs={'__module__': '__main__', '__qualname__': 'A'}, kwargs={}
Meta __init__: mcs=, name='A', bases=(), attrs={'__module__': '__main__', '__qualname__': 'A'}, kwargs={}
finished creating class A

为了创建类A本身，Python首先调用元类的__prepare__，传递类的名称（A），基类列表（一个空元组 - 它被称为列表，实际上是元组），以及任何关键字参数（无）。正如PEP 3115所述，元类需要返回一个字典或类似于dict的对象；这个返回一个空字典，所以我们好了。

（我没有在这里打印cls本身，但是如果您这样做，您将看到它只是。）

接下来，从__prepare__获得了一个字典后，Python首先调用元元__call__，即M0.__call__，将整个参数集作为args元组传递。然后，它使用__prepare__提供的字典来填充类的所有属性，将其作为attrs传递给元类__new__和__init__。如果打印从__prepare__返回并传递给__new__和__init__的字典的id，您将看到它们全部匹配。

既然A类没有方法或数据成员，我们只能看到神奇的__module__和__qualname__属性。我们也没有关键字参数，所以现在让我们继续创建类B：

about to create class B
Meta __prepare__: name='B', bases=(,), kwargs={'foo': 3}
M0 __call__: mmcls=, args=('B', (,), {'__module__': '__main__', '__qualname__': 'B', '__new__': , '__init__': , '__classcell__': }), kwargs={'foo': 3}
Meta __new__: mcs=, name='B', bases=(,), attrs={'__module__': '__main__', '__qualname__': 'B', '__new__': , '__init__': , '__classcell__': }, kwargs={'foo': 3}
Meta __init__: mcs=, name='B', bases=(,), attrs={'__module__': '__main__', '__qualname__': 'B', '__new__': , '__init__': , '__classcell__': }, kwargs={'foo': 3}
finished creating class B

这个类比较有趣。现在我们有一个基类，即__main__.A。类B还定义了几个方法（__new__和__init__），我们可以在传递给元类__new__和__init__方法的attrs字典中看到它们（请记住，这只是元类的__prepare__返回的现在填充的字典）。与以前一样，传递是通过元元类M0.__call__进行的。在属性字典中，我们还可以观察到神奇的__classcell__条目：请参见提供Python 3.6元类__classcell__示例，了解它是关于什么的简短说明，但是要超级简短，它是用于使super()工作。

关键字参数传递给所有三个元类方法，以及元元类的方法。（我不太确定为什么。请注意，在任何元类方法中修改字典不会影响其他方法，因为每次都是原始关键字参数的副本。但是，我们可以在元元类中进行修改：在 M0.__call__中添加kwargs.pop('foo', None)来观察。）

about to create instance b = B()
Meta __call__: cls=, args=('hello',), kwargs={'bar': 7}

B __new__: cls=, args=('hello',), kwargs={'bar': 7}
B __init__: args=('hello',), kwargs={'bar': 7}, 
finished creating instance b

return super().__new__(cls)

    def __call__(cls, *args, **kwargs):
        print("Meta __call__: cls={!r}, "
              "args={!r}, kwargs={!r}".format(cls, args, kwargs))
        return object.__new__(cls)

about to create instance b = B()
Meta __call__: cls=, args=('hello',), kwargs={'bar': 7}
finished creating instance b