为什么 abc.ABCMeta 抽象实例化检查不能对“list”和“dict”的派生进行检查？

我一直在尝试一些abcpython 中的模块。阿拉

>>> import abc

在正常情况下，如果 ABC 类包含未实现的类，则您希望它不会被实例化abstractmethod。你知道如下：

>>> class MyClass(metaclass=abc.ABCMeta):
...     @abc.abstractmethod
...     def mymethod(self):
...         return -1
...
>>> MyClass()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class MyClass with abstract methods mymethod

OR 对于任何派生类。一切似乎都工作正常，直到你继承了某些东西......说dict or list如下：

>>> class YourClass(list, metaclass=abc.ABCMeta):
...     @abc.abstractmethod
...     def yourmethod(self):
...         return -1
...
>>> YourClass()
[]

这很令人惊讶，因为type无论如何，这可能是主要工厂或元类的东西，所以我从以下内容中假设。

>>> type(abc.ABCMeta)
<class 'type'>
>>> type(list)
<class 'type'>

通过一些调查，我发现它可以归结为简单的事情，比如添加一个__abstractmethod__类的属性'object休息自然发生：

>>> class AbstractClass:
...     pass
...
>>> AbstractClass.__abstractmethods__ = {'abstractmethod'}
>>> AbstractClass()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class AbstractClass with abstract methods abstractmethod

因此，人们可以通过故意覆盖来避免检查__new__方法及清理__abstractmethods__如下：

>>> class SupposedlyAbstractClass(metaclass=abc.ABCMeta):
...     def __new__(cls):
...         cls.__abstractmethods__ = {}
...         return super(AbstractClass, cls).__new__(cls)
...     @abc.abstractmethod
...     def abstractmethod(self):
...         return -1
...
>>> SupposedlyAbstractClass()
<__main__.SupposedlyAbstractClass object at 0x000001FA6BF05828>

正如我亲自检查过的，这种行为在 Python 2.7 和 Python 3.7 中是相同的。我不知道这对于所有其他 python 实现是否相同。

最后，回到问题......为什么会这样？我们永远不应该用抽象类来创建抽象类是明智的吗？list, tuple or dict？或者我应该继续添加一个__new__类方法检查__abstractmethods__在实例化之前？

问题

如果你还有下一堂课：

from abc import ABC, abstractmethod
class Foo(list, ABC):
    @abstractmethod
    def yourmethod(self):
        pass

问题在于Foo can创建时没有任何错误，因为Foo.__new__(Foo)将呼叫直接委托给list.__new__(Foo)代替ABC.__new__(Foo)（负责检查所有抽象方法是否在要实例化的类中实现）

我们可以实施__new__在 Foo 上并尝试调用ABC.__new__:

class Foo(list, ABC):
    def __new__(cls, *args, **kwargs):
        return ABC.__new__(cls)

    @abstractmethod
    def yourmethod(self):
        pass
Foo()

但他提出了下一个错误：

TypeError: object.__new__(Foo) is not safe, use list.__new__()

这是因为ABC.__new__(Foo)调用object.__new__(Foo)这似乎是不允许的Foo继承自list

一个可能的解决方案

您可以添加额外的代码Foo.__new__为了检查要实例化的类中的所有抽象方法是否都已实现（基本上完成以下工作ABC.__new__).

像这样的事情：

class Foo(list, ABC):
    def __new__(cls, *args, **kwargs):
        if hasattr(cls, '__abstractmethods__') and len(cls.__abstractmethods__) > 0:
            raise TypeError(f"Can't instantiate abstract class {cls.__name__} with abstract methods {', '.join(cls.__abstractmethods__)}")
        return super(Foo, cls).__new__(cls)


    @abstractmethod
    def yourmethod(self):
        return -1

Now Foo()引发错误。但接下来的代码运行没有任何问题：

class Bar(Foo):
     def yourmethod(self):
         pass
Bar()