Python自学手册
本文示例将聚焦于dict和list，因为它们可能是最常被继承的内置类。
创建自定义字典
我们希望创建一个双向字典：当添加一个键值对时，键映射到值，同时值也映射到键。
这个字典中的元素数量始终是偶数。如果d[k] == v为True，那么d[v] == k也必然为True。
我们可以尝试通过自定义键值对的删除和设置行为来实现这一点。
pythonclass TwoWayDict(dict):def __delitem__(self, key):value = super().pop(key)super().pop(value, None)def __setitem__(self, key, value):if key in self:del self[self[key]]if value in self:del self[value]super().__setitem__(key, value)super().__setitem__(value, key)def __repr__(self):return f"{type(self).__name__}({super().__repr__()})" |
在这里，我们确保：
•删除键时，也会删除其对应的值
•当为k设置新值时，会正确移除任何已存在的旧值
•当设置一个键值对时，也会设置对应的值-键 对
向这个双向字典中设置和删除元素，看起来符合我们的预期：
python>>> d = TwoWayDict()>>> d[3] = 8>>> dTwoWayDict({3: 8, 8: 3})>>> d[7] = 6>>> dTwoWayDict({3: 8, 8: 3, 7: 6, 6: 7}) |
但调用这个字典的update方法会导致异常行为：
python>>> dTwoWayDict({3: 8, 8: 3, 7: 6, 6: 7})>>> d.update({9: 7, 8: 2})>>> dTwoWayDict({3: 8, 8: 2, 7: 6, 6: 7, 9: 7}) |
添加9: 7应该移除7: 6和6: 7，而添加8: 2应该移除3: 8和8: 3，但实际并未如此。
我们可以通过自定义update方法来修复这个问题：
pythondef update(self, items):if isinstance(items, dict):items = items.items()for key, value in items:self[key] = value |
但调用构造函数（初始化方法）也无法正常工作：
python>>> d = TwoWayDict({9: 7, 8: 2})>>> dTwoWayDict({9: 7, 8: 2}) |
因此，我们需要创建一个调用update方法的自定义初始化方法：
pythondef __init__(self, items=()):self.update(items) |
但pop方法仍然无法正常工作：
python>>> d = TwoWayDict()>>> d[9] = 7>>> dTwoWayDict({9: 7, 7: 9})>>> d.pop(9)7>>> dTwoWayDict({7: 9}) |
setdefault方法也同样存在问题：
python>>> d = TwoWayDict()>>> d.setdefault(4, 2)2>>> dTwoWayDict({4: 2}) |
核心问题在于：pop方法实际上并不会调用__delitem__，而setdefault方法也不会调用__setitem__。
如果想要解决这个问题，我们必须完全重新实现pop和setdefault方法：
pythonDEFAULT = object()class TwoWayDict(dict):# ...（省略已实现的方法）def pop(self, key, default=DEFAULT):if key in self or default is DEFAULT:value = self[key]del self[key]return valueelse:return defaultdef setdefault(self, key, value):if key not in self:self[key] = value |
但这一切都非常繁琐。当继承dict来创建自定义字典时，我们通常会期望update和__init__会调用__setitem__，pop和setdefault会调用__delitem__，但事实并非如此！
同样，get和pop方法也不会像你预期的那样调用__getitem__。
list和set存在同样的问题
list和set类存在与dict类类似的问题。我们来看一个示例。
我们创建一个自定义列表，继承自list构造函数，并覆盖__delitem__、__iter__和__eq__的行为。这个列表会自定义__delitem__方法，使其不实际删除元素，而是在该元素原本的位置留下一个“占位符”。__iter__和__eq__方法在比较两个HoleList类是否“相等”时，会跳过这些占位符。
这个类本身有点无意义（幸运的是，它不是Python Morsels的练习），但我们的重点不在于类本身，而在于继承list时存在的问题：
pythonclass HoleList(list):HOLE = object()def __delitem__(self, index):self[index] = self.HOLEdef __iter__(self):return (itemfor item in super().__iter__()if item is not self.HOLE)def __eq__(self, other):if isinstance(other, HoleList):return all(x == yfor x, y in zip(self, other))return super().__eq__(other)def __repr__(self):return f"{type(self).__name__}({super().__repr__()})" |
补充说明：如果你对这里的object()感到好奇，我在关于Python中哨兵值的文章中解释了它的用途。
如果我们创建两个HoleList对象，并从它们中删除元素，使它们的非占位符元素相同：
python>>> x = HoleList([2, 1, 3, 4])>>> y = HoleList([1, 2, 3, 5])>>> del x[0]>>> del y[1]>>> del x[-1]>>> del y[-1] |
我们会发现它们是相等的：
python>>> x == yTrue>>> list(x), list(y)([1, 3], [1, 3])>>> xHoleList([<object object at 0x7f56bdf38120>, 1, 3, <object object at 0x7f56bdf38120>])>>> yHoleList([1, <object object at 0x7f56bdf38120>, 3, <object object at 0x7f56bdf38120>]) |
但如果我们随后判断它们是否不相等，会发现它们既相等又不相等：
python>>> x == yTrue>>> x != yTrue>>> list(x), list(y)([1, 3], [1, 3])>>> xHoleList([<object object at 0x7f56bdf38120>, 1, 3, <object object at 0x7f56bdf38120>])>>> yHoleList([1, <object object at 0x7f56bdf38120>, 3, <object object at 0x7f56bdf38120>]) |
在Python 3中，通常情况下，重写__eq__方法会同时自定义相等性（==）和不等性（!=）检查的行为。但对于list或dict来说并非如此：它们同时定义了__eq__和__ne__方法，这意味着我们需要同时重写这两个方法。
pythondef __ne__(self, other):return not (self == other) |
dict也存在同样的问题：由于__ne__方法的存在，当继承dict时，我们需要注意同时重写__eq__和__ne__。
此外，与dict类似，list的remove和pop方法也不会调用__delitem__：
python>>> yHoleList([1, <object object at 0x7f56bdf38120>, 3, <object object at 0x7f56bdf38120>])>>> y.remove(1)>>> yHoleList([<object object at 0x7f56bdf38120>, 3, <object object at 0x7f56bdf38120>])>>> y.pop(0)<object object at 0x7f56bdf38120>>>> yHoleList([3, <object object at 0x7f56bdf38120>]) |
我们同样可以通过重新实现remove和pop方法来解决这些问题：
pythondef remove(self, value):index = self.index(value)del self[index]def pop(self, index=-1):value = self[index]del self[index]return value |
但这非常麻烦，而且我们无法确定是否已经解决了所有问题。
每当我们在list或dict的子类中自定义某部分核心功能时，都需要确保同时自定义其他包含相同功能（但不会委托给我们重写的方法）的方法。
Python开发者为什么要这样设计？
据我了解，内置的list、dict和set类型为了性能，内嵌了大量代码。本质上，他们在许多不同的函数之间复制粘贴了相同的代码，以避免额外的函数调用，从而使程序运行得更快一些。
我没有在网上找到相关资料，解释为什么做出这个决定，以及这种选择的替代方案会带来什么后果。但我大致相信，这是为了我们Python开发者的利益而设计的。如果dict和list不是通过这种方式实现更快的速度，核心开发者为什么会选择这种奇怪的实现方式呢？
继承list和dict的替代方案是什么？
既然继承list创建自定义列表很麻烦，继承dict创建自定义字典也很麻烦，那么替代方案是什么？
我们如何创建一个不继承自内置dict的类字典对象？
有几种创建自定义字典的方法：
1.完全遵循鸭子类型：明确你的数据结构需要具备哪些类字典的特性，然后创建一个完全自定义的类（看起来像字典、行为也像字典）。
2.继承一个辅助类，它会指引我们正确的方向，并告诉我们的对象需要哪些方法才能成为类字典对象。
3.找到一个更具可扩展性的dict重实现版本，然后继承它。
我们将跳过第一种方法：从头重新实现所有功能会花费很多时间，而Python提供了一些辅助工具，可以让事情变得更简单。我们将重点关注这些辅助工具，首先是那些指引我们方向的工具（上述第2点），然后是那些作为dict完整替代方案的工具（上述第3点）。
抽象基类：帮你实现“鸭子类型”的正确姿势
Python的collections.abc模块包含抽象基类，这些类可以帮助我们实现Python中一些常见的协议（即Java中所说的接口）。
我们想要创建一个类字典对象。字典是可变映射（mutable mapping），类字典对象本质上就是一种映射（mapping）。“mapping”这个词来源于“hash map”（哈希映射），这是许多其他编程语言对这种数据结构的称呼。
因此，我们需要创建一个可变映射。collections.abc模块提供了一个对应的抽象基类：MutableMapping！
如果我们继承这个抽象基类，就会发现它要求我们实现某些特定的方法才能正常工作：
python>>> from collections.abc import MutableMapping>>> class TwoWayDict(MutableMapping):... pass...>>> d = TwoWayDict()Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: Can't instantiate abstract class TwoWayDict with abstract methods __delitem__, __getitem__, __iter__, __len__, __setitem__ |
MutableMapping类要求我们定义获取、删除和设置元素的方式，迭代的方式，以及获取字典长度的方式。但一旦我们实现了这些方法，就会免费获得pop、clear、update和setdefault方法！
以下是使用MutableMapping抽象基类重新实现的TwoWayDict：
pythonfrom collections.abc import MutableMappingclass TwoWayDict(MutableMapping):def __init__(self, data=()):self.mapping = {}self.update(data)def __getitem__(self, key):return self.mapping[key]def __delitem__(self, key):value = self[key]del self.mapping[key]self.pop(value, None)def __setitem__(self, key, value):if key in self:del self[self[key]]if value in self:del self[value]self.mapping[key] = valueself.mapping[value] = keydef __iter__(self):return iter(self.mapping)def __len__(self):return len(self.mapping)def __repr__(self):return f"{type(self).__name__}({self.mapping})" |
与dict不同，这里的update和setdefault方法会调用我们实现的__setitem__方法，而pop和clear方法会调用我们实现的__delitem__方法。
你可能会认为，抽象基类会让我们脱离Python美妙的鸭子类型，进入某种强类型的面向对象编程领域。但实际上，抽象基类反而增强了鸭子类型。继承抽象基类帮助我们成为“更好的鸭子”。我们不必担心是否已经实现了可变映射所需的所有行为，因为如果我们忘记指定某些必要的行为，抽象基类会提醒我们。
我们之前创建的HoleList类需要继承MutableSequence抽象基类。一个自定义的类集合对象，可能需要继承MutableSet抽象基类。
UserList/UserDict：真正可扩展的列表和字典
当使用collections.abc中的映射（Mapping）、序列（Sequence）、集合（Set）及其可变子类时，你会经常发现自己需要创建一个现有数据结构的包装器。如果你正在实现一个类字典对象，使用字典作为底层实现会更简单；对于列表和集合也是如此。
Python实际上提供了两个更高级的辅助类，用于创建类列表和类字典对象，它们包装了list和dict对象。这两个类位于collections模块中，分别是UserList和UserDict。
以下是使用UserDict重新实现的TwoWayDict：
pythonfrom collections import UserDictclass TwoWayDict(UserDict):def __delitem__(self, key):value = self[key]super().__delitem__(key)self.pop(value, None)def __setitem__(self, key, value):if key in self:del self[self[key]]if value in self:del self[value]super().__setitem__(key, value)super().__setitem__(value, key)def __repr__(self):return f"{type(self).__name__}({self.data})" |
你可能会注意到上述代码有一个有趣的地方。
这段代码看起来与我们最初尝试继承dict时编写的代码（那个有很多bug的版本）非常相似：
pythonclass TwoWayDict(dict):def __delitem__(self, key):value = super().pop(key)super().pop(value, None)def __setitem__(self, key, value):if key in self:del self[self[key]]if value in self:del self[value]super().__setitem__(key, value)super().__setitem__(value, key)def __repr__(self):return f"{type(self).__name__}({super().__repr__()})" |
__setitem__方法完全相同，但__delitem__方法有一些细微的差别。
从这两段代码来看，UserDict似乎只是一个更好的dict。但事实并非完全如此：UserDict与其说是dict的替代品，不如说是dict的包装器。
UserDict类实现了字典应该具备的接口，但它在底层包装了一个实际的dict对象。
以下是我们编写上述UserDict代码的另一种方式，无需使用super调用：
pythonfrom collections import UserDictclass TwoWayDict(UserDict):def __delitem__(self, key):value = self.data.pop(key)self.data.pop(value, None)def __setitem__(self, key, value):if key in self:del self[self[key]]if value in self:del self[value]self.data[key] = valueself.data[value] = key |
这两个方法都引用了self.data，但我们并没有定义它。
UserDict类的初始化方法会创建一个字典，并将其存储在self.data中。这个类字典的UserDict类的所有方法，都围绕着这个self.data字典进行包装。UserList的工作方式与此相同，只是它的数据属性（data）包装了一个list对象。如果我们想要自定义这些类的某个dict或list方法，只需重写该方法并修改其行为即可。
你可以将UserDict和UserList视为包装类。当我们继承这些类时，我们是在包装一个数据属性（data），所有的方法查找都通过这个属性进行代理。
用专业的面向对象术语来说，我们可以将UserDict和UserList视为适配器类。
应该使用抽象基类还是UserDict和UserList？
UserList和UserDict类最初创建于collections.abc中的抽象基类之前。UserList和UserDict（至少以某种形式）在Python 2.0发布之前就已经存在，而collections.abc中的抽象基类直到Python 2.6才出现。
当你想要一个行为与list或dict几乎完全相同，但只需自定义少量功能时，适合使用UserList和UserDict类。
当你想要一个序列或映射，但它与list或dict差异较大，以至于你确实需要创建自己的自定义类时，collections.abc中的抽象基类会非常有用。
直接继承list和dict有意义吗？
直接继承list和dict并不总是坏事。
例如，以下是一个功能完善的DefaultDict版本（其行为与collections.defaultdict略有不同）：
pythonclass DefaultDict(dict):def __init__(self, *args, default=None, **kwargs):super().__init__(*args, **kwargs)self.default = defaultdef __missing__(self, key):return self.default |
这个DefaultDict使用__missing__方法实现了预期的行为：
python>>> d = DefaultDict({'a': 8})>>> d['a']8>>> d['b']>>> d{'a': 8}>>> e = DefaultDict({'a': 8}, default=4)>>> e['a']8>>> e['b']4>>> e{'a': 8} |
这里继承dict没有任何问题，因为我们没有重写那些分散在多个地方的功能。
如果你只是修改某个单一方法的功能，或者添加自己的自定义方法，那么直接继承list或dict可能是值得的。但如果你的修改需要在多个地方重复相同的功能（这种情况很常见），则可以考虑使用上述的替代方案。
创建自定义列表或字典时，请记住你有多种选择
当创建自己的类集合、类列表或类字典对象时，请仔细思考你的对象需要如何工作。
如果你需要修改某些核心功能，那么继承list、dict或set会很麻烦，我不建议这样做。
如果你正在创建list或dict的变体，并且只需自定义少量核心功能，可以考虑继承collections.UserList或collections.UserDict。
一般来说，如果你正在创建自定义对象，通常会想要使用collections.abc中的抽象基类。例如，如果你正在创建一个稍微自定义的序列或映射（类似collections.deque、range，或许还有collections.Counter），你会需要MutableSequence或MutableMapping。如果你正在创建一个自定义的类集合对象，你唯一的选择是collections.abc.Set或collections.abc.MutableSet（不存在UserSet）。
在Python中，我们并不经常需要创建自己的数据结构。当你确实需要创建自定义集合时，围绕现有数据结构创建包装器是一个很好的想法。当你需要时，请记住collections和collections.abc模块！
