第 30 章 毕业项目:命令行待办清单(To-Do)
📖 本章目标:把全书学的所有功夫拧成一台真正能用的"软件"。
学完本章,你就拥有了自己的第一个完整作品——一台会保存、会排序、还不容易崩的待办机器。
这一章不是学新语法,而是"验收"——看看这 29 章修炼下来的你,能不能独立造出一台能用的机器。
【开场小剧场】最后一战
学生: 皮皮,说好的毕业项目呢?今天要打最终 BOSS 了吧!
皮皮: 就是今天!我们要做命令行待办清单(To-Do List)——一个能记录任务、标记完成、按优先级排序、退出后数据还在的完整程序。
学生: 感觉要把所有武功都用到?
皮皮: 对!类与对象(第 23~25 章)、JSON 存取(第 22 章)、异常处理(第 20 章)、异常兜底、菜单循环……全在里面。打完这一仗,你就出师了。
学生: 那我从哪开始?
皮皮: 记住做软件的铁律:先想清楚要做什么,再写一行代码。 老板不会让你上来就写——第一步永远是"需求分析"。
30.1 需求分析:这台机器要会什么
第一步永远是列功能清单:
| 功能 | 说明 |
|---|---|
| 添加任务 | 标题 + 优先级(1低/2中/3高)+ 截止日期 |
| 查看全部 | 列出所有任务(带编号) |
| 标记完成 | 按编号把任务打勾 ✓ |
| 删除任务 | 按编号删除 |
| 查看待办 | 只看未完成的,按优先级从高到低排 |
| 持久化 | 退出自动保存,重启数据还在 |
| 防错 | 乱输入数字、损坏数据,都不崩 |
把需求拆成功能清单,是程序员开工前的第一件事。 功能定了,后面每一步都是在"逐条实现这张表"。这张表就是你的施工图。
💡 先设计,再动手:列完清单你会发现——"哪些功能用类、哪些用函数、存到哪"都清楚了。跳过需求分析直接写代码,写到一半一定返工。
30.2 第 1 步:Task 类(一张"任务卡片")
面向对象,先想"世界里有哪些角色"。 第一个角色:单个任务。
from datetime import datetime
class Task:
def __init__(self, title, priority=1, due=None):
self.title = title
self.done = False
self.priority = priority # 1低 / 2中 / 3高
self.due = due # 截止日期或 None
self.created = datetime.now().strftime("%Y-%m-%d %H:%M")
def mark_done(self):
self.done = True
def __str__(self):
mark = "✓" if self.done else " "
due_str = f" 截止:{self.due}" if self.due else ""
return f"[{mark}] P{self.priority} {self.title}{due_str}"
逐行拆解:
- __init__(self, title, priority=1, due=None):构造方法,接收三个参数,都带默认值;
- self.done = False:新任务默认未完成;
- self.created:记录创建时间(第 29 章 datetime 的 strftime);
- mark_done(self):一个方法,把 done 改成 True;
- __str__(self):魔法方法(第 25 章)——打印任务时显示成好看的样子;
- mark = "✓" if self.done else " ":完成打勾,没完成留空格;
- due_str:有截止日期才显示"截止:xxx"。
为持久化做准备: 加一对"翻译官"——任务 ↔ 字典互转:
def to_dict(self):
"""任务 → 字典(方便 JSON 存)"""
return {
"title": self.title, "done": self.done,
"priority": self.priority, "due": self.due,
"created": self.created,
}
@classmethod
def from_dict(cls, data):
"""字典 → 任务(方便 JSON 读)"""
task = cls(data["title"])
task.done = data["done"]
task.priority = data["priority"]
task.due = data["due"]
task.created = data["created"]
return task
逐行拆解:
- to_dict:把任务对象拆成普通字典——JSON 只能存字典、列表,不能存对象,所以必须先翻译;
- from_dict(data):反着来,从字典重建任务;
- @classmethod:类方法——不需要实例就能调用,TodoList 里一句 Task.from_dict(d) 就能批量重建。
🐍"皮皮注:
@classmethod表示这是'类方法'——不用实例就能调用,专门用来从字典'重建'任务。你在第 24 章见过super(),这又是 OOP 的一个好工具。先会用,原理后面自己体会。"
换例加深:亲眼看看这对"翻译官"
t = Task("背单词", priority=3)
d = t.to_dict()
print(d) # {'title': '背单词', 'done': False, ...}
t2 = Task.from_dict(d) # 从字典再变回一个任务
print(t2) # [ ] P3 背单词
print(t2.title) # 背单词 —— 和原来一模一样
to_dict 是"进存档",from_dict 是"读存档"。 有了它俩,任务想存就存、想取就取。
30.3 第 2 步:TodoList 类(任务大管家)
第二个角色:管理一堆任务的管家。
class TodoList:
def __init__(self):
self.tasks = []
def add(self, title, priority=1, due=None):
self.tasks.append(Task(title, priority, due))
print(f"✅ 已添加:{title}")
def list_all(self):
for i, t in enumerate(self.tasks, 1): # enumerate 带编号
print(f"{i}. {t}")
def mark_done(self, index):
if not (1 <= index <= len(self.tasks)):
print("❌ 没有这个编号!")
return
self.tasks[index - 1].mark_done()
def delete(self, index):
if not (1 <= index <= len(self.tasks)):
print("❌ 没有这个编号!")
return
removed = self.tasks.pop(index - 1)
print(f"🗑 已删除:{removed.title}")
def show_pending(self):
"""只看未完成,按优先级高→低"""
pending = [t for t in self.tasks if not t.done]
pending.sort(key=lambda t: t.priority, reverse=True) # lambda 排序
for t in pending:
print(t)
逐行拆解:
- self.tasks = []:管家一开始手里一堆空任务;
- add:造一个 Task,塞进列表(第 11 章 append);
- list_all:enumerate(self.tasks, 1) 从 1 开始编号(第 14 章);
- mark_done / delete:先范围校验(第 6 章比较运算),再 self.tasks[index - 1] 下标=编号-1;
- show_pending:列表推导式筛出未完成的(第 14 章),sort(key=lambda ..., reverse=True) 按优先级倒序(第 16 章 lambda)。
小细节都埋着学过的功: enumerate 编号(第 14 章)、lambda 排序(第 16 章)、not (1 <= index <= len(...)) 范围校验(第 6 章)。
换例加深:让 add 自动检查重复
def add(self, title, priority=1, due=None):
for t in self.tasks:
if t.title == title and not t.done: # 已有同名且未完成
print(f"⚠️ 已有同名待办:{title}")
return
self.tasks.append(Task(title, priority, due))
print(f"✅ 已添加:{title}")
加一道"防重复"检查——这是真实软件里最常见的需求之一。你看,有了类,加功能就是在原方法上改几行。
30.4 第 3 步:持久化(JSON 存取)
"退出后数据还在" 靠 JSON:
import json
DATA_FILE = "todo.json"
def save(self):
data = [t.to_dict() for t in self.tasks] # 列表推导式
with open(DATA_FILE, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
def load(self):
try:
with open(DATA_FILE, "r", encoding="utf-8") as f:
data = json.load(f)
self.tasks = [Task.from_dict(d) for d in data]
except FileNotFoundError:
self.tasks = [] # 第一次运行,没有文件
except json.JSONDecodeError:
print("数据文件损坏,已重置")
self.tasks = []
逐行拆解:
- [t.to_dict() for t in self.tasks]:推导式把每个任务翻译成字典,得到一个字典列表;
- json.dump(data, f, ensure_ascii=False, indent=2):第 29 章三件套,中文正常、格式好看;
- load:json.load 读回字典列表,再 Task.from_dict(d) 批量重建任务;
- except FileNotFoundError:第一次运行没有文件 → 空列表;
- except json.JSONDecodeError:文件被人手改坏了 → 提示并重置。
异常兜底(第 20 章)立功了: 文件不存在、被人手改坏,程序都稳稳接住,不崩。
🐍"皮皮注:读文件两大坑——文件不在、内容坏了。
try/except双保险一上,程序稳如老狗。记住:凡是'读外部的东西',都要想'如果它不在/它坏了怎么办'。"
30.5 第 4 步:菜单循环(把机器开起来)
def show_menu():
print("\n===== 皮皮待办清单 =====")
print("1. 添加任务")
print("2. 查看全部")
print("3. 标记完成")
print("4. 删除任务")
print("5. 查看待办(按优先级)")
print("0. 保存并退出")
print("========================")
def main():
todo = TodoList()
todo.load() # 启动时读回上次的任务
while True:
show_menu()
choice = input("请选择功能:")
if choice == "1":
title = input("任务内容:")
try:
priority = int(input("优先级(1低/2中/3高,默认1):") or "1")
except ValueError:
priority = 1 # 乱输入就退回默认
due = input("截止日期(可留空):") or None
todo.add(title, priority, due)
elif choice == "2":
todo.list_all()
elif choice == "3":
todo.list_all()
try:
idx = int(input("输入要标记完成的编号:"))
except ValueError:
print("❌ 请输入数字!")
continue
todo.mark_done(idx)
elif choice == "4":
todo.list_all()
try:
idx = int(input("输入要删除的编号:"))
except ValueError:
print("❌ 请输入数字!")
continue
todo.delete(idx)
elif choice == "5":
todo.show_pending()
elif choice == "0":
todo.save() # 退出前保存
print("已保存,再见!")
break
else:
print("❌ 没有这个选项,请重新输入!")
if __name__ == "__main__":
main()
逐行拆解:
- todo.load():启动第一件事——把上次的任务读回来;
- while True::菜单循环,选 0 才 break 退出(第 8 章);
- if choice == "1": ... elif ...:分支分发,每个选项调管家对应方法;
- int(input(...) or "1"):input 返回空串(假),or "1" 取默认 1(第 6 章真值);
- try/except ValueError:用户输"abc"这种非数字,退回默认、提示重来,不崩(第 20 章);
- todo.save() + break:退出前保存,数据不丢。
几个设计亮点:
- input(...) or "1":输入为空就用默认值(第 6 章真值:空字符串是假);
- try/except ValueError:输非数字就用默认,不崩(第 20 章);
- if __name__ == "__main__": 保护(第 21 章)——这个文件被 import 时不会自动启动菜单,只有直接运行才开。
30.6 完整代码
完整代码在 code/ch30/todo.py(约 180 行)。运行它,体验一个"软件"的诞生。
运行效果:
===== 皮皮待办清单 =====
1. 添加任务
2. 查看全部
...
请选择功能:1
任务内容:学完第30章
优先级(1低/2中/3高,默认1):3
截止日期(如 2026-08-20,可留空):2026-08-15
✅ 已添加:学完第30章
请选择功能:5
[ ] P3 学完第30章 截止:2026-08-15 ← 按优先级排最前
动手验证四步走:
1. py code/ch30/todo.py 启动;
2. 添加 2~3 个任务(不同优先级);
3. 标记完成一个、删除一个;
4. 选 0 退出,再重新启动——你会发现数据还在。这就是"持久化"。
🐍"皮皮注:看到没,退出再进来任务还在——这就是'软件'和'脚本'的分水岭。脚本跑完就忘,软件记得一切。"
【皮皮小课堂】本章要点(毕业小结)
这台待办机器用到的全部武功:
- 面向对象:
Task(任务卡片)+TodoList(大管家),数据和行为打包(第 23~25 章); - 魔法方法:
__str__让任务打印好看(第 25 章); - JSON 持久化:
to_dict/from_dict+dump/load,退出不丢(第 22、29 章); - 异常处理:文件缺失、乱输入,全兜住(第 20 章);
- 函数与分层:数据/逻辑/界面分开,菜单只做"转发"(第 15~17 章);
- 常用技巧:
enumerate编号、lambda排序、input() or 默认值、if __name__。
做项目的完整流程,记住这四步:
1. 需求分析:先列功能清单;
2. 设计数据结构:想清楚"谁是谁"(Task、TodoList);
3. 分层实现:数据层 / 业务层 / 界面层;
4. 测试兜底:跑通流程,把能想到的"乱输入"都试一遍。
以后的任何项目,都套这个流程。 你手里已经不是"零基础小白"了——你是一个会做项目的人。
【翻车现场】本章的坑
坑 1:编号和索引差 1
self.tasks[index - 1].mark_done() # 用户看到的编号从 1 开始
# 列表下标从 0 开始,所以 index - 1!
用户看到的编号从 1 开始,列表下标从 0 开始,两者差 1。忘了 -1,会操作到错误的任务。
坑 2:删除/标记越界编号
if not (1 <= index <= len(self.tasks)): # 越界保护
print("❌ 没有这个编号!")
return
用户输入 99、输入负数,不校验就 tasks[98] 直接 IndexError。任何"让用户填编号"的操作,先做范围检查。
坑 3:退出忘了 save
程序直接关,数据全丢——白干。退出选项里必须 save()。 甚至可以更进一步:每次操作完都存(代价是慢一点点),但"退出保存"是最低要求。
坑 4:priority 没校验范围
priority = int(input("优先级(1低/2中/3高,默认1):") or "1")
# 用户输入 99,也存进去了
进阶作业: 校验 priority 必须在 1~3 之间,否则用默认。你已经有 try/except 和 if 的全部本事,动手试试。
坑 5:int(input(...)) 裸奔,用户一输"abc"就崩
idx = int(input("输入要标记完成的编号:")) # ❌ 没包 try
# 用户手滑输了"abc" → ValueError,程序当场崩溃
任何"用户输入要转成数字"的地方,都必须 try/except ValueError 兜底。 这是"防错"需求的第一条——你以为用户会好好输数字?不,他们不会。
坑 6:from_dict 遇到"缺字段"的老数据就 KeyError
# 某次保存的任务缺少 "created" 字段(旧版本程序)
task = cls(data["title"])
task.created = data["created"] # ❌ KeyError: 'created'
如果升级了代码、字段加了新键,旧数据文件里没有它,data["created"] 直接崩。 稳妥做法是给缺失字段兜底:
task.created = data.get("created", "未知时间") # get 兜底(第 13 章)
task.due = data.get("due") # 缺了就是 None
data.get(key, 默认值) 比 data[key] 更抗造——数据是"自己人写的",但可能是"旧版本自己人写的"。凡是读历史数据,一律 get。
【本章习题】
一、选择题
1. (★) Task.to_dict() 的作用是?
- A. 把任务打印出来
- B. 把任务转成字典,方便 JSON 存储
- C. 删除任务
- D. 给任务编号
2. (★★) 用户看到的任务编号从 1 开始,而列表下标从 0 开始。要操作编号为 index 的任务,应该?
- A.
self.tasks[index] - B.
self.tasks[index - 1] - C.
self.tasks[index + 1] - D.
self.tasks[-index]
3. (★★) input("截止日期:") or None 的作用是?
- A. 输入为空时返回
None,非空时返回输入 - B. 总是返回 None
- C. 总是返回输入
- D. 输入非空时返回 None
4. (★★ 多选) 关于待办项目,下列说法正确的是?
- A.
@classmethod from_dict用来从字典"重建"任务 - B.
try/except ValueError让乱输入数字不崩溃 - C. 退出前必须
save(),否则数据丢失 - D. 用户输入的编号要先做范围检查,防止越界
5. (★★ 多选) 下列哪些技术在本项目中用到了?
- A.
__str__魔法方法让任务打印好看 - B.
enumerate给任务编号 - C.
lambda按优先级排序 - D.
json.dump/load持久化数据
二、判断题
1. (★) 这个项目用到了类、JSON、异常、循环等本书大部分知识。( )
2. (★★) load() 里 except FileNotFoundError 是处理"第一次运行没有数据文件"。( )
3. (★★) enumerate(self.tasks, 1) 会从 1 开始给任务编号。( )
4. (★★) input("优先级:") or "1" 的意思是:输入为空时用默认值 "1"。( )
三、代码纠错题
1. (★★) 下面的删除操作,用户输入 3 想删第 3 个任务,但删错对象,请改正:
def delete(self, index):
if not (1 <= index <= len(self.tasks)):
print("❌ 没有这个编号!")
return
removed = self.tasks.pop(index) # 这里有问题
print(f"已删除:{removed.title}")
2. (★★) 下面的代码让用户输入编号,但一输"abc"程序就崩溃,请改正:
def mark_done(self, index):
idx = int(input("输入要标记完成的编号:")) # 用户输"abc" → ValueError 崩溃
self.tasks[idx - 1].mark_done()
四、编程实战题
1. (基础 ★) 给 Task 类加一个方法 toggle():如果任务未完成就标记完成,已完成就取消完成(反转 done)。
2. (基础 ★★) 给系统加一个功能:显示已完成——只列出所有打勾的任务。
3. (基础 ★★) 给系统加一个功能:显示统计——打印任务总数、已完成数、待办数(如"共 5 个,完成 2,待办 3")。
4. (挑战 ★★★) 给系统加截止日期提醒:show_pending() 时,如果任务有截止日期且今天已经过了,在末尾加上 ⚠️已过期 提示(提示:用 datetime 比较 self.due 和今天)。
五、思考题(想清楚再回答)
1. (★★) 如果用户输入优先级 99,程序会怎么处理?这样合理吗?你想怎么改进?
2. (★★★) 如果两个 todo.py 同时运行、同时保存,会发生什么?真实软件怎么解决这个问题?
【参考答案与解析】
一、选择题
1. 答案:B
to_dict 把 Task 对象转成普通字典,json.dump 才能存。
2. 答案:B
用户看到第 1 个任务对应下标 0,所以 index - 1。
3. 答案:A
input(...) 返回空字符串(假)时,or None 取右边 None;非空(真)时取输入。"空就默认,非空就用输入"。
4. 答案:A、B、C、D
A 对:类方法重建任务;B 对:异常兜底;C 对:退出保存;D 对:越界保护。
5. 答案:A、B、C、D
A 对:__str__ 让打印好看;B 对:enumerate 编号;C 对:lambda 排序;D 对:json 持久化。这四样就是本项目最核心的"四大件"。
二、判断题
1. 正确(√)。OOP、JSON、异常、循环、函数、推导式……全部串起来了。
2. 正确(√)。第一次运行没有 todo.json,load 接住并返回空列表。
3. 正确(√)。enumerate(可迭代, 起始值) 第二个参数就是起始编号。
4. 正确(√)。空字符串是"假",or 取右边的默认值 "1";非空(真)时取输入。
三、代码纠错题
1. 解析: 列表下标从 0 开始,pop(index) 用 index 作为下标会错位。改正:
def delete(self, index):
if not (1 <= index <= len(self.tasks)):
print("❌ 没有这个编号!")
return
removed = self.tasks.pop(index - 1) # 下标 = 编号 - 1
print(f"已删除:{removed.title}")
2. 解析: int(input(...)) 没包 try,用户输"abc"直接 ValueError。改正:用 try/except 兜底,输错了提示重来:
def mark_done(self, index):
try:
idx = int(input("输入要标记完成的编号:"))
except ValueError:
print("❌ 请输入数字!")
return # 不让程序继续往下走
self.tasks[idx - 1].mark_done()
核心: 面向用户输入的地方,永远是 try/except 的战场。
四、编程实战题
1. 参考代码:
def toggle(self):
"""完成 ↔ 未完成 切换"""
self.done = not self.done
2. 参考代码:
def show_done(self):
"""只显示已完成的"""
done = [t for t in self.tasks if t.done]
if not done:
print("(还没有完成的任务)")
return
for t in done:
print(t)
# 菜单里加一项即可
3. 参考代码:
def show_stats(self):
total = len(self.tasks)
done = sum(1 for t in self.tasks if t.done)
pending = total - done
print(f"📊 共 {total} 个任务,已完成 {done},待办 {pending}")
# 菜单里加一项即可
解析: sum(1 for t in ...) 用生成器表达式(第 26 章)数出已完成数——一行搞定。
4. 参考代码:
from datetime import datetime, date
def show_pending(self):
pending = [t for t in self.tasks if not t.done]
pending.sort(key=lambda t: t.priority, reverse=True)
if not pending:
print("🎉 没有待办,全部完成!")
return
today = date.today()
for t in pending:
if t.due:
try:
due_date = datetime.strptime(t.due, "%Y-%m-%d").date()
if due_date < today:
print(f"{t} ⚠️已过期")
continue
except ValueError:
pass # 截止日期格式不对,忽略
print(t)
解析: datetime.strptime 把截止日期字符串转成日期,和今天比较;格式不对用 try 忽略——既提醒了过期,又不因为脏数据崩掉。
五、思考题
1. 参考思路: 现在 priority=99 也会被存进去,只是排序时排最前面,不合理(用户明明只有 1/2/3 三档)。改进:添加任务时校验 priority 必须 in (1, 2, 3),否则提示并默认 1:
if priority not in (1, 2, 3):
print("优先级只能是 1/2/3,已设为默认 1")
priority = 1
2. 参考思路: 两个程序同时运行时,后保存者会用 "w" 清空先保存者刚写的内容,后者的数据覆盖前者——一个程序的任务就丢了。真实软件的做法:①用数据库(如 SQLite),数据库自带"锁"保证同一时间只有一个写入;②每次操作都立即保存而不是退出才存;③用"版本号/时间戳"检测冲突,提示用户。你能想到这一步,说明并发思维已经萌芽——这正是后端开发的核心难题之一。
🐍"皮皮注:恭喜!你打完了最终 BOSS,正式从'魔法学院'毕业!这一章你把类、JSON、异常、循环、函数全部拧成了一台能跑、能存、还能防错的机器。这不是终点,而是你作为程序员的起点——去结语篇看看,接下来往哪个方向闯荡吧!"
📖 全书到此结束,去读《结语与番外》吧——你的下一段冒险,从那里开始。