致谢

Talin 撰写了下面的“原理” [1] 以及关于 ABC 与接口的大部分章节。仅凭这一点，他就应该获得联合作者的荣誉。PEP 的其余部分使用“我”指代第一作者。

重载 isinstance() 和 issubclass()

在开发本 PEP 及其配套的 PEP 3141 的过程中，我们反复面临在标准化更细粒度的 ABC 还是更少粒度的 ABC 之间的选择。例如，在某个阶段，PEP 3141 引入了用于复数的以下基类堆栈：MonoidUnderPlus、AdditiveGroup、Ring、Field、Complex（每个都派生自前一个）。讨论中提到了其他几种被排除的代数分类：Algebraic、Transcendental 和 IntegralDomain、PrincipalIdealDomain。在本 PEP 的早期版本中，我们考虑了独立类如 Set、ComposableSet、MutableSet、HashableSet、MutableComposableSet、HashableComposableSet 的用例。

这里的困境是，我们宁愿拥有更少的 ABC，但如果用户需要一个不够精细的 ABC 该怎么办？例如，考虑一位想要定义自己的超越数类型的数学家，但他也希望 float 和 int 被视为超越数。 PEP 3141 最初提出为此目的修补 float.__bases__，但有一些充分的理由可以使内置类型保持不变（例如，它们在同一地址空间中运行的所有 Python 解释器之间共享，如 mod_python 所使用的 [16]）。

另一个例子是有人想为一个具有 append() 方法的任何序列定义一个泛型函数（PEP 3124）。Sequence ABC（见下文）不保证 append() 方法，而 MutableSequence 不仅要求 append()，还要求各种其他修改方法。

为了解决这些以及类似的困境，下一节将提出一个用于 ABC 的元类，该元类允许我们将 ABC 添加为“虚拟基类”（与 C++ 中的概念不同），它可以添加到任何类，包括另一个 ABC。这使得标准库可以定义 Sequence 和 MutableSequence ABC，并将它们注册为内置类型（如 basestring、tuple 和 list）的虚拟基类，以便例如以下条件都为真

isinstance([], Sequence)
issubclass(list, Sequence)
issubclass(list, MutableSequence)
isinstance((), Sequence)
not issubclass(tuple, MutableSequence)
isinstance("", Sequence)
issubclass(bytearray, MutableSequence)

此处提出的主要机制是允许重载内置函数 isinstance() 和 issubclass()。重载的工作原理如下：调用 isinstance(x, C) 首先检查 C.__instancecheck__ 是否存在，如果存在，则调用 C.__instancecheck__(x) 而不是其正常实现。类似地，调用 issubclass(D, C) 首先检查 C.__subclasscheck__ 是否存在，如果存在，则调用 C.__subclasscheck__(D) 而不是其正常实现。

请注意，魔法名称不是 __isinstance__ 和 __issubclass__；这是因为参数的颠倒可能会引起混淆，特别是对于 issubclass() 重载。

这里的原型实现 [12]。

这里有一个（天真地简单）实现 __instancecheck__ 和 __subclasscheck__ 的示例

class ABCMeta(type):

    def __instancecheck__(cls, inst):
        """Implement isinstance(inst, cls)."""
        return any(cls.__subclasscheck__(c)
                   for c in {type(inst), inst.__class__})

    def __subclasscheck__(cls, sub):
        """Implement issubclass(sub, cls)."""
        candidates = cls.__dict__.get("__subclass__", set()) | {cls}
        return any(c in candidates for c in sub.mro())

class Sequence(metaclass=ABCMeta):
    __subclass__ = {list, tuple}

assert issubclass(list, Sequence)
assert issubclass(tuple, Sequence)

class AppendableSequence(Sequence):
    __subclass__ = {list}

assert issubclass(list, AppendableSequence)
assert isinstance([], AppendableSequence)

assert not issubclass(tuple, AppendableSequence)
assert not isinstance((), AppendableSequence)

下一节将提出一个完整的实现。

abc 模块：一个 ABC 支持框架

新的标准库模块 abc，用纯 Python 编写，充当 ABC 支持框架。它定义了一个元类 ABCMeta 和装饰器 @abstractmethod 和 @abstractproperty。示例实现由 [13] 提供。

ABCMeta 类重写了 __instancecheck__ 和 __subclasscheck__，并定义了一个 register 方法。register 方法接受一个参数，该参数必须是一个类；在调用 B.register(C) 之后，调用 issubclass(C, B) 将返回 True，因为 B.__subclasscheck__(C) 返回 True。此外，isinstance(x, B) 等价于 issubclass(x.__class__, B) or issubclass(type(x), B)。（type(x) 和 x.__class__ 可能不是同一个对象，例如当 x 是代理对象时。）

这些方法旨在应用于其元类是（派生自）ABCMeta 的类；例如

from abc import ABCMeta

class MyABC(metaclass=ABCMeta):
    pass

MyABC.register(tuple)

assert issubclass(tuple, MyABC)
assert isinstance((), MyABC)

最后两个断言等价于以下两个

assert MyABC.__subclasscheck__(tuple)
assert MyABC.__instancecheck__(())

当然，您也可以直接继承 MyABC

class MyClass(MyABC):
    pass

assert issubclass(MyClass, MyABC)
assert isinstance(MyClass(), MyABC)

同样，当然，元组不是 MyClass

assert not issubclass(tuple, MyClass)
assert not isinstance((), MyClass)

您可以将另一个类注册为 MyClass 的子类

MyClass.register(list)

assert issubclass(list, MyClass)
assert issubclass(list, MyABC)

您也可以注册另一个 ABC

class AnotherClass(metaclass=ABCMeta):
    pass

AnotherClass.register(basestring)

MyClass.register(AnotherClass)

assert isinstance(str, MyABC)

最后一个断言需要跟踪以下超类-子类关系

MyABC -> MyClass (using regular subclassing)
MyClass -> AnotherClass (using registration)
AnotherClass -> basestring (using registration)
basestring -> str (using regular subclassing)

abc 模块还定义了一个新的装饰器 @abstractmethod，用于声明抽象方法。包含至少一个已使用此装饰器声明但尚未被覆盖的方法的类无法实例化。这些方法可以在子类的覆盖方法中调用（使用 super 或直接调用）。例如

from abc import ABCMeta, abstractmethod

class A(metaclass=ABCMeta):
    @abstractmethod
    def foo(self): pass

A()  # raises TypeError

class B(A):
    pass

B()  # raises TypeError

class C(A):
    def foo(self): print(42)

C()  # works

注意： @abstractmethod 装饰器只能在类体内部使用，并且只能用于元类是（派生自）ABCMeta 的类。动态地向类添加抽象方法，或尝试在类创建后修改方法的抽象状态，是不支持的。 @abstractmethod 仅影响通过常规继承派生的子类；使用 register() 方法注册的“虚拟子类”不受影响。

实现： @abstractmethod 装饰器将函数属性 __isabstractmethod__ 设置为 True。 ABCMeta.__new__ 方法计算类型属性 __abstractmethods__，它是所有方法名的集合，这些方法名具有值为 True 的 __isabstractmethod__ 属性。它通过合并基类的 __abstractmethods__ 属性，添加新类字典中所有具有 true __isabstractmethod__ 属性的方法名，并移除新类字典中所有不具有 true __isabstractmethod__ 属性的方法名来实现。如果结果的 __abstractmethods__ 集合非空，则该类被视为抽象类，尝试实例化它将引发 TypeError。（如果这是在 CPython 中实现的，内部标志 Py_TPFLAGS_ABSTRACT 可以用来加速此检查 [6]。）

讨论： 与 Java 的抽象方法或 C++ 的纯抽象方法不同，这里定义的抽象方法可以有一个实现。可以通过 super 机制从覆盖它的类调用此实现。这可能有助于在使用协作式多重继承的框架中作为 super 调用的终结点 [7], [8]。

第二个装饰器 @abstractproperty，用于定义抽象数据属性。它是内置 property 类的子类，添加了 __isabstractmethod__ 属性

class abstractproperty(property):
    __isabstractmethod__ = True

它可以使用两种方式

class C(metaclass=ABCMeta):

    # A read-only property:

    @abstractproperty
    def readonly(self):
        return self.__x

    # A read-write property (cannot use decorator syntax):

    def getx(self):
        return self.__x
    def setx(self, value):
        self.__x = value
    x = abstractproperty(getx, setx)

与抽象方法类似，继承抽象属性（使用装饰器语法或长形式声明）的子类，除非用具体属性覆盖该抽象属性，否则无法实例化。

容器和迭代器的 ABC

collections 模块将定义用于处理集合、映射、序列以及某些辅助类型（如迭代器和字典视图）的 ABC。所有 ABC 都具有上述 ABCMeta 作为其元类。

ABC 提供其抽象方法的实现，这些实现技术上有效但相当无用；例如 __hash__ 返回 0，而 __iter__ 返回一个空迭代器。通常，抽象方法表示指示类型的空容器的行为。

一些 ABC 还提供具体（即非抽象）方法；例如，Iterator 类有一个 __iter__ 方法返回自身，满足了迭代器的一个重要不变量（在 Python 2 中，这需要由每个迭代器类重新实现）。这些 ABC 可以被认为是“混入”类。

PEP 中定义的 ABC 均未重写 __init__、__new__、__str__ 或 __repr__。定义标准的构造函数签名会不必要地限制自定义容器类型，例如 Patricia 树或 gdbm 文件。定义集合的特定字符串表示也是如此，留给各个实现。

注意： 没有用于排序操作（__lt__, __le__, __ge__, __gt__）的 ABC。在基类（抽象或非抽象）中定义这些会导致第二个操作数的类型出现问题。例如，如果类 Ordering 定义了 __lt__，那么对于任何 Ordering 实例 x 和 y，x < y 将被定义（即使它只定义了部分排序）。但这不可能：如果 list 和 str 都派生自 Ordering，这将意味着 [1, 2] < (1, 2) 应该被定义（并可能返回 False），而实际上（在 Python 3000 中！）这种“混合模式比较”操作是明确禁止的，并且会引发 TypeError。有关更多信息，请参阅 PEP 3100 和 [14]。（这是对接受相同类型另一个参数的操作的更一般问题的特殊情况。）

class Sized(metaclass=ABCMeta):
    @abstractmethod
    def __hash__(self):
        return 0
    @classmethod
    def __instancecheck__(cls, x):
        return hasattr(x, "__len__")
    @classmethod
    def __subclasscheck__(cls, C):
        return hasattr(C, "__bases__") and hasattr(C, "__len__")

字符串

Python 3000 可能至少有两个内置字符串类型：字节字符串（bytes），派生自 MutableSequence，以及（Unicode）字符字符串（str），派生自 Sequence 和 Hashable。

未解决的问题： 定义这些的基接口，以便替代实现和子类知道它们将面临什么。这可能是新 PEP 或 PEP 的主题（PEP 358 应被用于 bytes 类型）。

ABC 与鸭子类型

引入 ABC 是否意味着鸭子类型的终结？我认为不是。当一个类定义了 __getitem__ 方法时，Python 不会要求它派生自 BasicMapping 或 Sequence，也不会 x[y] 语法要求 x 是其中任何一个 ABC 的实例。只要它有一个 write 方法，您仍然可以将任何“类文件”对象分配给 sys.stdout。

当然，会有一些“胡萝卜”来鼓励用户派生自适当的基类；这些从某些功能的默认实现到区分映射和序列的改进能力不等。但没有“大棒”。如果 hasattr(x, "__len__") 对您有用，那太好了！ABC 旨在解决 Python 2 中根本没有良好解决方案的问题，例如区分映射和序列。

ABC 与泛型函数

ABC 与泛型函数（GF）兼容。例如，我自己的泛型函数实现 [4] 使用参数的类（类型）作为分派键，允许派生类覆盖基类。由于（从 Python 的角度来看）ABC 是相当普通的类，在 GF 的默认实现中使用 ABC 可能非常合适。例如，如果我有一个重载的 prettyprint 函数，定义集合的漂亮打印如下将是很有意义的

@prettyprint.register(Set)
def pp_set(s):
    return "{" + ... + "}"  # Details left as an exercise

并且可以轻松添加特定 Set 子类的实现。

我相信 ABC 也不会给 RuleDispatch，Phillip Eby 在 PEAK 中的 GF 实现 [5] 带来任何问题。

当然，GF 的支持者可能会声称 GF（以及具体类或实现类）就是您所需要的。但即使是他们也不会否认继承的有用性；并且可以轻松地将本 PEP 中提出的 ABC 视为可选的实现基类；没有要求所有用户定义的映射都派生自 BasicMapping。

ABC 与接口

ABC 与接口在本质上并不不兼容，但存在相当大的重叠。目前，我将留给接口的支持者来解释为什么接口更好。我预计，例如，在定义“映射性”的各种细微差别和命名法方面所做的许多工作，可以很容易地改编为使用接口而不是 ABC 的提案。

“接口”在此上下文中指的是一组关于附加到类的元数据元素的提案，这些元素不属于常规类层次结构，但允许进行某些类型的继承测试。

这些元数据将被设计成，至少在某些提案中，可以被应用程序轻松修改，从而允许应用程序编写者覆盖对象的正常分类。

这种将可变元数据附加到类的想法的缺点是类是共享状态，修改它们可能会导致意图冲突。此外，使用泛型函数可以更干净地覆盖对象的分类：在最简单的情况下，可以定义一个“类别成员资格”泛型函数，该函数在默认实现中简单地返回 False，然后提供返回 True 的覆盖，以用于任何感兴趣的类。