致谢

Talin 撰写了下面的基本原理 [1] 以及 ABC 与接口部分的大部分内容。仅凭这一点，他就值得成为共同作者。PEP 的其余部分使用“我”指代第一作者。

重载 isinstance() 和 issubclass()

在开发本 PEP 及其配套 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 该怎么办？例如，考虑一下想要定义自己的超越数类型的数学家的困境，但又希望浮点数和整数也被视为超越数。 PEP 3141 最初建议为此目的修补 float.__bases__，但有一些充分的理由来保持内置类型不变（其中之一是它们在同一地址空间中所有 Python 解释器之间共享，如 mod_python [16] 使用的那样）。

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

为了解决这些和类似的难题，下一节将提出一个用于 ABC 的元类，该元类将允许我们将 ABC 作为“虚拟基类”（与 C++ 中的概念不同）添加到任何类中，包括另一个 ABC 中。这允许标准库定义 ABC Sequence 和 MutableSequence 并将其注册为内置类型（如 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 机制从重写它的类中调用此实现。这对于使用协作多重继承的框架中的超级调用的终结点可能很有用 [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 可以被视为“mixin”类。

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

注意：没有用于排序操作的 ABC（__lt__、__le__、__ge__、__gt__）。在基类（抽象或非抽象）中定义这些操作会导致第二个操作数的接受类型出现问题。例如，如果类 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 的引入是否意味着鸭子类型的终结？我不这么认为。当 Python 定义__getitem__方法时，它不会要求一个类派生自BasicMapping或Sequence，也不会要求x[y]语法要求x是任一 ABC 的实例。您仍然可以将任何“类文件”对象分配给sys.stdout，只要它具有write方法即可。

当然，会有一些诱因来鼓励用户从相应的基类派生；这些诱因从某些功能的默认实现到区分映射和序列的改进能力不等。但没有强制要求。如果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 带来任何问题，RuleDispatch 是 Phillip Eby 在 PEAK 中的 GF 实现[5]。

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

ABC 与接口

ABC 本身与接口不冲突，但存在相当大的重叠。目前，我将把解释为什么接口更好的工作留给接口的支持者。我预计，用于定义各种“映射性”和命名法的许多工作可以轻松地适用于使用接口而不是 ABC 的提案。

在这种情况下，“接口”指的是一组附加到类的额外元数据元素的提案，这些元素不是常规类层次结构的一部分，但确实允许某些类型的继承测试。

至少在某些提案中，此类元数据的设计使其易于由应用程序修改，允许应用程序编写者覆盖对象的正常分类。

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