第 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 第三步:分层写代码(每块功能一个函数)
大程序最容易死于"所有代码糊在一起"。 我们把系统拆成三层:
- 数据层:管文件读写(
load_data/save_data); - 业务层:管逻辑(增删改查、统计、排序);
- 界面层:管菜单循环和输入。
数据层:加载与保存
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)
students.items():把字典变成[(学号, 学生信息), ...]的列表;key=lambda item: item[1]["score"]:每个item是(学号, 信息),取item[1](信息)里的"score"排序——第 16 章 lambda 的实战;reverse=True:从高到低。
运行效果(节选):
===== 学生成绩管理系统 =====
1. 添加学生
...
请选择功能:1
请输入学号:001
请输入姓名:小明
请输入成绩(0~100):88
✅ 添加成功!
自己跑一遍的流程建议:
1. 选 1 添加两三个学生;
2. 选 5 看全部、选 6 看统计、选 7 看排序;
3. 选 0 退出——到文件夹里看一眼 students.json,数据真的存下来了;
4. 再运行一次,选 5——数据还在!这就是"持久化"的奇迹。
🐍"皮皮注:仔细看你刚写的这套代码——数据层管'存取',业务层管'逻辑',界面层管'对话'。这三层分开,以后想改界面(比如换成网页),业务层一行都不用动。这叫分层思想,是软件工程的精髓。你,已经出师一半了!"
【皮皮小课堂】本章要点
- 做项目四步走:需求分析 → 设计数据结构 → 分层写函数 → 拼装测试。
- 数据结构选择:学号当键、信息当值——键唯一、查找快、天然防重。
- JSON:文本版的字典;
json.dump(写文件)、json.load(读文件)、json.dumps(转字符串)、json.loads(转回字典);写中文文件要ensure_ascii=False。 - 分层:数据层 / 业务层 / 界面层,各管各的,方便改。
- 异常兜底:文件不存在、数据损坏、输入非数字,都 try/except 接住。
if __name__ == "__main__":包住主程序,import 时不误跑。- 先验证,后入库:脏数据绝不让它进字典。
【翻车现场】本章的坑
坑 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" 代表?
- A. 学生姓名
- B. 学号
- C. 成绩
- D. 字典的 key 数量
2. (★★) json.dumps(students, ensure_ascii=False) 的作用是?
- A. 把 JSON 文本变成 Python 字典
- B. 把 Python 字典变成 JSON 字符串,并保留中文
- C. 把字典排序
- D. 删除字典
3. (★★) 第一次运行系统,load_data() 应该返回什么?
- A. 抛 FileNotFoundError
- B. 空字典
{} - C.
None - D. 一个长度为 1 的字典
4. (★★) students.pop("001") 执行后会发生什么?
- A. 删除键
"001"及其值,并返回被删除的值 - B. 只删除值,保留键
- C. 报错,字典不能 pop
- D. 返回 True
5. (★★ 多选) 关于这个系统的设计,下列说法正确的是?
- A. 用学号当字典键可以天然防止学号重复
- B. 业务函数应该接收
students作为参数,而不是在函数里自己定义 - C.
if __name__ == "__main__":保证 import 时不误运行主程序 - D. 数据层和业务层分开,方便以后换界面
二、判断题
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 拧成了一台能跑、能存、能防错的'机器'。休息一下,下一部分我们进入一个全新的世界——面向对象。这一次,你不再写'过程',而是开始'扮演上帝,设计角色'。"
📖 下一部分,面向对象编程:类与对象,给代码界的角色化一个妆。