在Python3中，是否可以为一个具有多个基的类动态创建元类？

Question

在Python2中，使用一个技巧可以创建一个具有多个基类的类，尽管这些基类的元类互为而不是子类。在

诀窍在于这些元类本身有一个元类（将其命名为“元元类”），并且该元元类为元类提供了一个调用方法，该方法可以在必要时动态创建基元类的公共子元类。最终，一个类的结果是其元类是新的子元类。代码如下：

>>> class MetaMeta(type):
...     def __call__(mcls, name, bases, methods):
...         metabases = set(type(X) for X in bases)
...         metabases.add(mcls)
...         if len(metabases) > 1:
...             mcls = type(''.join([X.__name__ for X in metabases]), tuple(metabases), {})
...         return mcls.__new__(mcls, name, bases, methods)
... 
>>> class Meta1(type):
...     __metaclass__ = MetaMeta
... 
>>> class Meta2(type):
...     __metaclass__ = MetaMeta
... 
>>> class C1:
...     __metaclass__ = Meta1
... 
>>> class C2:
...     __metaclass__ = Meta2
... 
>>> type(C1)
<class '__main__.Meta1'>
>>> type(C2)
<class '__main__.Meta2'>
>>> class C3(C1,C2): pass
... 
>>> type(C3)
<class '__main__.Meta1Meta2'>

这个例子（当然将语法改为class C1(metaclass=Meta1)等）在python3中不起作用。在

问题1:我是否正确地理解，在Python2中，第一个C3是使用第一个基的元类构造的，并且只有当{}不是{}和{}的普通子类时，才会出现错误，而在python3中，错误会提前出现？在

问题2：（如何）使上述示例在Python3中工作？我确实尝试过使用abc.ABCMeta的子类作为元元类，但是即使使用自定义的__subclasscheck__使issubclass(Meta1, Meta2)返回{}，C3的创建仍然会导致错误。在

注意：当然，我可以通过静态定义Meta1Meta2并显式地将其作为C3的元类来让Python3高兴起来。然而，这不是我想要的。我希望公共子元类是动态创建的。在

Answer 1

在python3中，在使用元类时，它必须准备好，并且它不知道最终（非元）类的基，以便在那时动态地创建一个元类。在

但是，与其让事情复杂化（我承认我无法完全理解您对元类的需求），您可以简单地使用普通的类层次结构，协同使用super作为元类。 你甚至可以用一个简单的 调用type：

class A(type):
    def __new__(metacls, name, bases,attrs):
        attrs['A'] = "Metaclass A processed"
        return super().__new__(metacls, name, bases,attrs)


class B(type):
    def __new__(metacls, name, bases,attrs):
        attrs['B'] = "Metaclass A processed"
        return super().__new__(metacls, name, bases,attrs)


C = type("C", (A, B), {})

class Example(metaclass=C): pass

以及：

^{pr2}$

如果你的元类一开始就不是为了协作而设计的，那么创建任何自动方法来组合它们是非常困难的——而且可能涉及到在一些元类构造函数中对type.__new__的调用进行monkey修补。在

至于不需要显式地构建C，可以使用一个普通函数作为元类参数，它将检查基并构建一个动态派生元类：

def Auto(name, bases, attrs):
    basemetaclasses = []
    for base in bases:
        metacls = type(base)
        if isinstance(metacls, type) and metacls is not type and not metacls in basemetaclasses:
            basemetaclasses.append(metacls)
    dynamic = type(''.join(b.__name__ for b in basemetaclasses), tuple(basemetaclasses), {})
    return dynamic(name, bases, attrs)

（这段代码与您的代码非常相似-但我使用了三行显式for而不是set以保持元类顺序-这可能很重要）

您可以让它们将Auto作为派生类的元类传递，但在其他情况下，它的工作方式与您的示例相同：

In [61]: class AA(metaclass=A):pass

In [62]: class BB(metaclass=B):pass

In [63]: class CC(AA,BB): pass
                                     -
...
TypeError:   metaclass conflict
...

In [66]: class CC(AA,BB, metaclass=Auto): pass

In [67]: type(CC)
Out[67]: __main__.AB

In [68]: CC.A
Out[68]: 'Metaclass A processed'