从零开始
学会 Python 实操

这份教材怎样帮你学会实操

这是给没有编程经验的学习者准备的第一阶段教材。你无需懂数学公式、命令行或英文术语。目标是让你独立完成“接收数据 → 判断与处理 → 保存结果”的小程序，并看懂后续机器学习代码中的常见 Python 写法。它不承诺学完即可训练大模型；模型原理、线性代数、NumPy、PyTorch 是后续阶段。

先下载并完整解压学习包，再双击 index.html。 不要在压缩包的预览窗口里运行脚本。网页、代码和示例数据均可离线使用；第一次安装 Python 需要联网，或提前从官方网站准备适合目标电脑的安装文件。网页本身不需要安装任何程序，也不依赖在线字体、CDN 或账号。运行 Python 代码则需要该电脑已安装 Python。

正文中的代码都是 Python；标注为“终端命令”的内容则写在终端里。网页的“复制”只复制代码，不会自动执行。为保证完整离线、避免额外大型运行环境，本教材不在网页中执行任意 Python。三个演示器只展示预设语义轨迹，真实练习请在自己的解释器里运行。

文件夹地图

• index.html：教材入口，双击打开。
• examples/ch02/ex02_01.py：第 02 章第 1 个示例，可以直接运行。
• practice/ch02/ex02_01.py：第 02 章第 1 道习题，留给你编写代码。
• solutions/ch02/ex02_01.py：该题参考答案；先尝试，再查看。
• projects/：四个综合项目，每个有分步任务、示例数据和完整实现。
• tools/check_practice.py：练习自检器；tools/verify_examples.py：全部示例核对器。
• notes/：错题本和复习记录模板；textbook.md：纯文字备份。

练习请编辑解压包原位置的 practice 文件。 网页文件链接会下载副本；若你修改的是“下载”目录中的副本，自检器仍会读取学习包里的原文件。最稳妥的方法是在编辑器里用 File → Open 打开题目注明的 practice 路径，修改并保存。

示例和习题分别编号，所以同一个 02_01 在 examples 和 practice 中不是同一段程序。编号的前两位是章节号，后两位是本章顺序。

四个工具分别做什么

编辑器负责修改文本，例如 Python 自带的 IDLE；解释器负责执行 Python 代码；终端负责接收启动程序的命令；浏览器负责显示教材。可以把编辑器想成写菜谱的纸，解释器想成按菜谱做菜的人，终端想成发出“开始做菜”的入口。类比只帮助入门；代码的准确含义以解释器规则为准。

hello.py 是文本文件，.py 告诉你这是 Python 源代码。print("你好") 的括号是调用，双引号包住字符串，print 把内容显示到输出区域。注意使用英文半角括号和引号，不能用中文的 （ ） “ ” 替换。

Windows 安装与首次运行

1. 打开 Python 官方下载页，按照 Windows 官方安装说明 安装 Python。官方目前提供 Python install manager；已有正常工作的 Python 3 不必为了本教材重装。安装流程随版本变化，以官方页面为准。
2. 安装完成后，关闭旧终端，再从开始菜单打开 PowerShell 或 Windows Terminal，输入 py --version。若 py 不可用但 python --version 成功，后续把 py 换成 python。
3. 确认输出是 Python 3.10 或更高。本教材使用的语法按 Python 3.10+ 编写，交付前在 3.12 环境实际验证；不是对所有操作系统组合都做过现场测试。
4. 将整个文件夹放在一个容易找到的位置，例如桌面。打开该文件夹，在文件资源管理器地址栏输入 powershell 并回车，通常即可在此目录启动 PowerShell。也可以手动输入 cd "完整文件夹路径"。
5. 输入下面的命令，看到文字即成功。命令前面没有要你复制的 $ 或 >>>。

py examples/ch01/ex01_01.py

Mac 安装与首次运行

1. 从 Python 官方下载页 获取 macOS 安装包，参考 macOS 官方说明 安装。学习用解释器不要依赖系统工具内部使用的 Python。
2. 用 Spotlight 搜索并打开“终端”，输入 python3 --version，确认 Python 3.10+。
3. 在终端输入 cd （注意末尾有空格），把解压后的学习包文件夹拖入终端，再按回车。拖入操作会帮助你填好带空格的路径。
4. 输入下面的命令：

python3 examples/ch01/ex01_01.py

之后所有标为 python ... 的通用命令，在尚未使用虚拟环境时，Windows 可改成 py ...，Mac 可改成 python3 ...。第 11 章使用虚拟环境时会给出精确路径。

完全不会编辑文件时怎么做

如果安装中包含 IDLE，在开始菜单或应用程序中打开它。选择 File → Open，打开任意 .py 文件；修改后按 Ctrl+S（Mac 用 Command+S）保存，再选择 Run → Run Module（常见快捷键 F5）。结果会出现在 IDLE Shell 中。练习也可以用任意纯文本代码编辑器完成。

不要用 Word 编辑 .py，也不要保存成 hello.py.txt。Windows 可以在文件资源管理器中开启“显示文件扩展名”；Mac 文本编辑器需要先转换为纯文本。使用 IDLE 通常更省事。

遇到 >>> 说明进入了 Python 交互模式，可以输入 Python 表达式。此时不能直接输入 py hello.py。输入 exit() 回到系统终端，再运行终端命令。... 是交互模式的续行提示，不是要写进程序里的字符。

一次学习的具体流程

每次安排 45—75 分钟，可按自己的时间拆开：5 分钟默写上一节；15 分钟读新知识；20 分钟手敲并改动示例；15 分钟独立做题；5 分钟记录错误。看懂答案不等于能够独立写出。 每个例子先写下预计输出，再运行，然后至少改两个输入。

卡住时按顺序做：复述题目 → 写出输入与输出 → 手算一个小例子 → 用中文列步骤 → 把步骤翻译成代码 → 用 print 看中间值。独立尝试 10—15 分钟后可以展开提示；再卡住才看解析。看过答案的题，第二天关掉答案重写。

换电脑继续学习

复制整个解压后的文件夹，或者复制压缩包后重新解压。已写好的 practice、projects 和 notes 也要一起带走。网页进度保存在当前浏览器本地，它不会自动同步，也可能因移动文件或浏览器清理而丢失：离开前点击“导出进度”，在另一台电脑点击“导入进度”。导出的 JSON 包含章节勾选和笔记，不包含你的 .py 源代码。浏览器禁止本地存储时仍可阅读，应手动导出进度。

第一周不要做的额外工作

不需要显卡，不需要注册模型 API，不需要安装 PyTorch，也不需要一次配置多个编辑器。第 00—16 章和四个项目只使用标准库。先把这条最短路径走通：保存一个文件 → 运行 → 修改 → 再运行。

AI / Agent 穿插内容怎样学

主页的“部分内容为info1110课程”用于标记你的课程关联。基础语法可以配合课堂复习；v1.1 新增的 AI / Agent 场景是自编延伸练习，不据此推定课程的考核范围。

保持原来的顺序：先学本章语法，完成普通示例，再做本章最后的“AI / Agent”示例与练习。遇到暂时不懂的 AI 名词，先关注代码中的字符串、列表、判断和函数；不需要先学神经网络。

本轮的小实验只使用 Python 标准库，完全离线。提示词是给模型的文字要求；大模型（LLM）根据上下文生成内容；工具（tool）是程序可以调用的函数；Agent 则围绕目标组织决策、工具执行和结果反馈。这里用固定数据和规则模拟部分流程，没有调用真实模型、没有网络推理、没有产生 API 费用。

每个场景示例都有 .py 文件，新增练习仍可用同一自检器检查。旧题号和进度文件格式保留；在本版导入旧进度后，新题会显示为未完成。

程序就是一系列明确指令

“帮我统计分数”对人足够，对计算机不够。你要写清楚：分数有哪些、怎样相加、人数怎么算、最后显示什么。通常先确定输入、处理、输出。比如输入两科成绩 80 和 90，处理是相加后除以 2，输出是 85.0。

Python 普通脚本从上到下执行；遇到函数定义会先记住函数，遇到调用才执行函数体（第 09 章）；遇到条件和循环会改变执行路径。先把现在的例子当作一行接一行执行。

表达式、语句和函数调用

2 + 3 是能得到一个值的表达式。在文件里单独写 2 + 3 会计算，但通常不会显示结果。print(2 + 3) 才会显示。print 是函数名，括号里的东西是传给它的参数。多个参数用英文逗号分开，默认用空格连接。

print("2 + 3") 输出文字 2 + 3；print(2 + 3) 输出数字 5。引号告诉 Python“里面是文本”，没有引号时则按代码解释。单引号与双引号都可以，开头和结尾必须匹配。

空行、注释、缩进

# 后直到这一行结束是注释，解释器不把它当作指令执行。注释最好解释“为什么”，例如“先换成分钟，方便比较”，而不是只重复代码。字符串中的 # 则是普通文字。

空行帮助人阅读。缩进在 Python 中则参与语法：同一代码块要用一致缩进，建议每层 4 个空格。顶层语句一般从最左边开始。不要混合 Tab 与空格。后面看到 if、for、def 后的冒号，下一层内容通常需要缩进。

先读懂一条报错

故意在练习文件里写 print("你好"，运行会看到 SyntaxError，意思是结构不符合语法。补上右括号后再运行。报错指向的位置有时是解释器发现问题的位置，真正漏掉的符号可能在上一行。

NameError 常表示名字没定义或拼错，如写成 pirnt。Print 与 print 不同，Python 区分大小写。每次只改一个问题，然后重新运行；不要一次凭感觉改很多行。

用中文先写算法

以“给两人平均分一笔钱”为例：得到总金额 → 得到人数 → 总金额除以人数 → 显示结果。暂时用固定数字，等第 02 章再接收键盘输入。写程序不等于背语法；先有步骤，再选择语法。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

print("你好，Python！")
print("今天开始学编程。")

你好，Python！
今天开始学编程。

print("2 + 3")
print(2 + 3)
print("结果是", 2 + 3)

2 + 3
5
结果是 5

print("年", "月", "日", sep="/")
print("正在学习", end="：")
print("Python")

年/月/日
正在学习：Python

# 先计算总分，再计算平均分
print(80 + 90)
print((80 + 90) / 2)
print("# 这部分仍会显示")

170
85.0
# 这部分仍会显示

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

我叫小林
我每天学习 45 分钟

print("我叫小林")
print("我每天学习 45 分钟")

20
4
96

print(12 + 8)
print(12 - 8)
print(12 * 8)

小林

print("小林")

苹果|3|12

print("苹果", 3, 12, sep="|")

80.0

print((70 + 90) / 2)

变量是绑定到对象的名字

age = 20 不是数学等式，而是把右边的值交给左边的名字。读成“让 age 指向整数 20”。执行 age = age + 1 时，先读旧值 20，算出 21，再把 age 绑定到 21。初学可把它想成贴标签；第 07 章会说明为什么两个标签可能指向同一个列表。

名字用字母、数字和下划线组合，不能以数字开头；推荐 study_minutes 这种小写下划线风格。class、if 等关键字不能当变量名。不要把变量起名为 list、str、sum，否则会遮住同名内置工具。

类型决定可以做哪些操作

type(x) 查看类型。3 + 2 是数值相加；"3" + "2" 是拼接；"3" + 2 会产生 TypeError。Python 不会替你猜应该拼接还是相加。

算术常用符号

+ - * / 分别是加减乘除，// 是向下取整的除法，% 是余数，** 是幂。正数场景下 125 // 60 得到 2，125 % 60 得到 5，常用来把分钟换成小时和分钟。负数时要小心：-7 // 3 得到 -3，因为向负无穷取整；-7 % 3 得到 2，满足 a == (a // b) * b + a % b。

通常先括号，再乘方，再乘除余，再加减；拿不准时用括号表达意图。-2 ** 2 是 -4，(-2) ** 2 才是 4。total += 5 相当于给当前 total 加 5 后赋回；total 必须先有值。

input 永远先给你字符串

input("年龄：") 会显示提示并等待输入，回车后返回字符串，不包含回车本身。输入 18，得到的是 "18"。要做整数运算，使用 int(...)；小数用 float(...)。int("18.5") 会报错，而 int(18.5) 得到 18，是向零截断，不是四舍五入。

str(18) 把数字变成文本。bool("") 是 False，而 bool("False") 是 True，因为它是非空字符串。不要用 bool 把用户输入的“否”自动转换成 False，要明确比较文本。

小数不是总能精确存储

二进制浮点数无法精确表示部分十进制小数。0.1 + 0.2 可能显示 0.30000000000000004。显示两位小数可以用格式化，比较近似数在第 13 章用 math.isclose。学习账本时把金额保存为整数“分”，例如 12.50 元表示为 1250 分。格式化改变显示，不会让底层数值变得精确。

把需求翻译成变量

“买 3 本书，每本 25 元，优惠 10 元”可以拆为 price、quantity、discount，再写 total = price * quantity - discount。变量名说明数据角色，减少神秘数字。先做固定输入，再加 input，是更容易排错的顺序。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

minutes = 30
minutes = minutes + 15
minutes += 5
print(minutes)

50

print(type(3).__name__)
print(type(3.0).__name__)
print(type("3").__name__)
print(type(True).__name__)
print(type(None).__name__)

int
float
str
bool
NoneType

total_minutes = 125
hours = total_minutes // 60
minutes = total_minutes % 60
print(hours, "小时", minutes, "分钟")

2 小时 5 分钟

3

text = input("请输入本周学习天数：")
days = int(text)
print("总分钟", days * 45)

请输入本周学习天数：总分钟 135

price_fen = 1250
quantity = 3
total_fen = price_fen * quantity
print(total_fen)
print(f"应付 {total_fen / 100:.2f} 元")

3750
应付 37.50 元

a = 10
b = 20
a, b = b, a
print(a, b)
print(-7 // 3, -7 % 3)

20 10
-3 2

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

77.0

celsius = 25
fahrenheit = celsius * 9 / 5 + 32
print(fahrenheit)

1 1 11

seconds = 3671
hours = seconds // 3600
minutes = (seconds % 3600) // 60
remaining = seconds % 60
print(hours, minutes, remaining)

12
8

20

a = int(input())
b = int(input())
print(a + b)

39.0

price = "19.5"
count = 2
print(float(price) * count)

4
5
5

books = 53
capacity = 12
print(books // capacity)
print(books % capacity)
print((books + capacity - 1) // capacity)

12.0

distance_km = 5
time_seconds = 1500
time_hours = time_seconds / 3600
print(distance_km / time_hours)

字符串是有顺序的文本

text = "Python" 包含 6 个字符，len(text) 得到 6。索引从 0 开始：text[0] 是 P，text[1] 是 y；负索引从末尾数，text[-1] 是 n。长度为 n 的非空字符串，正索引范围是 0 到 n-1。空字符串 "" 的长度为 0，没有第一个字符。

"你好" 的长度是 2；但有些 emoji 和组合字符由多个 Unicode 码点组成，len 不等于所有场景下肉眼看到的图形数。普通中英文练习先按常见字符理解即可。

切片的左闭右开

text[start:stop:step] 从 start 开始，到 stop 之前停止，按 step 跨步取。text[1:4] 取索引 1、2、3。省略 start 通常从开头，省略 stop 通常到结尾。text[:3] 是前三个，text[3:] 是从索引 3 到末尾，text[::-1] 是倒序。

记忆方法：“开始要，结束不要”。先在纸上写索引，再圈出实际取到的位置。普通正向切片中，取几个常可用 stop-start 理解；遇到负步长要重新沿步长方向数。步长不能是 0。单个索引越界报 IndexError，切片超出边界通常会自动截到可用范围。

方法调用读成“对这个对象做什么”

text.strip() 是调用字符串对象的方法，返回去掉两端空白的新字符串；不会删除中间空格。lower() 变小写，upper() 变大写，replace(old, new) 替换文本，split() 按连续空白拆分，split(",") 按逗号拆分，"-".join(parts) 用连字符把多个字符串连接。

" a b ".split() 得到两个词；"a,,b".split(",") 中间会保留空字符串。CSV 含引号或逗号时不要自己 split，第 12 章用 csv 模块。

字符串不能就地修改

name[0] = "L" 会失败，因为 str 不可变。name.upper() 返回新字符串；如果没有保存它，旧变量仍指向原字符串。写 name = name.upper() 才让 name 指向转换结果。不可变不等于变量不能重新赋值。

格式化输出

f"你好，{name}" 会把 name 的值放入文本；f 必须紧贴开头引号。f"{score:.2f}" 显示两位小数，f"{rate:.1%}" 将比例显示为一位小数的百分数。格式化常用于报告，不应把显示后的字符串重新拿来做数值运算。

转义符 \n 表示换行，\t 表示制表符，\\ 表示一个反斜杠。r"C:\notes" 是原始字符串的一种写法，但以单个反斜杠结尾仍有语法限制。处理路径优先用第 12 章的 pathlib，少手写反斜杠。三引号可以书写多行字符串，里面的缩进也可能成为文本的一部分。

一个实用的文本清洗流程

用户输入账号 → 去掉两端空白 → 统一大小写 → 检查是否为空 → 保存。每一步都先打印 repr(text)，就能看到看不见的空格和换行。例如 repr(" hi\n") 会显示带引号和转义符的表示。不要为了“清洗”随意删除有意义的内部空格或符号。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

word = "Python"
print(word[0], word[-1])
print(word[1:4])
print(word[:2], word[2:])
print(word[::-1])

P n
yth
Py thon
nohtyP

raw = "  Alice\n"
clean = raw.strip().lower()
print(repr(raw))
print(clean)
print(len(clean))

'  Alice\n'
alice
5

sentence = "  learn   python today  "
words = sentence.split()
print(words)
print("-".join(words))

['learn', 'python', 'today']
learn-python-today

name = "小林"
score = 86.456
rate = 0.875
print(f"{name}的分数：{score:.2f}")
print(f"完成率：{rate:.1%}")
print(f"编号：{7:03d}")

小林的分数：86.46
完成率：87.5%
编号：007

text = "python is fun"
text.replace("fun", "useful")
print(text)
text = text.replace("fun", "useful")
print(text)
print("python" in text)

python is fun
python is useful
True

topic = "  Python 列表  "
level = "零基础"
clean_topic = topic.strip()
prompt = f"请面向{level}读者解释：{clean_topic}。"
print(prompt)
print(f"主题字符数：{len(clean_topic)}")

请面向零基础读者解释：Python 列表。
主题字符数：9

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

learner@example.com

email = "  Learner@Example.COM  "
print(email.strip().lower())

138****5678

phone = "13812345678"
print(phone[:3] + "****" + phone[-4:])

csv

filename = "report.final.csv"
print(filename.split(".")[-1])

I love Python

text = "  I   love  Python  "
print(" ".join(text.split()))

bdf
fedcba
abc

s = "abcdef"
print(s[1::2])
print(s[::-1])
print(s[:3])

已完成 35.0%

completed = 7
total = 20
print(f"已完成 {completed / total:.1%}")

Python
6

text = "  Python  "
text = text.strip()
print(text)
print(len(text))

what is python?
15

question = "  What is Python?  "
cleaned = question.strip().lower()
print(cleaned)
print(len(cleaned))

从比较得到真假

== 判断相等，!= 判断不等，>、<、>=、<= 比较大小。赋值 = 与比较 == 完全不同。18 <= age < 60 是合法链式比较，表示年龄同时落在这个区间。

and 要两边条件都成立，or 至少一边成立，not 取反。判断是否周末应写 day == "周六" or day == "周日"，不能写 day == "周六" or "周日"；后一项非空字符串总为真。

if 是选一条路径

基本结构是 if 条件:，下一行缩进写条件为真时做的事。elif 是前面没有选中时继续检查，else 是前面全部没有选中时兜底。一条 if/elif/else 链只会执行最多一个分支。多个独立 if 则会分别检查，有可能都执行。

成绩分级如果先判断 score >= 60，90 分也会先进入这个分支；高等级通常从高到低写。缩进结束代表这个分支结束。程序随后继续执行分支后面的语句。

真值不是只有 True 和 False

0、0.0、空字符串、空列表、空字典、空集合和 None 常被当作假；非空容器通常为真。if items: 常用来表示“有元素”。"0" 和 "False" 都是非空字符串，是真。

None 经常表示缺失值，判断它用 is None 或 is not None。值相等通常用 ==；is 判断是否为同一个对象，不要用它比较普通字符串或整数的数值相等。

短路能避免无意义运算

and 左边为假就不看右边；or 左边为真就不看右边。例如 count > 0 and total / count > 60，count 为 0 时不会执行除法，避免除零。技术上 and/or 返回某个操作数，而不保证一定返回 bool；刚开始尽量让两边都是明确条件。

用边界检查自己的判断

判断“满 100 减 10”，最有价值的测试不是只测 200，而是测 99、100、101。判断合法成绩，至少测 -1、0、60、100、101。先验证输入范围，再做业务分级，能避免把不可能的值分成正常等级。

把复杂判断拆成有意义的名字

不要把所有逻辑塞进一个长 if。可以先算 has_ticket、is_open，再判断 if has_ticket and is_open:。表达式很长时加括号，明确逻辑关系。条件中的布尔变量不必写 == True。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

score = 59
if score >= 60:
    print("通过")
else:
    print("继续练习")
print("记录完成")

继续练习
记录完成

score = 85
if not 0 <= score <= 100:
    print("成绩无效")
elif score >= 90:
    print("优秀")
elif score >= 60:
    print("通过")
else:
    print("待加强")

通过

age = 20
has_ticket = True
if age >= 18 and has_ticket:
    print("允许进入")
else:
    print("条件未满足")

允许进入

count = 0
total = 80
if count > 0 and total / count >= 60:
    print("平均分通过")
else:
    print("人数不足或平均分未通过")

人数不足或平均分未通过

score = 0
if score is None:
    print("尚未提交")
else:
    print(f"已提交，成绩 {score}")
print(bool("False"), bool(""))

已提交，成绩 0
True False

request = " 请解释列表 "
cleaned = request.strip()
if cleaned == "":
    route = "请先输入问题"
elif "计算" in cleaned:
    route = "交给计算工具"
else:
    route = "进入文字讲解"
print(route)

进入文字讲解

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

奇数

n = 17
if n % 2 == 0:
    print("偶数")
else:
    print("奇数")

107

amount = 99
if amount >= 100:
    shipping = 0
else:
    shipping = 8
print(amount + shipping)

无效

score = 105
if not 0 <= score <= 100:
    print("无效")
elif score >= 60:
    print("通过")
else:
    print("未通过")

工作日

day = "周一"
if day == "周六" or day == "周日":
    print("周末")
else:
    print("工作日")

12

a, b, c = 7, 12, 9
largest = a
if b > largest:
    largest = b
if c > largest:
    largest = c
print(largest)

已填

value = 0
if value is None:
    print("未填")
else:
    print("已填")

可以启动

has_data = True
has_config = True
is_running = False
if has_data and has_config and not is_running:
    print("可以启动")
else:
    print("暂不能启动")

ok

reply = "  hello  "
limit = 5
cleaned = reply.strip()
if cleaned == "":
    print("empty")
elif len(cleaned) > limit:
    print("too_long")
else:
    print("ok")

为什么需要循环

三个分数可以手写三次相加，三千个就不行。for score in scores: 的含义是从 scores 中依次取一个元素，把它绑定给 score，然后执行缩进块。块执行完再取下一个，取完就结束。每一次重复称为一次“迭代”。

本章先把 [70, 85, 60] 理解成一串有顺序的数据，叫列表。第 07 章再系统学习增删改查。循环变量可以任意起名，但 score 比 x 更容易理解。

range 生成整数序列

range(5) 对应 0、1、2、3、4；range(1, 6) 对应 1、2、3、4、5；range(2, 10, 2) 对应 2、4、6、8。与切片一样，终点不包含。range(5, 0, -1) 是 5、4、3、2、1。步长必须非零，方向与边界不匹配时可能一个数都没有。

range 本身不是列表，一般不用为了遍历把它转成 list。要观察全部内容时可以 print(list(range(5)))。range 使用整数边界，不接受 0.5 作为步长。

累计与计数模板

累计先设 total = 0，每次执行 total += value。计数先设 count = 0，满足条件时执行 count += 1。初始值写在循环前；如果写在循环体里，每次都会清零。

“及格人数”累加的是 1；“及格分数总和”累加的是 score。两个题目只差一句话，代码里的更新对象却不同。每次写循环都要问：本轮取到什么？保留什么状态？状态怎么变？什么时候结束？

手工追踪表

对 [2, 4, 1] 求和：初始 total=0；第 1 轮 value=2，更新为 2；第 2 轮 value=4，更新为 6；第 3 轮 value=1，更新为 7。不要只看最后输出，要能解释中间过程。网页的循环演示器可以逐步显示同样的状态变化。

空数据也要考虑

空列表的 for 一次也不执行，因此 total 保留 0。这是合理的空和，但平均值不能直接写 total/len(values)，因为人数为 0。先检查长度再除。求最大值时也要明确空数据怎么处理；第 09 章用函数返回 None 或抛异常表达约定。

循环之后变量还在吗

for 不会创建独立作用域。非空循环结束后，循环变量通常仍绑定最后一个值；如果循环一次未执行，这个名字可能根本没定义。不要依赖“最后的循环变量”作为结果；建立明确的结果变量更可靠。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

scores = [70, 85, 60]
for score in scores:
    print("分数", score)
print("遍历结束")

分数 70
分数 85
分数 60
遍历结束

total = 0
for value in [2, 4, 1]:
    total += value
    print(value, total)
print("总和", total)

2 2
4 6
1 7
总和 7

count = 0
for score in [59, 60, 80, 40]:
    if score >= 60:
        count += 1
print(count)

2

for number in range(1, 4):
    print(number)
print("倒数")
for number in range(3, 0, -1):
    print(number)

1
2
3
倒数
3
2
1

names = ["小林", "小陈", "小王"]
for number, name in enumerate(names, start=1):
    print(number, name)

1 小林
2 小陈
3 小王

scores = []
total = 0
for score in scores:
    total += score
if len(scores) == 0:
    print("没有成绩")
else:
    print(total / len(scores))

没有成绩

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

55

total = 0
for number in range(1, 11):
    total += number
print(total)

110

total = 0
for number in range(2, 21, 2):
    total += number
print(total)

3
135

days = 0
total = 0
for minutes in [0, 30, 45, 0, 60]:
    if minutes > 0:
        days += 1
    total += minutes
print(days)
print(total)

cat:3
python:6
AI:2

for word in ["cat", "python", "AI"]:
    print(f"{word}:{len(word)}")

-2

numbers = [-5, -2, -9]
largest = numbers[0]
for number in numbers[1:]:
    if number > largest:
        largest = number
print(largest)

5

count = 0
for char in "Education".lower():
    if char in "aeiou":
        count += 1
print(count)

python

words = ["I", "study", "python", "daily"]
longest = ""
for word in words:
    if len(word) > len(longest):
        longest = word
print(longest)

for 与 while 怎样选

有一串现成数据需要逐项处理，优先 for；需要“持续做，直到某个条件改变”，常用 while。例如反复请求输入直到合法、持续显示菜单直到用户选择退出。不要为了用 while 把简单遍历写得更复杂。

while 条件: 每次进入循环前都会重新检查条件。先检查，再执行，所以条件一开始为假时执行零次。构成一个可控 while 的三个部分是：初始状态、继续条件、状态更新。遗漏更新可能产生无限循环。

手工走一遍计数器

n = 3；检查 n>0 为真，输出 3，然后 n-=1；再检查 2>0，输出 2；再检查 1>0，输出 1；最后 n=0，条件为假，退出。条件不是进入时检查一次就永远不变，每轮都会重新计算。

break 与 continue

break 立即结束它所在的最内层循环；continue 跳过本轮剩余语句，开始下一轮。嵌套循环里的 break 通常只退出内层。函数里的 return 则结束整个当前函数，第 09 章会讲。

while 中如果把计数器更新放在 continue 之后，某些路径可能永远跳过更新。解决方法是确保每条继续执行的路径都推进状态，或者直接用 for 遍历。

哨兵输入与菜单

哨兵是约定的结束标记，例如输入 q 就结束录入。先检查是不是 q，再把其他输入转换成数字，否则 int("q") 会直接报错。数据值可能本身为 0 时，别把 0 随意当结束信号；选不会与有效输入冲突的标记。

嵌套循环怎样执行

外层走一步，内层通常完整走一遍。两组实验学习率 × 三个批大小，会有 2×3=6 种组合。把外层看成行、内层看成列有助于理解，但它不必真是二维表。不要把“两个顺序排列的循环”误认为“两个嵌套循环”。

从错误中退出

终端里的长时间循环通常可以用 Ctrl+C 中断；IDLE 可用 Shell 中断或 Restart Shell。Ctrl+C 是恢复控制的方法，不是正确终止条件的替代品。调试时先限制最大次数，例如最多 5 轮，再观察状态。

Python 还有 for/while 的 else：仅在循环正常耗尽或条件变假、没有由 break 退出时执行。初学阶段用 found 变量更直白；阅读别人代码遇到循环 else 时记住“没有 break 才执行”，它不属于内部 if。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

remaining = 3
while remaining > 0:
    print(remaining)
    remaining -= 1
print("开始")

3
2
1
开始

for value in [4, 8, 15, 16]:
    if value > 10:
        print("首个大于 10 的数", value)
        break
    print("检查过", value)

检查过 4
检查过 8
首个大于 10 的数 15

total = 0
for value in [10, -1, 20, -5, 30]:
    if value < 0:
        continue
    total += value
print(total)

60

10
20
q

total = 0
while True:
    text = input().strip()
    if text == "q":
        break
    total += int(text)
print(total)

30

for model in ["A", "B"]:
    for batch_size in [2, 4]:
        print(model, batch_size)

A 2
A 4
B 2
B 4

found = False
for value in [1, 3, 5]:
    if value % 2 == 0:
        found = True
        print(value)
        break
if not found:
    print("没有偶数")

没有偶数

step = 0
max_steps = 3
finished = False
while step < max_steps:
    step += 1
    print(f"第 {step} 轮")
    if step == 2:
        finished = True
        break
print(f"已完成：{finished}")
print(f"实际轮数：{step}")

第 1 轮
第 2 轮
已完成：True
实际轮数：2

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

15

number = 1
total = 0
while number <= 5:
    total += number
    number += 1
print(total)

72

for score in [40, 55, 72, 90]:
    if score >= 60:
        print(score)
        break

3
75

count = 0
total = 0
for value in [-1, 30, 0, 45, -1]:
    if value == -1:
        continue
    count += 1
    total += value
print(count)
print(total)

3

for attempt, guess in enumerate([2, 4, 7, 9], start=1):
    if guess == 7:
        print(attempt)
        break

0 0
0 1
0 2
1 0
1 1
1 2

for row in range(2):
    for column in range(3):
        print(row, column)

1
3
5

n = 0
while n < 5:
    n += 1
    if n % 2 == 0:
        continue
    print(n)

14

number = 2048
total = 0
while number > 0:
    total += number % 10
    number //= 10
print(total)

3
2

remaining = 5
steps = 0
while remaining > 0 and steps < 3:
    remaining -= 1
    steps += 1
print(steps)
print(remaining)

列表解决一组数据的问题

values = [10, 20, 30] 把多个对象放在有顺序的容器中，可按索引取元素，也可以遍历。列表可以混合类型，但同一业务列表尽量保持结构一致，便于处理。len(values) 是元素个数；嵌套列表的长度只数外层元素，不自动数所有叶子。

单项赋值 values[1] = 99 改变原列表。append(x) 在末尾加入一个对象；extend(xs) 逐项加入另一个可迭代对象中的内容；insert(i, x) 插入；pop() 删除并返回末尾元素；pop(i) 按索引删除并返回；remove(x) 删除第一个相等的值，找不到会报 ValueError。del values[i] 也能按索引删除。

append 与 extend 的区别

对 [1, 2] 执行 append([3,4]) 得到 [1,2,[3,4]]，因为加入的是一个列表对象；extend([3,4]) 得到 [1,2,3,4]，因为逐项加入。初学可记：“append 装一个，extend 逐个装”。append("ab") 装入一个字符串，extend("ab") 会装入 a 和 b 两个字符。

sort 与 sorted 的区别

values.sort() 修改原列表，并返回 None；sorted(values) 返回新的排序列表，原对象不变。不要写 values = values.sort()，否则 values 会变成 None。reverse() 也是就地修改并返回 None。降序可用 sorted(values, reverse=True)。

两个名字可能指向同一个对象

b = a 没有复制列表，只是让 b 也指向 a 指向的对象。因此 b.append(3) 后，通过 a 也会看到变化。与之不同，b = [9] 只是让 b 改绑到另一个列表，不会修改 a 指向的旧列表。

读代码时问两个问题：“这是在修改对象，还是在改变名字的绑定？” 列表方法、元素赋值经常修改对象；普通 = 给名字重新绑定。列表上的 += 通常会就地扩展，不能简单把所有类型上的 += 都理解为创建新对象。

浅拷贝复制外壳

b = a.copy() 或 b = a[:] 创建新外层列表。如果元素是整数等不可变对象，通常足够；若元素本身是列表，内层仍可能共享。copy.deepcopy(a) 会递归复制常见嵌套结构，但不是所有对象都适合或需要深拷贝。

grid = [[0] * 3] * 2 的两行指向同一个内层列表，改一行会影响另一行。用循环每次新建 [0] * 3，或第 10 章的 [[0] * 3 for _ in range(2)]，让每行独立。

不要一边遍历一边删同一列表

删除会让后面的元素向前移动，迭代位置却继续推进，容易跳过元素。更直白的方法是建立新列表，只把要保留的元素 append 进去。第 10 章可写成列表推导式。

元组是不可变的序列

point = (3, 4) 常表示一组固定结构的数据。x, y = point 是解包，元素数量要匹配。单元素元组写 (3,)，逗号不能省；(3) 只是整数外加括号。元组的槽位不能重新赋值，但若里面放了可变列表，那个列表仍能改变，所以“元组不可变”并非内部所有东西都永远不变。

精讲：列表复制，到底复制到哪一层

先把名字想成指向对象的箭头。b = a 多画了一根箭头，并没有新建列表；b = a.copy() 新建一个外层列表，但外层里面装着的元素仍指向原来的对象。

以 a = [[1], [2]]、b = a.copy() 为例，先在纸上画出两个外层方框，再画两个内层方框。两个外层各自独立，但它们都指向那两个内层方框。

回到示例 07_05，逐行运行，再分别替换成表中的操作。不要把三个操作连着执行后拿结果与表比较：表中每一行都假设你重新初始化了 a 和 b。

迁移到会话记录： messages 常是“列表里面装字典”。外层 .copy() 不能隔离每条字典里的修改。如果只是给复制后的列表追加新消息，外层复制常已够用；如果还要修改旧消息里的字段，就需要明确哪些层应独立。第 08 章先学会读写字典，第 14 章再处理不同会话的独立状态。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

tasks = ["阅读", "练习"]
tasks.append("复习")
tasks[0] = "读第 7 章"
last = tasks.pop()
print(tasks)
print(last)

['读第 7 章', '练习']
复习

a = [1, 2]
a.append([3, 4])
b = [1, 2]
b.extend([3, 4])
print(a)
print(b)

[1, 2, [3, 4]]
[1, 2, 3, 4]

scores = [80, 60, 90]
ordered = sorted(scores)
print(scores)
print(ordered)
result = scores.sort()
print(scores)
print(result)

[80, 60, 90]
[60, 80, 90]
[60, 80, 90]
None

a = [1, 2]
b = a
b.append(3)
print(a)
b = [9]
print(a)
print(b)

[1, 2, 3]
[1, 2, 3]
[9]

import copy
a = [[1], [2]]
b = a.copy()
c = copy.deepcopy(a)
b[0].append(9)
print(a)
print(b)
print(c)

[[1, 9], [2]]
[[1, 9], [2]]
[[1], [2]]

bad = [[0] * 2] * 2
bad[0][0] = 9
print(bad)
good = []
for _ in range(2):
    good.append([0] * 2)
good[0][0] = 9
print(good)

[[9, 0], [9, 0]]
[[9, 0], [0, 0]]

point = (3, 4)
x, y = point
print(x, y)
print(type((3,)).__name__)
print(type((3)).__name__)

3 4
tuple
int

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

[60, 85]

passed = []
for score in [30, 60, 85, 59]:
    if score >= 60:
        passed.append(score)
print(passed)

[95, 90, 80]
[70, 95, 80, 60, 90]

scores = [70, 95, 80, 60, 90]
print(sorted(scores, reverse=True)[:3])
print(scores)

[1, 2]
[1, 2, 3]

a = [1, 2]
b = a.copy()
b.append(3)
print(a)
print(b)

['C', 'A', 'B']

tasks = ["A", "B", "C"]
last = tasks.pop()
tasks.insert(0, last)
print(tasks)

21

grid = [[1, 2, 3], [4, 5, 6]]
total = 0
for row in grid:
    for value in row:
        total += value
print(total)

['a', 'b', 'c']

unique = []
for item in ["a", "b", "a", "c", "b"]:
    if item not in unique:
        unique.append(item)
print(unique)

[1, 2, 3]

values = [3, 1, 2]
values.sort()
print(values)

[[1, 2], [3, 4]]
[[9, 2], [3, 4]]

original = [[1, 2], [3, 4]]
copied = []
for row in original:
    copied.append(row.copy())
copied[0][0] = 9
print(original)
print(copied)

字典是键到值的映射

student = {"name": "小林", "score": 85} 用字段名取值：student["score"]。键必须可哈希，常见字符串和整数可以作为键，列表不行。相同键只能保存一个当前值，再赋值会覆盖旧值。

student["city"] 在键不存在时抛 KeyError；student.get("city", "未知") 返回默认值但不把它写入字典。判断键是否存在可以用 "city" in student，字典上的 in 默认检查键，不检查值。

遍历方式要明确

for key in data 遍历键，data.values() 提供值，data.items() 提供键值对。常用 for key, value in data.items():。现代 Python 字典保留插入顺序，但这不代表按键的大小排序；需要排序就显式调用 sorted。

不要遍历字典时添加或删除键。可以先生成要删除的键列表，再进行删除；或创建新字典。只更新已有键的值是另一回事，但初学仍建议保持流程清楚。

计数的核心公式

counts[word] = counts.get(word, 0) + 1 的意思：先读旧次数，没有就视作 0，再加 1，最后写回。get 本身不负责更新。这种“读旧值 → 计算 → 写回”的模式与变量累计相同，只是状态按键分开保存。

一条记录与多条记录

字典表示一个学生，字典列表表示多个学生：[{"name":"A","score":80}, ...]。先用 for 取一个 record，再用 record["score"] 取该记录字段。不要对整个 records 直接写 records["score"]，外层是列表，索引需要整数或切片。

面对复杂结构，先逐层问 type 和 len，再用一个很小的数据例子。很多所谓“AI 数据问题”本质是把列表、字典、字符串层次搞错。

集合用于去重和成员判断

set([1,1,2]) 得到只含 1 与 2 的集合。空集合写 set()，{} 是空字典。集合元素也需要可哈希；集合不提供索引，迭代顺序不作为程序结果约定。想稳定展示可排序元素，用 sorted。

交集 a & b 是两边都有；并集 a | b 是任一边有；差集 a - b 是只在 a；对称差 a ^ b 是只在一边。set 去重不保留你想要的原列表顺序；保序去重可组合 seen 集合与结果列表。

怎样选容器

不要为了显得高级强行选择复杂结构。先画出一条数据，再决定“一条用什么、多条用什么”。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

student = {"name": "小林", "score": 85}
student["score"] = 90
print(student["name"], student["score"])
print(student.get("city", "未知"))
print("city" in student)

小林 90
未知
False

counts = {}
for word in "python is fun python is useful".split():
    counts[word] = counts.get(word, 0) + 1
for word, count in counts.items():
    print(word, count)

python 2
is 2
fun 1
useful 1

students = [
    {"name": "A", "score": 55},
    {"name": "B", "score": 80},
]
for student in students:
    if student["score"] >= 60:
        print(student["name"])

B

train_ids = {1, 2, 3}
test_ids = {3, 4}
print(sorted(train_ids & test_ids))
print(sorted(train_ids | test_ids))
print(sorted(train_ids - test_ids))

[3]
[1, 2, 3, 4]
[1, 2]

records = [("书", 30), ("餐饮", 20), ("书", 50)]
totals = {}
for category, amount in records:
    totals[category] = totals.get(category, 0) + amount
print(totals)

{'书': 80, '餐饮': 20}

seen = set()
unique = []
for word in ["a", "b", "a", "c"]:
    if word not in seen:
        seen.add(word)
        unique.append(word)
print(unique)

['a', 'b', 'c']

messages = [
    {"role": "user", "content": "什么是列表？"},
    {"role": "assistant", "content": "列表保存有顺序的元素。"},
]
messages.append({"role": "user", "content": "给我一个例子。"})
for message in messages:
    print(f"{message['role']}: {message['content']}")
print(len(messages))

user: 什么是列表？
assistant: 列表保存有顺序的元素。
user: 给我一个例子。
3

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

{'apple': 8, 'pear': 2, 'banana': 4}

stock = {"apple": 3, "pear": 2}
stock["apple"] += 5
stock["banana"] = 4
print(stock)

{'b': 1, 'a': 3, 'n': 2}

counts = {}
for char in "banana":
    counts[char] = counts.get(char, 0) + 1
print(counts)

3
{'batch_size': 16}

config = {"batch_size": 16}
print(config.get("epochs", 3))
print(config)

True

ids = ["s1", "s2", "s1", "s3"]
print(len(ids) != len(set(ids)))

['python']

a = {"python", "math"}
b = {"python", "english"}
print(sorted(a & b))

{'台北': ['A', 'C'], '高雄': ['B']}

records = [
    {"name": "A", "city": "台北"},
    {"name": "B", "city": "高雄"},
    {"name": "C", "city": "台北"},
]
groups = {}
for record in records:
    city = record["city"]
    if city not in groups:
        groups[city] = []
    groups[city].append(record["name"])
print(groups)

{1: 2, 0: 1}

records = [{"label": 1}, {"label": 0}, {"label": 1}]
counts = {}
for record in records:
    label = record["label"]
    counts[label] = counts.get(label, 0) + 1
print(counts)

24

config = {"training": {"batch_size": 8, "epochs": 3}}
training = config["training"]
print(training["batch_size"] * training["epochs"])

hi
bye
2

messages = [
    {"role": "user", "content": "hi"},
    {"role": "assistant", "content": "hello"},
    {"role": "user", "content": "bye"},
]
count = 0
for message in messages:
    if message["role"] == "user":
        print(message["content"])
        count += 1
print(count)

为什么需要函数

同一段“清洗文本、计算平均分、检查范围”的代码如果复制三次，改规则时就要改三处。函数把一个明确任务装进有名字的代码块，调用时传入数据，再得到结果。好函数名通常是动词，例如 clean_text、calculate_total。

基本形式是 def 函数名(参数):，缩进部分叫函数体。def 执行时创建函数，并不立即跑函数体；写 函数名(实际值) 才是调用。形参是定义中的名字，实参是调用时传入的值。例如 def double(number) 里的 number 是形参，double(5) 里的 5 是实参。

从调用到返回的四步

看到 answer = add(2, 3)：先求实参得到 2 和 3；进入函数，把它们分别绑定给 a 和 b；执行函数体并求出 5；return 把 5 交回调用位置，最后 answer 绑定 5。把函数调用想成表达式中的一个可求值步骤，而不只是“跳到另一段代码”。

print 与 return 必须分清

print 把内容显示到屏幕，便于人看；return 把对象交还给调用者，便于后续程序继续使用。一个只 print 没有 return 的函数，调用结果默认是 None。print(add(2, 3)) 先由 add 返回值，再让 print 显示它。

执行 return 后，当前函数立即结束，后面的函数体语句不执行。所有需要结果的路径都应有明确返回，否则有些输入会意外得到 None。返回多个值时常用 return total, count，实际返回的是一个元组，调用者可以解包。

参数的几种写法

位置参数按顺序对应；关键字参数按名字对应。power(3, exponent=2) 更容易看出第二项含义。def power(base, exponent=2) 给了默认值，调用者可以省略 exponent。普通调用中位置参数放在关键字参数前面，避免给同一个参数赋值两次。

默认值在函数定义时求值，不是每次调用重新创建。不要使用 items=[] 作为想要“每次一个新列表”的默认值，改为 items=None，进入后 if items is None: items=[]。这个检查必须用 is None，不能简单 if not items，否则调用者传入的空列表也会被替换。

作用域决定去哪里找名字

函数内部赋值创建的名字通常是局部变量，外面不能直接使用。函数可以读取外层可见名字，但把所有输入写成参数更容易理解和测试。不要一开始就依赖 global 修改全局变量。

如果函数里给 x 赋值，Python 通常把该函数中的 x 当作局部名字，即使你在赋值之前试图读外部 x，也可能得到 UnboundLocalError。改为传参和返回值，比到处加 global 更清楚。

传入列表会不会被修改

函数参数获得的是对象引用的绑定。函数内执行 items.append(x) 会修改调用者共享的列表；执行 items = [] 只改变局部参数的绑定，不会替换调用者的名字。不能简单说“Python 都是值传递”或“所有赋值都修改外部”。要看是否修改了同一个对象。

若希望函数不改输入，可先建立新列表再处理。题目应声明是否允许修改输入，测试也应检查这一点。

写函数前的输入输出约定

先用一句话描述职责；列出输入类型、合法范围、返回值；决定空输入怎么办；给出至少三个样例。平均分函数可约定空列表返回 None，也可约定抛 ValueError，两种都可能合理，关键在于调用者知道并处理。不要让约定靠读函数内部猜。

本章开始的部分习题附带额外函数测试。你除了打印展示结果，还要按指定函数名与参数实现功能；自检器会用其他输入调用函数，检查边界和是否修改了输入。

精讲：把一次函数调用拆成五个时刻

读示例 09_01 时，按“实参 → 形参 → 函数体 → 返回值 → 接收位置”追踪。对于 answer = add(2, 3)：

def 出现时先定义函数，函数体要等调用才运行。形参是函数定义里的名字，实参是调用时提供的值。第二次调用会有新的一次局部执行环境。

精讲：print 与 return 分别通向哪里

可以把 print 看作显示窗口，把 return 看作把结果交回调用位置。函数可以一边打印、一边返回，两件事互不替代。没有执行到带值的 return 时，正常结束的函数返回 None；None 是一个值，表示这里没有提供具体结果，不是字符串 "None"。

先运行示例 09_02，只把函数体中的 print(x * 2) 改成 return x * 2，预测输出会从几行变为几行。外面的 print(answer) 保持原样，这样才能单独观察返回值的变化。

为什么 AI 工具要 return？ 后面的程序需要拿到结果继续处理。若工具只打印“找到 3 条记录”，调用者拿到的可能是 None，不能把它当成列表遍历。调试日志可以 print；供下游使用的数据要设计明确的返回结构。

精讲：局部名字变化与共享对象变化

示例 09_05 中 value = value + 10 让局部名字 value 指向新整数，外面的 score 仍指向旧整数。示例 09_06 中 items.append(...) 修改双方指向的同一个列表。两者都符合“参数先绑定到传入的对象”，不需要死记“列表传引用、整数传值”这种容易误导的口诀。

默认列表陷阱的检查方法：连续调用两次，再观察第二次是否带上第一次的记录。修复时用 items is None 判断有没有提供列表；不要用 if not items，否则调用者明确传入的空列表也会被替换。这在需要修改调用者列表时会改变约定。

闭卷小问： 函数中有三个 return，一次调用最多执行几个？答案是一个；执行到第一个 return 后，本次调用就结束。不同输入可以走到不同的 return。

精讲：为什么函数调用了三次，外面的计数仍是 0

假设 next_round(current) 返回 current + 1。写 next_round(rounds) 只计算出新值，没有把它存回 rounds；写 rounds = next_round(rounds) 才会更新调用位置的名字。记住这条完整路线：旧值作为实参进入 → 函数算出新值 → return 交回 → 调用者赋值保存。

这两行写法可以放进相同的 for 循环，分别运行验证。每次普通函数调用都有自己的局部名字；整数值不会因为函数里给形参重新赋值，就自动改变调用者的名字。第 09 章新增示例 09_10 让你同时观察两个调用方式。

实操：把任务预算写成明确的输入与返回值

想象一个离线 Agent 练习，每做一步扣掉一部分预算。先定义 remaining_budget(remaining, used) 只负责计算“还剩多少”，再由外面决定是否保存新预算、打印或继续执行。这样可以分别手算单步结果和连续多步的结果。

给自己画三列：调用前余额、传入的 used、返回的新余额。先从 60 扣 15，再从新余额扣 50；按本题约定余额最低为 0，应得到 45、0。若两次都拿原始 60 作为输入，第二次会得到 10，那是调用方的数据流写错了，未必是函数公式写错。

闭卷检查： return 是否等于“修改调用者变量”？不等于。修改列表对象、重新绑定局部名字、返回一个值，是三个需要分别观察的动作。

作用域报错的下一站

在函数里直接写 rounds += 1，却没有把 rounds 设成参数或先在本次调用中赋值，会涉及 UnboundLocalError。第 13 章的示例 13_07 提供可运行的错误与修复对照；它会用该章学过的 try/except 捕获错误，便于继续观察修复结果。此处先练好参数与返回值，不必提前记异常处理语法。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

def add(a, b):
    return a + b

result = add(2, 3)
print(result)
print(add(10, 20) * 2)

5
60

def show_double(number):
    print(number * 2)

result = show_double(3)
print(result)

6
None

def mean(values):
    if not values:
        return None
    return sum(values) / len(values)

print(mean([80, 100]))
print(mean([]))

90.0
None

def greet(name, prefix="你好"):
    return f"{prefix}，{name}"

print(greet("小林"))
print(greet(prefix="晚上好", name="小陈"))

你好，小林
晚上好，小陈

score = 60

def improve(value):
    value = value + 10
    return value

new_score = improve(score)
print(score, new_score)

60 70

def add_item(items):
    items.append("B")

def replace_items(items):
    items = ["C"]

tasks = ["A"]
add_item(tasks)
replace_items(tasks)
print(tasks)

['A', 'B']

def bad_add(value, items=[]):
    items.append(value)
    return items

print(bad_add("A"))
print(bad_add("B"))

def good_add(value, items=None):
    if items is None:
        items = []
    items.append(value)
    return items

print(good_add("A"))
print(good_add("B"))

['A']
['A', 'B']
['A']
['B']

def summarize(values):
    """返回数值列表的总和与项数。"""
    return sum(values), len(values)

total, count = summarize([2, 4, 6])
print(total, count)

12 3

def count_words(text):
    words = text.split()
    return {"count": len(words), "empty": len(words) == 0}

result = count_words("  learn Python   today ")
print(result["count"])
print(result["empty"])
print(count_words("")["count"])

3
False
0

def next_round(current):
    return current + 1

rounds = 0
for _ in range(3):
    next_round(rounds)
print(f"未接收：{rounds}")

for _ in range(3):
    rounds = next_round(rounds)
    print(f"保存后：{rounds}")

未接收：0
保存后：1
保存后：2
保存后：3

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

77.0

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32

print(to_fahrenheit(25))

75.0
None

def mean(values):
    if not values:
        return None
    return sum(values) / len(values)

print(mean([60, 90]))
print(mean([]))

100

def clamp(value, low, high):
    if value < low:
        return low
    if value > high:
        return high
    return value

print(clamp(120, 0, 100))

['A', 'B']

def clean_names(names):
    result = []
    for name in names:
        clean = name.strip()
        if clean:
            result.append(clean)
    return result

print(clean_names([" A ", "  ", "B"]))

66.7%

def pass_rate(scores, threshold=60):
    if not scores:
        return None
    count = 0
    for score in scores:
        if score >= threshold:
            count += 1
    return count / len(scores)

print(f"{pass_rate([50, 60, 90]):.1%}")

['A']
['B']

def append_new(value, items=None):
    if items is None:
        items = []
    items.append(value)
    return items

print(append_new("A"))
print(append_new("B"))

True

def is_palindrome(text):
    cleaned = "".join(text.lower().split())
    return cleaned == cleaned[::-1]

print(is_palindrome("Never odd or even"))

[90.0, 180.0]

def discounted(prices, rate=0.9):
    result = []
    for price in prices:
        result.append(price * rate)
    return result

print(discounted([100, 200]))

6
Pyth
False

def summarize_text(text):
    cleaned = text.strip()
    return {
        "chars": len(cleaned),
        "preview": cleaned[:4],
        "empty": cleaned == "",
    }

result = summarize_text("  Python  ")
print(result["chars"])
print(result["preview"])
print(result["empty"])

45
0

def remaining_budget(remaining, used):
    result = remaining - used
    if result < 0:
        return 0
    return result

budget = 60
budget = remaining_budget(budget, 15)
print(budget)
budget = remaining_budget(budget, 50)
print(budget)

列表推导式按“结果 遍历 条件”读

[x * x for x in numbers if x > 0]：遍历 numbers；只保留大于 0 的 x；对每个保留项计算 x*x；收集到新列表。写法里结果在前，执行时仍先从遍历中拿到 x。

初学先展开成四行：result=[]；for；if；append。展开后理解了再缩写。列表推导式会一次生成完整列表；并非更省内存。多个嵌套 for 可以表达展开矩阵，但可读性差时普通循环更好。

两种 if 写法的区别

[x for x in nums if x > 0] 是筛选，会减少元素数量；[x if x > 0 else 0 for x in nums] 是逐项选择结果，每个输入都有一个输出。前者的 if 在 for 后；后者的 if/else 属于前面的结果表达式。

字典推导式如 {word: len(word) for word in words}；集合推导式如 {word.lower() for word in words}。字典若产生重复键，后面的值覆盖前面。

排序的 key 是“拿什么来比”

sorted(records, key=...) 默认会用 key 返回的值排序。可以先定义普通函数 def get_score(record): return record["score"]。lambda record: record["score"] 是只含一个表达式的小函数，不是必须掌握的炫技写法。

多条件排序可返回元组，例如 key=lambda r: (-r["score"], r["name"]) 表示分数降序，同分姓名升序。先比较第一项，相同再看第二项。Python 排序是稳定的，键相等时保留输入相对顺序。

zip 把多个序列并排配对

zip(names, scores) 每次给一个姓名和一个分数。默认遇到较短序列结束，较长序列余下元素会被忽略。需要一一对应时，先检查长度，或在本教材支持的 Python 3.10+ 中使用 zip(..., strict=True)，不等长会报 ValueError。

enumerate 给单个序列配索引；zip 把多个序列配成行。zip 和 enumerate 返回可迭代工具对象，要观察所有结果可 list(...)，但遍历时不必先转列表。

any 与 all

any(条件序列) 问是否至少一个为真；all(条件序列) 问是否全部为真。空输入时 any 返回 False，all 返回 True。这是逻辑约定，不能用 all([]) 推断“有数据而且合格”，业务上还要检查非空。

先保证正确，再追求简洁

一行代码不一定更容易维护。清洗文本、解析数字、记录错误同时发生时，普通 for 更清楚。函数职责明确、变量名直白、测试覆盖边界，通常比把所有代码缩成一行重要。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

numbers = [-2, 0, 3, 4]
result = []
for number in numbers:
    if number > 0:
        result.append(number ** 2)
print(result)
print([number ** 2 for number in numbers if number > 0])

[9, 16]
[9, 16]

numbers = [-2, 0, 3]
print([x for x in numbers if x > 0])
print([x if x > 0 else 0 for x in numbers])

[3]
[0, 0, 3]

records = [
    {"name": "B", "score": 90},
    {"name": "A", "score": 90},
    {"name": "C", "score": 80},
]
ordered = sorted(records, key=lambda row: (-row["score"], row["name"]))
print([row["name"] for row in ordered])

['A', 'B', 'C']

names = ["A", "B"]
scores = [80, 90]
for index, (name, score) in enumerate(zip(names, scores, strict=True), start=1):
    print(index, name, score)

1 A 80
2 B 90

scores = [50, 80, 90]
print(any(score >= 60 for score in scores))
print(all(score >= 60 for score in scores))
print(any([]), all([]))

True
False
False True

words = ["cat", "python", "AI"]
lengths = {word: len(word) for word in words}
print(lengths)

{'cat': 3, 'python': 6, 'AI': 2}

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

[9]

def positive_squares(values):
    return [value ** 2 for value in values if value > 0]

print(positive_squares([-2, 0, 3]))

['a', 'cat', 'dog', 'python']

def sort_words(words):
    return sorted(words, key=lambda word: (len(word), word))

print(sort_words(["dog", "a", "cat", "python"]))

[0, 0, 5]

def replace_negative(values):
    return [0 if value < 0 else value for value in values]

print(replace_negative([-2, 0, 5]))

{'A': 80, 'B': 90}

def make_scores(names, scores):
    return dict(zip(names, scores, strict=True))

print(make_scores(["A", "B"], [80, 90]))

True
False

def all_positive(values):
    return bool(values) and all(value > 0 for value in values)

print(all_positive([1, 2]))
print(all_positive([]))

[1, 2, 3]

def flatten(rows):
    return [value for row in rows for value in row]

print(flatten([[1, 2], [], [3]]))

模块就是组织代码的文件

一个 .py 文件可以作为模块。import math 导入模块，然后 math.sqrt(9) 使用其中的函数。from math import sqrt 直接导入名字，调用时写 sqrt(9)。前者来源清晰，后者更短；避免 from module import *，它会让名字来源难以追踪。

Python 首次导入模块时会执行模块顶层代码，然后通常缓存模块。因此不要在工具模块顶层直接开启交互输入、训练过程或大量文件写入。函数定义放顶层可以，真正运行的入口放在 main 保护下。

入口保护是什么意思

if __name__ == "__main__": 判断这个文件是否作为入口直接运行。如果直接 python app.py，条件为真；如果另一个文件 import app，条件通常为假。常见结构是定义 main()，然后在这条 if 中调用 main()。

这让同一个文件既可直接运行，也可被测试或其他文件导入复用。入口保护不是防止别人使用代码的安全机制，它只是运行方式判断。

两个文件怎样合作

建立同一文件夹中的 helpers.py，定义 def double(x): return x*2；另一个 main.py 写 from helpers import double，再调用它。从该文件夹启动 main.py。不要把你的文件命名为 random.py、json.py、csv.py 或 math.py，否则可能遮住标准库并造成看起来奇怪的导入错误。

模块搜索与解释器路径有关。发生 ModuleNotFoundError 时，先检查名称、当前使用的解释器和项目结构，不要反复随机安装。import sys; print(sys.executable) 可显示当前解释器路径。

标准库与第三方包

标准库随正常的 Python 安装提供，例如 math、random、pathlib、json、csv、collections、datetime、statistics、unittest。第三方包需要额外安装，例如 NumPy 和 PyTorch。本教材第一阶段只用标准库，你无需联网安装这些库才能完成作业。

pip 是安装 Python 包的工具。优先 python -m pip ...，意思是让“这个 Python”运行 pip，减少包装到另一个解释器里的问题。包名和导入名不一定相同，要看包的官方文档。

虚拟环境为什么有用

不同项目可能需要不同版本依赖。venv 为每个项目建立独立的解释器入口和包目录。它不是虚拟机，也不需要给每个练习建一个环境；整个学习包用一个即可。第一阶段没有第三方包，虚拟环境是操作练习，不是运行基础示例的硬性条件。

在学习包根目录打开终端，Windows 执行：

py -m venv .venv
.\.venv\Scripts\python.exe --version
.\.venv\Scripts\python.exe examples/ch01/ex01_01.py
.\.venv\Scripts\python.exe -m pip --version

Mac 执行：

python3 -m venv .venv
./.venv/bin/python --version
./.venv/bin/python examples/ch01/ex01_01.py
./.venv/bin/python -m pip --version

上面使用精确路径，无需先激活。可选激活方式：Windows PowerShell 为 .\.venv\Scripts\Activate.ps1，Mac 为 source .venv/bin/activate，激活后可用 python，退出用 deactivate。若 PowerShell 阻止激活脚本，直接使用上面的解释器完整路径即可，不必为了课程放宽系统执行策略。

换电脑时复制源代码和依赖清单，重新创建 .venv，不要搬运旧 .venv。不同操作系统路径和二进制依赖不通用。后续有第三方依赖时，可在旧环境用 python -m pip freeze > requirements.txt 保存安装快照，在新环境用 python -m pip install -r requirements.txt 安装；跨系统或新版本仍可能需要调整。当前教材无需安装第三方依赖。

随机数与实验记录

random.Random(42) 建立局部随机数生成器，可帮助在相同环境与调用顺序下复现实验。不要把固定 seed 理解为跨所有库、硬件、版本的绝对一致保证。后续学习 PyTorch 时还需要记录版本、硬件和确定性设置。

环境操作依据 Python Packaging 官方指南；具体安装选项变化时请以官方页面为准。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

import math
print(math.sqrt(81))
print(math.ceil(2.1))
print(math.floor(-2.1))
print(math.isclose(0.1 + 0.2, 0.3))

9.0
3
-3
True

from collections import Counter
counts = Counter("a b a c b a".split())
print(counts["a"])
print(counts["missing"])
print(counts.most_common(2))

3
0
[('a', 3), ('b', 2)]

from datetime import date
start = date(2026, 1, 1)
end = date(2026, 1, 8)
print((end - start).days)

7

import random
first = random.Random(42)
second = random.Random(42)
a = [first.random() for _ in range(3)]
b = [second.random() for _ in range(3)]
print(a == b)
print(all(0 <= value < 1 for value in a))

True
True

def double(value):
    return value * 2

def main():
    print(double(5))

if __name__ == "__main__":
    main()

10

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

34.33
2

import statistics
values = [1, 2, 100]
print(f"{statistics.mean(values):.2f}")
print(statistics.median(values))

[('red', 3)]

from collections import Counter
counts = Counter("red blue red green red blue".split())
print(counts.most_common(1))

3

import math
print(math.ceil(23 / 8))

0.3

from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))

True
[0, 1, 2, 3, 4]

import random
original = list(range(5))
a = original.copy()
b = original.copy()
random.Random(7).shuffle(a)
random.Random(7).shuffle(b)
print(a == b)
print(original)

相对路径相对于哪里

Path("data.txt") 默认相对于当前工作目录，不一定是代码文件所在目录。你从不同目录启动脚本，可能读到不同地方。终端先 cd 到学习包根目录可以减少混乱。

需要固定相对脚本位置时用 BASE = Path(__file__).resolve().parent，再写 BASE / "data" / "scores.csv"。__file__ 通常在脚本中存在，但交互窗口和某些 notebook 环境中没有。Path 的 / 在这里是拼接路径，不是数值除法；它会按操作系统处理分隔符。

文本读写与覆盖

path.read_text(encoding="utf-8") 返回整个文件字符串；path.write_text(text, encoding="utf-8") 写入文本，已有同名文件会被覆盖。父目录不存在时先 mkdir(parents=True, exist_ok=True)。本章示例将演示文件写入当前工作目录下的 outputs/，可反复运行并覆盖这些专用示例文件；不要替换成你自己的重要文件路径。

用 with path.open("r", encoding="utf-8") as file: 打开文件，离开 with 块后自动关闭。"r" 读取，"w" 覆盖写，"a" 追加，"x" 只在文件不存在时新建。二进制模式如 rb 面向字节，本阶段先专注文本。

一行一行处理

for line in file 可以逐行处理，避免一次把大文件读进内存。line 通常保留行末换行符。若只想去掉行末换行，用 rstrip("\n")；strip() 会连两端其他空白一起删除，是否合适取决于数据。splitlines() 把完整字符串拆成行，适合小文件。

CSV 是表格，不是随便按逗号拆

CSV 一行一条记录，通常第一行是列名。字段里可能包含逗号、引号甚至换行，所以使用 csv.DictReader / DictWriter。打开 CSV 时加 newline=""，让 csv 模块正确处理换行。

CSV 读取的字段默认是字符串，"80" 要 int 后才能计算。不要把表头拼错或空字符串当成正常分数；第 13 章学习识别与记录错误。Excel 导出的文件可能含 BOM，可尝试 encoding="utf-8-sig" 读取 UTF-8 BOM 文件，不要对所有编码问题盲目使用 errors="ignore"。

JSON 保存嵌套结构

JSON 能表示对象、数组、字符串、数字、布尔值和 null。读入 Python 后对应 dict、list、str、int/float、bool、None。JSON 文本里是 true/false/null，Python 源码里是 True/False/None。JSON 要求对象键为字符串；集合等类型不能直接序列化。

json.dumps(obj) 返回 JSON 字符串，json.loads(text) 把字符串解析为对象。json.dump(obj,file) 和 json.load(file) 面向文件对象。ensure_ascii=False 保留中文便于阅读，indent=2 让缩进清晰。数据不合法时会报 JSONDecodeError；不要使用 eval 读取 JSON。

JSONL 是每行一个 JSON 对象

每行独立解析，适合逐条流式处理记录。空行怎么处理、坏行是跳过还是终止，都要制定约定。AI 数据集常见这种格式；文本中的换行应由 JSON 转义，而不是直接破坏一行一条记录的结构。

跨电脑可靠性

使用 UTF-8、pathlib、明确的相对脚本路径，避免硬编码 C:\Users\你的名字 或 /Users/你的名字。把数据和代码一起打包。文件写出后读回来核对条数和关键字段，比“没有报错”更有说服力。

精讲：路径正确，文件才会出现在你预期的位置

Path("data/input.json") 从当前工作目录开始寻找；当前工作目录由你怎样启动程序决定。Path(__file__).resolve().parent 从脚本文件的位置定位。把项目放到另一台电脑后，后者更适合寻找随项目一起复制的数据。__file__ 用于脚本；在交互窗口或某些笔记本里不要假设它存在。

请从学习包根目录运行示例 12_06，再换一个目录用完整路径运行同一个文件，观察它打印的路径字段。该示例只解析路径，不会创建文件。真正需要写文件时，先确认目标目录；mkdir(parents=True, exist_ok=True) 可以创建缺失目录。

“先读再改再写完整 JSON”与“每行追加一条 JSONL”是两种不同设计。不要在 JSON 数组末尾直接追加另一个 JSON 对象；拼在一起通常不再是一个合法的 JSON 文档。JSONL 则约定一行一个 JSON 值，读取时逐行解析。本教材日志只使用一行一个对象。

精讲：字符串看起来像数字，不等于已经是数字

CSV 读回的 "80" 是字符串；先用 int 转换再计算。JSON 读回的值则取决于原 JSON 的类型：80 读成整数，"80" 仍是字符串，null 读成 None。成功解析文件只说明格式可以读取，不能证明字段类型和业务范围正确。

编码统一使用 UTF-8。CSV 文件使用 newline="" 交给 csv 模块处理换行；来自部分表格软件的 UTF-8 BOM 文件可以按明确需求用 utf-8-sig 读取。不要靠到处删首字符来修复表头。

自查顺序： 找到文件 → 确认编码 → 解析格式 → 检查字段 → 转换类型 → 执行业务。后面 JSON 会话示例先解决保存与读回；第 13 章补上输入校验。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

from pathlib import Path
folder = Path("outputs")
folder.mkdir(exist_ok=True)
path = folder / "example12_01.txt"
path.write_text("第一天：变量\n第二天：循环\n", encoding="utf-8")
text = path.read_text(encoding="utf-8")
print(text, end="")

第一天：变量
第二天：循环

from pathlib import Path
folder = Path("outputs")
folder.mkdir(exist_ok=True)
path = folder / "example12_02.txt"
path.write_text(" Python \n\n AI \n", encoding="utf-8")
with path.open(encoding="utf-8") as file:
    for line in file:
        clean = line.strip()
        if clean:
            print(clean)

Python
AI

import csv
from pathlib import Path
folder = Path("outputs")
folder.mkdir(exist_ok=True)
path = folder / "example12_03.csv"
with path.open("w", encoding="utf-8", newline="") as file:
    writer = csv.DictWriter(file, fieldnames=["name", "score"])
    writer.writeheader()
    writer.writerows([{"name": "小林", "score": 80}, {"name": "小陈", "score": 90}])
with path.open(encoding="utf-8", newline="") as file:
    rows = list(csv.DictReader(file))
print(type(rows[0]["score"]).__name__)
print(sum(int(row["score"]) for row in rows))

str
170

import json
config = {"name": "练习", "batch_size": 8, "enabled": True}
text = json.dumps(config, ensure_ascii=False)
restored = json.loads(text)
print(text)
print(restored == config)

{"name": "练习", "batch_size": 8, "enabled": true}
True

import json
from pathlib import Path
folder = Path("outputs")
folder.mkdir(exist_ok=True)
path = folder / "example12_05.jsonl"
records = [{"id": 1, "text": "你好"}, {"id": 2, "text": "Python"}]
with path.open("w", encoding="utf-8") as file:
    for record in records:
        file.write(json.dumps(record, ensure_ascii=False) + "\n")
with path.open(encoding="utf-8") as file:
    for line in file:
        record = json.loads(line)
        print(record["id"], record["text"])

1 你好
2 Python

from pathlib import Path
path = Path("data") / "train.jsonl"
print(path.name)
print(path.stem)
print(path.suffix)

train.jsonl
train
.jsonl

import json
from pathlib import Path

messages = [{"role": "user", "content": "学习函数"}]
path = Path("outputs/ai_chat_demo.json")
path.parent.mkdir(parents=True, exist_ok=True)
text = json.dumps(messages, ensure_ascii=False, indent=2)
path.write_text(text, encoding="utf-8")
restored = json.loads(path.read_text(encoding="utf-8"))
print(type(restored).__name__)
print(restored[0]["content"])
print(restored == messages)

list
学习函数
True

独立练习

先在 practice 中作答；提示和答案默认收起。勾选表示你已独立完成，不是自动判定通过。

['A', 'B']

def nonempty_lines(text):
    result = []
    for line in text.splitlines():
        clean = line.strip()
        if clean:
            result.append(clean)
    return result

print(nonempty_lines(" A \n\n B "))

8

import json

def read_batch_size(text):
    config = json.loads(text)
    return config.get("batch_size", 8)

print(read_batch_size('{"name":"demo"}'))

30

import csv
import io

def csv_total(text):
    reader = csv.DictReader(io.StringIO(text))
    return sum(int(row["amount"]) for row in reader)

print(csv_total("amount\n10\n20\n"))

[{'id': 1}, {'id': 2}]

import json

def parse_jsonl(text):
    records = []
    for line in text.splitlines():
        if line.strip():
            records.append(json.loads(line))
    return records

print(parse_jsonl('{"id":1}\n\n{"id":2}\n'))

['.txt', '.gz', '']

from pathlib import Path

def suffixes(names):
    return [Path(name).suffix for name in names]

print(suffixes(["a.txt", "b.tar.gz", "README"]))

[10, 20]

from pathlib import Path
from tempfile import TemporaryDirectory

def read_numbers(path):
    return [int(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]

with TemporaryDirectory() as folder:
    path = Path(folder) / "numbers.txt"
    path.write_text("10\n20\n", encoding="utf-8")
    print(read_numbers(path))

2
hello

import json

def parse_messages(text):
    messages = []
    for line in text.splitlines():
        if not line.strip():
            continue
        messages.append(json.loads(line))
    return messages

text = '{"role":"user","content":"hi"}\n\n{"role":"assistant","content":"hello"}'
messages = parse_messages(text)
print(len(messages))
print(messages[1]["content"])

三种不同的问题

语法错误让代码无法按语法解析，例如少冒号；运行时错误发生在执行到某一步时，例如 int("abc")；逻辑错误可能完全不报错，却给出错误结果，例如平均分除以固定 3 而不是实际人数。第三种尤其需要测试发现。

读 traceback 的步骤

先看最后一行的异常类型和消息，再往上找到你自己文件的行号，打开那一行，检查参与操作的变量类型和值。若这个值来自上一步，再追到它的来源。长报错栈不意味着有很多独立错误；它经常是在描述同一个错误的调用路径。

最小化问题

把大程序缩成还能复现错误的最小例子。打印 repr(value) 看不可见字符，打印 type(value) 看字符串还是数字，打印 len(values) 看是否为空。用小数据手算结果，避免一开始在上万条数据里找错。

try 与 except

把“确实可能失败的一小段”放入 try。except ValueError as error: 处理特定错误并获取消息。不要用裸 except 吞掉所有异常，不然 Ctrl+C 等中断也可能被拦截；也不要 except Exception: pass 把错误静默丢掉。

多个错误可以分别处理，例如文件不存在与 JSON 格式错误。else 可放 try 成功后执行的代码，finally 常用于不论成功失败都要执行的清理。文件关闭优先使用 with，减少手写 finally。

什么时候主动 raise

输入不符合函数约定时，可以 raise ValueError("batch_size 必须大于 0")。清晰消息比后来意外除零好。交互层可以捕获并让用户重试；核心处理函数通常报告错误，让调用者决定如何处理。

assert 与正式输入校验

assert actual == expected 常用在开发和测试中核对内部预期。它失败会抛 AssertionError。不要用 assert 替代处理外部输入的验证，因为 Python 优化模式可能移除 assert；用户输入校验应使用 if 和 raise。

浮点测试用 math.isclose(actual, expected, rel_tol=..., abs_tol=...)，容差应由问题精度决定。接近 0 时绝对容差尤其有用。不要不加思考地对所有问题套同一个容差。

为一个函数设计测试

以 mean 为例：正常输入 [2,4] →3；单元素 [5] →5；空输入 [] →None；负数 [-2,2] →0；输入不被修改。不要只选“好看的输入”。测试通过说明满足这些检查，不证明对所有可能输入绝对正确。

怎样用本教材自检器

先编辑 practice/ch09/ex09_02.py 并保存。在学习包根目录执行：

python tools/check_practice.py 09_02
python tools/check_practice.py --chapter 09

Windows 无虚拟环境时把 python 换成 py；Mac 换成 python3。自检先比较示例输出，再对部分函数题使用其他输入。它只运行学习包中的指定题目文件，不会替你保存编辑器里尚未保存的内容。未完成题显示未通过是正常的。不要用 --solutions 代替作答；该选项仅用于核验参考答案。

失败时按报告找到：运行报错、输出不同，或函数额外测试失败。先看题目函数名是否一致、return 是否遗漏、空数据是否处理，再看格式。若靠硬编码示例输出过关，并没有达到学习目的；至少自己再换两个输入。

精讲：Traceback 从哪里开始读

遇到报错先保留完整输出，再读最后一行的异常类型和原因。往上找你自己代码对应的文件名、行号和那一行表达式。最靠近末尾的调用帧通常是异常出现的地方；更上面的调用帧解释程序怎样走到那里。

练习时建立一个临时文件，只写 value = int("abc") 并运行。你应看到 ValueError。现在把输入改成 "12" 再运行：异常消失，但没有 print 就不会显示 12。这说明“运行成功”和“输出符合需求”要分别检查。不要为了看到内容而把所有函数都改成 print。

精讲：解析成功只是第一道检查

json.loads 可以读出列表、数字、字符串或字典。因此不能在解析后直接假设结果有 result["answer"]。结构化模型输出也需要检查：最外层类型是什么、必需字段是否存在、字段类型是否符合约定、值是否在范围内。

Python 中 bool 是 int 的子类。如果约定“次数必须是整数，不能是 True”，仅 isinstance(value, int) 会把 True 放进来。可以使用 type(value) is int，或在 isinstance 检查之外明确排除 bool。请理解约定后选择，不要机械地把所有 isinstance 改掉。

只有可恢复的错误才适合重试。格式错误可以要求重新生成；重复执行一个已经成功写入的工具可能造成重复记录。后面的离线示例只重试读取预设回复，最多三次；它不代表网络重试或有副作用工具的完整策略。

精讲：自检失败时怎样缩小问题

输出比较失败时，自检器会显示第一处不同的行，用引号让行首行尾空格可见。先比这一行，再检查多余的提示语和换行。函数测试失败时，Traceback 会显示 assert 对应的条件；把那组输入单独送进自己的函数，逐步打印中间值。

assert 适合本教材的开发检查。运行 Python 时若使用 -O，断言可能被移除；真正需要始终执行的外部输入校验，应写 if 和 raise。

修复实验：函数里为什么读不到外面的计数

先看新增示例 13_07 的 broken_round。函数体中出现 rounds += 1，Python 会把这里的 rounds 视为这个函数的局部名字；而 += 又要先读取旧值，所以在局部值尚未建立时抛出 UnboundLocalError。即使外面已有 rounds=0，也不能在这处读取中自动补上局部值。

示例专门捕获这一个异常并打印它的类型，随后显示外面的 rounds 仍是 0。修复版显式接收 current 并返回 current+1，再由外面赋值保存。这样每一次调用的输入和结果都能单独测试。

想看完整 Traceback，可以在临时副本里只保留 rounds、broken_round 的定义及 broken_round() 调用，去掉捕获部分再运行。此时出现异常并退出是预期现象。不同 Python 版本的错误措辞可能有差别；先看类型、文件行号和出错表达式，不必背整句英文。

实操：JSONL 的一行数据要经过三道检查

下面训练记录的约定由本教材自行制定：每行是一个对象；text 是字符串，去首尾空白后非空；label 是整数 0 或 1，不能是 True/False。它只是小型练习格式，不代表任何模型厂商的训练接口。

先确保最外层是字典，才能按字段读取；先确保 text 是字符串，才能 strip；先确保 label 是本题允许的整数类型，才能检查值域。格式能解析、字段类型正确、符合使用约定，是三件事。

为什么原始行号必须在跳过空行之前取得

用 enumerate(text.splitlines(), start=1) 先得到物理行号，再跳过空行。如果先删掉空行再编号，第 3 行的错误就可能被写成第 2 行，回原文件时会找错位置。

新增示例 13_08 有 6 行：第 1 行合法、第 2 行为空、第 3 行 JSON 损坏、第 4 行字段类型错误、第 5 行 label 超范围、第 6 行合法。先手算：保留 2 条、跳过 1 行、记录 3 个错误，错误行号应为 3、4、5。运行后逐个比对。

坏行之后还能继续，是因为明确选择了 continue

解析失败后先保存行号和错误类别，再 continue 到下一行；合法行才加入 records。try 只包住 json.loads，并只捕获 JSONDecodeError。若把整个处理函数都包进宽泛的 except 后默默跳过，拼错变量名等程序缺陷也可能被隐藏。

这个例子处理内存字符串，所以每次运行不改任何数据文件。接入第 12 章文件读取时，可以把 Path(...).read_text(encoding="utf-8") 的结果交给函数。文件不存在或编码不对属于读取层错误，不能冒充“某一行 JSON 不合法”；大文件逐行流式读取留作后续改写。

CSV 精修：从文本到可以计算的数字，中间发生了什么

前置：第 07 章列表、第 09 章函数、第 12 章 csv 和 StringIO，以及本章的 ValueError。先完成 12_03 的 CSV 字符串求和，再做下面的坏数据练习。StringIO 把内存字符串包装成可读取的文本流，不会创建文件。

本例约定表头严格为 name,score，顺序也相同；每条记录两列，姓名去掉首尾空白后非空，成绩是 int 能转换的整数字符串，范围 0 到 100。先检查列数，再检查姓名，再转换成绩，最后检查范围。第一处失败就记下原因并 continue，不能把同一条坏记录加进 valid。

0 是有效成绩。 不要用 if not score 判断“没有填成绩”，因为整数 0 的真假值为 False。应在转换前看字符串是否为空，或让 int('') 抛出 ValueError。int('80.5') 也会失败；int(' 80 ') 和 int('+80') 可以成功，本题接受 int 的这些常规写法。

为什么不直接 split(',') 或按记录数冒充行号

"林,一",80 的姓名中含逗号，csv.reader 能把它读成两列；split(',') 会错误拆成三部分。CSV 的引号内还可以合法换行，所以“第几条记录”和“原文件第几行”并不总相同。

示例 13_09 使用 reader.line_num，表示解析完当前记录时已经读到的物理行号，即记录结束行号。完全空的物理行（没有任何字符）解析成 [] 后跳过；小李 是一列，不是空行；小李, 是两列，第二列是空字符串，属于整数转换失败。坏记录只报告第一处错误。

三层实操：每次只增加一种困难

1. 读懂： 先预测示例 13_09 保留几条、错误几条，以及错误行号。运行后逐项对照上表。两个列表不是重复数据：valid 给统计层，errors 给修复原始数据的人。
2. 改写： 将 bad 改为 90，预测合法记录变为 3 条；将 101 改为 100，预测它通过；将 0 改为 -1，预测 range 错误；把“小李”改为“小李,”，预测错误从 columns 变为 integer。每次只改一项，保留其他输入。
3. 迁移： 完成习题 13_10 的离线工具耗时汇总。沿用检查顺序，但独立写出函数和边界；不看成绩例子的代码也能说明每层输入与输出，再接第 17 章成绩表清洗项目。

本例会继续处理字段错误，但错误表头会直接抛出 ValueError。严重引号错误可能让 csv.reader 抛出 csv.Error；该异常向调用者报告并停止，因为无法确定下一条记录从哪里开始。不要将所有 CSV 错误都理解成“可以安全跳过一行”。读取真实文件时使用 open(path, encoding="utf-8", newline="")，让 csv 模块处理换行。

示例实验室

先预测，再运行，再完成每例后的改写任务。输入栏是运行时需键入的内容，不要写入代码文件。

texts = ["10", "bad", "20"]
values = []
for text in texts:
    try:
        value = int(text)
    except ValueError:
        print("跳过无效值", repr(text))
    else:
        values.append(value)
print(sum(values))

跳过无效值 'bad'
30

def divide(total, count):
    if count <= 0:
        raise ValueError("count 必须为正数")
    return total / count

try:
    divide(10, 0)
except ValueError as error:
    print(error)

count 必须为正数

import math
result = 0.1 + 0.2
print(result == 0.3)
print(math.isclose(result, 0.3, rel_tol=1e-9, abs_tol=1e-12))

False
True

def clamp(value, low, high):
    return min(max(value, low), high)

assert clamp(-1, 0, 10) == 0
assert clamp(5, 0, 10) == 5
assert clamp(11, 0, 10) == 10
print("3 个检查通过")

3 个检查通过

lines = ["80", "oops", "90"]
for line_number, text in enumerate(lines, start=1):
    try:
        score = int(text)
    except ValueError:
        print(f"第 {line_number} 行不是整数：{text}")
        continue
    if not 0 <= score <= 100:
        print(f"第 {line_number} 行超出范围")
        continue
    print("保留", score)

保留 80
第 2 行不是整数：oops
保留 90

import json

def read_answer(text):
    data = json.loads(text)
    if not isinstance(data, dict):
        raise ValueError("最外层必须是对象")
    answer = data.get("answer")
    if not isinstance(answer, str) or not answer.strip():
        raise ValueError("answer 必须是非空字符串")
    return answer.strip()

replies = ["not-json", '{"answer": 12}', '{"answer": "先学函数"}']
for attempt, reply in enumerate(replies, start=1):
    try:
        answer = read_answer(reply)
    except ValueError:
        print(f"第 {attempt} 次：格式或内容不合格")
        continue
    print(f"第 {attempt} 次：{answer}")
    break
else:
    print("已用完预设回复，停止")

第 1 次：格式或内容不合格
第 2 次：格式或内容不合格
第 3 次：先学函数

rounds = 0

def broken_round():
    rounds += 1
    return rounds

try:
    broken_round()
except UnboundLocalError as error:
    print(type(error).__name__)
print(f"外部轮数：{rounds}")

def fixed_round(current):
    return current + 1

rounds = fixed_round(rounds)
rounds = fixed_round(rounds)
print(f"修复后：{rounds}")

UnboundLocalError
外部轮数：0
修复后：2

import json

def read_training_lines(text):
    records, errors = [], []
    blank_lines = 0
    for line_number, line in enumerate(text.splitlines(), start=1):
        if not line.strip():
            blank_lines += 1
            continue
        try:
            item = json.loads(line)
        except json.JSONDecodeError:
            errors.append({"line": line_number, "kind": "json"})
            continue
        if not isinstance(item, dict):
            errors.append({"line": line_number, "kind": "schema"})
            continue
        content = item.get("text")
        label = item.get("label")
        if not isinstance(content, str) or type(label) is not int:
            errors.append({"line": line_number, "kind": "schema"})
            continue
        if not content.strip() or label not in (0, 1):
            errors.append({"line": line_number, "kind": "value"})
            continue
        records.append({"text": content.strip(), "label": label})
    return records, errors, blank_lines

text = '\n'.join([
    '{"text": " Python ", "label": 1}',
    '',
    '{"text": "broken", "label": 0',
    '{"text": 42, "label": 0}',
    '{"text": "hello", "label": 2}',
    '{"text": "Agent", "label": 0}',
])
records, errors, blank_lines = read_training_lines(text)
print(f"保留 {len(records)} 条，跳过 {blank_lines} 个空行")
for error in errors:
    print(f"第 {error['line']} 行：{error['kind']}")
print(records)

保留 2 条，跳过 1 个空行
第 3 行：json
第 4 行：schema
第 5 行：value
[{'text': 'Python', 'label': 1}, {'text': 'Agent', 'label': 0}]

import csv
import io

def clean_scores_csv(text):
    reader = csv.reader(io.StringIO(text, newline=""), strict=True)
    if next(reader, None) != ["name", "score"]:
        raise ValueError("表头必须为 name,score")
    valid, errors = [], []
    for row in reader:
        end_line = reader.line_num
        if not row:
            continue
        if len(row) != 2:
            errors.append((end_line, "columns"))
            continue
        name = row[0].strip()
        if not name:
            errors.append((end_line, "name"))
            continue
        try:
            score = int(row[1].strip())
        except ValueError:
            errors.append((end_line, "integer"))
            continue
        if not 0 <= score <= 100:
            errors.append((end_line, "range"))
            continue
        valid.append({"name": name, "score": score})
    return valid, errors

text = 'name,score\n"林,一",80\n\n小陈,bad\n小周,101\n小李\n小何,0\n'
valid, errors = clean_scores_csv(text)
print(valid)
for end_line, reason in errors:
    print(f"结束行 {end_line}：{reason}")