如果你没有被Python的super()惊愕过，那么要么是你不了解它的威力，要么就是你不知道如何高效地使用它。
有许多介绍super()的文章，这一篇与其它文章的不同之处在于:
- 提供了实例
- 阐述了它的工作模型
- 展示了任何场景都能使用它的手段
- 有关使用super()的类的具体建议
- 基于抽象ABCD钻石模型的实例
下面是一个使用Python 3语法，扩展了builtin类型dict中方法的子类：
import pprint
import logging
import collections
class LoggingDict(dict): def __setitem__(self, key, value): logging.info('Setting %r to %r' % (key, value)) super().__setitem__(key, value) LoggingDict继承了父类dict的所有特性，同时其扩展了__setitem__方法来记录被设置的key；在记录日志之后，该方法用super()将真正的更新操作代理给其父类。
我们可以使用dict.__setitem__(self, key, value)来完成super()的功能，但是super()更优，因为它是一个计算出来的间接引用。
间接的一个好处是，我们不需要使用名字来指定代理类。如果你将基类换成其它映射(mapping)类型，super()引用将会自动调整。你只需要一份代码:
class LoggingDict(someOtherMapping): # 新的基类 def __setitem__(self, key, value): logging.info('Setting %r to %r' % (key, value)) super().__setitem__(key, value) # 无需改变 对于计算出的间接引用，其除了隔离变化外，依赖于Python的动态性，可以在运行时改变其指向的class。
计算取决于类在何处被调用以及实例的继承树；super在何处调用取决于类的源码，在上例中super()是在LoggingDict.__setitem__方法中被调用的；实例的继承树在后文详述。
下面先构造一个有序的logging字典：
class LoggingOD(LoggingDict, collections.OrderedDict):
pass 新class的继承树是：LoggingOD, LoggingDict, OrderedDict, dict, object。出人意料的是OrderedDict竟然介于LoggingDict之后和dict之前，这意味着LoggingDict.__setitem__中super()调用会将键/值的更新委托给OrderedDict而不是dict。
在上例中，我们并没有修改LoggingDict的源码，只是创建了一个子类，这个子类的唯一逻辑是组合两个已有的类并控制它们的搜索顺序(search order)。
Search Order
上面提到的搜索顺序或者继承树的官方称谓是Method Resolution Order（方法解析顺序）即MRO。可以用__mro__属性方便地打印出对象的MRO：
pprint.pprint(LoggingOD.__mro__)
(,
,
,
,
)
如果我们想创建出其MRO符合我们意愿的子类，就必须知道它是如何计算的。MRO的计算很简单，MRO序列包含类、类的基类以及基类们的基类......这个过程持续到到达object，object是所有类的根类；这个序列中，子类总是出现在其父类之前，如果一个子类有多个父类，父类按照子类定义中的基类元组的顺序排列。
上例中MRO是按照这些约束计算出来的:
- LoggingOD在其父类LoggingDict, OrderedDict之前
- LoggingDict在OrderedDict之前是因为LoggingOD.bases是(LoggingDict, OrderedDict)
- LoggingDict在它的父类dict之前
- OrderedDict在它的父类dict之前
- dict在它的父类object之前
解析这些约束的过程称为线性化(linearization)。创建出MRO符合我们期望的子类只需知道两个约束：子类在父类之前；符合__bases__里的顺序。
Practical Advice
super()用来将方法调用委托给其继承树中的一些类。为了让super能正常作用，类需要协同设计。下面是三条简单的解决实践：
- 被调用的super()需存在
- 调用者和被调用者的参数签名需匹配
- 方法的任何出现都需要使用super()
1) 先来看一下使调用者和被调者参数签名匹配的策略。对于一般的方法调用而言，被调者在被调之前其信息是已经获知的；然而对于super()，直到运行时才能确定被调者（因为后面定义的子类可能会在MRO中引入新的类）。
一种方法是使用positional参数固定签名。这种方法对于像__setitem__这种只有两个参数的固定签名是适用的。LoggingDict例子中__setitem__的签名和dict中一致。
另一种更灵活的方法是规约继承树中的每一个方法都被设计成接受keyword参数和一个keyword参数字典，“截留住”自身需要的参数，然后将剩下的参数使用**kwds转发至父类中的方法，使得调用链中的最后一次调用中参数字典为空（即沿着继承树一层一层地将参数剥离，每层都留下自己需要的，将余下的参数传递给基类）。
每一层都会剥离其所需的参数，这样就能保证最终将空字典传递给不需要参数的方法（比如，object.__init__不需要参数）：
class Shape:
def __init__(self, shapename, **kwds): self.shapename = shapename super().__init__(**kwds) class ColoredShape(Shape): def __init__(self, color, **kwargs): self.color = color super().__init__(**kwargs) cs = ColoredShape(color='red', shapename='circle') 2) 现在来看一下如何保证目标方法存在。
上例仅展示了最简单的情形。我们知道object有一个__init__方法，它也总是MRO链中最后一个类，因此任意数量的super().__init__最终都会以调用object.__init__结束。换言之，我们可以保证调用继承树上任意对象的super().__init__方法都不会以产生AttributeError而失败。
对于object没有的方法（比如draw()方法），我们需要写一个根类并保证它在object对象之前被调用。根类的作用仅仅是将方法调用“截住”而不会再进一步调用super()。
Root.draw也可以使用defensive programming策略使用断言来保证draw()方法不会再被调用。
class Root:
def draw(self): #: 代理调用链止于此 assert not hasattr(super(), 'draw') class Shape(Root): def __init__(self, shapename, **kwds): self.shapename = shapename super().__init__(**kwds) def draw(self): print('Drawing. Setting shape to:', self.shapename) super().draw() class ColoredShape(Shape): def __init__(self, color, **kwds): self.color = color super().__init__(**kwds) def draw(self): print('Drawing. Setting color to:', self.color) super().draw() cs = ColoredShape(color='blue', shapename='square') cs.draw() Drawing. Setting color to: blue
Drawing. Setting shape to: square
如果子类想在MRO中注入其它类，那么这些类也需要继承自Root，这样在继承路径上的任何类调用draw()方法都不会最终代理至object而抛出AttributeError。这一规定需在文档中明确，这样别人在写新类的时候才知道需要继承Root。这一约束与Python中要求所有异常必须继承自BaseException并无不同。
3) 上面讨论的两点保证了方法的存在以及签名的正确，然而我们还必须保证在代理链上的每一步中都super()都被调用。这一目标很容易达成，只需要协同设计每一个相关类——在代理链上的每一步中增加一个supper()
How to Incorporate a Non-cooperative Class
在某些场景下，子类可能希望使用多重继承，其大部分父类都是协同设计的，同时也需要继承自一个第三方类（可能将要使用的方法没有使用super或者该类没有继承自根类）。这种情形很容易通过使用adapter class来解决。
例如，下面的Moveable类没有调用super()，init()函数签名与object.init也不兼容，而且它不集成自Root：
class Moveable:
def __init__(self, x, y): self.x = x self.y = y def draw(self): print('Drawing at position:', self.x, self.y) 如果我们想将这个类与之前协同设计的ColoredShape层级一起使用的话，我们需要创建一个适配器(adapter)，它调用了必须的super()方法。
class MoveableAdapter(Root):
def __init__(self, x, y, **kwds): self.moveable = Moveable(x, y) super().__init__(**kwds) def draw(self): self.moveable.draw() super().draw() class MoveableColoredShape(ColoredShape, MoveableAdapter): pass MoveableColoredShape(color='red', shapename='triangle', x=10, y=20).draw() Drawing. Setting color to: red
Drawing. Setting shape to: triangle
Drawing at position: 10 20
Complete Example - Just for Fun
在Python 2.7和3.2中，collections模块有一个Counter类和一个OrderedDict类，可以将这两个类组合产生一个OrderedCounter类：
from collections import Counter, OrderedDict
class OrderedCounter(Counter, OrderedDict): 'Counter that remembers the order elements are first seen' def __repr__(self): return '%s(%r)' % (self.__class__.__name__, OrderedDict(self)) def __reduce__(self): return self.__class__, (OrderedDict(self),) oc = OrderedCounter('abracadabra') pprint.pprint(oc) OrderedCounter(OrderedDict([('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 1)]))
Notes and References
-
当子类化诸如dict()的builtin时，通常需要同时重载或者扩展多个方法。在上面的例子中，_setitem_扩展不能用于诸如dict.update等其它方法，因此可能需要扩展这些方法。这一需求不止限于super()，子类化builtins时都需要。
-
在多继承中，如果要求父类按照指定顺序（例如，LoggingOD需要LoggingDict在OrderedDict前面，而OrderedDict在dict前面），可以利用断言来验证或者使用文档来表明方法解析顺序：
position = LoggingOD.__mro__.index
assert position(LoggingDict) < position(collections.OrderedDict)
assert position(OrderedDict) < position(dict)
-
关于线性化算法可以参阅Python MRO documentation和Wikipedia entry for C3 Linearization。
-
Dylan编程语言)有一个像Python的super()的next-method方法，可以参见Dylan's class docs来了解它如何工作。
-
上面例子中使用的是Python 3的super()，Python 2的语法与之不同之处在于其
type和object参数须是显式的，另外Python 2中的super()只适用于新式类。