Python MRO 与 super() 深度解析：多继承背后的 C3 算法

1
class Animal:
2
    def __init__(self, name):
3
        self.name = name
4
        print(f"Animal.__init__({name})")
5

6
    def speak(self):
7
        return "..."
8

9
class Dog(Animal):
10
    def __init__(self, name, breed):
11
        super().__init__(name)  # 调用父类 Animal.__init__
12
        self.breed = breed
13
        print(f"Dog.__init__({name}, {breed})")
14

15
    def speak(self):
16
        return f"{self.name} says: Woof!"
17

18
dog = Dog("Buddy", "Golden Retriever")
19
print(dog.speak())

1
class Flyable:
2
    def __init__(self):
3
        print("Flyable.__init__")
4
        self.can_fly = True
5

6
    def fly(self):
7
        return f"{self.name} is flying!"
8

9
class Swimmable:
10
    def __init__(self):
11
        print("Swimmable.__init__")
12
        self.can_swim = True
13

14
    def swim(self):
15
        return f"{self.name} is swimming!"
16

17
class Duck(Flyable, Swimmable):
18
    def __init__(self, name):
19
        super().__init__()
20
        self.name = name
21
        print(f"Duck.__init__({name})")

1
class Flyable:
2
    def __init__(self):
3
        super().__init__()  # ← 关键：继续调用链
4
        print("Flyable.__init__")
5
        self.can_fly = True
6

7
class Swimmable:
8
    def __init__(self):
9
        super().__init__()  # ← 关键：继续调用链
10
        print("Swimmable.__init__")
11
        self.can_swim = True
12

13
class Duck(Flyable, Swimmable):
14
    def __init__(self, name):
15
        super().__init__()
16
        self.name = name
17
        print(f"Duck.__init__({name})")
18

19
duck = Duck("唐老鸭")
20
print(f"can_fly: {duck.can_fly}")
21
print(f"can_swim: {duck.can_swim}")

1
class A:
2
    def method(self):
3
        print("A.method")
4

5
class B(A):
6
    def method(self):
7
        print("B.method 开始")
8
        print(f"B 的 MRO: {[c.__name__ for c in B.__mro__]}")
9
        super().method()
10
        print("B.method 结束")
11

12
class C(B):
13
    def method(self):
14
        print("C.method 开始")
15
        print(f"C 的 MRO: {[c.__name__ for c in C.__mro__]}")
16
        super().method()
17
        print("C.method 结束")
18

19
C().method()

1
class Base:
2
    def __init__(self):
3
        super().__init__()
4
        print("Base.__init__")
5

6
class Left(Base):
7
    def __init__(self):
8
        super().__init__()
9
        print("Left.__init__")
10

11
class Right(Base):
12
    def __init__(self):
13
        super().__init__()
14
        print("Right.__init__")
15

16
class Child(Left, Right):
17
    def __init__(self):
18
        super().__init__()
19
        print("Child.__init__")
20

21
print("Child 的 MRO:", [c.__name__ for c in Child.__mro__])
22
print("---")
23
child = Child()

1
L[A] = [A, object]
2
L[B] = B + merge(L[A], A) = B + merge([A, object], [A])
3
     = B + A + merge([object]) = [B, A, object]
4

5
L[C] = C + merge(L[A], A) = [C, A, object]  (同上)
6

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

10
     → B 是好头部（B 不在 [A, object] 或 [A, object] 或 [C] 的尾部）
11
     = D + B + merge([A, object], [C, A, object], [C])
12

13
     → A 不是好头部（A 在 [C, A, object] 的尾部），跳过
14
     → C 是好头部
15
     = D + B + C + merge([A, object], [A, object])
16

17
     → A 是好头部
18
     = D + B + C + A + merge([object], [object])
19

20
     → object
21
     = [D, B, C, A, object]

1
class A:
2
    def greet(self):
3
        return "A"
4

5
class B(A):
6
    def greet(self):
7
        return "B" + super().greet()
8

9
class C(A):
10
    def greet(self):
11
        return "C" + super().greet()
12

13
class D(B, C):
14
    def greet(self):
15
        # 正常 super() 按 MRO [D, B, C, A] 查找
16
        normal = super().greet()          # → B → C → A
17
        # 跳过 B，直接从 C 开始
18
        skip_b = super(B, self).greet()   # → C → A
19
        return f"normal={normal}, skip_b={skip_b}"
20

21
print(D.__mro__)  # [D, B, C, A, object]
22
print(D().greet())
23
# normal=BCA, skip_b=CA

1
class Plugin:
2
    """基类插件，所有插件的祖先"""
3
    def __init__(self, **kwargs):
4
        super().__init__(**kwargs)
5
        self.plugins = []
6
        print(f"Plugin 初始化完成")
7

8
class LoggingMixin:
9
    """日志混入类"""
10
    def __init__(self, log_level="INFO", **kwargs):
11
        super().__init__(**kwargs)
12
        self.log_level = log_level
13
        print(f"LoggingMixin: log_level={log_level}")
14

15
    def log(self, message):
16
        print(f"[{self.log_level}] {message}")
17

18
class CacheMixin:
19
    """缓存混入类"""
20
    def __init__(self, cache_size=100, **kwargs):
21
        super().__init__(**kwargs)
22
        self.cache_size = cache_size
23
        self._cache = {}
24
        print(f"CacheMixin: cache_size={cache_size}")
25

26
    def get_cached(self, key):
27
        return self._cache.get(key)
28

29
    def set_cached(self, key, value):
30
        self._cache[key] = value
31

32
class DataProcessor(Plugin, LoggingMixin, CacheMixin):
33
    def __init__(self, name, **kwargs):
34
        super().__init__(**kwargs)
35
        self.name = name
36
        print(f"DataProcessor: name={name}")
37

38
    def process(self, data):
39
        self.log(f"Processing {len(data)} items")
40
        # ... 处理逻辑
41
        self.set_cached("last_result", data)
42
        return data
43

44
# 使用
45
processor = DataProcessor(
46
    name="my-processor",
47
    log_level="DEBUG",
48
    cache_size=500
49
)
50
print(f"log_level: {processor.log_level}")
51
print(f"cache_size: {processor.cache_size}")

1
# Django 内部模式示意
2
class View:
3
    def __init__(self, **kwargs):
4
        super().__init__(**kwargs)
5

6
class TemplateResponseMixin:
7
    template_name = "default.html"
8
    def render_to_response(self, context):
9
        # 渲染模板
10
        pass
11

12
class SingleObjectMixin:
13
    model = None
14
    def get_object(self):
15
        # 获取单个对象
16
        pass
17

18
class DetailView(SingleObjectMixin, TemplateResponseMixin, View):
19
    def get(self, request, *args, **kwargs):
20
        self.object = self.get_object()
21
        return self.render_to_response({"object": self.object})

1
import timeit
2

3
class A:
4
    def method(self): pass
5

6
class B(A):
7
    def method(self): super().method()
8

9
class C(B):
10
    def method(self): super().method()
11

12
class D(C):
13
    def method(self): super().method()
14

15
# super() 调用开销
16
t = timeit.timeit("D().method()", globals=globals(), number=100000)
17
print(f"10万次 super() 链调用: {t:.4f}s")
18
# 约 0.03-0.05s，每次调用约 300-500 纳秒

1
def debug_mro(cls):
2
    """打印完整的 MRO 链和每个类的方法定义"""
3
    print(f"=== MRO for {cls.__name__} ===")
4
    for i, klass in enumerate(cls.__mro__):
5
        methods = [m for m in dir(klass)
6
                   if not m.startswith('_') and callable(getattr(klass, m, None))]
7
        print(f"  {i}. {klass.__name__}: {methods[:5]}...")
8

9
class A:
10
    def process(self): pass
11

12
class B(A):
13
    def process(self): super().process()
14

15
class C(A):
16
    def process(self): super().process()
17

18
class D(B, C):
19
    def process(self): super().process()
20

21
debug_mro(D)