Bilibili 同步视频
✨在 Python 面向对象编程体系里，继承是实现代码复用、层级架构搭建的核心基石，而 super() 函数更是继承场景中高频使用的核心语法。多数开发者初识该函数时，都片面将其定义为「直接调用父类方法」，实则其底层运行逻辑远比表象复杂，今日逐层拆解，理清 super() 真实运行原理与实用写法。
📌 基础语法・新旧版本用法区分
🔹 Python 2 规范写法
语法格式严谨，必须主动传入当前类名与实例对象 self，书写格式固定：
super(子类名, self).__init__()
语法冗余性较强，也是早期版本语法设计的局限所在。
🔹 Python 3 精简写法
版本迭代后完成语法简化，摒弃冗余传参，一行极简代码即可实现调用：
super().__init__()
简洁易记，大幅降低日常开发中的书写成本，也是当下主流开发通用写法。
⚡ 核心价值・解锁代码高效复用
在类的继承开发场景中，父类往往已经封装完善初始化参数、基础属性、通用逻辑等成熟代码。
借助 super() 函数，子类无需重复复刻冗余代码，可直接承接父类已定义好的构造方法与属性参数。
举个实用场景：继承线程基础类时，线程名称、运行基础配置等通用参数，均可通过 super() 直接调用父类初始化逻辑完成赋值，仅需专注编写子类独有的业务逻辑，从根源上精简代码体量，提升程序整体整洁度与维护效率。
🚫 破除误区・告别单一父类固有认知
绝大多数编程初学者都会陷入致命认知偏差：误以为 super() 仅能调用直系父类方法。
这个认知在单继承场景中看似成立，一旦进入多继承开发模式，便会彻底失效。
🧭 底层本质・依托 MRO 顺序执行
super() 函数的真正核心逻辑，并非定向调用直系父类，而是遵循 MRO（方法解析顺序）列表，依次调用排序内下一个层级类的对应方法。
在多层多继承架构中，系统会自动生成固定的 MRO 执行优先级序列，代码执行时严格依照序列顺序逐层匹配调用，而非按照代码书写的继承顺序盲目执行。
简单举例：当存在多层交叉继承关系时，子类中 super() 触发调用的类，并非直观认知里的上层父类，而是 MRO 排序顺位里紧随其后的类，这也是多继承场景下方法调用不混乱的核心
🔍 多继承 MRO 实战示例
下面通过一个具体的多继承示例，展示 MRO 列表的生成规则以及 super() 如何按 MRO 顺序执行：
class A:
def __init__(self):
print("A.__init__() 被调用")
super().__init__()
def show(self):
print("A.show() 被调用")
class B:
def __init__(self):
print("B.__init__() 被调用")
super().__init__()
def show(self):
print("B.show() 被调用")
class C(A, B):
def __init__(self):
print("C.__init__() 被调用")
super().__init__() # 这里会按 MRO 顺序调用 A.__init__
def show(self):
print("C.show() 被调用")
super().show() # 按 MRO 顺序调用下一个类的方法
# 1. 查看 MRO 列表
print("C 类的 MRO 顺序:", C.__mro__)
print("C 类的 MRO 方法解析顺序:", C.mro())
# 2. 创建实例，观察 __init__ 调用顺序
print("\n--- 创建 C 实例，观察初始化顺序 ---")
c = C()
# 3. 调用 show 方法，观察 super() 的执行路径
print("\n--- 调用 c.show() 方法 ---")
c.show()
# 4. 手动按 MRO 顺序调用
print("\n--- 手动按 MRO 顺序调用 show 方法 ---")
for cls in C.__mro__:
if hasattr(cls, 'show') and cls.show != C.show:
print(f"调用 {cls.__name__}.show(): ", end="")
cls.show(c)
代码执行结果分析：
C 类的 MRO 顺序: (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
C 类的 MRO 方法解析顺序: [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
--- 创建 C 实例，观察初始化顺序 ---
C.__init__() 被调用
A.__init__() 被调用
B.__init__() 被调用
--- 调用 c.show() 方法 ---
C.show() 被调用
A.show() 被调用
--- 手动按 MRO 顺序调用 show 方法 ---
调用 A.show(): A.show() 被调用
调用 B.show(): B.show() 被调用
关键点解析：
-
MRO 生成规则：Python 使用 C3 线性化算法生成 MRO 列表。对于
class C(A, B)，MRO 顺序为C → A → B → object。 -
super()的执行逻辑：- 在
C.__init__()中，super().__init__()会调用 MRO 中C的下一个类A的__init__方法 - 在
A.__init__()中，super().__init__()会调用 MRO 中A的下一个类B的__init__方法 - 在
B.__init__()中，super().__init__()会调用object.__init__
- 在
-
方法调用顺序：当调用
c.show()时：- 首先执行
C.show()中的print("C.show() 被调用") - 然后
super().show()会调用 MRO 中C的下一个类A的show方法 - 注意：
A.show()中没有super().show()，所以调用链在此终止
- 首先执行
-
验证 MRO：通过
C.__mro__或C.mro()可以查看类的完整方法解析顺序，这是理解super()行为的关键。
这个示例清晰地展示了 super() 并非简单地调用"父类"，而是严格遵循 MRO 顺序调用"下一个类"的方法。在多继承场景中，这种机制确保了方法调用的确定性和一致性。
⚠️ 常见错误与排查
在实际开发中，super() 的使用常伴随一些典型错误。了解这些常见陷阱能帮助开发者写出更健壮的代码。
🔴 错误 1：在非类方法中使用 super()
错误示例：
class Parent:
def __init__(self):
self.value = 10
def some_function():
# ❌ 错误：在普通函数中调用 super()
super().__init__()
print("这会导致运行时错误")
some_function()
错误原因：
super() 只能在类的方法内部使用，因为它需要访问当前类的 __class__ 和实例的 self 来确定 MRO 顺序。在普通函数或模块全局作用域中，super() 无法确定上下文。
正确写法：
class Parent:
def __init__(self):
self.value = 10
class Child(Parent):
def __init__(self):
# ✅ 正确：在类方法内部使用 super()
super().__init__()
print(f"继承的值: {self.value}")
c = Child() # 输出: 继承的值: 10
🔴 错误 2：多继承时参数传递混乱
错误示例：
class A:
def __init__(self, x):
self.x = x
super().__init__()
class B:
def __init__(self, y):
self.y = y
super().__init__()
class C(A, B):
def __init__(self, x, y):
# ❌ 错误：参数传递混乱
super().__init__(x) # 只传了 x，B.__init__ 缺少 y 参数
self.z = x + y
c = C(1, 2) # TypeError: B.__init__() missing 1 required positional argument: 'y'
错误原因：
在多继承场景中，所有父类的 __init__ 方法都需要正确的参数。如果某个父类需要特定参数而 super() 调用没有传递，会导致运行时错误。
正确写法：
class A:
def __init__(self, x, **kwargs):
self.x = x
super().__init__(**kwargs) # 传递剩余参数
class B:
def __init__(self, y, **kwargs):
self.y = y
super().__init__(**kwargs)
class C(A, B):
def __init__(self, x, y):
# ✅ 正确：使用 **kwargs 传递所有参数
super().__init__(x=x, y=y)
self.z = x + y
c = C(1, 2)
print(f"x={c.x}, y={c.y}, z={c.z}") # 输出: x=1, y=2, z=3
🔴 错误 3：混淆 super() 与直接类名调用
错误示例：
class Parent:
def process(self):
print("Parent.process()")
return "parent_result"
class Child(Parent):
def process(self):
# ❌ 错误：直接调用父类方法，破坏了 MRO 链
result = Parent.process(self) # 直接调用，跳过可能的中间类
print(f"Child 处理: {result}")
return f"child_{result}"
class Middle(Parent):
def process(self):
print("Middle.process() - 这个类会被跳过！")
return "middle_result"
class GrandChild(Child, Middle):
def process(self):
# 期望调用链: GrandChild → Child → Middle → Parent
# 实际调用链: GrandChild → Child → Parent (Middle 被跳过)
return super().process()
gc = GrandChild()
print(gc.process())
# 输出:
# Parent.process()
# Child 处理: parent_result
# child_parent_result
# Middle.process() 完全没被调用！
错误原因：
直接使用 Parent.method(self) 硬编码调用会绕过 Python 的 MRO 机制，在多继承中可能导致某些中间类的方法被意外跳过。
正确写法：
class Parent:
def process(self):
print("Parent.process()")
return "parent_result"
class Child(Parent):
def process(self):
# ✅ 正确：使用 super() 保持 MRO 链完整
result = super().process()
print(f"Child 处理: {result}")
return f"child_{result}"
class Middle(Parent):
def process(self):
print("Middle.process()")
return "middle_result"
class GrandChild(Child, Middle):
def process(self):
# 现在调用链完整: GrandChild → Child → Middle → Parent
return super().process()
gc = GrandChild()
print(gc.process())
# 输出:
# Middle.process()
# Child 处理: middle_result
# Parent.process()
# child_middle_result
🔴 错误 4：在静态方法或类方法中使用 super()
错误示例：
class Parent:
@classmethod
def create(cls):
return cls()
class Child(Parent):
@classmethod
def create(cls):
# ❌ 错误：在类方法中错误使用 super()
instance = super().create() # 缺少 cls 参数
instance.type = "child"
return instance
错误原因：
在类方法中，super() 需要显式传递当前类作为第一个参数，因为类方法的第一个参数是 cls 而不是 self。
正确写法：
class Parent:
@classmethod
def create(cls):
print(f"Parent.create() with cls={cls.__name__}")
return cls()
class Child(Parent):
@classmethod
def create(cls):
# ✅ 正确：在类方法中正确使用 super()
instance = super(Child, cls).create() # Python 3 中也可用 super()
instance.type = "child"
return instance
class GrandChild(Child):
@classmethod
def create(cls):
# ✅ 另一种正确写法
instance = super().create()
instance.generation = "grand"
return instance
gc = GrandChild.create() # 正常执行
🛠️ 排查技巧
- 查看 MRO 顺序：使用
ClassName.__mro__或ClassName.mro()确认方法解析顺序 - 调试 super() 调用：在复杂继承中，可以临时添加打印语句跟踪
super()的实际调用目标 - 参数检查：确保所有父类方法都收到正确的参数，特别是在多继承场景中
- 使用类型提示：为方法添加类型提示，IDE 能在编码阶段发现一些参数不匹配问题
原理。
🎯 实战总结
-
📝 日常开发优先使用 Python 3 极简
super()写法，兼顾简洁与实用性； -
🧩 善用
super()承接父类通用逻辑，聚焦子类专属业务开发； -
🛡️ 摒弃片面认知，牢记其依托 MRO 顺序 运行的底层规则，从容应对复杂多继承架构开发；
-
💻 吃透底层逻辑，方能规避继承场景下的方法调用冲突、逻辑错乱等各类开发隐患。
深耕语法底层原理，跳出表层用法局限，才能真正玩转 Python 面向对象继承架构，写出更规范、更高效、更易拓展的优质代码💫。展的优质代码💫。
