super() 在 Python 继承中按 MRO 委托调用，非简单调父类；误区包括：未在每层显式调用导致初始化中断、误认其总调直接父类、混用显式父类调用破坏 MRO；正确做法是各层均用 super().__init__(**kwargs) 并保持签名兼容。
Python类继承中，super() 的使用不当会导致父类初始化被跳过、重复调用或参数不匹配，核心问题在于没理解 super() 是按 MRO（方法解析顺序）委托调用，而非简单“调父类”。
误区一：只在子类 __init__ 里调一次 super().__init__() 就万事大吉
多层继承或多重继承时，仅靠一层 super() 无法保证所有父类都被正确初始化。Python 的 super() 返回的是 MRO 中**当前类之后的下一个类**，不是直接父类。如果某个中间类没写 super().__init__()，调用链就断了。
例如：
class A:
def __init__(self):
print("A init")
super().__init__() # 这里会报错（object.__init__ 不接受参数），但更关键的是：它本该继续向上？其实 A 在 MRO 最后，super() 返回 object
<p>class B(A):
def <strong>init</strong>(self):
print("B init")
super().<strong>init</strong>() # → 调 A.<strong>init</strong>()</p><p>class C(B):
def <strong>init</strong>(self):
print("C init")
super().<strong>init</strong>() # → 调 B.<strong>init</strong>()
这段看似没问题，但如果把 A 改成继承自另一个类，或引入 mixin，漏掉某处 super()，初始化就会中断。
立即学习“Python免费学习笔记（深入）”；
- ✅ 正确做法：每个参与继承链的类（包括中间类），只要重写了
__init__，都必须显式调用super().__init__(...)，并确保参数签名兼容（推荐用**kwargs向上传递） - ⚠️ 特别注意：如果父类
__init__接收固定参数，而子类super().__init__()没传对，会直接报TypeError
误区二：认为 super() 总是调用直接父类
super() 查找的是当前类在 MRO 中的**下一个类**，不是语法上的父类。在多重继承中，MRO 可能跳过某个父类，也可能先调另一个分支。
比如：
创建 Flask + Vue.js 全栈项目，采用单端口架构、uv 依赖管理、结构化日志和生产级前端设计。当用户要求以下操作时触发：创建新的 Flask+Vue 项目、搭建 Web 应用、构建全栈 Python+Vue 应用、初始化 Flask Web 项目、设置单端口 Flask 前后端项目。触发词：新建项目、创建项目、搭建项目、Flask项目、Vue项目。
class X: pass class Y: pass class A(X): pass class B(Y): pass class C(A, B): pass <p>print(C.<strong>mro</strong>)</p><h1>→ (<class '<strong>main</strong>.C'>, <class '<strong>main</strong>.A'>, <class '<strong>main</strong>.X'>, <class '<strong>main</strong>.B'>, <class '<strong>main</strong>.Y'>, <class 'object'>)</h1><p>
在 C.__init__ 中写 super().__init__()，实际调的是 A.__init__()，不是 A 和 B 两个父类都调——除非 A.__init__ 里也写了 super().__init__()，才会继续走到 X，再往下才可能到 B（但这里不会，因为 X 后是 B，而 X 的 super() 指向 B，前提是 X 也实现且调用了 super()）。
- ✅ 验证方式：打印
ClassName.__mro__，看清调用路径 - ✅ 协作式初始化前提：所有相关类都遵循“接收
**kwargs，处理自己需要的参数，其余传给super()”的约定
误区三：混用 ParentClass.__init__(self, ...) 和 super()
显式写父类名调用（如 A.__init__(self)）会硬编码调用目标，破坏 MRO 的动态性，在菱形继承等场景下极易引发重复初始化或遗漏。
例如经典菱形继承：
class A:
def __init__(self):
print("A")
super().__init__() # 实际是 object.__init__
<p>class B(A):
def <strong>init</strong>(self):
print("B")
super().<strong>init</strong>()</p><p>class C(A):
def <strong>init</strong>(self):
print("C")
super().<strong>init</strong>()</p><p>class D(B, C):
def <strong>init</strong>(self):
print("D")
super().<strong>init</strong>() # ✅ 正确：按 MRO (D→B→C→A→object) 走，A 只执行一次
如果 B.__init__ 改成 A.__init__(self)，那么 D 初始化时：B 直接调 A，跳过了 C；接着 super() 在 B 里失效，C 根本不执行——结果是 C 的逻辑丢失，且 A 可能被重复调（如果 C 也被显式调）。
- ✅ 坚持统一用
super()，避免混用 - ✅ 所有类的
__init__签名尽量保持一致（如都支持**kwargs）
实用建议：让初始化更健壮
协作式初始化不是银弹，但能大幅降低出错概率：
- 每个类的
__init__接收**kwargs，提取自己需要的参数，删掉后把剩余**kwargs传给super().__init__() - 用
inspect.signature()或文档明确标注各层所需参数，避免隐式依赖 - 测试时检查 MRO 和实际初始化输出顺序，确认每层都走到了
- 简单单继承场景若确定无扩展需求，显式调父类也可行，但一旦涉及复用或组合，立刻切回
super()风格
