Python 多继承深度解析：MRO、C3 线性化与 super() 的正确打开方式

清水白石008

775人浏览 · 2026-03-15 07:26:11

清水白石008 · 2026-03-15 07:26:11 发布

Python 多继承深度解析：MRO、C3 线性化与 super() 的正确打开方式

一、引言：多继承，Python 最被误解的特性之一

如果你问一个有经验的 Python 开发者，哪个语言特性最容易踩坑，多继承一定榜上有名。

不是因为它设计得差，恰恰相反——Python 的多继承机制经过精心设计，背后有一套严谨的数学理论支撑。真正的问题在于，大多数人从来没有认真理解过它，只是凭直觉在用，然后在某个深夜被一个莫名其妙的 AttributeError 或者初始化遗漏 bug 搞得焦头烂额。

这篇文章，我们就把多继承这件事彻底讲透：MRO 是什么、C3 线性化怎么算、super() 为什么经常讲不清，以及在真实项目中如何安全地使用多继承体系。

二、MRO 是什么？为什么需要它？

2.1 问题的起源

多继承最经典的问题场景叫菱形继承（Diamond Inheritance）：

class A:
    def hello(self):
        print("A.hello")

class B(A):
    def hello(self):
        print("B.hello")

class C(A):
    def hello(self):
        print("C.hello")

class D(B, C):
    pass

d = D()
d.hello()  # 输出什么？

D 同时继承了 B 和 C，两者都有 hello 方法，都继承自 A。Python 该调用哪个？

答案是 B.hello。但更重要的问题是：Python 是按照什么规则决定的？

2.2 MRO 的定义

MRO（Method Resolution Order，方法解析顺序）是 Python 在查找属性或方法时，遍历类继承链的顺序列表。

每个类都有一个 __mro__ 属性，可以直接查看：

print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)

# 更友好的展示
print([cls.__name__ for cls in D.__mro__])
# ['D', 'B', 'C', 'A', 'object']

Python 查找方法时，就按这个列表从左到右依次查找，找到第一个就停止。逻辑清晰，没有歧义。

三、C3 线性化：MRO 背后的数学

Python 2.3 之前用的是深度优先搜索（DFS）算法来计算 MRO，这在某些复杂继承场景下会产生违反直觉的结果。Python 2.3 引入了 C3 线性化算法，彻底解决了这个问题。

3.1 C3 算法的核心思想

C3 线性化的目标是生成一个满足以下三个约束的线性序列：

子类优先于父类
多个父类按照声明顺序排列
单调性：如果在某个类的 MRO 中 A 在 B 前面，那么在所有子类的 MRO 中 A 也在 B 前面

3.2 手动推导 C3 线性化

C3 的计算公式：

L[C(B1, B2, ..., Bn)] = C + merge(L[B1], L[B2], ..., L[Bn], [B1, B2, ..., Bn])

merge 操作规则：

取第一个序列的头部元素
检查该元素是否出现在其他序列的尾部（非头部位置）
如果没有，取出该元素，从所有序列中删除它，追加到结果
如果有，跳过，尝试下一个序列的头部
重复直到所有序列为空

用菱形继承来演示：

L[A] = [A, object]
L[B] = [B, A, object]
L[C] = [C, A, object]

L[D] = D + merge([B, A, object], [C, A, object], [B, C])

第1步：取 B，B 不在任何序列尾部 → 取出 B
       结果：[D, B]，剩余：[A, object], [C, A, object], [C]

第2步：取 A，A 在 [C, A, object] 的尾部 → 跳过
       取 C，C 不在任何序列尾部 → 取出 C
       结果：[D, B, C]，剩余：[A, object], [A, object], []

第3步：取 A，A 不在任何序列尾部 → 取出 A
       结果：[D, B, C, A]，剩余：[object], [object]

第4步：取 object → 取出
       最终：[D, B, C, A, object]

和 D.__mro__ 完全一致，验证成功。

3.3 C3 会拒绝不合理的继承

C3 不是万能的，它会主动拒绝违反单调性的继承结构：

class A: pass
class B(A): pass
class C(A, B): pass  # 违反单调性！A 在 B 前，但 B 继承自 A

# TypeError: Cannot create a consistent method resolution order (MRO)
# for bases A, B

这个报错是 Python 在保护你，告诉你这个继承结构本身就有逻辑问题。

四、super() 为什么经常讲不清？

这是本文最核心的问题，也是最多人搞错的地方。

4.1 super() 的常见误解

大多数教程这样介绍 super()：

“super() 用于调用父类的方法”

这个描述不准确，而且会在多继承场景下误导你。

super() 的真实含义是：按照当前类的 MRO，调用下一个类的方法。

“下一个类"不一定是你以为的"父类”，这就是混乱的根源。

4.2 用代码揭示真相

class A:
    def __init__(self):
        print(f"A.__init__ 被调用，self 类型：{type(self).__name__}")
        super().__init__()

class B(A):
    def __init__(self):
        print(f"B.__init__ 被调用，self 类型：{type(self).__name__}")
        super().__init__()

class C(A):
    def __init__(self):
        print(f"C.__init__ 被调用，self 类型：{type(self).__name__}")
        super().__init__()

class D(B, C):
    def __init__(self):
        print(f"D.__init__ 被调用，self 类型：{type(self).__name__}")
        super().__init__()

d = D()

输出：

D.__init__ 被调用，self 类型：D
B.__init__ 被调用，self 类型：D
C.__init__ 被调用，self 类型：D
A.__init__ 被调用，self 类型：D

注意几个关键点：

self 始终是 D 的实例，不会变
B.__init__ 里的 super() 调用的是 C.__init__，不是 A.__init__
这是因为 D 的 MRO 是 [D, B, C, A, object]，在 B 之后的下一个是 C

super() 是协作式调用链，它沿着 MRO 传递，而不是直接跳到某个固定的父类。

4.3 为什么"讲不清"？

原因有三：

第一，super() 的行为依赖于实例的实际类型，而不是定义它的类

class B(A):
    def __init__(self):
        super().__init__()  # 这里的 super() 不是固定的 A
                            # 而是"D 的 MRO 中 B 之后的那个类"

当你单独实例化 B() 时，super() 指向 A。但当你实例化 D() 时，B 里的 super() 指向 C。同一行代码，行为不同。

第二，大多数教程只演示单继承场景

单继承下 super() 确实就是"调用父类"，这个简化描述在单继承时没问题，但一旦进入多继承就失效了。

第三，协作式调用链需要所有类都配合

如果继承链中有一个类没有调用 super().__init__()，整个链就断了。这个隐性约定很容易被忽视。

五、实战：多继承体系中避免父类初始化遗漏

理论讲完，来解决真实问题。

5.1 问题复现：初始化遗漏

class Logger:
    def __init__(self):
        self.log_level = "INFO"
        print("Logger 初始化完成")

class Cache:
    def __init__(self):
        self.cache = {}
        print("Cache 初始化完成")

class Service(Logger, Cache):
    def __init__(self):
        super().__init__()  # 只调用了 Logger.__init__，Cache 被遗漏！
        self.name = "MyService"

s = Service()
# 输出：Logger 初始化完成
# Cache 初始化完成  ← 这行也出现了！因为 Logger 里也调用了 super()

print(s.log_level)  # "INFO" ✅
print(s.cache)      # {} ✅

等等，这里其实没有遗漏？对，因为 Logger 里也调用了 super().__init__()，链条是完整的。

但如果 Logger 没有调用 super()：

class Logger:
    def __init__(self):
        self.log_level = "INFO"
        print("Logger 初始化完成")
        # 没有调用 super().__init__()！链条断了

class Cache:
    def __init__(self):
        self.cache = {}
        print("Cache 初始化完成")

class Service(Logger, Cache):
    def __init__(self):
        super().__init__()
        self.name = "MyService"

s = Service()
# 输出：Logger 初始化完成
# Cache 初始化完成 ← 这行不会出现了！

print(s.cache)  # AttributeError: 'Service' object has no attribute 'cache'

这就是真实项目中最常见的初始化遗漏 bug，而且往往在运行时才暴露，很难在代码审查阶段发现。

5.2 解决方案一：协作式 super() 规范

所有参与多继承的类，都必须在 __init__ 中调用 super().__init__()，这是协作式多继承的基本约定：

class Logger:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)  # 必须调用，传递剩余参数
        self.log_level = kwargs.get("log_level", "INFO")

class Cache:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)  # 必须调用
        self.cache = {}
        self.cache_size = kwargs.get("cache_size", 100)

class Database:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.db_url = kwargs.get("db_url", "sqlite:///:memory:")

class Service(Logger, Cache, Database):
    def __init__(self, name, **kwargs):
        super().__init__(**kwargs)  # 一次调用，链式传递
        self.name = name

s = Service(
    name="UserService",
    log_level="DEBUG",
    cache_size=200,
    db_url="postgresql://localhost/mydb"
)

print(s.name)       # UserService
print(s.log_level)  # DEBUG
print(s.cache)      # {}
print(s.cache_size) # 200
print(s.db_url)     # postgresql://localhost/mydb

注意这里用 **kwargs 传递参数的技巧：每个类从 kwargs 中取出自己需要的参数，剩余的继续往下传。这样整个初始化链条既完整又灵活。

5.3 解决方案二：Mixin 模式（推荐）

更优雅的方式是用 Mixin 模式重新设计继承结构。Mixin 是一种专门用于"混入"功能的类，它不代表一种"是什么"的关系，而是"有什么能力"的关系：

class LogMixin:
    """日志能力混入，不依赖其他类"""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._log_level = "INFO"

    def log(self, message: str, level: str = "INFO"):
        print(f"[{level}] {message}")

    def set_log_level(self, level: str):
        self._log_level = level


class CacheMixin:
    """缓存能力混入"""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._cache: dict = {}

    def get_cache(self, key: str):
        return self._cache.get(key)

    def set_cache(self, key: str, value):
        self._cache[key] = value

    def clear_cache(self):
        self._cache.clear()


class RetryMixin:
    """重试能力混入"""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._max_retries = kwargs.get("max_retries", 3)

    def with_retry(self, func, *args, **kwargs):
        import time
        for attempt in range(self._max_retries):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                if attempt == self._max_retries - 1:
                    raise
                wait = 2 ** attempt
                self.log(f"第 {attempt+1} 次失败，{wait}s 后重试：{e}", "WARN")
                time.sleep(wait)


class BaseService:
    """基础服务类，所有服务的根"""

    def __init__(self, name: str, **kwargs):
        self.name = name

    def __repr__(self):
        return f"{self.__class__.__name__}(name={self.name!r})"


# 组合使用：UserService 拥有日志、缓存、重试三种能力
class UserService(LogMixin, CacheMixin, RetryMixin, BaseService):
    def __init__(self, name: str, **kwargs):
        super().__init__(name=name, **kwargs)

    def get_user(self, user_id: int):
        # 先查缓存
        cached = self.get_cache(f"user:{user_id}")
        if cached:
            self.log(f"缓存命中：user:{user_id}")
            return cached

        # 模拟数据库查询（带重试）
        def fetch():
            return {"id": user_id, "name": f"用户{user_id}"}

        user = self.with_retry(fetch)
        self.set_cache(f"user:{user_id}", user)
        self.log(f"已缓存：user:{user_id}")
        return user


# 验证 MRO
print([cls.__name__ for cls in UserService.__mro__])
# ['UserService', 'LogMixin', 'CacheMixin', 'RetryMixin', 'BaseService', 'object']

svc = UserService(name="user-service", max_retries=5)
print(svc)                    # UserService(name='user-service')
print(svc.get_user(42))       # [INFO] 已缓存：user:42 → {'id': 42, 'name': '用户42'}
print(svc.get_user(42))       # [INFO] 缓存命中：user:42 → {'id': 42, 'name': '用户42'}

Mixin 模式的优势：

每个 Mixin 职责单一，易于测试和复用
通过组合而非深层继承来扩展功能
MRO 清晰可预测，初始化链条完整

5.4 用工具验证初始化完整性

在复杂项目中，可以写一个简单的检查工具：

def check_mro_init(cls):
    """检查 MRO 中所有类是否都调用了 super().__init__()"""
    import dis, inspect

    issues = []
    for klass in cls.__mro__[:-1]:  # 排除 object
        if '__init__' not in klass.__dict__:
            continue
        source = inspect.getsource(klass.__init__)
        if 'super().__init__' not in source and 'super().__init__' not in source:
            issues.append(klass.__name__)

    if issues:
        print(f"⚠️  以下类的 __init__ 未调用 super().__init__()：{issues}")
    else:
        print(f"✅  {cls.__name__} 的 MRO 初始化链完整")

check_mro_init(UserService)  # ✅  UserService 的 MRO 初始化链完整