本文共 3918 字，大约阅读时间需要 13 分钟。

Python 类继承与多继承详解

单继承与MRO

在 Python 中，类继承是面向对象编程的核心概念之一。单继承的基本逻辑非常简单：一个子类继承自一个父类，子类可以通过继承获得父类的属性和方法，同时可以定义自己的新功能。

MRO（方法查找顺序）

在单继承的情况下，子类的方法查找顺序遵循 MRO（Method Resolution Order），即从子类开始，依次查找父类，直到找到对应的方法或属性为止。MRO 列表可以通过 类名.mro() 查看。

class C:
    x = 222
class B(C):
    pass
class A(B):
    pass
obj = A()
print(obj.x)  # 输出: 222
print(A.mro())  # 输出: [A, B, C, object]

super() 函数

在 Python 中，super() 函数用于调用当前类的父类的方法或构造器。super() 返回一个特殊对象，该对象会参考当前类的 MRO 列表，依次查找父类中的属性或方法。

class People:
    school = "虹桥校区"
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
class Teacher(People):
    def __init__(self, name, age, gender, level):
        super().__init__(name, age, gender)
        self.level = level
    def score(self):
        print("%s 正在为学生打分" % self.name)
tea1 = Teacher("biu", 19, "male", 20)
print(tea1.__dict__)  # 输出: {'name': 'biu', 'age': 19, 'gender': 'male', 'level': 20}

多继承与菱形问题

Python 支持多继承，一个子类可以同时继承多个父类。这种能力带来了灵活性，但也引入了菱形问题（Diamond problem）。在菱形继承结构中，子类可能会有多个父类都定义了同一个方法，这样会导致混淆。

菱形继承结构

在菱形继承结构中，一个子类可能继承多个父类，而这些父类中有多个都定义了同一个方法。Python 的 MRO 列表通过 C3 算法来解决这个问题，确保查找顺序符合预期。

class A(object):
    def test(self):
        print("from A")
class B(A):
    def test(self):
        print("from B")
class C(A):
    def test(self):
        print("from C")
class D(B, C):
    pass
obj = D()
print(obj.test())  # 输出: from B
print(D.mro())  # 输出: [D, B, C, A, object]

C3 算法

C3 算法用于构造 MRO 列表，遵循以下规则：

深度优先与广度优先

在 Python 中，经典类（没有显式继承 object 类）和新式类（显式继承 object 类）在属性查找上的行为有所不同。

经典类（深度优先）

class G:
    def test(self):
        print("from G")
class E(G):
    def test(self):
        print("from E")
class F(G):
    def test(self):
        print("from F")
class B(E):
    def test(self):
        print("from B")
class C(F):
    def test(self):
        print("from C")
class D(G):
    def test(self):
        print("from D")
class A(B, C, D):
    pass
obj = A()
print(obj.test())  # 输出: from B

新式类（广度优先）

class G(object):
    def test(self):
        print("from G")
class E(G):
    def test(self):
        print("from E")
class F(G):
    def test(self):
        print("from F")
class B(E):
    def test(self):
        print("from B")
class C(F):
    def test(self):
        print("from C")
class D(G):
    def test(self):
        print("from D")
class A(B, C, D):
    pass
obj = A()
print(obj.test())  # 输出: from B

mixins 机制

mixins 机制允许一个子类同时继承多个功能类，而不会破坏继承关系的纯度。mixins 类通常以特定的命名规范（如 Mixin 后缀）标识，表示它们是为功能混入而设计的，而不是作为子类的直接继承。

class Vehicle:
    pass
class FlyableMixin:
    def fly(self):
        print("I am flying")
class CivilAircraft(FlyableMixin, Vehicle):
    pass
class Helicopter(FlyableMixin, Vehicle):
    pass
class Car(Vehicle):
    pass

组合关系

组合关系用于表示一种“拥有”关系。组合关系适用于“has-a”关系，而不是“is-a”关系。

class Abb:
    school = "虹桥校区"
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
class Student(Abb):
    def choose(self):
        print("%s 选课成功" % self.name)
class Teacher(Abb):
    def __init__(self, name, age, gender, level):
        Abb.__init__(self, name, age, gender)
        self.level = level
    def score(self):
        print("%s 正在为学生打分" % self.name)
class Course:
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period
    def tell(self):
        print("课程信息：%s %s %s" % (self.name, self.price, self.period))
python = Course("python", 20000, "6mons")
linux = Course("linux", 20000, "5mons")
stu1 = Student("lili", 18, "female")
stu2 = Student("nana", 16, "female")
stu3 = Student("dada", 19, "male")
tea1 = Teacher("egon", 18, "female", 10)
tea2 = Teacher("biu", 19, "male", 20)
stu1.courses = []
stu1.courses.append(python)
stu1.courses.append(linux)
for course_obj in stu1.courses:
    course_obj.tell()

通过以上内容，可以清晰地理解 Python 类继承与多继承的核心概念及其应用场景。