第 12 章　动手做一个小项目

12.1项目是什么：成绩统计小工具

我们的项目是：读入一组学生成绩，计算并打印统计报告（平均分、最高分、最低分、及格人数），并把报告保存到文件。

选它是因为：它不大不小，刚好能覆盖我们学过的几乎每一个知识点，而且结果清晰可验证——你一眼就能看出算得对不对。

把「做项目」变成一套工作流：需求 → 设计 → 编码 → 测试

写作业程序，是「想到哪写到哪」；做项目，要用一套成熟的工作流，一共四步，每步都有明确的产出物：

新手最大的坑，是把四步压成一步——拿到题目直接敲代码。后果通常是：写到一半发现需求没想清（到底要不要保存文件？）、块与块缠在一起（读文件的代码里混着算平均）。后面 12.2 到 12.7 的四个版本，恰好就是这套工作流的现场演示：先定需求（12.1），再拆解定契约（12.2），然后按版本增量编码（12.3～12.6），最后整合并测试（12.7）。

12.2拆解需求：把大问题切成小问题

新手最大的误区，是一上来就想写完整代码。正确的方法是：先拆解，再动手。

「成绩统计小工具」这个需求，可以拆成 4 个清晰的子任务：

拆解的验收标准：每个子任务「输入输出一句话说得清」

把需求切成 4 块只是第一步，拆解合格与否有个硬标准：每个子任务的输入是什么、输出是什么，都能用一句话说清。说清输入输出的那张表，就是函数的契约。契约定了，4 个函数就可以分开写、分开测：负责「读」的先把成绩列表造出来，负责「算」的拿现成列表开工，谁也不等谁；将来某个环节要改（比如报告加一栏），只要契约不变，其他函数一行不动。这就是「大问题拆小问题」的全部价值——小问题之间只靠契约咬合，不靠内部细节纠缠。

12.3第一版：硬编码，先跑起来

拆解完后，不要急着写完整版。先写一个最简版本：把成绩「硬编码」（直接写在代码里），只做最核心的「算平均分」，先让程序跑起来。

scores = [88, 76, 95, 61, 82]   # 先直接写死在代码里

total = 0
for s in scores:
    total = total + s
average = total / len(scores)

print("平均分：", average)        # 输出：平均分：80.4

这个 7 行的版本，已经能算出平均分了。它虽然简陋，但验证了核心逻辑是对的——这就是「先跑起来」的意义：尽早看到结果，尽早发现错误。

「最小」指最小闭环，不是最小行数

MVP（最小可用版本）里的「最小」常被误读成「写得越少越好」。它真正的含义是最小闭环：输入 → 处理 → 输出这一整条链路被完整打通，哪怕每个环节都简陋。第一版硬编码成绩、只算平均分，看似偷工减料，其实意义重大——它第一次证明了「数据进得来、算得出、打得印」，核心通路是通的。之后每一版只加一个能力（v2 函数、v3 文件、v4 异常），加完就整版再验一次，这叫增量验证。反面教材是「一次性写完再调」：四五个新能力混在一起出问题，你根本说不清 bug 藏在哪一层——这正是下一章调试要还的债，与其事后还，不如增量时就规避。

scores = []           # 边界：一个成绩都没有

total = 0
for s in scores:      # 循环体一次也不执行，total 还是 0
    total = total + s
average = total / len(scores)   # 0 / 0 → 崩！

print("平均分：", average)      # 这行永远执行不到

12.4第二版：用函数封装

第一版只有一个「算平均」，太零散。现在用第 9 章学的函数，把「算统计」封装成一个独立函数，顺便把最高分、最低分、及格人数都算出来。

def compute_stats(scores):
    total = 0
    highest = scores[0]    # 先假设第一个是最高分
    lowest = scores[0]     # 先假设第一个是最低分
    passed = 0

    for s in scores:
        total = total + s          # 累加求和
        if s > highest:             # 遇到更大的就更新
            highest = s
        if s < lowest:              # 遇到更小的就更新
            lowest = s
        if s >= 60:                # 及格（≥60）
            passed = passed + 1

    average = total / len(scores)
    return average, highest, lowest, passed

scores = [88, 76, 95, 61, 82]
avg, high, low, p = compute_stats(scores)
print(avg, high, low, p)   # 输出：80.4 95 61 4

逐行看几个关键点：

• highest = scores[0]：这是「找最值」的经典套路——先假设第一个最大，遍历时遇到更大的就替换。
• return average, highest, lowest, passed：函数可以一次返回多个值（用逗号隔开），调用时用 avg, high, low, p 一次接收。
• 这里「累加器 + 找最值 + 计数」三种模式叠加在同一个循环里，体现了循环的威力。

找最值的「基准」为什么必须是第一个元素

12.4 的套路是「先假设第一个最大/最小，遇到更强的就替换」。为什么基准不干脆写个 0，还非要 scores[0]？因为0 不是中立起点，它自己就是候选值：一旦所有成绩都是负数（换个场景：全是零下的温度、全为负的偏差），写死 0 的「最大值」会永远是 0——可数据里根本没有 0！基准必须来自数据内部，第一个元素正是「既在数据内、又天然参与比较」的成员。这条教训可以推广成一句口诀：初始化要选「不会说谎」的值：计数器从 0 起（没计数就是 0，诚实）；找最值从第一个元素起（它真的在数据里）；累加器从 0 起（没累加就是 0）。

def bad_max(scores):
    m = 0                     # 基准写死 0
    for s in scores:
        if s > m:
            m = s
    return m

def good_max(scores):
    m = scores[0]             # 基准取第一个元素
    for s in scores:
        if s > m:
            m = s
    return m

print(bad_max([88, 76, 95, 61, 82]))   # 95  ——碰巧对
print(good_max([88, 76, 95, 61, 82]))  # 95
print(bad_max([-12, -30, -7]))        # 0   ——说谎！数据里没有 0
print(good_max([-12, -30, -7]))       # -7  ——正确的最大值

12.5第三版：加文件，持久化

成绩不能总写在代码里——它应该从文件读进来。我们假设有一个 scores.txt 文件，每行一个成绩：

88
76
95
61
82

用第 11 章的文件读写，写一个 load_scores 函数，从文件读入成绩列表：

def load_scores(filename):
    scores = []
    f = open(filename, "r")      # 打开文件（读模式）
    for line in f:               # 逐行读
        scores.append(int(line.strip()))
    f.close()
    return scores

这里有几个新细节：

• for line in f：文件对象可以直接被 for 遍历，每次取一行（一行是一个字符串）。
• line.strip()：去掉每行末尾的换行符（\n）和空白。
• int(...)：把字符串 "88" 转成整数 88——因为文件里读出来的是文字，要转成数字才能计算。

同样，把报告「写」进文件也用函数封装：

def save_report(text, filename):
    f = open(filename, "w")      # 打开文件（写模式）
    f.write(text)
    f.close()

读文件的三段流水：读 → 清洗 → 转换

load_scores 只有 6 行，却串着一条三段式流水线：读（for line in f 拿到一行字符串）→ 清洗（line.strip() 去掉换行符与空白）→ 转换（int(...) 变成整数）。真实世界的成绩文件很少干净：末尾可能多按了回车（多出空行）、录入员可能敲错一个字母、不同系统导出的换行风格还可能不同。三段流水就是为这些「脏东西」准备的防线。先看各段到底在对抗什么：

• 读：文件对象被 for 遍历时每次吐出一整行，行的末尾带着换行符——读到的永远是字符串，这点永远不假。
• 清洗：strip() 把首尾的空白与换行统统剥掉，得到「净内容」；剥完可能是正常数字，也可能是空串（空行）或乱码（脏字）。
• 转换：int() 只认「长得像整数」的净内容，认不出就抛 ValueError——这正是防线发挥作用的地方。

def load_scores_robust(filename):
    scores = []
    skipped = 0
    f = open(filename, "r")
    for line in f:
        clean = line.strip()          # 清洗：去换行与空白
        try:
            scores.append(int(clean))  # 转换：行得通就收下
        except ValueError:
            skipped = skipped + 1     # 行不通：跳过并计数
    f.close()
    return scores, skipped

scores, skipped = load_scores_robust("scores.txt")
print("有效成绩：", scores)   # 有效成绩： [88, 76, 95, 61]
print("跳过行数：", skipped)  # 跳过行数： 2

12.6第四版：加异常，变健壮

现在程序有个隐患：如果 scores.txt 不存在，open 会直接抛异常、程序崩溃。用第 11 章的 try/except 兜住它：

def load_scores(filename):
    scores = []
    try:
        f = open(filename, "r")
        for line in f:
            scores.append(int(line.strip()))
        f.close()
    except FileNotFoundError:
        print("找不到文件", filename, "，返回空列表")
    return scores

这样即使文件不存在，程序也不会崩，而是打印一句提示，返回空列表，继续往下跑。

兜住之后：三选一的「出路」

第 11 章说过 except 兜住后必须给出路。具体到「文件读不到」这个场景，出路有三种：

本项目选第二种，但只兜一半就撒手是不够的：load_scores 兜住文件缺失、返回空列表之后，main 还得接得住这份「空」——这正是完整代码里 if not scores: print("没有数据，程序结束"); return 的由来。异常防线和业务防线首尾相接，程序才真正站得稳。

def load_scores(filename):
    scores = []
    try:
        f = open(filename, "r")
        for line in f:
            scores.append(int(line.strip()))
        f.close()
    except FileNotFoundError:                     # 防线一
        print("找不到文件", filename, "，返回空列表")
    return scores

def main():
    scores = load_scores("scores.txt")   # 拿到 []
    if not scores:                        # 防线二
        print("没有数据，程序结束")
        return
    # ……后面的计算不会执行到

main()

12.7完整代码与逐行回顾

把四个版本合并、串起来，就是最终的程序。我们把整体流程放进一个 main() 函数，让结构清晰：

def load_scores(filename):
    """从文件读取成绩，返回列表"""
    scores = []
    try:
        f = open(filename, "r")
        for line in f:
            scores.append(int(line.strip()))
        f.close()
    except FileNotFoundError:
        print("找不到文件", filename, "，返回空列表")
    return scores


def compute_stats(scores):
    """计算统计信息，返回(平均, 最高, 最低, 及格人数)"""
    if len(scores) == 0:
        return None          # 空列表，没有统计意义
    total = 0
    highest = scores[0]
    lowest = scores[0]
    passed = 0
    for s in scores:
        total = total + s
        if s > highest:
            highest = s
        if s < lowest:
            lowest = s
        if s >= 60:
            passed = passed + 1
    average = total / len(scores)
    return average, highest, lowest, passed


def make_report(scores, stats):
    """把统计结果拼成一段报告文字"""
    avg, high, low, passed = stats
    lines = []
    lines.append("=== 成绩统计报告 ===")
    lines.append("人数：" + str(len(scores)))
    lines.append("平均分：" + str(avg))
    lines.append("最高分：" + str(high))
    lines.append("最低分：" + str(low))
    lines.append("及格人数：" + str(passed))
    return "\n".join(lines)


def save_report(text, filename):
    """把报告写入文件"""
    f = open(filename, "w")
    f.write(text)
    f.close()


def main():
    scores = load_scores("scores.txt")       # ① 读
    if not scores:
        print("没有数据，程序结束")
        return
    stats = compute_stats(scores)             # ② 算
    report = make_report(scores, stats)       # ③ 拼报告
    print(report)                             # 打印到屏幕
    save_report(report, "report.txt")         # ④ 存文件


main()

整个程序的数据流非常清晰，像一条流水线：

代码跑不通怎么办：调试方法论

四个版本合并成一个程序之后，总有一天它跑得通，但结果不对——这比直接崩溃更难受。崩溃有 Traceback 指路（第 11 章），「静悄悄算错」才真考验功夫。调试有两条基本功，都简单得不像技术：

基本功一：打印定位。别盯着代码猜，让程序自己交代中间过程——在关键位置插一行 print(变量)，看看中间量到底等于几。比如某个版本算出平均分 16.4，而验收标准说是 80.4（例题 1 的对账单起作用了）。别乱翻代码，先在循环结束处打一行 print(total)：预期 402，实际打出 82——正好是最后一个成绩！累加环节出了问题，循着 82 这条线索回看循环体，一眼就能看到 total = total + s 被多缩进了一层，根本没进循环，退出循环后才执行了一次（s 停在最后一个值 82）。修复只需删一个缩进——但若没有 print 拍下的 82，这个 bug 够你盯半小时。

基本功二：二分排除。程序长、线索少时，不知道该在哪打点？在程序中段随便打一个：打印值正确，说明前半段无罪，bug 藏在后半段；打印值不对，bug 在前半段。每打一个点就排除一半代码：12 行的程序，第一点后剩 6 行，再一点剩 3 行，三点之内锁定到那一行。这两个基本功与第 11 章「异常即跳转」是一对：异常告诉你程序死在哪，调试打印告诉你程序活到哪、算到哪。图 12-3 画出了这套循环。

测试三件套：正常、边界、异常

调试是「出了事再查」，测试是「没事时先备好对账单」。给这个项目备三组用例，就能把大部分意外拦在上线前：正常用例（常规数据，对答案）、边界用例（空数据、单元素、全同分、刚好压线的 60 与 59）、异常用例（文件不存在、脏数据行）。三件套一旦写好，每次改代码后全量重跑——这叫回归测试：专门防「修好东墙、塌了西墙」。

# ① 正常用例
print(compute_stats([88, 76, 95, 61, 82]))   # (80.4, 95, 61, 5)
# ② 边界用例：单人、空
print(compute_stats([100]))                   # (100.0, 100, 100, 1)
print(compute_stats([]))                       # None（防线：len==0 提前返回）
# ③ 异常用例：文件不存在 → 留给 main 的防线链
# 屏幕依次打印：
#   找不到文件 scores.txt ，返回空列表
#   没有数据，程序结束