Python多重继承的使用小结_Python

继承是面向对象编程中的一个特性，允许类继承另一个类的属性和方法。在 python 中，你可以实现不同类型的继承，比如单继承、多继承和多层继承。本章详细介绍了多重继承。

什么是多重继承？

多重继承是一种继承方式，其中单个类可以继承多个父类的属性和方法。当你想把多个类的功能整合到一个类里时，这可以用。下图展示了多重继承 −

多重继承的例子

在下面的例子中，子类继承了父类和母类 -

class father:
    def skill1(self):
        print("father's skill: gardening")
 
class mother:
    def skill2(self):
        print("mother's skill: cooking")
 
class child(father, mother):
    pass
 
c = child()
c.skill1()
c.skill2()

上述代码的输出为−

father's skill: gardening
mother's skill: cooking

解释：在这个例子中，子类可以同时访问其父类的 skill1（） 和 skill2（） 方法。当我们创建 child 实例并调用 skill1（） 时，它执行的是 father 类的方法。同样，当我们调用 skill2（） 时，它执行的是母类的方法。

但是，如果两个父类都有同名的方法，会发生什么？谁会被处决？这就是方法分辨率次序（mro）发挥作用的地方。

多重继承的方法解析顺序

如果同名方法在多个父类中定义，python 会遵循特定的顺序来决定执行哪个方法。该命令被称为方法解析令（mro）。该阶数由c3线性化算法（也称为mro）确定。mro命令如下所示。

首先，python 在子类中查找方法。
如果找不到，它会按列表的顺序搜索父类。
直到找到方法或搜索所有类为止。

多重继承最核心的问题是：当多个父类有同名方法时，子类调用该方法会优先执行哪个父类的？python 通过mro（method resolution order，方法解析顺序） 来解决这个问题，遵循 “从左到右、深度优先” 的原则（python3 中是 c3 算法，本质是优化后的深度优先）。

你可以用mro（）方法或__mro__属性检查对象的mro。例如−

print(child.mro())

output:
[<class '__main__.child'>, <class '__main__.father'>, <class '__main__.mother'>, 
<class 'object'>]

示例

在以下示例中，child 类继承了 father 和 mother 类的 skill（）方法，但调用的是 mother's 方法。

class father:
    def skill(self):
        print("father's skill: gardening")

class mother:
    def skill(self):
        print("mother's skill: cooking")

class child(father, mother):
    pass

c = child()
c.skill()

解释：当技能方法在子类实例c中被调用时，它首先会在子类中查找该方法。由于子类没有技能方法，它会按父类排序（父类，然后是母类）搜索父类，并执行第一个找到的。

上述代码的输出为−

father's skill: gardening

在多重继承中使用 super（）

super（） 函数被子类用于调用父类的方法。如果你在多重继承情况下的方法中使用 super（），它会严格按照 mro 命令来决定调用哪个方法。

示例

在这个例子中，我们有一个包含四个类的类层级结构：a、b、c 和 d。类 d 继承自 b 和 c，证明了多重继承。

class a:
    def show(self):
        print("class a")

class b(a):
    def show(self):
        print("class b")
        super().show()

class c(a):
    def show(self):
        print("class c")
        super().show()

class d(b, c):
    def show(self):
        print("class d")
        super().show()

d = d()
d.show()

上述代码的输出为−

class d
class b
class c
class a

解释：d类的mro为[d， b， c， a，对象]。这意味着当某个方法在d实例上被调用时，python会先在d中寻找该方法，然后是b，再是c，最后是a。因此，“d类”、“b类”、“c类”和“a类”将按该顺序印刷。

多重继承中的钻石问题

钻石问题是多重继承中常见的问题。当两个父类继承同一个基类，而子类继承两个父类时，就会出现这种情况。下图展示了这个场景：

钻石问题导致在继承基类时，该调用哪个方法产生混淆。python 通过遵循我们之前讨论过的方法解析顺序（mro）来解决这个问题。让我们看看钻石问题的例子 −

示例

下面的代码演示了钻石问题以及python如何通过mro解决 −

class a:
    def show(self):
        print("class a")

class b(a):
    def show(self):
        print("class b")

class c(a):
    def show(self):
        print("class c")

class d(b, c):
    pass

d = d()
d.show()

上述代码的输出为−

class b

解释：d类的mro命令为[d， b， c， a]。所以，当调用 d.show（）时，它首先在类 d 里查找，但那里没有 show 函数，于是它会去 class b，找到 show 函数并执行它。

多重继承的坑与最佳实践

1. 避免的问题

钻石继承（菱形继承）：多个父类最终继承自同一个基类，可能导致重复调用或属性冲突（python3 的 c3 算法已解决，但仍需谨慎）。
代码可读性差：过多父类会让代码逻辑混乱，难以维护。

2. 最佳实践

尽量少用多重继承：能用单一继承 + 组合 / 接口实现的，就不用多重继承。
使用 mixin 模式：将通用功能封装成 mixin 类（仅包含方法，无属性），作为辅助继承，主逻辑仍用单一继承。

# mixin类：仅提供通用功能
class swimmixin:
    def swim(self):
        print("会游泳")

# 主父类
class person:
    def eat(self):
        print("会吃饭")

# 子类：主继承person，辅助继承swimmixin
class student(person, swimmixin):
    pass

stu = student()
stu.eat()   # 输出：会吃饭
stu.swim()  # 输出：会游泳

多重继承的利弊

多重继承有若干优缺点 -

优点	缺点
提升代码模块化和可复用性。	增加了复杂度，可能导致模糊性。
允许将多个类别的功能组合在一起。	这可能导致钻石问题。
可以创建复杂的现实关系	调试和维护更难。

多重继承是一种面向对象编程的概念，其中来自多个父类的方法可以被子类继承。我们讨论了 python 如何利用方法解析顺序（mro）处理多重继承，以及如何使用 super（）函数。钻石问题在多重继承中很常见，但 python 通过 mro 解决了这个问题。多重继承的主要缺点是让职业层级结构更复杂且更难理解。