30天入门Python（基础篇）——第28天：Python面向对象之继承与多继承

📅 学习日期：第28天 | ⏱️ 预计用时：55分钟 | 📊 难度等级：⭐⭐⭐⭐

🎯 学习目标

• • 理解继承的概念和意义
• • 掌握单继承的语法和使用
• • 学会使用 super() 函数
• • 理解方法重写和扩展
• • 掌握多继承的语法和 MRO 机制
• • 了解 mixin 设计模式
• • 避免常见的继承陷阱

欢迎大家关注此公众号，后台留言"python书籍"可免费获取【Python办公自动化高清PDF】电子书一本

此外小庄推荐一本适合于新手\小白入手一本 Python基础书籍，欢迎大家订阅，也感谢大家支持，我才有更新的动力

一、什么是继承？

1.1 继承的概念

继承是面向对象编程的三大特征之一（封装、继承、多态）。它允许我们基于已有的类创建新类，新类自动获得父类的属性和方法。

• • 父类（基类、超类）：被继承的类
• • 子类（派生类）：继承的类

        Animal (父类)
       /      \
      /        \
   Dog        Cat (子类)
  (继承)     (继承)

1.2 为什么需要继承？

没有继承的问题：

# 重复代码！
classDog:
def__init__(self, name, age):
self.name = name
self.age = age
defeat(self):
print(f"{self.name} 在吃东西")
defsleep(self):
print(f"{self.name} 在睡觉")
defbark(self):
print(f"{self.name} 汪汪叫")

classCat:
def__init__(self, name, age):
self.name = name
self.age = age
defeat(self):
print(f"{self.name} 在吃东西")
defsleep(self):
print(f"{self.name} 在睡觉")
defmeow(self):
print(f"{self.name} 喵喵叫")

使用继承后：

classAnimal:
def__init__(self, name, age):
self.name = name
self.age = age
defeat(self):
print(f"{self.name} 在吃东西")
defsleep(self):
print(f"{self.name} 在睡觉")

classDog(Animal):
defbark(self):
print(f"{self.name} 汪汪叫")

classCat(Animal):
defmeow(self):
print(f"{self.name} 喵喵叫")

二、单继承

2.1 基本语法

class子类名(父类名):
pass

2.2 完整示例

# 父类
classPerson:
def__init__(self, name, age):
self.name = name
self.age = age

defintroduce(self):
print(f"我叫 {self.name}，今年 {self.age} 岁。")

defwork(self):
print("我正在工作")

# 子类
classStudent(Person):
defstudy(self):
print(f"{self.name} 正在学习")

# 使用
stu = Student("小明", 20)
stu.introduce()  # 继承自 Person
stu.study()      # Student 自己的方法
stu.work()       # 继承自 Person

2.3 方法重写（Override）

子类可以重新定义父类的方法：

classPerson:
def__init__(self, name, age):
self.name = name
self.age = age

defwork(self):
print("我正在工作")

classStudent(Person):
# 重写父类的 work 方法
defwork(self):
print(f"{self.name} 正在学习，不是在工作")

classTeacher(Person):
# 重写父类的 work 方法
defwork(self):
print(f"{self.name} 正在讲课")

# 测试
stu = Student("小明", 20)
stu.work()  # 小明 正在学习，不是在工作

teacher = Teacher("王老师", 35)
teacher.work()  # 王老师 正在讲课

2.4 扩展父类方法

使用 super() 调用父类方法，在其基础上添加新功能：

classPerson:
def__init__(self, name, age):
self.name = name
self.age = age

defintroduce(self):
print(f"我叫 {self.name}，今年 {self.age} 岁。")

classStudent(Person):
def__init__(self, name, age, student_id):
# 调用父类 __init__
super().__init__(name, age)
# 添加子类特有属性
self.student_id = student_id

defintroduce(self):
# 调用父类方法
super().introduce()
# 添加额外信息
print(f"我的学号是 {self.student_id}。")

stu = Student("小明", 20, "S2026001")
stu.introduce()
# 我叫 小明，今年 20 岁。
# 我的学号是 S2026001。

2.5 super() 的两种用法

classParent:
def__init__(self, name):
self.name = name

classChild(Parent):
def__init__(self, name, age):
# 方式一：使用 super()（推荐）
super().__init__(name)

# 方式二：直接调用父类（不推荐，多继承时有问题）
# Parent.__init__(self, name)

self.age = age

三、继承中的属性查找顺序

3.1 属性查找规则

当访问一个属性时，Python 按照以下顺序查找：

1. 1. 实例属性：对象自己的属性
2. 2. 类属性：子类的类属性
3. 3. 父类属性：沿着继承链向上查找

classA:
    attr = "A"

classB(A):
    attr = "B"

classC(B):
    attr = "C"

obj = C()
print(obj.attr)  # C（优先使用最近的）

del C.attr
print(obj.attr)  # B

del B.attr
print(obj.attr)  # A

3.2 isinstance() 和 issubclass()

classAnimal:
pass

classDog(Animal):
pass

classCat(Animal):
pass

dog = Dog()

# isinstance: 判断对象是否是某类或其子类的实例
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True（Dog 继承自 Animal）
print(isinstance(dog, Cat))     # False

# issubclass: 判断类是否是另一类的子类
print(issubclass(Dog, Animal))  # True
print(issubclass(Cat, Animal))  # True
print(issubclass(Dog, Cat))     # False

四、多继承

4.1 多继承语法

Python 支持一个类继承多个父类：

class子类(父类1, 父类2, 父类3, ...):
pass

4.2 完整示例

classFlyer:
deffly(self):
print("我会飞！")

classSwimmer:
defswim(self):
print("我会游泳！")

classRunner:
defrun(self):
print("我会跑！")

# 多继承
classDuck(Flyer, Swimmer, Runner):
defquack(self):
print("嘎嘎嘎！")

duck = Duck()
duck.fly()    # 我会飞！
duck.swim()   # 我会游泳！
duck.run()    # 我会跑！
duck.quack()  # 嘎嘎嘎！

4.3 方法名冲突问题

当多个父类有同名方法时，Python 使用 MRO（方法解析顺序） 决定调用哪个：

classA:
defmethod(self):
print("A 的方法")

classB:
defmethod(self):
print("B 的方法")

classC(A, B):
pass

classD(B, A):
pass

C().method()  # A 的方法（A 排在 B 前面）
D().method()  # B 的方法（B 排在 A 前面）

4.4 查看 MRO

classA:
pass

classB:
pass

classC(A, B):
pass

# 方式一：使用 __mro__
print(C.__mro__)
# (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

# 方式二：使用 mro() 方法
print(C.mro())
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

4.5 C3 线性化算法

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

1. 1. 子类优先于父类
2. 2. 按照继承声明中的从左到右顺序
3. 3. 保持单调性（子类在父类之前的关系不变）

classA:
pass

classB(A):
pass

classC(A):
pass

classD(B, C):
pass

print(D.mro())
# [D, B, C, A, object]

五、super() 在多继承中的作用

5.1 链式调用

classA:
def__init__(self):
print("A 初始化")
super().__init__()

classB:
def__init__(self):
print("B 初始化")
super().__init__()

classC(A, B):
def__init__(self):
print("C 初始化")
super().__init__()

c = C()
# 输出:
# C 初始化
# A 初始化
# B 初始化

5.2 协作式调用

super() 在多继承中按照 MRO 链式调用每个父类的方法：

classBase:
defprocess(self):
print("Base 处理")

classA(Base):
defprocess(self):
print("A 处理")
super().process()

classB(Base):
defprocess(self):
print("B 处理")
super().process()

classC(A, B):
defprocess(self):
print("C 处理")
super().process()

C().process()
# 输出:
# C 处理
# A 处理
# B 处理
# Base 处理

六、MixIn 设计模式

6.1 什么是 MixIn？

MixIn 是一种通过多继承来组合功能的设计模式。它不是严格的"继承关系"，而是"能力组合"。

classJSONMixin:
"""提供导出为 JSON 的能力"""
defto_json(self):
import json
return json.dumps(self.__dict__, ensure_ascii=False, indent=2)

classCSVMixin:
"""提供导出为 CSV 的能力"""
defto_csv(self):
return",".join(str(v) for v inself.__dict__.values())

classReport:
def__init__(self, title, data):
self.title = title
self.data = data

# 组合多个 MixIn
classJSONReport(Report, JSONMixin):
pass

classCSVReport(Report, CSVMixin):
pass

classUniversalReport(Report, JSONMixin, CSVMixin):
pass

report = UniversalReport("销售报告", {"total": 1000, "count": 50})
print(report.to_json())
print(report.to_csv())

6.2 MixIn 命名约定

• • MixIn 类通常以 Mixin 结尾
• • MixIn 不应该被单独实例化
• • MixIn 通常没有 __init__ 方法（或需要特定属性存在）

七、多重继承的最佳实践

7.1 优先使用组合而非继承

# ❌ 不推荐：深层继承链
classAnimal:
pass

classMammal(Animal):
pass

classPet(Mammal):
pass

classDog(Pet):
pass

# ✅ 推荐：组合模式
classAnimal:
def__init__(self, name):
self.name = name

classPetBehavior:
defplay(self):
print("正在玩耍")

classDog(Animal):
def__init__(self, name):
super().__init__(name)
self.behavior = PetBehavior()

defplay(self):
self.behavior.play()

7.2 避免菱形继承问题

# ⚠️ 菱形继承：A 被继承两次
classA:
def__init__(self):
print("A 初始化")

classB(A):
def__init__(self):
super().__init__()

classC(A):
def__init__(self):
super().__init__()

classD(B, C):
def__init__(self):
super().__init__()

# Python 的 MRO 确保 A.__init__ 只被调用一次
d = D()
print(D.mro())  # [D, B, C, A, object]

7.3 继承 vs 组合决策表

八、实战项目：员工管理系统

classEmployee:
"""员工基类"""
def__init__(self, name, employee_id, base_salary):
self.name = name
self.employee_id = employee_id
self.base_salary = base_salary

defget_salary(self):
returnself.base_salary

defintroduce(self):
returnf"员工: {self.name} (ID: {self.employee_id})"


classManagerMixin:
"""经理能力 MixIn"""
defmanage_team(self):
returnf"{self.name} 正在管理团队"

defconduct_review(self):
returnf"{self.name} 正在进行绩效评估"


classProgrammer(Employee):
"""程序员类"""
def__init__(self, name, employee_id, base_salary, language):
super().__init__(name, employee_id, base_salary)
self.language = language
self._bonus = 0

defcode(self):
returnf"{self.name} 正在用 {self.language} 编程"

defadd_bonus(self, amount):
self._bonus += amount

defget_salary(self):
returnself.base_salary + self._bonus


classTechLead(Programmer, ManagerMixin):
"""技术主管：程序员 + 管理能力"""
def__init__(self, name, employee_id, base_salary, language, team_size):
super().__init__(name, employee_id, base_salary, language)
self.team_size = team_size


classHR(Employee, ManagerMixin):
"""HR：员工 + 管理能力"""
def__init__(self, name, employee_id, base_salary, department):
super().__init__(name, employee_id, base_salary)
self.department = department

definterview(self):
returnf"{self.name} 正在面试候选人"


# 使用
programmer = Programmer("张三", "P001", 15000, "Python")
print(programmer.introduce())  # 员工: 张三 (ID: P001)
print(programmer.code())       # 张三 正在用 Python 编程
print(f"月薪: {programmer.get_salary()}")

lead = TechLead("李四", "TL001", 25000, "Java", 5)
print(lead.introduce())
print(lead.code())
print(lead.manage_team())     # MixIn 提供的方法
print(f"月薪: {lead.get_salary()}")

hr = HR("王五", "HR001", 12000, "人事部")
print(hr.introduce())
print(hr.interview())
print(hr.conduct_review())    # MixIn 提供的方法

九、总结

核心要点

1. 1. 继承是"is-a"关系，组合是"has-a"关系
2. 2. 优先使用 super() 而非直接调用父类
3. 3. 避免过深的继承链（不超过 3 层）
4. 4. MixIn 提供能力，不是基类
5. 5. 多继承注意 MRO，避免同名方法冲突

十、练习题

练习 1：图形类继承

创建 Shape 基类，Circle、Rectangle、Triangle 子类，各自实现面积和周长计算。

练习 2：带日志功能的字典

创建 LoggedDict，继承 dict，每次读写操作时打印日志。

练习 3：多继承冲突解决

创建两个父类，各有同名方法，在子类中决定调用哪个父类的方法。

参考答案

classLoggedDict(dict):
def__getitem__(self, key):
print(f"[LOG] 读取 key: {key}")
returnsuper().__getitem__(key)

def__setitem__(self, key, value):
print(f"[LOG] 设置 {key} = {value}")
super().__setitem__(key, value)

def__delitem__(self, key):
print(f"[LOG] 删除 key: {key}")
super().__delitem__(key)

d = LoggedDict()
d["name"] = "小明"# [LOG] 设置 name = 小明
print(d["name"])    # [LOG] 读取 key: name → 小明

🎉 恭喜你完成了第28天的学习！继承和多继承是面向对象设计的重要工具。

📌 下一天预告：第29天 —— Python面向对象之多态与抽象类