继承让子类复用父类代码，多态让不同对象以统一接口表现出不同行为。本章基于课件案例，带你掌握单继承、多继承、方法重写和多态（含鸭子类型）。
一、单继承（9.6.1）
父类Animal，子类 Cat 继承并扩展。
python
# coding = utf-8
# 代码文件：ch09/ch9_6_1.py
class Animal:
"""父类（基类）：表示通用的动物"""
def __init__(self, name):
"""构造方法：初始化动物的名字"""
self.name = name # 实例变量：存储动物的名字
def show_info(self):
"""实例方法：打印动物的名字"""
print('动物的名字：{}'.format(self.name))
def move(self):
"""实例方法：打印动物的动作"""
print('动物动一动...')
class Cat(Animal):
"""子类（派生类）：继承自Animal，表示猫"""
def __init__(self, name, age):
"""
子类构造方法：比父类多一个age参数
super().__init__(name) 调用父类构造，确保父类的name被正确初始化
如果省略这行，父类的name属性就不会创建，后续调用show_info()会报错
"""
super().__init__(name) # 调用父类Animal的__init__，传入name
self.age = age # 子类新增的实例变量：年龄（父类中没有）
# ---------- 测试代码 -------cat = Cat('Tom', 2) # 创建Cat对象：name='Tom', age=2
# 调用父类继承来的方法
cat.move() # 输出“动物动一动...” → 子类没有move，自动从父类继承
cat.show_info() # 输出“动物的名字：Tom” → 子类没有show_info，自动从父类继承
# 尝试访问子类新增的属性
print(cat.age) # 输出 2 → age是子类独有的属性
print(cat.name) # 输出 Tom → name是从父类继承来的属性，通过super()初始化
# 关键点解析
-继承语法：class 子类(父类):，Cat 后面括号中的 Animal 表示继承自 Animal。
-super() 的作用：super() 返回一个代表父类的代理对象，通过它可以调用父类的方法。在子类构造方法中，必须用 super().__init__(参数) 调用父类构造，否则从父类继承的属性不会被初始化。
-方法查找顺序：当调用 cat.move() 时，Python 先查找子类 Cat 有没有 move 方法，没有则到父类 Animal 中查找。
-子类扩展：子类可以添加父类没有的新属性和新方法（如这里的 age）。
二、多继承与方法重写（9.6.2 & 9.6.3）
Horse 和 Donkey 作为两个父类，Mule 多继承它们，并重写 show_info。
python
# coding = utf-8
# 代码文件：ch09/ch9_6_2.py
class Horse:
"""父类1：马"""
def __init__(self, name):
"""构造方法：初始化马的名字"""
self.name = name
def show_info(self):
"""实例方法：打印马的信息"""
print('马的名字：{}'.format(self.name))
def run(self):
"""实例方法：马奔跑"""
print('马跑...')
class Donkey:
"""父类2：驴"""
def __init__(self, name):
"""构造方法：初始化驴的名字"""
self.name = name
def show_info(self):
"""实例方法：打印驴的信息"""
print('驴的名字：{}'.format(self.name))
def run(self):
"""实例方法：驴奔跑"""
print('驴跑...')
def roll(self):
"""实例方法：驴打滚（马没有这个方法）"""
print('驴打滚...')
class Mule(Horse, Donkey):
"""
子类：骡子（马和驴的杂交后代）
多继承语法：括号内按顺序列出多个父类，用逗号分隔
继承顺序决定了方法解析顺序（MRO）：Mule → Horse → Donkey
"""
def __init__(self, name, age):
"""
构造方法：name传给父类，age是子类新增
super().__init__(name) 按MRO顺序调用第一个父类的构造方法
本例中MRO为 Mule → Horse → Donkey，所以调用的是 Horse.__init__(name)
"""
super().__init__(name) # 调用Horse的构造，初始化name
self.age = age # 子类新增属性
def show_info(self):
"""
方法重写（Override）：子类重新定义父类已有的方法
如果不重写，MRO会先找到Horse.show_info，输出“马的名字...”
重写后，调用m.show_info()将执行这里的版本
"""
print('骡的名字：{}'.format(self.name))
# ---------- 测试代码 -------m = Mule('骡宝莉', 1) # 创建Mule对象
# 测试1：调用run() → 多继承下的方法查找
m.run()
# 输出“马跑...”
# 原因：Mule没有run，按MRO顺序查找：Mule → Horse → Donkey
# 在Horse中找到run，所以执行Horse.run，不继续找Donkey.run
# 测试2：调用roll() → 只在一个父类中存在
m.roll()
# 输出“驴打滚...”
# 原因：Mule没有roll，Horse没有roll，在Donkey中找到roll
# 测试3：调用show_info() → 方法重写
m.show_info()
# 输出“骡的名字：骡宝莉”
# 原因：虽然Horse和Donkey都有show_info，但Mule重写了show_info
# 所以直接执行Mule自己的版本，不向上查找
# 补充：查看MRO顺序
print(Mule.__mro__)
# 输出：(<class '__main__.Mule'>, <class '__main__.Horse'>,
# <class '__main__.Donkey'>, <class 'object'>)
# __mro__属性可以查看方法解析顺序，对调试多继承非常有帮助
# 关键点解析
-多继承语法：class 子类(父类1, 父类2, ...): 括号内按顺序列出多个父类。
-MRO（方法解析顺序）：当调用一个方法时，Python 按照 MRO 顺序依次查找。MRO 可通过 类名.__mro__ 查看。本例中 MRO 为 Mule → Horse → Donkey → object。
-super() 在多继承中的行为：super() 按 MRO 顺序调用下一个类的同名方法。在 Mule 构造中，super().__init__(name) 只调用了 Horse.__init__，因为 MRO 中 Horse 是第一个父类。
-方法重写：子类定义了与父类同名的方法，会覆盖父类的方法。本例中 Mule 重写了 show_info，所以调用的是子类版本。
-方法查找规则：子类自己的方法优先 → 然后按 MRO 顺序查找父类。
三、多态性
# 3.1 继承体系内的多态（9.7.1）
子类重写父类方法后，同一方法在不同对象上表现不同。
python
# coding = utf-8
# 代码文件：ch09/ch9_7_1.py
class Animal:
"""父类：动物（基类）"""
def speak(self):
"""通用的叫声方法：不知道具体什么动物叫"""
print('动物叫，但不知道是哪种动物叫！')
class Dog(Animal):
"""子类：狗（继承自Animal）"""
def speak(self):
"""重写speak方法：狗的专属叫声"""
print('小狗：汪汪叫...') # 狗叫的实现
class Cat(Animal):
"""子类：猫（继承自Animal）"""
def speak(self):
"""重写speak方法：猫的专属叫声"""
print('小猫：喵喵叫...') # 猫叫的实现
# ---------- 测试多态 -------an1 = Dog() # 创建Dog对象
an2 = Cat() # 创建Cat对象
# 调用同一个方法名，执行不同的实现
an1.speak() # 输出“小狗：汪汪叫...” → 执行Dog.speak
an2.speak() # 输出“小猫：喵喵叫...” → 执行Cat.speak
# 多态的本质：同一个方法名，在不同对象上有不同行为
# Python在运行时根据对象的实际类型决定调用哪个方法（动态绑定）
# 3.2 鸭子类型测试与多态（9.7.2）
Python 不要求对象必须继承自同一父类，只要有相同方法名即可。
python
# coding = utf-8
# 代码文件：ch09/ch9_7_2.py
def start(obj):
"""
多态函数：接收任何具有speak方法的对象
不关心对象的类型，只关心它是否有speak方法
这就是“鸭子类型”的核心思想
"""
obj.speak() # 调用对象的speak方法
class Animal:
"""父类：动物"""
def speak(self):
print('动物叫，但不知道是哪种动物叫！')
class Dog(Animal):
"""子类：狗"""
def speak(self):
print('小狗：旺旺叫...')
class Cat(Animal):
"""子类：猫"""
def speak(self):
print('小猫：喵喵叫...')
class Car:
"""
汽车类：完全独立于Animal继承体系
但Car也实现了speak方法，因此也可以传入start函数
这就是“鸭子类型”的体现
"""
def speak(self):
print('小汽车：嘀嘀叫...')
# ---------- 测试鸭子类型 -------start(Dog()) # 传入Dog对象 → 输出“小狗：旺旺叫...”
start(Cat()) # 传入Cat对象 → 输出“小猫：喵喵叫...”
start(Car()) # 传入Car对象 → 输出“小汽车：嘀嘀叫...”
# Car没有继承Animal，但因为实现了speak方法，所以也能正常工作
# 鸭子类型的核心：如果它走起来像鸭子、叫起来像鸭子，那它就是鸭子
# Python不检查对象类型，只检查方法是否存在
# 关键点解析
-多态（继承体系内）：子类重写父类方法后，同一个方法名在不同子类中有不同实现。调用时根据对象实际类型执行对应版本。
-动态绑定：方法调用在运行时才决定，而不是编译时。
-鸭子类型：Python 特有的多态实现方式。不关心对象的继承体系，只关心对象是否有需要的方法。只要实现了方法，就可以被调用。
-灵活性与风险：鸭子类型让代码更灵活，但如果传入的对象没有预期的方法，程序会在运行时抛出 AttributeError。
四、核心要点速览
-继承：子类获得父类非私有成员，实现代码复用。单继承结构简单，多继承功能强大但需注意 MRO。
-super()：调用父类方法，推荐在构造方法中使用，确保父类属性被正确初始化。
-方法重写：子类定义同名方法覆盖父类实现，用于扩展或替换父类行为。
-MRO（方法解析顺序）：多继承时决定方法查找顺序，可通过 类名.__mro__ 查看。
-多态：同一方法名在不同对象上执行不同逻辑，依赖于动态绑定。
-鸭子类型：Python 不依赖继承体系实现多态，只要对象实现了指定方法即可，更加灵活。
