返回首页

Roadmap
更新于 2026年11月14日 全文 1324 字未阅读

第 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 用组合。

随堂练习#

  1. 基于 Student 写一个 TopStudent 子类,额外记录奖学金金额;
  2. 给 LinearModel 加一个 save(path) 方法,把 weight 和 bias 写成 JSON 文件;
  3. 用继承的方式,把 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。 想回头复习某个知识点,直接用侧边栏的目录跳转就行。

阅读 --