第三十篇：多重继承与 Mixin 模式——优雅组合行为

前言

**多重继承（Multiple Inheritance）**允许一个类同时拥有多个父类的特性，而 Mixin 模式则是利用多重继承实现行为组合的设计模式。本文将深入讲解 Python 中多重继承的实现、MRO 方法解析顺序、Mixin 的使用技巧及避免钻石继承问题的最佳实践。

多重继承基础

基本语法

class Flyable:
    def fly(self):
        return f"正在飞翔..."

class Swimmable:
    def swim(self):
        return f"正在游泳..."

class Walkable:
    def walk(self):
        return f"正在行走..."

# 鸭子同时具备三种能力
class Duck(Flyable, Swimmable, Walkable):
    def quack(self):
        return "嘎嘎嘎！"

duck = Duck()
print(duck.fly())      # 正在飞翔...
print(duck.swim())     # 正在游泳...
print(duck.walk())     # 正在行走...
print(duck.quack())    # 嘎嘎嘎！

init 与多重继承的陷阱

class Animal:
    def __init__(self, name):
        self.name = name

class Flyable:
    def __init__(self):
        self.max_altitude = 100

class Bird(Animal, Flyable):
    def __init__(self, name, color):
        # ❌ 错误方式：分别调用父类构造
        Animal.__init__(self, name)
        Flyable.__init__(self)
        self.color = color

bird = Bird("麻雀", "褐色")
print(bird.name)       # 麻雀
print(bird.max_altitude)  # 100

MRO —— 方法解析顺序

什么是 MRO？

当一个类继承多个父类且有共同祖先时，Python 需要决定方法的调用顺序。**MRO（Method Resolution Order）**就是解决这个问题的算法。

查看 MRO

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

class B(A):
    def greet(self):
        print("B.greet")
        super().greet()

class C(A):
    def greet(self):
        print("C.greet")
        super().greet()

class D(B, C):
    def greet(self):
        print("D.greet")
        super().greet()

# 查看 D 的 MRO
print(D.mro())
# [<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>]

d = D()
d.greet()
# D.greet
# B.greet
# C.greet
# A.greet
# （每个类的 greet 只被调用一次！）

C3 线性化算法

Python 使用 C3 线性化算法确定 MRO，核心规则：

子类始终在父类之前
保持父类之间的声明顺序
每个类的 MRO 是其自身 + 各父类 MRO 的合并

钻石继承问题

问题描述

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

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

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

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

d = D()
d.method()
# D.method → B.method → C.method → A.method
# ⚠️ A.method 只被调用了一次！MRO 避免了重复调用

⚠️ 不使用 super() 的后果

class BadExample:
    pass

class Parent1(BadExample):
    def __init__(self):
        print("Parent1.__init__")

class Parent2(BadExample):
    def __init__(self):
        print("Parent2.__init__")

class Child(Parent1, Parent2):
    def __init__(self):
        Parent1.__init__(self)  # ❌ 直接调用，不遵循 MRO
        Parent2.__init__(self)  # ❌ Parent2.__init__ 会被调用两次

child = Child()
# 输出：
# Parent1.__init__
# Parent2.__init__
# Parent1.__init__  ← 再次执行！因为 MRO 被绕过

Mixin 模式

什么是 Mixin？

Mixin 是一个专门设计用于被继承的小型类，它提供额外的功能但不打算独立实例化。通过组合多个 Mixin，可以实现代码的高度复用。

经典 Mixin 示例

from datetime import datetime

# 日志 Mixin
class LoggingMixin:
    def log(self, message):
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] {message}")

# 可序列化 Mixin
class SerializableMixin:
    def to_dict(self):
        return {key: value for key, value in self.__dict__.items()}
    
    @classmethod
    def from_dict(cls, data):
        instance = cls()
        for key, value in data.items():
            setattr(instance, key, value)
        return instance

# JSON 序列化 Mixin
import json

class JSONMixin:
    def to_json(self):
        return json.dumps(self.to_dict(), ensure_ascii=False)
    
    @classmethod
    def from_json(cls, json_str):
        data = json.loads(json_str)
        return cls.from_dict(data)

# 使用混合类
class User(LoggingMixin, SerializableMixin, JSONMixin):
    def __init__(self, name, email):
        self.name = name
        self.email = email
    
    def greet(self):
        msg = f"{self.name} 向你问好"
        self.log(msg)  # 来自 LoggingMixin
        return msg

user = User("小明", "xm@example.com")
print(user.greet())          # 小明 向你问好
print(user.to_dict())         # {'name': '小明', 'email': 'xm@example.com'}
print(user.to_json())         # {"name": "小明", "email": "xm@example.com"}

Mixin 的最佳实践

原则一：Mixin 不应该有自己的状态

# ✅ 好的 Mixin：无状态
class ValidatableMixin:
    def validate(self):
        errors = []
        for attr_name in self._validation_fields:
            value = getattr(self, attr_name, None)
            if not value:
                errors.append(f"{attr_name} 不能为空")
        return errors

# ❌ 坏的 Mixin：持有状态
class StatefulBadMixin:
    cache = {}  # 类变量被所有子类共享，可能引起混乱
    
    def process(self, item):
        if item in self.cache:
            return self.cache[item]
        result = item.upper()
        self.cache[item] = result
        return result

原则二：Mixin 应该小而专注

# ✅ 小且专注的 Mixin
class DateStampedMixin:
    def mark_created(self):
        self.created_at = datetime.now()

class TimestampedMixin:
    def mark_modified(self):
        self.updated_at = datetime.now()

class AccessibleMixin:
    def mark_accessed(self):
        self.last_accessed = datetime.now()

# 按需组合
class Document(DateStampedMixin, TimestampedMixin, AccessibleMixin):
    def __init__(self, title):
        self.title = title

doc = Document("会议纪要")
doc.mark_created()   # 添加 created_at
doc.mark_modified()  # 添加 updated_at
doc.mark_accessed()  # 添加 last_accessed

原则三：Mixin 之间不应冲突

class PrinterMixin:
    def display(self):
        print("PrinterMixin.display")

class LoggerMixin:
    def display(self):
        print("LoggerMixin.display")

# ❌ 冲突：两个 Mixin 都有 display 方法
# class BadClass(PrinterMixin, LoggerMixin):
#     pass

# ✅ 解决方案：确保每个 Mixin 的方法签名不同或调用 super()
class PrinterMixin2:
    def print_output(self):
        print("PrinterMixin2.print_output")

class LoggerMixin2:
    def log_message(self):
        print("LoggerMixin2.log_message")

class GoodClass(PrinterMixin2, LoggerMixin2):
    pass

good = GoodClass()
good.print_output()  # PrinterMixin2.print_output
good.log_message()   # LoggerMixin2.log_message

实战：权限系统设计

class PermissionMixin:
    """权限检查 Mixin"""
    _permissions = set()
    
    @classmethod
    def has_permission(cls, perm):
        return perm in cls._permissions
    
    def check_permission(self, perm):
        if not self.has_permission(perm):
            raise PermissionError(f"缺少权限：{perm}")

class RoleMixin:
    """角色管理 Mixin"""
    _roles = set()
    
    @classmethod
    def assign_role(cls, role):
        cls._roles.add(role)
    
    def get_roles(self):
        return list(self._roles)

class AuditMixin:
    """审计追踪 Mixin"""
    _action_log = []
    
    def log_action(self, action):
        from datetime import datetime
        entry = {
            "action": action,
            "timestamp": datetime.now().isoformat(),
            "class": self.__class__.__name__,
        }
        self._action_log.append(entry)
    
    def get_audit_log(self):
        return list(self._action_log)


class Admin(PermissionMixin, RoleMixin, AuditMixin):
    """管理员"""
    _permissions = {"read", "write", "delete", "manage_users"}
    _roles = {"admin"}
    
    def __init__(self, username):
        self.username = username
        self.log_action("Admin initialized")
    
    def delete_user(self, target):
        self.check_permission("delete")
        self.log_action(f"Deleted user {target}")
        return f"已删除用户 {target}"

class Editor(PermissionMixin, AuditMixin):
    """编辑者"""
    _permissions = {"read", "write"}
    _roles = {"editor"}
    
    def __init__(self, username):
        self.username = username
        self.log_action("Editor initialized")
    
    def create_post(self, title, content):
        self.check_permission("write")
        self.log_action(f"Created post '{title}'")
        return f"已发布文章：{title}"


# 测试
admin = Admin("admin_01")
admin.log_action("Logged in")
print(admin.get_audit_log())

try:
    admin.delete_user("test_user")
except PermissionError as e:
    print(e)

editor = Editor("editor_01")
post = editor.create_post("Hello World", "Welcome!")
print(editor.get_audit_log())

Mixin vs 抽象基类

特性	Mixin	ABC（抽象基类）
意图	添加额外功能	定义接口契约
必须实现	否	是（@abstractmethod）
独立性	通常不独立实例化	通常也不独立实例化
灵活性	高度灵活，随意组合	较严格的结构化继承
适用场景	跨领域关注点（日志、序列化）	明确的多态接口

from abc import ABC, abstractmethod

# ABC 定义强制接口
class Printable(ABC):
    @abstractmethod
    def print_content(self):
        pass

# Mixin 添加辅助能力
class PageNumberingMixin:
    def add_page_number(self):
        return "[Page]"

# 组合使用
class Document(Printable, PageNumberingMixin):
    def __init__(self, content):
        self.content = content
    
    def print_content(self):
        return self.add_page_number() + self.content

doc = Document("Hello World!")
print(doc.print_content())  # [Page]Hello World!

总结

本文讲解了多重继承与 Mixin 的核心知识：

多重继承 — 一个类继承多个父类，获取组合能力
MRO — C3 线性化算法决定方法解析顺序
钻石继承 — MRO 保证父类方法只调用一次
super() 正确使用 — 配合 MRO 而非直接调用父类
Mixin 原则 — 小而专注、无状态、不冲突
实战应用 — 权限系统、日志追踪、序列化等
最佳实践 — 优先组合优于深层继承

下一篇文章将深入讲解定制类：特殊方法详解。

本文是 Python 教程系列的第三十篇。