与外界打交道 · 文件·异常·模块

第22章 综合项目一:学生成绩管理系统

综合项目一

第 22 章 综合项目一:学生成绩管理系统

📖 本章目标:把函数、字典、循环、异常、文件、JSON 全揉在一起,完成你的第一个"软件"。
学完本章,你会亲手写一个能长期保存数据、能增删改查、还不容易崩的管理系统。
这是全书第一个"大 Boss"。前面 21 章学的每招,今天全部上场。别怕——项目再大,拆成小块,一块一块做,就都是小事。


【开场小剧场】终于要打怪了

学生: 皮皮,我们学了好多招式,啥时候能打一次真正的"怪"?

皮皮: 就是现在!今天做综合项目——学生成绩管理系统。它麻雀虽小五脏俱全:有菜单、有增删改查、能存盘、能防错。

学生: 感觉像开了一家"数据小卖部"?

皮皮: 对!而你就是老板。今天这套流程,跟大厂做"软件"的思路一模一样——先想需求,再分模块,最后拼起来。

学生: 万一拼完有 Bug 呢?

皮皮: (咧嘴一笑)那不是"万一",那是"一定"。Bug 不是你的敌人,它是你写的代码在跟你说话——今天的重点之一,就是听懂它说什么。


22.1 第一步:需求分析(想清楚再动手)

做任何程序,先写"功能清单"。 我们的系统要有:

功能 说明
添加学生 存学号 + 姓名 + 成绩;学号不能重复
删除学生 按学号删除
修改成绩 按学号改成绩
查询学生 按学号查一个人的信息
显示全部 列出所有学生
统计 最高分 / 最低分 / 平均分
排序 按成绩从高到低显示
持久化 退出后数据还在(下次启动能读回来)

其中 持久化(persistence) 是重点:上次第 19 章学的文件读写,这次用更漂亮的 JSON 格式存。

逐项拆解"功能清单"这个习惯:
- 清单写下来,你才知道要写几个函数;
- 每一条对应一个菜单选项(界面层),对应一个业务函数(业务层);
- 功能清单 = 你的施工图纸。没有图纸就开工,十有八九盖成歪楼。

💡 皮皮的开工铁律: "程序再小,先写三行需求。写完需求,你已经赢了一半——因为 80% 的'写崩了',是'没想清楚就开写'造成的。"


22.2 第二步:数据结构(用什么装数据)

我们用一个字典:学号当键,学生的姓名和成绩当值:

students = {
    "001": {"name": "小明", "score": 88},
    "002": {"name": "小红", "score": 92.5},
}

逐行拆解:
- 外层字典:键是学号,值是"一个学生的信息";
- 内层字典:{"name": ..., "score": ...}——这个学生长什么样;
- 所以 students["001"] 得到 {"name": "小明", "score": 88},students["001"]["score"] 得到 88。

好处:按学号查找 O(1),天然防重复(键唯一)。这正是第 13 章"前台登记表"的威力。

换例加深:想加"班级"字段?内层字典直接加

students["001"]["class"] = "三年二班"    # 给已有学生加一个字段

内层是字典,想加什么字段随手加——这就是"字典套字典"的灵活性。

JSON 长啥样? JSON 是"文本版的字典/列表",专门用来跨程序存数据:

{
  "001": { "name": "小明", "score": 88 }
}

和 Python 字典长得几乎一样,但它是纯文本,能存进文件、能在别的语言里读。用 json 模块转换:

import json

json.dumps(students)          # Python 字典 → JSON 字符串
json.loads(json_str)          # JSON 字符串 → Python 字典

逐行拆解:
- json.dumps(...):dumps = dump string,把 Python 对象变成字符串;
- json.loads(...):loads = load string,把字符串变回 Python 对象;
- 读写文件还有一对兄弟:json.dump(数据, 文件) 直接写进文件、json.load(文件) 直接从文件读。

写进文件、读回文件(最常用的组合):

import json

students = {"001": {"name": "小明", "score": 88}}

# 存进文件
with open("students.json", "w", encoding="utf-8") as f:
    json.dump(students, f, ensure_ascii=False, indent=2)

# 读回内存
with open("students.json", "r", encoding="utf-8") as f:
    back = json.load(f)
print(back["001"]["name"])     # 小明

读写文件时记得 ensure_ascii=False,否则中文会变成 \uXXXX 乱码(翻车现场坑 1 细讲)。

🐍"皮皮注:dump/load 是一对'文件版',dumps/loads 是一对'字符串版'。带 s 的记成 s = string(字符串),别搞混。"


22.3 第三步:分层写代码(每块功能一个函数)

大程序最容易死于"所有代码糊在一起"。 我们把系统拆成三层:

  1. 数据层:管文件读写(load_data / save_data);
  2. 业务层:管逻辑(增删改查、统计、排序);
  3. 界面层:管菜单循环和输入。

数据层:加载与保存

import json

DATA_FILE = "students.json"

def load_data():
    try:
        with open(DATA_FILE, "r", encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        return {}          # 第一次运行,还没有文件
    except json.JSONDecodeError:
        print("数据文件损坏,已重置。")
        return {}

def save_data(students):
    with open(DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(students, f, ensure_ascii=False, indent=2)

逐行拆解 load_data:
- open(DATA_FILE, "r", ...) 读文件 → json.load(f) 把 JSON 文本变回字典;
- except FileNotFoundError: return {}:第一次运行文件还不存在 → 返回空字典,程序继续;
- except json.JSONDecodeError::文件被手改坏了 → 友好提示 + 返回空字典;
- 两个 try 兜底,保证"不管文件出啥事,程序都不崩"。

逐行拆解 save_data:
- json.dump(students, f, ...):把字典直接写进文件(注意是 dump,不是 dumps);
- ensure_ascii=False:保留中文;
- indent=2:每层缩进 2 格,文件里更好看(不写也能存,就是挤成一行)。

业务层:添加学生(带查重 + 异常)

def add_student(students):
    sid = input("请输入学号:")
    if sid in students:
        print("❌ 学号已存在,不能重复添加!")
        return
    name = input("请输入姓名:")
    try:
        score = float(input("请输入成绩(0~100):"))
    except ValueError:
        print("❌ 成绩必须是个数字!")
        return
    students[sid] = {"name": name, "score": score}
    print("✅ 添加成功!")

逐行拆解:
- if sid in students::先查重——学号已经存在就拒绝,return 提前退出;
- try: score = float(...) except ValueError:输入的不是数字 → 友好提示 + return;
- students[sid] = {...}:都通过了,才真正写入字典;
- "先验证,后入库"——脏数据绝不让它进来。

界面层:菜单循环

def show_menu():
    print("\n===== 学生成绩管理系统 =====")
    print("1. 添加学生")
    print("2. 删除学生")
    print("3. 修改成绩")
    print("4. 查询学生")
    print("5. 显示全部")
    print("6. 统计(最高/最低/平均)")
    print("7. 按成绩排序显示")
    print("0. 保存并退出")
    print("============================")

def main():
    students = load_data()
    while True:
        show_menu()
        choice = input("请选择功能:")
        if choice == "1":
            add_student(students)
        elif choice == "2":
            delete_student(students)
        elif choice == "0":
            save_data(students)
            print("已保存,再见!")
            break
        # ... 其余选项同理

if __name__ == "__main__":
    main()

逐行拆解 main:
- students = load_data():启动时先把数据从文件读进内存(没有就空字典);
- while True::菜单循环——不选退出就一直转;
- choice = input(...):读用户选的数字;
- 一堆 elif:只做"转发",把命令交给对应的业务函数;
- choice == "0":save_data(students) 把内存数据写回文件,break 退出。

为什么每个功能一个函数? 因为"删除学生"的代码会很长,全堆在 while True 里,菜单循环会乱成一锅粥。函数 = 把大问题切成小问题,这是程序员最重要的思维。

💡 注意 main() 里每个业务函数都要传 students 参数——函数不偷偷用全局变量(第 17 章学的),数据怎么进怎么出,清清楚楚。


22.4 第四步:完整代码(装起来!)

把所有功能补齐,完整代码放在 code/ch22/student_system.py(约 150 行)。运行它,输入菜单数字就能操作。

完整代码:

import json

DATA_FILE = "students.json"

# ---------- 数据层 ----------

def load_data():
    try:
        with open(DATA_FILE, "r", encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        return {}
    except json.JSONDecodeError:
        print("数据文件损坏,已重置。")
        return {}

def save_data(students):
    with open(DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(students, f, ensure_ascii=False, indent=2)

# ---------- 业务层 ----------

def add_student(students):
    sid = input("请输入学号:")
    if sid in students:
        print("❌ 学号已存在,不能重复添加!")
        return
    name = input("请输入姓名:")
    try:
        score = float(input("请输入成绩(0~100):"))
    except ValueError:
        print("❌ 成绩必须是个数字!")
        return
    students[sid] = {"name": name, "score": score}
    print("✅ 添加成功!")

def delete_student(students):
    sid = input("请输入要删除的学号:")
    if sid not in students:
        print("❌ 没找到这个学号!")
        return
    students.pop(sid)
    print("✅ 删除成功!")

def update_student(students):
    sid = input("请输入要修改的学号:")
    if sid not in students:
        print("❌ 没找到这个学号!")
        return
    try:
        score = float(input("请输入新成绩(0~100):"))
    except ValueError:
        print("❌ 成绩必须是个数字!")
        return
    students[sid]["score"] = score
    print("✅ 修改成功!")

def search_student(students):
    sid = input("请输入要查询的学号:")
    if sid not in students:
        print("❌ 没找到这个学号!")
        return
    s = students[sid]
    print(f"学号:{sid}  姓名:{s['name']}  成绩:{s['score']}")

def show_all(students):
    if not students:
        print("(还没有学生数据)")
        return
    print("\n--- 全体学生成绩单 ---")
    for sid, s in students.items():
        print(f"{sid}  {s['name']}  {s['score']}")

def show_stats(students):
    if not students:
        print("(还没有学生数据)")
        return
    scores = [s["score"] for s in students.values()]
    print(f"最高分:{max(scores)}")
    print(f"最低分:{min(scores)}")
    print(f"平均分:{sum(scores) / len(scores):.2f}")

def sort_by_score(students):
    if not students:
        print("(还没有学生数据)")
        return
    ranked = sorted(students.items(),
                    key=lambda item: item[1]["score"], reverse=True)
    print("\n--- 按成绩排序(高→低) ---")
    for sid, s in ranked:
        print(f"{s['name']}({sid}):{s['score']}")

# ---------- 界面层 ----------

def show_menu():
    print("\n===== 学生成绩管理系统 =====")
    print("1. 添加学生")
    print("2. 删除学生")
    print("3. 修改成绩")
    print("4. 查询学生")
    print("5. 显示全部")
    print("6. 统计(最高/最低/平均)")
    print("7. 按成绩排序显示")
    print("0. 保存并退出")
    print("============================")

def main():
    students = load_data()
    while True:
        show_menu()
        choice = input("请选择功能:")
        if choice == "1":
            add_student(students)
        elif choice == "2":
            delete_student(students)
        elif choice == "3":
            update_student(students)
        elif choice == "4":
            search_student(students)
        elif choice == "5":
            show_all(students)
        elif choice == "6":
            show_stats(students)
        elif choice == "7":
            sort_by_score(students)
        elif choice == "0":
            save_data(students)
            print("已保存,再见!")
            break
        else:
            print("❌ 没有这个选项,请重新输入!")

if __name__ == "__main__":
    main()

几个你可能看不懂的地方,逐行拆解:

scores = [s["score"] for s in students.values()]

第 14 章的列表推导式在这里大显身手:把所有学生的成绩"摘"出来,凑成一个列表,再喂给 max/min/sum。

ranked = sorted(students.items(),
                key=lambda item: item[1]["score"], reverse=True)

运行效果(节选):

===== 学生成绩管理系统 =====
1. 添加学生
...
请选择功能:1
请输入学号:001
请输入姓名:小明
请输入成绩(0~100):88
✅ 添加成功!

自己跑一遍的流程建议:
1. 选 1 添加两三个学生;
2. 选 5 看全部、选 6 看统计、选 7 看排序;
3. 选 0 退出——到文件夹里看一眼 students.json,数据真的存下来了;
4. 再运行一次,选 5——数据还在!这就是"持久化"的奇迹。

🐍"皮皮注:仔细看你刚写的这套代码——数据层管'存取',业务层管'逻辑',界面层管'对话'。这三层分开,以后想改界面(比如换成网页),业务层一行都不用动。这叫分层思想,是软件工程的精髓。你,已经出师一半了!"


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 1:json.dump 中文变成 \uXXXX

json.dump(students, f)     # ❌ 文件里全是 明小

改正:

json.dump(students, f, ensure_ascii=False)   # 保留中文

ensure_ascii=True 是默认值,会把非 ASCII 字符转成转义符。写中文一定要 ensure_ascii=False。

坑 2:第一次运行文件不存在,直接崩

open(DATA_FILE, "r") 第一次运行根本没这个文件 → FileNotFoundError。在 load 里用 try 接住,返回空字典。

坑 3:json 文件被手改坏了,load 崩

手动编辑 JSON 少个括号,json.load 抛 JSONDecodeError。同样用 try 接住,给个友好提示。

坑 4:把 JSON 和 Python 字典划等号

JSON 和 Python 字典长得像,但 JSON 是文本格式,没有 True 只有 true、没有单引号、键必须双引号。跨程序传数据用 JSON,程序内部运算还是用 Python 对象。

坑 5:所有功能堆在 while 里

菜单循环里直接写几十行增删改查逻辑,循环体爆炸、没法复用。每个功能抽成函数,循环只负责"转发"。

坑 6:业务函数忘了收 students 参数

def add_student():          # ❌ 没参数
    students = {}           # 自己建一个空字典,每次调用都是新的!

如果不把 students 传进去,函数里自己 students = {},那每次调用都是一个新的空字典,数据全丢。业务函数必须接收同一个 students,所有函数操作的是同一份数据。


【本章习题】

一、选择题

1. (★) 项目里用 students = {"001": {"name": "小明", "score": 88}} 存数据,键 "001" 代表?

2. (★★) json.dumps(students, ensure_ascii=False) 的作用是?

3. (★★) 第一次运行系统,load_data() 应该返回什么?

4. (★★) students.pop("001") 执行后会发生什么?

5. (★★ 多选) 关于这个系统的设计,下列说法正确的是?

二、判断题

1. (★) JSON 文件是纯文本,可以在 Python 和其他语言之间交换数据。( )

2. (★★) students.pop(sid) 删除键的同时会返回被删除的值。( )

3. (★★) 系统的数据只存在内存里,关掉程序再打开,数据还在。( )

4. (★★) json.load(f) 是把文件里的 JSON 文本读出来,变回 Python 对象。( )

三、代码纠错题

1. (★★) 下面的保存函数把中文存成了 \u 转义序列,请改正:

import json

def save_data(students):
    with open("students.json", "w", encoding="utf-8") as f:
        json.dump(students, f)

2. (★★) 下面的 add_student 每次调用数据都会丢,请指出问题并改正:

def add_student():
    students = {}
    sid = input("请输入学号:")
    name = input("请输入姓名:")
    students[sid] = {"name": name}
    print("添加成功!")

# main 里这样调用:
students = load_data()
add_student()
print(students)    # 还是空的!

四、编程实战题

1. (基础 ★) 给系统加一个功能:按姓名查询。输入姓名,打印所有同名学生的学号和成绩(提示:遍历 students.items(),比对 s['name'])。

2. (基础 ★★) 给系统加一个功能:显示不及格名单(成绩 < 60),列出所有不及格学生的姓名和成绩。

3. (基础 ★★) 给系统加一个功能:按学号修改姓名(不只是成绩)。设计好函数 rename_student(students),并在菜单里加一个选项。

4. (挑战 ★★★) 给系统加一个功能:按成绩区间筛选。函数 search_by_range(students) 让用户输入最低分和最高分,打印成绩落在这个区间内的所有学生(含边界),并按成绩从高到低显示。

五、思考题(不写代码,想清楚再回答)

1. (★★) 如果要求"学号不能重复",除了"添加时检查 sid in students",还能怎么保证?如果两个程序同时往一个文件里写,会发生什么?



【参考答案与解析】

一、选择题

1. 答案:B
键是学号,值是包含姓名和成绩的字典。

2. 答案:B
dumps 字典→JSON 字符串;ensure_ascii=False 保留中文不转义。

3. 答案:B
第一次运行没有数据文件,返回空字典,后续添加学生往里填。

4. 答案:A
dict.pop(key) 删除该键值对,并返回被删除的值。这里被删的是 {"name": "小明", "score": 88}。

5. 答案:A、B、C、D
A 对:字典键唯一;B 对:函数接收参数,不依赖全局变量,可测试、可复用;C 对:__main__ 判断;D 对:分层的好处。

二、判断题

1. 正确(√)。JSON 是通用文本格式。

2. 正确(√)。dict.pop(key) 删除并返回该键的值。

3. 错误(×)。内存数据关机即失;只有 save_data 写到 JSON 文件后,重启再 load_data 才还在。这就是"持久化"的意义。

4. 正确(√)。json.load(文件) 从文件读取 JSON 文本并转回 Python 对象。

三、代码纠错题

1. 解析: 默认 ensure_ascii=True 会把中文转成 \u 转义。改正:

import json

def save_data(students):
    with open("students.json", "w", encoding="utf-8") as f:
        json.dump(students, f, ensure_ascii=False, indent=2)

2. 解析: add_student 没有接收 students 参数,自己在函数里 students = {}——每次调用都是新的空字典,数据全丢。改正:让函数接收并操作同一个 students:

def add_student(students):
    sid = input("请输入学号:")
    if sid in students:
        print("❌ 学号已存在!")
        return
    name = input("请输入姓名:")
    students[sid] = {"name": name}
    print("添加成功!")

# main 里这样调用:
students = load_data()
add_student(students)     # 把同一个字典传进去
print(students)           # 能看到刚加的学生

核心: 所有业务函数必须操作同一份 students 数据——用参数传进去,别在函数里自己建。

四、编程实战题

1. 参考代码:

def search_by_name(students):
    name = input("请输入要查询的姓名:")
    found = False
    for sid, s in students.items():
        if s["name"] == name:
            print(f"学号:{sid}  姓名:{s['name']}  成绩:{s['score']}")
            found = True
    if not found:
        print("❌ 没找到这个姓名!")

# 在菜单里加:elif choice == "8": search_by_name(students)

2. 参考代码:

def show_failed(students):
    failed = {sid: s for sid, s in students.items() if s["score"] < 60}
    if not failed:
        print("🎉 没有不及格的学生!")
        return
    print("\n--- 不及格名单 ---")
    for sid, s in failed.items():
        print(f"{s['name']}({sid}):{s['score']}")

3. 参考代码:

def rename_student(students):
    sid = input("请输入要改名的学号:")
    if sid not in students:
        print("❌ 没找到这个学号!")
        return
    new_name = input("请输入新姓名:")
    students[sid]["name"] = new_name
    print("✅ 改名成功!")

# 菜单里加:elif choice == "9": rename_student(students)
# 记得把菜单文字也加上"9. 修改姓名"

4. 参考代码:

def search_by_range(students):
    try:
        low = float(input("请输入最低分:"))
        high = float(input("请输入最高分:"))
    except ValueError:
        print("❌ 请输入数字!")
        return
    if low > high:
        print("❌ 最低分不能大于最高分!")
        return

    result = [(sid, s) for sid, s in students.items()
              if low <= s["score"] <= high]
    result.sort(key=lambda item: item[1]["score"], reverse=True)

    if not result:
        print("这个区间内没有学生。")
        return
    print(f"\n--- {low} ~ {high} 分的学生(高→低) ---")
    for sid, s in result:
        print(f"{s['name']}({sid}):{s['score']}")

拆解: 先校验输入(数字、区间合法),再用列表推导式筛出区间内的人,sort(key=lambda...) 按成绩从高到低,最后打印。

五、思考题

1. 参考思路:
- 除了"添加时检查",还可以:用学号当字典键本身就保证唯一(后写的会覆盖);也可以在文件层做校验,加载时如果发现重复学号就报错提示。
- 两个程序同时写一个文件:后写者会覆盖先写者的内容(因为 "w" 先清空),可能互相"打架"丢失数据。真实系统会用数据库的锁/事务解决。思考到这里,你已经摸到并发问题的门槛了——这正是数据库要解决的核心问题之一。

🐍"皮皮注:恭喜你,完成了第一个综合项目!你亲手把函数、字典、循环、异常、文件、JSON 拧成了一台能跑、能存、能防错的'机器'。休息一下,下一部分我们进入一个全新的世界——面向对象。这一次,你不再写'过程',而是开始'扮演上帝,设计角色'。"


📖 下一部分,面向对象编程:类与对象,给代码界的角色化一个妆。

📦 本章配套代码

运行方式:命令行进入目录后执行 py 文件名.py(Windows)或 python3 文件名.py(Mac/Linux)