返回首页

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

第 6.2 节 封装:组织数据与处理逻辑#

预计学习时长: 30 分钟

本节目标:

  • 知道封装是「把数据和操作它的逻辑放在一起,并对外只暴露必要接口」;
  • 会用 @property 把属性变成受保护的读写接口;
  • 会设计一个「数据处理器」类,把清洗逻辑收进去;
  • 会用一个类封装机器学习模型的超参数配置。

封装要解决什么问题#

看这段代码:

class Student:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score


student = Student("小明", 18, 92)
student.score = 500        # 分数怎么可能是 500?

属性是公开的,谁都能改。数据一旦被改坏,错误往往在很远的地方才爆出来,排查起来非常痛苦。

封装的做法是:把属性藏起来,只提供「安全的方法」让外面用。

Case 49:构建成绩分析对象——封装数据与统计方法#

任务: 设计一个 ScoreAnalyzer,对外只提供统计方法,成绩数据由它自己保管。

class ScoreAnalyzer:
    """封装一组成绩,并提供各种统计方法。"""

    def __init__(self, scores=None):
        self._scores = []
        if scores:
            self.add_all(scores)

    # 对外的接口:添加成绩
    def add_all(self, scores):
        for score in scores:
            self.add(score)

    def add(self, score):
        """添加一个分数,不合法时直接拒绝。"""
        if not isinstance(score, (int, float)):
            raise TypeError(f"分数必须是数字,收到 {type(score).__name__}")
        if not 0 <= score <= 100:
            raise ValueError(f"分数必须在 0 到 100 之间,收到 {score}")
        self._scores.append(float(score))

    # 对外的接口:取数据
    @property
    def scores(self):
        """返回成绩列表的副本,外部改不到内部数据。"""
        return list(self._scores)

    @property
    def count(self):
        return len(self._scores)

    @property
    def average(self):
        return sum(self._scores) / len(self._scores) if self._scores else 0

    def summary(self):
        return (f"共 {self.count} 个成绩,平均分 {self.average:.2f},"
                f"最高 {max(self._scores) if self._scores else 0},"
                f"最低 {min(self._scores) if self._scores else 0}")


analyzer = ScoreAnalyzer([88, 95, 76])
analyzer.add(61)

print(analyzer.summary())
print("取出来的成绩:", analyzer.scores)

try:
    analyzer.add(150)
except ValueError as e:
    print("被拒绝了:", e)

输出:

共 4 个成绩,平均分 80.00,最高 95.0,最低 61.0
取出来的成绩: [88.0, 95.0, 76.0, 61.0]
被拒绝了: 分数必须在 0 到 100 之间,收到 150

关键点

  • 属性名以 _ 开头是 Python 的约定,表示「这是内部使用的,外部别直接碰」。它不是强制private,但所有人都遵守这个约定;
  • @property 把一个方法伪装成属性。写 analyzer.average 不带括号,拿到的是算好的值;写 analyzer.summary() 带括号,因为 summary 是普通方法;
  • scores 这个 property 返回的是 list(self._scores)——一份拷贝。外部拿到后随便改,也不会影响内部数据;
  • raise 是主动抛出异常。这里用它拒绝非法数据,让错误在发生的地方就暴露出来,而不是留到后面统计时才出错。

@property 什么时候用?

  • 只是设置和读取一个值 → 普通属性就够了(self.name = name);
  • 读取时需要计算(比如平均值)→ 用 @property;
  • 设置时需要校验(比如分数必须在 0-100)→ 用 @property + @分数.setter。

记住一条原则:外部读到的永远是「有效状态」,不可能读到坏数据。

Case 50:创建数据处理器——使用对象完成数据清洗#

任务: 把第 5 章的清洗逻辑封装成一个 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_score = (row.get("score") or "").strip()

            if not name:
                self._report(index, "姓名为空")
                continue
            if not raw_score:
                self._report(index, f"{name}:成绩缺失")
                continue

            try:
                score = float(raw_score)
            except ValueError:
                self._report(index, f"{name}:成绩 {raw_score!r} 不是数字")
                continue

            if not self.minimum <= score <= self.maximum:
                self._report(index, f"{name}:成绩 {score} 超出范围")
                continue

            self.records.append({"name": name, "score": score})

        return self

    def _report(self, index, message):
        self.issues.append(f"第 {index} 行:{message}")

    def summary(self):
        if not self.records:
            return "没有有效数据"
        scores = [r["score"] for r in self.records]
        return (f"有效 {len(scores)} 条,平均分 {sum(scores) / len(scores):.2f},"
                f"跳过 {len(self.issues)} 条")


raw = [
    {"name": "小明", "score": "92"},
    {"name": "小红", "score": "78"},
    {"name": "小刚", "score": ""},
    {"name": "小丽", "score": "abc"},
    {"name": "小强", "score": "150"},
]

cleaner = DataCleaner().load(raw)

print(cleaner.summary())
print("有效数据:", cleaner.records)
print("问题清单:")
for issue in cleaner.issues:
    print("  -", issue)

输出:

有效 2 条,平均分 85.00,跳过 3 条
有效数据: [{'name': '小明', 'score': 92.0}, {'name': '小红', 'score': 78.0}]
问题清单:
  - 第 4 行:小刚:成绩缺失
  - 第 5 行:小丽:成绩 'abc' 不是数字
  - 第 6 行:小强:成绩 150.0 超出范围

关键点

  • load() 返回 self,这是「链式调用」的常见写法:DataCleaner().load(raw) 一行完成创建和载入;
  • _report 以 _ 开头,是类的内部方法,外部不该调用;
  • 把 minimum / maximum 做成构造参数,这个清洗器就能复用到别的场景(比如清洗「体温」只要传 minimum=35, maximum=42);
  • 清洗过程、结果、问题清单全在对象里,外部不需要在函数之间传一堆参数。这是封装最实在的好处。

链式调用不止 load

cleaner = DataCleaner().load(raw)     # load 返回 self,链式调用能一路串下去
print(cleaner.summary())

每个方法都返回 self,就能一路串下去。比如再实现 sort_by_score() 和 top(10) 两个方法, 就能写成 DataCleaner().load(raw).sort_by_score().top(10)。 这类写法在 Pandas 里也很常见(df.dropna().sort_values().head())。

Case 51:构建模型配置对象——封装机器学习模型的参数#

任务: 用一个类封装训练超参数,并自动检查配置是否合理。

class ModelConfig:
    """机器学习模型的超参数配置。"""

    def __init__(self, learning_rate=0.001, epochs=100, batch_size=32,
                 model_name="linear_regression"):
        self.model_name = model_name
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.batch_size = batch_size
        self._validate()

    def _validate(self):
        if not 0 < self.learning_rate < 1:
            raise ValueError(f"学习率必须在 0 和 1 之间,收到 {self.learning_rate}")
        if self.epochs <= 0:
            raise ValueError(f"训练轮数必须大于 0,收到 {self.epochs}")
        if self.batch_size <= 0:
            raise ValueError(f"批大小必须大于 0,收到 {self.batch_size}")

    def as_dict(self):
        """返回配置字典,方便保存成 JSON 或传给训练函数。"""
        return {
            "model_name": self.model_name,
            "learning_rate": self.learning_rate,
            "epochs": self.epochs,
            "batch_size": self.batch_size,
        }

    def __str__(self):
        return (f"{self.model_name}(lr={self.learning_rate}, "
                f"epochs={self.epochs}, batch_size={self.batch_size})")


config = ModelConfig(learning_rate=0.01, epochs=200)
print(config)
print(config.as_dict())

try:
    ModelConfig(learning_rate=5)
except ValueError as e:
    print("配置无效:", e)

输出:

linear_regression(lr=0.01, epochs=200, batch_size=32)
{'model_name': 'linear_regression', 'learning_rate': 0.01, 'epochs': 200, 'batch_size': 32}
配置无效: 学习率必须在 0 和 1 之间,收到 5

关键点

  • 配置在构造时就校验(_validate() 在 __init__ 末尾调用)。这样一份非法的配置根本创建不出来,而不是等到训练跑了一小时才报错;
  • as_dict() 让配置能存进 JSON、传给训练函数、或者打印出来。类 → 字典是项目中常见的桥接方式;
  • __str__ 是特殊方法,定义了之后 print(config) 就会用你的格式,而不是打印一串 object at 0x...;
  • __init__ 里每个参数都有默认值,所以 ModelConfig() 就能用。默认值要选合理——learning_rate=0.001、batch_size=32 都是业界常用起点。

配置文件是机器学习项目的标配 把超参数从代码里抽出来,你才能:跑多个实验做对比、把配置存进 git 追踪变化、在不同机器上复现同样的结果。 有了 ModelConfig 这个类打底,后面接 JSON、接命令行参数、接配置文件都是水到渠成的事。

本节小结#

手段写法作用
内部属性self._data约定「外部别直接碰」
只读属性@property读取时自动计算
属性赋值校验@x.setter写入时检查合法性
主动抛错raise ValueError("...")在出错点立刻暴露问题
特殊方法__str__定义打印格式

三条核心规矩:数据用 _ 开头表示内部、读取接口用 @property、错误在发生的地方就抛出来。

随堂练习#

  1. 给 ScoreAnalyzer 加一个 @property average,并让它在空数据时返回 0;
  2. 给 ModelConfig 加一个 __repr__,让调试时打印更有用;
  3. 写一个 TemperatureValidator 类:接收温度,超过 35 到 42 的范围时抛 ValueError,并提供一个 is_fever() 方法判断是否发烧。
点击查看参考答案
# 练习 3
class TemperatureValidator:
    """体温校验器。"""

    NORMAL_LOW = 35
    NORMAL_HIGH = 42

    def __init__(self, celsius):
        self.celsius = self._validate(celsius)

    @staticmethod
    def _validate(value):
        if not isinstance(value, (int, float)):
            raise TypeError("体温必须是数字")
        if not TemperatureValidator.NORMAL_LOW <= value <= TemperatureValidator.NORMAL_HIGH:
            raise ValueError(f"体温 {value} 超出正常范围 "
                             f"{TemperatureValidator.NORMAL_LOW}-"
                             f"{TemperatureValidator.NORMAL_HIGH}")
        return float(value)

    def is_fever(self):
        return self.celsius >= 37.3


print(TemperatureValidator(36.5).is_fever())

练习 3 里用了 @staticmethod——它修饰的方法不需要 self,只是放在类里方便归类。和 @property 搭配时,@property 必须写在最上面。

下一节预告 最后一节我们学继承:让新的类「长出」已有类的能力,然后用它搭出一个完整的机器学习模型——从训练到预测。

阅读 --