第 6.3 节 继承:复用已有代码#
预计学习时长: 35 分钟
本节目标:
- 知道继承是什么,子类能「白拿」父类的属性和方法;
- 会用
super()调用父类的初始化;- 会用
isinstance()判断对象类型;- 能用类组织一个「训练 → 预测」的机器学习模型流程。
继承:让新类站在旧类的肩膀上#
如果两个类大部分一样,只是多了一点点能力,复制粘贴一遍会很痛苦:
- 新类一改,老类还得再改一遍;
- 逻辑重复两遍,容易写出两个版本不一致的 bug。
继承解决这个问题:新类声明「我基于某个已有类」,然后只写自己多出来的那部分。
Case 52:创建不同类型的学生——使用继承复用学生类#
任务: 在 Student 的基础上创建 graduate_student(研究生)和 exchange_student(交换生)。
class Student:
"""普通学生。"""
def __init__(self, name, age, scores=None):
self.name = name
self.age = age
self.scores = list(scores) if scores else []
def average(self):
if not self.scores:
return 0
return sum(self.scores) / len(self.scores)
def introduce(self):
return f"我是 {self.name},{self.age} 岁,平均分 {self.average():.2f}"
class GraduateStudent(Student):
"""研究生:在普通学生的基础上多一个导师。"""
def __init__(self, name, age, scores=None, advisor="未指定"):
super().__init__(name, age, scores) # 调用父类的 __init__
self.advisor = advisor
def introduce(self):
base = super().introduce() # 复用父类的方法,再加一句
return f"{base},导师是 {self.advisor}"
class ExchangeStudent(Student):
"""交换生:多一个来源国家。"""
def __init__(self, name, age, scores=None, country="中国"):
super().__init__(name, age, scores)
self.country = country
def introduce(self):
return f"{super().introduce()},来自 {self.country}"
people = [
Student("小明", 18, [88, 92]),
GraduateStudent("小红", 23, [95, 89], advisor="张老师"),
ExchangeStudent("小刚", 20, [76, 83], country="日本"),
]
for person in people:
print(person.introduce())输出:
我是 小明,18 岁,平均分 90.00
我是 小红,23 岁,平均分 92.00,导师是 张老师
我是 小刚,20 岁,平均分 79.50,来自 日本关键点
class GraduateStudent(Student):表示「继承自Student」。子类自动拥有父类的name、age、scores属性和average()方法;super().__init__(name, age, scores)调用父类的构造函数。不写这一行,子类就拿不到name这些属性。几乎每个子类的__init__第一件事都是它;super().introduce()调用父类的方法,子类可以在结果基础上加工。这是复用逻辑最舒服的方式;- 父类叫「基类」或「父类」,子类叫「派生类」或「子类」;
- 子类可以新增属性(
advisor、country),也可以覆盖父类的方法(这里两个子类都重写了introduce)。
super()为什么这么写super()是一个「父类代理」对象,super().introduce()就是「让父类帮我做这件事」。 比直接写Student.introduce(self)更好,因为如果父类换了名字,或者有多个父类(多重继承),super()会自动处理。
Case 53:构建不同的数据处理器——通过继承扩展处理方法#
任务: 基于第 6.2 节的 DataCleaner,创建专门处理「分数」和「年龄」的子类。
class DataCleaner:
"""通用的数据清洗器。"""
def __init__(self, minimum=0, maximum=100):
self.minimum = minimum
self.maximum = maximum
self.records = []
self.issues = []
def load(self, raw_rows):
for index, row in enumerate(raw_rows, start=2):
name = (row.get("name") or "").strip()
raw_value = (row.get("value") or "").strip()
if not name:
self._report(index, "姓名为空")
continue
if not raw_value:
self._report(index, f"{name}:数值为空")
continue
try:
value = float(raw_value)
except ValueError:
self._report(index, f"{name}:数值 {raw_value!r} 不是数字")
continue
if not self.minimum <= value <= self.maximum:
self._report(index, f"{name}:数值 {value} 超出范围")
continue
self.records.append({"name": name, "value": value})
return self
def _report(self, index, message):
self.issues.append(f"第 {index} 行:{message}")
def summary(self):
if not self.records:
return "没有有效数据"
values = [r["value"] for r in self.records]
return (f"有效 {len(values)} 条,平均值 {sum(values) / len(values):.2f},"
f"跳过 {len(self.issues)} 条")
class ScoreCleaner(DataCleaner):
"""专门清洗分数。"""
def __init__(self):
super().__init__(minimum=0, maximum=100)
def grade_distribution(self):
"""子类新增的方法:统计各等级人数。"""
counts = {"A": 0, "B": 0, "C": 0, "D": 0}
for record in self.records:
value = record["value"]
if value >= 90:
counts["A"] += 1
elif value >= 80:
counts["B"] += 1
elif value >= 60:
counts["C"] += 1
else:
counts["D"] += 1
return counts
class AgeCleaner(DataCleaner):
"""专门清洗年龄,范围不同。"""
def __init__(self):
super().__init__(minimum=0, maximum=150)
def age_buckets(self):
"""子类新增的方法:按年龄段分组。"""
buckets = {"未成年": 0, "青年": 0, "中年": 0}
for record in self.records:
value = record["value"]
if value < 18:
buckets["未成年"] += 1
elif value < 40:
buckets["青年"] += 1
else:
buckets["中年"] += 1
return buckets
score_cleaner = ScoreCleaner().load([
{"name": "小明", "value": "92"},
{"name": "小红", "value": "78"},
{"name": "小刚", "value": "150"},
])
print(score_cleaner.summary())
print("等级分布:", score_cleaner.grade_distribution())
age_cleaner = AgeCleaner().load([
{"name": "小明", "value": "17"},
{"name": "小红", "value": "25"},
])
print(age_cleaner.summary())
print("年龄段:", age_cleaner.age_buckets())输出:
有效 2 条,平均值 85.00,跳过 1 条
等级分布: {'A': 1, 'B': 0, 'C': 1, 'D': 0}
有效 2 条,平均值 21.00,跳过 0 条
年龄段: {'未成年': 1, '青年': 1, '中年': 0}关键点
父类放「通用逻辑」,子类放「专属逻辑」。清洗规则是通用的,等级分布和年龄段是特有的;
ScoreCleaner.__init__只做一件事:把范围改成 0-100,再交给父类。super().__init__(...)是子类定制父类行为的入口;isinstance可以检查继承关系:isinstance(score_cleaner, ScoreCleaner) # True isinstance(score_cleaner, DataCleaner) # True —— 它确实是 DataCleaner isinstance(score_cleaner, AgeCleaner) # False「子类 is 父类」成立,反过来不成立。这就是面向对象的「is-a」关系。
什么时候不该用继承? 如果两个类只是「都有几个方法」但职责不同,那应该用组合(一个类里放另一个类的实例),而不是继承。 记住一句口诀:is-a 用继承,has-a 用组合。
Case 54:模拟机器学习模型——使用类与对象组织模型训练和预测流程#
任务: 用类搭一个迷你机器学习框架:数据 → 训练 → 预测 → 评估。
class LinearModel:
"""一元线性模型:y = w * x + b。"""
def __init__(self, learning_rate=0.01, epochs=1000):
self.learning_rate = learning_rate
self.epochs = epochs
self.weight = 0.0
self.bias = 0.0
self.loss_history = []
def predict(self, x):
"""用当前参数预测一个数。"""
return self.weight * x + self.bias
def _loss(self, x, y):
"""均方误差的一半(更利于求导)。"""
return (self.predict(x) - y) ** 2 / 2
def fit(self, x, y):
"""用梯度下降训练。"""
n = len(x)
for epoch in range(self.epochs):
grad_w = 0.0
grad_b = 0.0
for xi, yi in zip(x, y):
error = self.predict(xi) - yi
grad_w += error * xi
grad_b += error
self.weight -= self.learning_rate * grad_w / n
self.bias -= self.learning_rate * grad_b / n
loss = sum(self._loss(xi, yi) for xi, yi in zip(x, y)) / n
self.loss_history.append(loss)
return self
def evaluate(self, x, y):
"""返回平均绝对误差。"""
errors = [abs(self.predict(xi) - yi) for xi, yi in zip(x, y)]
return sum(errors) / len(errors)
def report(self):
loss = self.loss_history[-1] if self.loss_history else 0
return (f"weight={self.weight:.3f}, bias={self.bias:.3f}, "
f"最终 loss={loss:.5f}")
class Pipeline:
"""把清洗、训练、评估串成一条流水线。"""
def __init__(self, model):
self.model = model
self.records = []
def load(self, raw_rows):
for row in raw_rows:
name = (row.get("name") or "").strip()
raw_x = (row.get("x") or "").strip()
raw_y = (row.get("y") or "").strip()
if not name or not raw_x or not raw_y:
continue
try:
x = float(raw_x)
y = float(raw_y)
except ValueError:
continue
self.records.append({"name": name, "x": x, "y": y})
return self
def run(self):
x = [r["x"] for r in self.records]
y = [r["y"] for r in self.records]
if len(x) < 2:
raise ValueError("至少需要两条数据才能训练")
self.model.fit(x, y)
return self
def evaluate(self):
x = [r["x"] for r in self.records]
y = [r["y"] for r in self.records]
return self.model.evaluate(x, y)
raw = [
{"name": "a", "x": "1", "y": "3"},
{"name": "b", "x": "2", "y": "5"},
{"name": "c", "x": "3", "y": "7"},
{"name": "d", "x": "4", "y": "9"},
{"name": "e", "x": "", "y": "11"},
]
pipeline = Pipeline(LinearModel(learning_rate=0.05, epochs=1000)).load(raw).run()
print(pipeline.model.report())
print(f"平均绝对误差:{pipeline.evaluate():.4f}")
print("预测 x=5 的结果:", round(pipeline.model.predict(5), 4))输出:
weight=2.000, bias=1.000, 最终 loss=0.00000
平均绝对误差:0.0001
预测 x=5 的结果: 11.0001关键点
- 这个
LinearModel和真正的LinearRegression做的事情几乎一样——梯度下降就是「算误差 → 按误差调整参数」; predict()是推理,fit()是训练。这是所有机器学习框架的核心接口划分;Pipeline用组合(持有self.model)而不是继承,把「数据流」和「模型」解耦。想换成别的模型,只需传一个别的对象进来;loss_history记录每一轮的损失,就像训练时打印的那条下降曲线。真实项目里画出这条曲线,是判断训练是否正常的第一手段。
你现在已经具备学机器学习的基础了 回看这六章:变量和数据类型(第 1 章)、循环和条件(第 2 章)、列表字典(第 3 章)、函数和模块(第 4、5 章)、类和对象(第 6 章)——机器学习要用的东西,你已经全部学过了。
接下来该学的是库:用 NumPy 基础入门课程 把计算加速,用 Pandas 基础入门课程 把数据处理做得更省事,用 scikit-learn 把上面这个手写的 LinearModel 换成工业级实现。
建议你回头把 Case 54 的代码亲手敲一遍,然后去 NumPy 课程里看看同样的线性回归用数组写出来是什么样子——那个对比会让你对「抽象」这件事有更具体的体感。
本节小结#
| 概念 | 写法 |
|---|---|
| 定义子类 | class 子类(父类): |
| 调用父类初始化 | super().__init__(...) |
| 调用父类方法 | super().method() |
| 判断类型 | isinstance(obj, 子类) |
三条核心规矩:子类自动继承父类能力、super() 是调用父类的标准方式、is-a 用继承而 has-a 用组合。
随堂练习#
- 基于
Student写一个TopStudent子类,额外记录奖学金金额; - 给
LinearModel加一个save(path)方法,把weight和bias写成 JSON 文件; - 用继承的方式,把
Pipeline里的数据清洗部分独立成一个DataLoader类,让Pipeline继承它。
点击查看参考答案
# 练习 1
class TopStudent(Student):
def __init__(self, name, age, scores=None, scholarship=0):
super().__init__(name, age, scores)
self.scholarship = scholarship
def introduce(self):
return f"{super().introduce()},获得奖学金 {self.scholarship} 元"
print(TopStudent("小明", 18, [95, 96], scholarship=5000).introduce())
# 练习 2
import json
class LinearModel:
# ... 省略其他方法 ...
def save(self, path):
with open(path, "w", encoding="utf-8") as f:
json.dump({"weight": self.weight, "bias": self.bias}, f)
# 练习 3
class DataLoader:
def __init__(self):
self.records = []
def load(self, raw_rows):
for row in raw_rows:
try:
self.records.append({
"name": (row.get("name") or "").strip(),
"x": float(row.get("x")),
"y": float(row.get("y")),
})
except (TypeError, ValueError):
continue
return self
class Pipeline(DataLoader):
def __init__(self, model):
super().__init__()
self.model = model练习 3 里 Pipeline(DataLoader) 表示「流水线是一种数据加载器」。不过严格说,Pipeline 和 DataLoader 是「has-a」关系,用组合(self.loader = DataLoader())其实更合适。两种都行,重要的是理解「继承表达 is-a,组合表达 has-a」。
课程到这里就结束了 六章、18 节、54 个案例,你从一行
Hello World走到了一个能训练、能预测的迷你模型框架。 接下来的路怎么走,推荐顺序是:NumPy 基础入门课程 → Pandas 基础入门课程 → scikit-learn。 想回头复习某个知识点,直接用侧边栏的目录跳转就行。