Python的多重继承把我坑惨了，这些坑你要绕开

原创

风一样的男子

发布于 2026-06-23 13:55:40

880

那个让我加班到凌晨3点的Bug

去年我在写一个数据处理框架，想设计几个"混入类"（Mixin）来复用功能。代码大概是这样的：

class LogMixin:
    def log(self, msg):
        print(f"[LOG] {msg}")
        super().log(msg)  # 我也不知道为什么要调用super，但看教程都这么写

class SaveMixin:
    def save(self):
        print("保存数据")
        super().save()

class DataProcessor(LogMixin, SaveMixin):
    def process(self):
        self.log("开始处理")
        self.save()

运行起来直接报错：AttributeError: 'super' object has no attribute 'log'

我当时的心态：super()不是调用父类吗？LogMixin没有父类啊，为什么会调用super？

加了super之后，代码就崩了。不加super，又怕漏掉什么东西。我完全不知道该怎么写才是对的。

那个晚上，我把Python多重继承的机制翻了个底朝天。今天把这些"坑"和"绕坑指南"整理出来，希望你能比我少走弯路。

为什么Python的多重继承让人头疼？

先承认一个事实：多重继承本身就很复杂。不是Python独有的问题，C++、Java（接口多重继承）都有类似的复杂度。

Python的多重继承有几个特点，让事情变得更微妙：

一个类可以继承任意多个父类——灵活性高，但容易失控
方法查找有固定的顺序（MRO）——规则明确，但不直观
super()不是简单调用父类——它沿着MRO链条走

这些特点单独看都没问题，组合在一起就很容易写出"看着对、跑着错"的代码。

坑1：`super()`到底在调用谁？

这是最让我困惑的问题。看一个经典例子：

class A:
    def method(self):
        print("A")
        super().method()

class B:
    def method(self):
        print("B")

class C(A, B):
    def method(self):
        print("C")
        super().method()

c = C()
c.method()

输出是：

C
A
B

等等，A和B没有任何继承关系，为什么A里的super().method()会调到B的方法？

这就是Python的MRO（方法解析顺序）在起作用。C.mro()的输出是：

[<class 'C'>, <class 'A'>, <class 'B'>, <class 'object'>]

super()不是"调用父类"，而是调用MRO中的下一个类。

所以当你写super().method()时，Python会去找当前类在MRO中的下一个类，调用它的同名方法。这就是为什么A的super()会调到B——因为MRO里A后面就是B。

绕坑指南：

如果你写的Mixin类没有父类，**不要在Mixin里调用super()**，除非你明确知道它会调用谁
如果一定要用super()，确保MRO链条上的所有类都实现了同名方法
用ClassName.__mro__查看调用顺序，调试必备

坑2：钻石继承——顶层类被初始化两次

当多个父类最终继承自同一个基类时，就形成了"钻石"形状：

class Top:
    def __init__(self):
        print("Top初始化")
        self.data = []

class Left(Top):
    def __init__(self):
        print("Left初始化")
        Top.__init__(self)  # 手动调用父类

class Right(Top):
    def __init__(self):
        print("Right初始化")
        Top.__init__(self)  # 手动调用父类

class Bottom(Left, Right):
    def __init__(self):
        Left.__init__(self)
        Right.__init__(self)

b = Bottom()

输出：

Left初始化
Top初始化
Right初始化
Top初始化   # Top被初始化了两次！

Top的__init__被执行了两次，self.data被重置了。这在真实项目中可能引发灾难。

解决方案：用super()代替手动调用父类。

class Top:
    def __init__(self):
        print("Top初始化")
        super().__init__()

class Left(Top):
    def __init__(self):
        print("Left初始化")
        super().__init__()

class Right(Top):
    def __init__(self):
        print("Right初始化")
        super().__init__()

class Bottom(Left, Right):
    def __init__(self):
        print("Bottom初始化")
        super().__init__()

b = Bottom()

输出：

Bottom初始化
Left初始化
Right初始化
Top初始化

Top只被调用了一次。super()沿着MRO链条确保每个父类只被执行一次。

绕坑指南：

在多重继承中，永远用super()调用父类构造函数，不要手动调用Parent.__init__(self)
除非你有非常特殊的原因，否则手动调用父类是钻石继承的头号杀手

坑3：MRO计算失败——"Cannot create a consistent method resolution order"

这个错误信息看着就让人绝望。来看一个会触发它的例子：

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

# 没问题，MRO: D -> B -> C -> A -> object

但如果继承顺序有冲突，就会报错：

class A: pass
class B: pass
class C(A, B): pass
class D(B, A): pass

class E(C, D): pass  # TypeError!

Python无法找到一个既满足C的父类顺序（A在B前）、又满足D的父类顺序（B在A前）的线性化方案。这就是C3线性化算法无法处理的情况。

这种错误在大型项目（比如SageMath的类别体系）中非常常见，曾有开发者专门写了一个模块来解决这个问题。

绕坑指南：

保持继承层次简单、有向无环
避免在多个父类之间交叉依赖
如果MRO报错，说明你的继承图太复杂了，需要重构

坑4：NamedTuple和多重继承不兼容

这个坑比较隐蔽。你想定义一个同时继承NamedTuple和其他类的类型：

from typing import NamedTuple

class Animal:
    def eat(self):
        print("吃")

class Person(NamedTuple, Animal):  # TypeError!
    name: str
    age: int

报错：TypeError: Multiple inheritance with NamedTuple is not supported

因为NamedTuple是CPython用C实现的，它不支持多重继承的元类组合。

绕坑指南：

需要用NamedTuple时，不要把它和其他类混在一起继承
或者用dataclass代替NamedTuple，dataclass对多重继承的支持更好

坑5：多重继承让类变得"臃肿"

这不是语法错误，但比语法错误更可怕。

看Tkinter（Python的标准GUI库）的例子。tkinter.Button的实例有214个属性，因为它从多个父类继承了大量方法。

import tkinter as tk
btn = tk.Button()
print(len(dir(btn)))  # 214

这意味着：

IDE自动补全弹出一大堆你根本不需要的方法
命名冲突的风险极高
新人根本搞不清哪些方法是"属于这个类"的

绕坑指南：

多重继承只适合Mixin模式——小而专注的功能组合
用Mixin后缀命名这些类，明确告诉读者"这不是完整的类，只是功能片段"
如果继承链超过3层，考虑用组合代替继承

正确的多重继承姿势：Mixin模式

如果你确实要用多重继承，用Mixin模式。

Mixin的核心思想是：提供单一、可复用的功能，不定义新类型。

class LogMixin:
    """只提供日志功能，不定义新类型"""
    def log(self, msg):
        print(f"[{self.__class__.__name__}] {msg}")
    # 注意：这里没有调用super()

class SaveMixin:
    """只提供保存功能"""
    def save(self):
        print(f"保存数据到{self.get_save_path()}")

class DataProcessor(LogMixin, SaveMixin):
    def get_save_path(self):
        return "/tmp/data.json"
    
    def process(self):
        self.log("开始处理")
        self.save()

这样写有几个好处：

每个Mixin只做一件事，职责清晰
不需要在Mixin里调用super()，避免了"调用谁"的困惑
可以随意组合不同的Mixin

Mixin的命名规范：类名以Mixin结尾，一眼就能看出它是混入类而非实体类。

什么时候该用多重继承？

说实话，大多数情况下你不需要多重继承。

场景	是否推荐	理由
组合多个Mixin功能	✅ 推荐	代码复用，职责单一
需要同时具备两种"类型"	⚠️ 谨慎	考虑是否用接口代替
为了复用代码而继承多个类	❌ 避免	用组合+委托更清晰
解决复杂的设计问题	❌ 避免	大概率是设计出了问

Python的经典指导原则是：用组合代替继承，用接口代替多重继承。

如果确实需要多重继承，记住这三个原则：

保持浅层次：不超过2层父类
每个父类职责单一：只做一件事
用super()统一调用：避免手动指定父类

一张图总结

多重继承的生存指南
├── 必须用super()——永远不要手动调用父类
├── 查看MRO——用ClassName.__mro__调试
├── Mixin模式——小功能、不调用super、命名带Mixin后缀
├── 避免钻石继承——如果避免不了，让顶层类的__init__可以重复调用
└── 当不确定时——用组合代替继承

回到开头那个Bug

我的LogMixin里调用了super().log(msg)，但LogMixin在MRO里是第一个，它后面是SaveMixin，而SaveMixin没有log方法，所以报错。

修复方案：

class LogMixin:
    def log(self, msg):
        print(f"[LOG] {msg}")
        # 把super()去掉！Mixin只做自己的事

class SaveMixin:
    def save(self):
        print("保存数据")
        # 同样不调用super()

或者，如果确实需要super()串联调用，确保链条上所有类都有同名方法。但在Mixin场景下，不调用super()是更安全的选择。

那个晚上之后，我对Python多重继承有了全新的认识。希望这篇文章能让你少加一次班。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python3

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python3

登录后参与评论

0 条评论

热度