第 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); - 清洗过程、结果、问题清单全在对象里,外部不需要在函数之间传一堆参数。这是封装最实在的好处。
链式调用不止
loadcleaner = 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、错误在发生的地方就抛出来。
随堂练习#
- 给
ScoreAnalyzer加一个@property average,并让它在空数据时返回 0; - 给
ModelConfig加一个__repr__,让调试时打印更有用; - 写一个
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 必须写在最上面。
下一节预告 最后一节我们学继承:让新的类「长出」已有类的能力,然后用它搭出一个完整的机器学习模型——从训练到预测。