Python 的 super() 到底调用了谁
写出下面这段代码的时候,十个人里有九个以为 super() 就是“调用父类”:
1class A:
2 def who(self):
3 return "A"
4
5class B(A):
6 def who(self):
7 return "B -> " + super().who()
8
9class C(A):
10 def who(self):
11 return "C -> " + super().who()
12
13class D(B, C):
14 pass
15
16print(D().who())如果 super() 的含义是“父类”,那么 B 里的 super().who() 应该调用 A,输出应该是 B -> A。实际运行结果是:
1B -> C -> AB 的 super() 调到了 C——一个和 B 没有任何直接继承关系的类。这不是 bug,而是 Python 多重继承的核心设计。
MRO:类创建时就写死的名单
super() 的查找顺序由 MRO(Method Resolution Order,方法解析顺序)决定。MRO 在类被定义的那一刻就算好了,存在 __mro__ 属性里:
1>>> D.__mro__
2(<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)super() 的真实语义是:以“当前方法定义所在的类”为起点,在实例类型的 MRO 名单里,找到排在它后面的、第一个实现了这个方法的类。
D().who() 的完整过程是:
D自己没有who,沿 MRO 找到B.who,执行;B.who里的super().who()不是找B的父类A,而是在D的 MRO 里找B后面的下一个——是C;C.who里的super().who()同理,找到A;- 拼出
B -> C -> A。
名单是怎么排出来的
MRO 用的是 C3 线性化算法,规则可以概括成三条:
- 子类永远排在它的父类前面;
- 多个基类按声明顺序排(
class D(B, C)里B在C前); - 每个类只出现一次,且相对顺序不能和前两条冲突。
第三条不是摆设。有些继承结构就是排不出合法顺序:
1class X: pass
2class Y(X): pass
3
4class Z(X, Y): pass运行到第三行直接报错:
1TypeError: Cannot create a consistent method resolution order (MRO) for bases X, Y原因是矛盾:Z 的声明要求 X 排在 Y 前面,而 Y 是 X 的子类又要求 Y 排在前面。遇到这个报错,通常说明继承图本身画歪了,需要拆出一个公共基类来解环。
super() 不是父类指针
在方法里不带参数写 super(),等价于:
1super(__class__, self)这里有两个关键角色,各管一件事:
type(self)(实例的实际类型)决定用哪份 MRO 名单;__class__(方法定义所在的类)决定从名单的哪个位置往后找。
__class__ 是编译器自动注入的,你不需要写。也正因为它是编译器魔法,离开类体定义的方法它就不存在了——在模块顶层或者普通函数里调用无参的 super(),会得到:
1RuntimeError: super(): no arguments另外,super() 返回的不是父类的实例,而是一个代理对象,它只做一件事:转发属性访问到 MRO 里的下一个类。你也可以手动指定起点,比如 super(B, self).who() 表示“从 B 之后开始找”,这在需要跳过某个类的行为时很有用。
同一个方法,两种跳转
把上面两件事组合起来,会得到一个更反直觉的现象:
1print(B().who()) # B -> A
2print(D().who()) # B -> C -> A同样是 B.who 里的那行 super().who(),两次执行跳到了不同的类:
B()的实例,type(self)是B,MRO 是B, A, object,从B往后找到A;D()的实例,type(self)是D,MRO 是D, B, C, A, object,从B往后找到C。
这正是 mixin 能工作的原理:mixin 在写 super() 的时候并不需要知道“下一个是谁”,由最终组合它的那个类决定。super() 是一条链上的接力棒,而不是一个写死的地址。
把 init 写成协作式的
很多人在多重继承里不用 super(),而是显式调用父类构造函数,觉得“更可控”:
1class A:
2 def __init__(self):
3 print("A.__init__")
4
5class B(A):
6 def __init__(self):
7 A.__init__(self)
8 print("B.__init__")
9
10class C(A):
11 def __init__(self):
12 A.__init__(self)
13 print("C.__init__")
14
15class D(B, C):
16 def __init__(self):
17 B.__init__(self)
18 C.__init__(self)
19 print("D.__init__")
20
21D()输出:
1A.__init__
2B.__init__
3A.__init__
4C.__init__
5D.__init__两个问题:A 被初始化了两次(如果它是数据库连接池,就是两次握手、两份资源),而且 C 的初始化发生在 B 之后——顺序也没法沿 MRO 走。全部改用 super():
1class A:
2 def __init__(self):
3 print("A.__init__")
4
5class B(A):
6 def __init__(self):
7 print("B.__init__")
8 super().__init__()
9
10class C(A):
11 def __init__(self):
12 print("C.__init__")
13 super().__init__()
14
15class D(B, C):
16 def __init__(self):
17 print("D.__init__")
18 super().__init__()
19
20D()输出变成:
1D.__init__
2B.__init__
3C.__init__
4A.__init__每个类恰好一次,严格沿 MRO。这就是“协作式多重继承”:每个 __init__ 都负责把接力棒传下去,哪怕自己的直接父类是 object。
参数怎么传
构造函数带参数时,惯用的约定是“各取所需,其余下传”:
1class LogMixin:
2 def __init__(self, *, log_level="info", **kwargs):
3 self.log_level = log_level
4 super().__init__(**kwargs)
5
6class Base:
7 def __init__(self, name, **kwargs):
8 self.name = name
9 super().__init__(**kwargs)
10
11class Service(LogMixin, Base):
12 def __init__(self, name, **kwargs):
13 super().__init__(name=name, **kwargs)
14
15svc = Service("api", log_level="debug")
16print(svc.name, svc.log_level) # api debug链条是 Service → LogMixin → Base → object:LogMixin 消化 log_level,Base 消化 name,最后 object.__init__() 收到空参数。三个要点:
- 链上每一层都要继续调
super().__init__(...),包括最底层的Base; - 参数统一走
**kwargs,每层只取自己认识的,剩下的继续下传; - 顶层把显式参数收进签名,避免同一个参数在链上被传两遍。
四个常见的坑
- 中途断链。 链上任何一层忘了调
super().__init__(),它之后的所有类都不会被初始化,而且不报错,只会在某个属性缺失时炸出AttributeError,离案发现场很远。 - 报错位置在 object 上。 如果某个参数沿途没人消化,最终报的是
TypeError: object.__init__() takes exactly one argument。看着像是object出了问题,其实是链条中某层漏了消化参数。 - MRO 冲突。 出现
Cannot create a consistent method resolution order时,去检查继承图有没有画出矛盾的顺序,而不是去改调用代码。 - 无参 super() 用错地方。 它只在类体定义的方法里可用;模块级或普通函数里会得到
RuntimeError: super(): no arguments。
排查时最顺手的一招,是在出问题的方法里加一行:
1print(type(self).__mro__)把实际生效的名单打出来,再看当前类排在哪、后面是谁,跳转目标一目了然。
小结
| 直觉 | 事实 |
|---|---|
super() 调用父类 | 在实例类型的 MRO 里,找当前类之后的下一个 |
| MRO 深度优先遍历 | C3 线性化,每类一次,声明顺序不乱 |
显式调 父类.__init__ 更稳 | 会重复执行、打断 MRO 链 |
| mixin 直接父类是 object,不用 super | 恰恰必须 super,下一个是谁由组合方决定 |
记住一句话就够了:super() 不是“我的父类”,而是“这条链上,我后面的那位”。至于是谁,得看最终的 MRO 名单——写 mixin 的人不需要知道,组合 mixin 的人才说了算。
参考文档
- Python/内建函数/super - Primers 编程伙伴
- Python/内建函数/print - Primers 编程伙伴
- Python/内建函数/object - Primers 编程伙伴
- Python/内建函数/type - Primers 编程伙伴
本文由 AI 辅助生成并经人工校验,如有疏漏欢迎指正。