进阶修炼与毕业 · 进阶与毕业

第30章 毕业项目:待办清单

命令行待办清单

第 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 退出,再重新启动——你会发现数据还在。这就是"持久化"。

🐍"皮皮注:看到没,退出再进来任务还在——这就是'软件'和'脚本'的分水岭。脚本跑完就忘,软件记得一切。"


【皮皮小课堂】本章要点(毕业小结)

这台待办机器用到的全部武功:

做项目的完整流程,记住这四步:
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() 的作用是?

2. (★★) 用户看到的任务编号从 1 开始,而列表下标从 0 开始。要操作编号为 index 的任务,应该?

3. (★★) input("截止日期:") or None 的作用是?

4. (★★ 多选) 关于待办项目,下列说法正确的是?

5. (★★ 多选) 下列哪些技术在本项目中用到了?

二、判断题

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、异常、循环、函数全部拧成了一台能跑、能存、还能防错的机器。这不是终点,而是你作为程序员的起点——去结语篇看看,接下来往哪个方向闯荡吧!"


📖 全书到此结束,去读《结语与番外》吧——你的下一段冒险,从那里开始。

📦 本章配套代码

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