python必背源代码继承和多态代码

一、单继承与 super() 属性复用必背源代码

单继承是子类派生自单个父类的机制。掌握单继承的关键在于掌握 super().__init__()：子类扩展自身特有属性的同时，必须将属于父类的通用参数交由父类的构造函数进行初始化，从而避免重复定义和状态遗漏。

1. 核心标准代码模板

# 基础环境：Python 3.6+
class Animal:
    """通用动物基类"""
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def eat(self):
        return f"{self.name} 正在进食"

    def speak(self):
        raise NotImplementedError("子类必须实现 speak 方法")


class Dog(Animal):
    """狗派生类：继承通用状态，扩展独有属性与重写方法"""
    def __init__(self, name: str, age: int, breed: str):
        # 关键：调用父类构造，完成基础属性 name 和 age 的初始化
        super().__init__(name, age)
        self.breed = breed  # 子类专有属性

    def speak(self):
        # 方法重写（Override）
        return f"{self.name}（{self.breed}）汪汪叫！"

    def fetch(self):
        # 子类特有方法
        return f"{self.name} 飞快地捡回了飞盘"

2. 调用与输出验证

# 实例化与方法调用
dog = Dog(name="旺财", age=3, breed="金毛")
print(dog.eat())    # 继承自 Animal
print(dog.speak())  # 调用 Dog 重写后的方法
print(dog.fetch())  # 调用 Dog 特有方法

二、多重继承与 MRO 解析顺序必背源代码

多重继承允许一个子类同时继承多个父类。当多个父类拥有共同的祖先时，会构成典型的“菱形继承（Diamond Problem）”。Python 2.3 起全面采用 C3 线性化算法 构建方法解析顺序（Method Resolution Order，简称 MRO），彻底解决了多继承下的调用重复和拓扑错乱问题。

1. 菱形继承标准测试模板

class A:
    def __init__(self):
        print("  -> 进入 A.__init__")
        super().__init__()
        print("  <- 离开 A.__init__")


class B(A):
    def __init__(self):
        print("  -> 进入 B.__init__")
        super().__init__()  # 注意：这里的 super() 下一步并不是 A，而是 C！
        print("  <- 离开 B.__init__")


class C(A):
    def __init__(self):
        print("  -> 进入 C.__init__")
        super().__init__()
        print("  <- 离开 C.__init__")


class D(B, C):
    def __init__(self):
        print("  -> 进入 D.__init__")
        super().__init__()
        print("  <- 离开 D.__init__")

2. MRO 路径检查与输出验证

print("D 的 MRO 搜索解析链条:")
for idx, cls in enumerate(D.__mro__):
    print(f"  [{idx}] {cls.__name__}")

print("
开始实例化 d = D():")
d = D()

三、多态的本质：鸭子类型（Duck Typing）必背代码

在诸如 Java 或 C++ 等强类型静态语言中，多态通常严格依赖“子类向上转型为父类引用”。但在 Python 中，类型是动态绑定的，多态依靠的是鸭子类型哲学（Duck Typing）：“如果一只鸟走起来像鸭子、叫起来像鸭子，那它就可以被当作鸭子”。

这意味着：业务消费函数只需要要求传入的对象具备指定的“方法签名”，而根本不关心该对象究竟属于哪个类，也不强制要求它们继承自同一个基类。

1. 支付网关统一接口实战范式

# 两个互不继承的独立类，仅约定共同的 pay(amount) 行为
class AlipayGateway:
    def pay(self, amount: float) -> bool:
        print(f"[支付宝] 发起扫码扣款 ￥{amount:.2f}，通信状态：SUCCESS")
        return True


class WechatPayGateway:
    def pay(self, amount: float) -> bool:
        print(f"[微信支付] 调起统一下单接口 ￥{amount:.2f}，返回 prepay_id")
        return True


class MockTestGateway:
    """单元测试专用桩对象，同样无需继承父类"""
    def pay(self, amount: float) -> bool:
        print(f"[测试桩] 模拟环境直接放行 ￥{amount:.2f}")
        return True


# 高层业务消费函数：完全体现多态性
def checkout_order(gateway, total_price: float):
    """
    结账逻辑：依赖多态接口，对修改关闭、对扩展开放（开闭原则）
    """
    print(f"准备结算订单，金额: {total_price}")
    success = gateway.pay(total_price)  # 统一多态调用
    if success:
        print("订单结算成功，更新数据库状态
")
    else:
        print("支付失败，回滚库存
")

2. 统一调用与输出验证

# 客户端传入不同渠道的支付实例
checkout_order(AlipayGateway(), 199.00)
checkout_order(WechatPayGateway(), 88.50)
checkout_order(MockTestGateway(), 0.01)

四、规范化多态：抽象基类（ABC）必背模板

鸭子类型非常灵活，但在中大型工程协作中，若仅靠口头约定方法名，容易发生拼写错误（例如将 pay 误写为 do_pay），且这种错误在运行时才爆发。Python 内置的 abc 模块提供了抽象基类（Abstract Base Class），可以在类实例化时强制校验子类是否实现了所有抽象方法。

1. 抽象基类标准约束代码

from abc import ABC, abstractmethod


class DataExporter(ABC):
    """抽象数据导出器：定义导出规范"""

    def __init__(self, filename: str):
        self.filename = filename

    @abstractmethod
    def format_data(self, data: list) -> str:
        """将原始数据转换为特定文本格式"""
        pass

    def export(self, data: list):
        """模板方法：通用导出骨架逻辑"""
        content = self.format_data(data)  # 调用子类实现的抽象方法
        print(f"正在写入文件 [{self.filename}]，内容如下:
{content}")


class CsvExporter(DataExporter):
    def format_data(self, data: list) -> str:
        return "
".join([",".join(row) for row in data])


class JsonExporter(DataExporter):
    def format_data(self, data: list) -> str:
        import json
        return json.dumps(data, ensure_ascii=False, indent=2)


class BrokenExporter(DataExporter):
    """故意遗漏 format_data 的错误子类"""
    pass

2. 运行与防御性报错验证

raw_records = [
    ["ID", "User", "Role"],
    ["1", "Alice", "Admin"],
    ["2", "Bob", "Dev"]
]

# 正确实现的子类正常工作
csv = CsvExporter("users.csv")
csv.export(raw_records)

# 遗漏抽象方法的子类在【实例化时】直接拦截抛出 TypeError
try:
    broken = BrokenExporter("broken.dat")
except TypeError as err:
    print(f"
防御性拦截生效: {err}")

五、继承与多态的高频避坑指南

在实际工程中，关于继承和多态的高频错误集中在以下三处，应牢记排查方法：

六、全景速查与代码记忆清单

下方的全景思维图谱对 Python 继承与多态的核心语法机制、代码范式以及关键方法进行了汇总归纳，可作为开发时的速查参照。

代码记忆核心口诀

• 单继承：子类派生传基类，重写构造 super() 带；扩展属性自己配，公共状态父类给。
• 多重继承：菱形继承莫心慌，__mro__ 里面看方向；C3 算法拓扑排，同层从左到右来。
• 多态机制：动态语言鸭子型，只要方法签名灵；消费函数调接口，具体实现任你请。
• 抽象约束：接口规范用 ABC，@abstractmethod 记心里；漏写实现实例崩，团队协作显神功。