为什么类定义的元类关键字参数接受可调用对象？

背景

蟒蛇3文档 https://docs.python.org/3.6/reference/datamodel.html#determining-the-appropriate-metaclass清楚地描述了类的元类是如何确定的：

• 如果没有给出基类和显式元类，则使用 type()
• 如果给出了显式元类并且它不是 type() 的实例，则直接将其用作元类
• 如果 type() 的实例作为显式元类给出，或者定义了基类，则使用最派生的元类

因此，根据第二条规则，可以使用可调用对象来指定元类。例如。，

class MyMetaclass(type):
    pass

def metaclass_callable(name, bases, namespace):
    print("Called with", name)
    return MyMetaclass(name, bases, namespace)

class MyClass(metaclass=metaclass_callable):
    pass

class MyDerived(MyClass):
    pass

print(type(MyClass), type(MyDerived))

问题1

是元类MyClass: metaclass_callable or MyMetaclass？文档中的第二条规则表示提供的可调用“直接用作元类”。然而，元类似乎更有意义MyMetaclass since

• MyClass and MyDerived有类型MyMetaclass,
• metaclass_callable被调用一次，然后似乎无法恢复，
• 派生类不使用（据我所知）metaclass_callable以任何方式（他们使用MyMetaclass).

问题2

有没有什么事情是你可以用可调用函数做而不能用它的实例做的？type？接受任意可调用的目的是什么？

关于你的第一个问题，元类应该是MyMetaclass（事情是这样的）：

In [7]: print(type(MyClass), type(MyDerived))
<class '__main__.MyMetaclass'> <class '__main__.MyMetaclass'>

原因是，如果元类不是类型的实例，python 通过将这些参数传递给它来调用元类name, bases, ns, **kwds (see new_class）并且由于您在该函数中返回真实的元类，因此它获得了元类的正确类型。

关于第二个问题：

接受任意可调用的目的是什么？

没有什么特别的目的，这实际上是元类的本质这是因为从类创建实例总是通过调用它来调用元类__call__ method:

Metaclass.__call__()

这意味着您可以将任何可调用对象作为元类传递。因此，例如，如果您使用嵌套函数测试它，结果仍然是相同的：

In [21]: def metaclass_callable(name, bases, namespace):
             def inner():
                 return MyMetaclass(name, bases, namespace)
             return inner()
   ....: 

In [22]: class MyClass(metaclass=metaclass_callable):
             pass
   ....: 

In [23]: print(type(MyClass), type(MyDerived))
<class '__main__.MyMetaclass'> <class '__main__.MyMetaclass'>

有关更多信息，请参阅 Python 如何创建类：

它称为new_class它调用的函数prepare_class在其内部，然后正如您在内部所看到的prepare_classpython 调用__prepare__适当的元类的方法，除了找到适当的元（使用_calculate_metafunction ) 并为类创建适当的命名空间。

因此，这里的全部内容就是执行元类方法的层次结构：

1. __prepare__ ¹
2. __call__
3. __new__
4. __init__

这是源代码：

# Provide a PEP 3115 compliant mechanism for class creation
def new_class(name, bases=(), kwds=None, exec_body=None):
    """Create a class object dynamically using the appropriate metaclass."""
    meta, ns, kwds = prepare_class(name, bases, kwds)
    if exec_body is not None:
        exec_body(ns)
    return meta(name, bases, ns, **kwds)

def prepare_class(name, bases=(), kwds=None):
    """Call the __prepare__ method of the appropriate metaclass.

    Returns (metaclass, namespace, kwds) as a 3-tuple

    *metaclass* is the appropriate metaclass
    *namespace* is the prepared class namespace
    *kwds* is an updated copy of the passed in kwds argument with any
    'metaclass' entry removed. If no kwds argument is passed in, this will
    be an empty dict.
    """
    if kwds is None:
        kwds = {}
    else:
        kwds = dict(kwds) # Don't alter the provided mapping
    if 'metaclass' in kwds:
        meta = kwds.pop('metaclass')
    else:
        if bases:
            meta = type(bases[0])
        else:
            meta = type
    if isinstance(meta, type):
        # when meta is a type, we first determine the most-derived metaclass
        # instead of invoking the initial candidate directly
        meta = _calculate_meta(meta, bases)
    if hasattr(meta, '__prepare__'):
        ns = meta.__prepare__(name, bases, **kwds)
    else:
        ns = {}
    return meta, ns, kwds


def _calculate_meta(meta, bases):
    """Calculate the most derived metaclass."""
    winner = meta
    for base in bases:
        base_meta = type(base)
        if issubclass(winner, base_meta):
            continue
        if issubclass(base_meta, winner):
            winner = base_meta
            continue
        # else:
        raise TypeError("metaclass conflict: "
                        "the metaclass of a derived class "
                        "must be a (non-strict) subclass "
                        "of the metaclasses of all its bases")
    return winner

_{1. Note that it get called implicitly inside the new_class function and before the return.}