简单的例子

目标是通过从两者派生的元类创建一个抽象枚举类abc.ABCMeta and enum.EnumMeta。例如：

import abc
import enum

class ABCEnumMeta(abc.ABCMeta, enum.EnumMeta):
    pass

class A(abc.ABC):
    @abc.abstractmethod
    def foo(self):
        pass

class B(A, enum.IntEnum, metaclass=ABCEnumMeta):
    X = 1

class C(A):
    pass

现在，在 Python3.7 上，此代码将被正确解释（在 3.6.x 和可能更低的版本上，不会出现错误）。事实上，我们的 MRO 显示一切看起来都很棒B源自两者A and IntEnum.

>>> B.__mro__
(<enum 'B'>, __main__.A, abc.ABC, <enum 'IntEnum'>, int, <enum 'Enum'>, object)

抽象枚举不是抽象的

然而，尽管B.foo还没有定义，我们仍然可以实例化B没有任何问题，并致电foo().

>>> B.X
<B.X: 1>
>>> B(1)
<B.X: 1>
>>> B(1).foo() 

这看起来相当奇怪，因为即使我使用自定义元类，从 ABCMeta 派生的任何其他类都无法实例化。

>>> class NewMeta(type): 
...     pass
... 
... class AbcNewMeta(abc.ABCMeta, NewMeta):
...     pass
... 
... class D(metaclass=NewMeta):
...     pass
... 
... class E(A, D, metaclass=AbcNewMeta):
...     pass
...
>>> E()
TypeError: Can't instantiate abstract class E with abstract methods foo

Question

为什么使用派生自元类的类EnumMeta and ABCMeta有效地忽略ABCMeta，而使用派生自的元类的任何其他类ABCMeta用它？即使我自定义了也是如此__new__操作员。

class ABCEnumMeta(abc.ABCMeta, enum.EnumMeta):
    def __new__(cls, name, bases, dct):
        # Commented out lines reflect other variants that don't work
        #return abc.ABCMeta.__new__(cls, name, bases, dct)
        #return enum.EnumMeta.__new__(cls, name, bases, dct)
        return super().__new__(cls, name, bases, dct)

我很困惑，因为这似乎违背了元类的含义：元类应该定义类的定义和行为方式，在这种情况下，使用既是抽象又是枚举的元类定义一个类创建一个默默地忽略抽象组件的类。这是一个错误，这是有意为之，还是有什么我不明白的事情？

正如 @chepner 的回答所述，发生的事情是Enum元类覆盖普通元类'__call__方法，使得Enum类永远不会通过普通方法实例化，因此，ABCMeta检查不会触发其抽象方法检查。

然而，在类创建方面，元类的__new__正常运行，并且抽象类机制用于将类标记为抽象的属性确实创建了该属性___abstractmethods__在创建的类上。

因此，您要做的就是进一步自定义您的元类以在代码中执行抽象检查__call__:

import abc
import enum

class ABCEnumMeta(abc.ABCMeta, enum.EnumMeta):

    def __call__(cls, *args, **kw):
        if getattr(cls, "__abstractmethods__", None):
            raise TypeError(f"Can't instantiate abstract class {cls.__name__} "
                            f"with frozen methods {set(cls.__abstractmethods__)}")
        return super().__call__(*args, **kw)

这将使B(1)表达式失败并出现相同的错误abstractclass实例化。

但请注意，Enum无论如何，类都不能进一步继承，并且它只是在不缺少抽象方法的情况下创建它可能已经违反了您想要检查的内容。也就是说：在上面的例子中，class B可以声明并且B.x会起作用，即使缺少foo方法。如果你想防止这种情况，只需在元类中进行相同的检查即可”__new__:

import abc
import enum

class ABCEnumMeta(abc.ABCMeta, enum.EnumMeta):

    def __new__(mcls, *args, **kw):
        cls = super().__new__(mcls, *args, **kw)
        if issubclass(cls, enum.Enum) and getattr(cls, "__abstractmethods__", None):
            raise TypeError("...")
        return cls

    def __call__(cls, *args, **kw):
        if getattr(cls, "__abstractmethods__", None):
            raise TypeError(f"Can't instantiate abstract class {cls.__name__} "
                            f"with frozen methods {set(cls.__abstractmethods__)}")
        return super().__call__(*args, **kw)

（不幸的是，ABCCPython 中的抽象方法检查似乎是在本机代码中执行的，在ABCMeta.__call__方法 - 否则，我们可以调用而不是模仿错误ABCMeta.__call__明确覆盖super的行为而不是硬编码TypeError there.)