Python
18 异常处理、调试与测试
traceback 精读、pdb、pytest,以及 LangChain 的容错分层
- Python
- 进阶
目标:把「报错 → 定位 → 修复 → 预防」做成一条完整技能链——精读 traceback、写对 try 的每个分支、自定义异常、用断点和 pytest 排查与预防 bug。LangChain 的容错机制(max_retries / with_fallbacks / OutputFixingParser)就是这套技能的框架化成品。
1. 为什么需要:全文红色的恐惧
入门课(10-文件和异常)教过 try/except 的基本句式,但你独立写代码时大概率仍是这个心路:程序一跑,终端刷出十几行红色英文 → 心跳加速 → 从第一行逐字读 → 越读越懵 → 干脆用 try: 包住整个 main() 让红色消失 → 程序”能跑了”,bug 还在,只是看不见了。
问题不在你,在于缺了后半套技能。try 只是「处理」一环,完整链条是四步:
| 环节 | 技能 | 本章 |
|---|---|---|
| 报错 | 认异常类型、读 traceback | 第 2、3 节 |
| 定位 | 从 traceback 找到”案发现场”那一行 | 第 3、6 节 |
| 修复 | 断点暂停程序、盘问现场变量 | 第 6 节 |
| 预防 | 写测试把 bug 钉死,防复发 | 第 7 节 |
处理(try)反而是最不重要的一环——先定位,才知道该在哪处理、处理什么。
2. 异常的真实身份:对象,长在一棵树上
2.1 异常发生时,Python 内部做了什么
raise ValueError("...") 和函数调用本质相似:创建一个 ValueError 实例,沿当前函数 → 调用者 → 调用者的调用者……逐层上抛。每层若没有 try 接住就继续上抛,抛到脚本最顶层还没人接,Python 才打印 traceback 并退出。所以 traceback 不是”错误报告”,而是这颗异常对象途经每一层的路线图。异常是对象,就有类、有继承树:
BaseException # 一切异常的根
├── SystemExit # sys.exit() 触发的"退出请求"
├── KeyboardInterrupt # 你按 Ctrl+C
└── Exception # ← 日常说的"异常"都在这棵子树下
├── ValueError # 值不对:int("abc")
│ └── UnicodeError # 编解码出错(Unicode 家族之根)
│ ├── UnicodeDecodeError # bytes → str 失败
│ └── UnicodeEncodeError # str → bytes 失败
├── TypeError # 类型不对:"a" + 1
├── LookupError # "查不到"家族的公共父类
│ ├── IndexError # 按序号查:列表[99]
│ └── KeyError # 按键查:字典["不存在的键"]
├── ArithmeticError
│ └── ZeroDivisionError
└── OSError # 系统操作失败家族
├── FileNotFoundError
└── PermissionError
两个入门课没讲的关系,现在能看清:
- KeyError 和 IndexError 是亲兄弟,共同父类
LookupError(“查找失败”)。所以except LookupError:一句同时接住越界和缺键——按家族捕获,比逐个罗列干净。 - UnicodeError 是 ValueError 的后代:按 utf-8 解码字节流失败,本质是”传给 decode 的值不合法”。它的实例还自带精确位置:
>>> try:
... b"\xff\xfeabc".decode("utf-8")
... except UnicodeDecodeError as e:
... print(e.reason, e.start, e.end)
invalid start byte 0 1
2.2 异常也是对象:e 有属性
except ... as e 里的 e 是普通对象,能查属性、能存变量、能再抛出去:
e = KeyError("scroe")
print(e.args) # ('scroe',) —— 构造参数原样存在 args 元组里
print(repr(e)) # KeyError('scroe') —— repr 带类型名,调试信息全
try:
open("/no/such/file")
except FileNotFoundError as e:
print(e.errno, e.strerror, e.filename) # 2 No such file or directory /no/such/file
OSError 家族自带 errno(系统错误码)、filename 属性——这是”异常是对象”的实用面:接住后可按属性分支处理,而不是去解析报错字符串。
2.3 速查表(入门版升级)
报错时先认家族、再认具体类:
| 报错 | 家族 | 一句话病因 |
|---|---|---|
TypeError | — | 类型不匹配:"a" + 1、len(5) |
ValueError / UnicodeDecodeError | ValueError 家族 | 类型对但值非法:int("abc")、乱码解码 |
KeyError / IndexError | LookupError 家族 | 容器里查不到:键不存在 / 序号越界 |
AttributeError / NameError | — | 名字层面:属性不存在 / 名字根本没定义 |
FileNotFoundError / PermissionError | OSError 家族 | 文件层面:路径错 / 没权限 |
ImportError / ModuleNotFoundError | — | 导入失败(17 章坑 1) |
3. traceback 精读训练
3.1 一份真实 traceback,逐行拆解
三层调用的程序(保存为 demo.py,traceback 为真实输出,~~~ 是 3.11+ 的精确标注,见 6.4):
def parse_score(text):
return int(text) # 出错的"现场"
def build_report(row):
score = parse_score(row[1])
return {"name": row[0], "score": score}
def main():
rows = [("小明", "92"), ("小红", "abc")]
for row in rows:
print(build_report(row))
main()
{'name': '小明', 'score': 92} ← 异常前的输出照常执行
Traceback (most recent call last): ← 固定开场白
File "/tmp/demo.py", line 13, in <module> ← 第 1 站:脚本顶层调 main()
main()
~~~~^^
File "/tmp/demo.py", line 11, in main ← 第 2 站:main 的第 11 行
print(build_report(row))
~~~~~~~~~~~~^^^^^
File "/tmp/demo.py", line 5, in build_report ← 第 3 站:build_report 的第 5 行
score = parse_score(row[1])
File "/tmp/demo.py", line 2, in parse_score ← 第 4 站:最深处,案发现场
return int(text) # 出错的"现场"
ValueError: invalid literal for int() with base 10: 'abc' ← 案件定性
精读三步口诀:
- 从最后一行读起:先知道”是什么错”——
int()收到了'abc'。 - 往上找最后一个属于你自己代码的行号:越往下离现场越近,这里
line 2, in parse_score就是第一案发现场。真实项目的 traceback 中间常夹着几百行框架内部(site-packages)调用,跳过它们,找文件路径是你项目的那一行。 - 记住栈是倒着长的:traceback 顺序 = 调用发生顺序(外层在前),不是时间顺序;
parse_score才是最后执行的代码。
第一行的正常输出也值得注意:异常只杀死”出错那一刻之后”的代码——所以不能靠”有没有输出”判断程序对不对。
3.2 异常链:During handling 与 raise from
实战常见形态:在 except 里处理时又抛了新异常,两个 traceback 被链在一起:
import json
def load_config(path):
try:
with open(path, encoding="utf-8") as f:
return json.load(f)
except FileNotFoundError:
raise RuntimeError("配置文件缺失,无法启动")
load_config("config.json")
Traceback (most recent call last):
File "/tmp/chain.py", line 4, in load_config ← 旧案:文件打不开
with open(path, encoding="utf-8") as f:
FileNotFoundError: [Errno 2] No such file or directory: 'config.json'
During handling of the above exception, another exception occurred:
↑ 翻译:处理上面那个错时,又出了新错
Traceback (most recent call last):
File "/tmp/chain.py", line 10, in <module> ← 新案:你抛的 RuntimeError
load_config("config.json")
File "/tmp/chain.py", line 8, in load_config
raise RuntimeError("配置文件缺失,无法启动")
RuntimeError: 配置文件缺失,无法启动
During handling of the above exception 是隐式链:Python 看到你在 except 块里抛了新异常,自动把旧异常记到新异常的 __context__ 属性上一起展示。看到它不要慌——它在送线索:真正的根因在上面那半段。
想表达得更明确,用 raise ... from e 建显式链(存入 __cause__ 属性),同样两段 traceback,中间的措辞变成:
The above exception was the direct cause of the following exception:
区别在语义:隐式链说”处理时碰巧又出事了”(可能是失误),显式链说”我就是要把底层错误翻译成业务错误”(有意为之,raise RuntimeError("配置文件缺失") from e)。第三个惯用法是裸 raise——接住、记录、原样上抛:
try:
load_config("config.json")
except FileNotFoundError:
print("记入日志") # 比如记日志
raise # 一个字都不写:把刚接住的异常原样再抛出去
4. try 的完整语法
4.1 五个部件全貌
def transfer(amount):
try:
amount = int(amount) # ① 只放"预计可能出错"的最小范围
except ValueError: # ② 按类型接
print(" 金额不是数字,拒绝")
return False
else: # ③ try 没出错才执行
print(" 转账成功")
return True
finally: # ④ 无论如何都执行
print(" [流水] 本次操作结束")
transfer("100") # 打印:转账成功 → [流水] 本次操作结束
transfer("abc") # 打印:金额不是数字,拒绝 → [流水] 本次操作结束
else 为什么存在?执行顺序:try 出错 → 匹配的 except → finally;try 没错 → 跳过 except → else → finally。若把”成功后的代码”写在 try 块尾部,它自己出的错会被同一串 except 接住——意外接住了你在成功分支里新写代码的错误,制造混乱。else 的语义是”这些代码我担保不出错,出错了别让上面的 except 背锅”。
finally 什么时候用:无论成败都要做的清理——关文件、释放连接。它连 return 都拦得住:try 里写了 return,Python 也会先执行完 finally 再真正返回(练习 2 会亲眼看到)。日常清理更推荐 with(第 10 章用过,机制在 19 章拆解)。
4.2 多分支与”按家族捕获”
def load_rows(path):
rows = []
with open(path, encoding="utf-8") as f:
for line in f:
name, score = line.strip().split(",")
rows.append((name, int(score)))
return rows
for path in ["scores_ok.txt", "bad.txt", "nope.txt"]:
try:
print(path, "->", load_rows(path))
except FileNotFoundError: # 分支 1:文件层面的问题
print(f"{path} -> 文件不存在,跳过")
except ValueError as e: # 分支 2:内容层面的问题
print(f"{path} -> 内容格式错({e}),跳过")
scores_ok.txt -> [('小明', 92)]
bad.txt -> 内容格式错(invalid literal for int() with base 10: 'abc'),跳过
nope.txt -> 文件不存在,跳过
要点:多个 except 从上往下匹配,命中即止——具体的放前面(如 UnicodeDecodeError),家族名放后面(ValueError);split(",") 解包失败和 int() 转换失败抛的都是 ValueError,被同一分支接住——分支按类型切,不按行号切。
4.3 嵌套 try:内层管细节,外层管大局
def load_rows_safe(path):
rows = []
with open(path, encoding="utf-8") as f: # 外层风险:文件本身
for line in f:
try: # 内层风险:某一行格式
name, score = line.strip().split(",")
rows.append((name, int(score)))
except ValueError:
print(f"跳过坏行: {line.strip()!r}")
return rows
内层 try 在循环里,只包”处理一行”的最小代码——一行坏了跳过继续;若把 try 包在整个循环外,一行坏就全盘放弃。try 的包裹范围本身就是设计决策:包多大 = 出错时愿意放弃多少。
4.4 光杆 except 的危害(实证)
# ❌ 光杆 except:等价于 except BaseException
try:
raise KeyboardInterrupt # 你按 Ctrl+C 时抛的就是它
except:
print("连 Ctrl+C 都被吞了,程序杀不掉") # 真实运行:这行真的会打印
光杆 except: 会连 KeyboardInterrupt(Ctrl+C)、SystemExit 一起吞掉——程序杀不死、退出请求失灵。换成 except Exception: 后同一程序直接被 Ctrl+C 终止(我实测过:异常正常上抛,打印不再出现)。规则:只捕预计中的异常;接住了处理不了的,用裸 raise 转交上层。
5. 自定义异常
标准异常说不清业务语义:ValueError 只表示”值不对”,但”库存不足”和”商品不存在”该是两种可区分的错误。定义方式是继承 Exception:
class InventoryError(Exception):
"""库存相关错误的基类:商品不存在、库存不足……"""
def ship(product, qty, stock):
if product not in stock:
raise InventoryError(f"商品不存在: {product}", list(stock))
if stock[product] < qty:
raise InventoryError(f"库存不足: 需要 {qty},只剩 {stock[product]}")
stock[product] -= qty
return f"已发货 {product} x{qty}"
stock = {"苹果": 10}
try:
ship("梨子", 2, stock)
except InventoryError as e:
print(e.args) # ('商品不存在: 梨子', ['苹果'])
if len(e.args) == 2:
print("可下单的商品:", e.args[1]) # 可下单的商品: ['苹果']
机制与设计要点:
- 类体只有一个 docstring 也行——继承来的构造器自动把所有参数收进
e.args元组。要更结构化,可派生子类、在__init__里存属性,目前的 args 够用。 - 为什么是一个家族而不只是一个类?再派生
OutOfStockError(InventoryError)、UnknownProductError(InventoryError)后,调用方except InventoryError:一句接住全部库存错误,需要细分时再按子类分支——正是第 2 节 LookupError 家族的用法,只是这棵树是你自己种的。 - 为什么框架都有自己的异常家族(pydantic 的
ValidationError、21 章展开):框架内部可能抛十几种底层错误,对外统一成自家异常后,使用者只需except 框架的Error:,不必 import 每个叶类,也不受框架内部重构影响。自定义异常 = 给调用方一个稳定的错误接口。
6. 调试方法阶梯
6.1 第一级:print 大法(何时够用)
def discount(price, off):
result = price - price * off
print(f"[debug] price={price} off={off} result={result}") # 用完删
return result
print(discount(100, 0.8)) # 期望八折 80,实际打印 20
够用的判断标准:已猜到嫌疑变量是谁,只想看它的值——上例 debug 输出直接确认公式写反了(八折应为 price * off)。劣势:每次只看一个快照、要改代码、忘删就上线。
6.2 第二级:breakpoint() 进 pdb
嫌疑不确定、要在现场”暂停时间”盘问所有变量时,用断点——在怀疑的位置写 breakpoint():
def discount(price, off):
result = price - price * off
breakpoint() # 程序跑到这里暂停,进入 pdb,等你下命令
return result
print("折后价:", discount(100, 0.8))
运行后进入交互式调试器(真实会话,(Pdb) 后是输入的命令):
$ python3 pdb_demo.py
> /tmp/pdb_demo.py(3)discount()
-> breakpoint() # 程序跑到这里暂停,进入 pdb,等你下命令
(Pdb) p price # p 表达式:查看变量当前值
100
(Pdb) p price - price * off # p 也能现场验算
20.0
(Pdb) n # next:执行下一行
> /tmp/pdb_demo.py(4)discount()
-> return result
(Pdb) c # continue:全速跑完,退出调试
折后价: 20.0
四个命令够入门:p 表达式(看值/验算)、n(下一行)、c(跑完)、l(list,列出当前位置附近代码,迷路时看自己在哪)。与 print 的本质区别:print 是”提前埋点看一个变量”,断点是”时间暂停后随意盘问所有变量”。退出用 q。
6.3 第三级:IDE 图形调试
VS Code / PyCharm 点行号左侧设红点、点”调试”运行——断点、单步、看变量全部鼠标化,本质是图形化的 pdb。会了 breakpoint() 那套概念,IDE 调试零成本上手。
6.4 Python 3.11+:报错精确到列
3.11 起 traceback 用 ~~~ 标出错在表达式的哪一段。最贴心的场景——键名打错:
data = {"name": "小明", "score": 92}
bonus = data["scroe"] + 10 # score 拼成了 scroe
Traceback (most recent call last):
File "/tmp/col.py", line 2, in <module>
bonus = data["scroe"] + 10
~~~~^^^^^^^^^ ← 直接指出问题在 data["scroe"] 这一段
KeyError: 'scroe'
一行里有多个候选出错点时(长表达式、嵌套调用),标注能省一半排查时间;3.10 及以前只有行号。
7. 测试入门:pytest 当安全网
7.1 最小可用:test_ 前缀 + assert
调试修好的 bug,怎么保证不再犯、以后改代码不弄坏别的?靠测试。pytest 是 Python 事实标准的测试框架(17 章的虚拟环境里 pip install pytest)。规则两条:测试写在 test_ 开头的文件里、每个测试是 test_ 开头的函数,函数体用普通 assert:
# test_div.py —— 与 div.py 同目录
from div import safe_div
def test_normal():
assert safe_div(10, 2) == 5 # assert 为真:通过;为假:失败
def test_zero_returns_none():
assert safe_div(10, 0) is None # b 为 0 应返回 None(docstring 的承诺)
7.2 安全网工作流:修 bug 前先写复现测试
safe_div 里藏着一个真 bug:
def safe_div(a, b):
"""两数相除;b 为 0 时返回 None"""
if a > 0 or b > 0: # bug:本意是判断 b == 0,手滑写成 or
return a / b
return None
工作流四步:先写一个会失败的测试复现 bug → 跑,看到它红 → 修代码 → 跑,看到它绿。上面的 test_zero_returns_none 就是复现测试,python3 -m pytest -q 真实输出:
FAILED test_div.py::test_zero_returns_none - ZeroDivisionError: division by zero
1 failed, 1 passed in 0.03s
pytest 把案发现场(div.py 出错的那行)直接贴进失败报告——它替你跑了”复现 → 定位”这一步。修代码(if b == 0:)再跑:2 passed,这个测试从此常驻,bug 再冒头立即变红。纪律是永远不先改代码——先红后绿,“绿”才有意义(没见过红就绿,可能根本没测到)。
7.3 两个高频工具
参数化:一组数据跑同一个测试,逻辑只写一遍(一句话了解,够用):
@pytest.mark.parametrize("a,b,expect", [(10, 2, 5), (9, 3, 3), (0, 5, 0), (-8, 4, -2)])
def test_more(a, b, expect):
assert safe_div(a, b) == expect
测异常:异常路径也是行为,也要测——pytest.raises 断言”这块代码应当抛某异常”:
def test_bad_type():
with pytest.raises(TypeError): # with 块内抛 TypeError → 测试通过
safe_div("10", 2) # 字符串不能除:TypeError
with 块内没抛指定异常则测试失败(DID NOT RAISE)——和 assert 一样是双向断言,正好把第 5 节的自定义异常也纳入保护。
7.4 fixture:测试专用的准备工作
被测函数常依赖「环境」——一个临时文件、一份初始数据、一个假对象。pytest 的 fixture 就是「测试前的准备 + 测试后的收拾」,以参数形式注入:测试函数声明什么参数名,pytest 就把准备好的东西自动递进来。最常用的是内置的 tmp_path——每个测试独享的临时目录,跑完自动删除:
def test_save_and_load(tmp_path): # 参数名固定,pytest 自动注入
path = tmp_path / "data.json"
save_students(path, [{"name": "小明", "score": 92}])
assert load_students(path)[0]["score"] == 92
不用 fixture 就得自己建目录、自己清理,还怕多个测试互相污染。自定义 fixture 用 @pytest.fixture 装饰器声明(本质就是 14 章讲的装饰器),等「多个测试共享一份昂贵准备」时再学不迟;另一个高频内置是 monkeypatch,专门在测试里临时改环境变量、屏蔽网络调用。先记住 tmp_path,够用很久。
8. 常见坑
坑 1:except 里抛新错,掩盖根因
# ❌ 处理失败时只留一句笼统的话
try:
total = read_total("bills.txt") # 实际错误:某行没有逗号 → ValueError
except Exception:
print("处理失败") # 真实运行仅打印此句,线索全灭
ValueError 的类型、消息、行号全部消失——而那正是定位所需。修法:要”翻译”就 raise 新异常 from e 保住链条(3.2 节);要”记录”就 print(repr(e)) 或裸 raise 上抛,别把 e 扔掉。
坑 2:finally 里 return,吞掉异常(3.14 起有警告)
# ❌ 想在 finally 里"兜底返回",结果异常消失了
def f():
try:
1 / 0
finally:
return -1 # Python 3.14+ 先报 SyntaxWarning
print(f()) # 打印 -1,ZeroDivisionError 无声消失
Python 3.14.8 真实运行:先打印 SyntaxWarning: 'return' in a 'finally' block,随后输出 -1——除零错误被吞,调用方拿到的”正常值”是假象。机制:finally 在函数退出前执行,其中的 return 直接终结函数,把正在上抛的异常半路丢弃。Python 3.14 起(PEP 765)触发 SyntaxWarning(python3 -W error 运行直接判 SyntaxError),未来版本将彻底禁止。修法:finally 只做清理、绝不 return,兜底值写在 except 里。
坑 3:捕获过宽 + 吞掉一切
两个变体都要命:except Exception: 接住一切后只写 pass——拼写错误(NameError/AttributeError/TypeError)全被静默,程序带内伤继续跑,错都错在离现场很远的地方;以及 try 块越包越大(第 10 章提过)——中途一旦出错,后面无辜代码全被跳过。修法:except 永远写具体类型(最多宽到家族,2.1 节);try 只包危险的那一两行(4.3 节)。
9. 在 LangChain 里的样子:容错分层
调用 LLM 的链路处处会错:网络抖、限流、Key 失效、输出格式不对。LangChain 没用一个大 try 包住一切,而是按错误层级分层容错,每层对应本章一个概念。
第一层:解析级自修复(OutputFixingParser,第 3 章)。 PydanticOutputParser 解析失败本应抛 ValidationError(pydantic 的自定义异常家族,第 5 节),OutputFixingParser 把这层包了起来:
fix_parser = OutputFixingParser.from_llm(model, parser) # model=修复用LLM, parser=原解析器
wrong_output = {"answer": "蒙娜丽莎的作者是达芬奇……", "sources": "90%"} # 字段错:应为 confidence
output = fix_parser.parse(json.dumps(wrong_output, ensure_ascii=False))
# AnswerWithConfidence(answer='蒙娜丽莎的作者是达芬奇……', confidence=90)
逐行读:wrong_output 不符合 schema,交给原 parser 必抛 ValidationError;fix_parser.parse 内部接住这个异常、不向上抛,而是把错误输出 + 格式指令再发给一次 LLM 修格式,修出合法结果——“except 分支里换一种方式自救”,还可用低规格模型当修复器降本。边界:只修格式不修语义("90%" 被改成 90 是编造的合法值)。
第二层:请求级重试(max_retries,第 1 章)。 ChatOpenAI(max_retries=2) 对”网络错误 / 429 限流 / 5xx”自动重试最多 2 次,401 等客户端错误不重试——框架内部写好了”except 瞬时错误 → 等一下再试”的循环,你只声明次数。这是对异常分类处理的典范:可重试与不可重试分开对待。
第三层:链路级兜底(with_fallbacks)。 重试解决不了的(Key 无效、服务整体故障)用备胎:
fake_llm = ChatOpenAI(api_key="invalid-key", max_retries=0) # 必定 401 的主模型
real_llm = ChatOpenAI(api_key=os.environ["OPENAI_API_KEY"]) # 可用的备胎
llm_with_fallback = fake_llm.with_fallbacks(fallbacks=[real_llm])
llm_with_fallback.invoke("你好") # 主模型失败 → 自动切 real_llm,正常返回
逐行读:max_retries=0 显式关掉重试(“这类错重试也没用”);with_fallbacks 相当于给整个调用套了最外层 try——主对象抛任何异常,就按 fallbacks 列表顺序逐个尝试备胎,全失败才抛给你。列表可挂多个、按序降级(高质量模型 → 快速模型 → 硬编码回复)。
| 层 | LangChain 机制 | 对应本章概念 | 处理什么错 |
|---|---|---|---|
| 解析级 | OutputFixingParser | except 里换方式自救 | 模型输出格式不对 |
| 请求级 | max_retries | except + 重试循环 | 网络抖动、限流(瞬时) |
| 链路级 | with_fallbacks | 嵌套 try 的最外层兜底 | Key 失效、服务故障(持续) |
设计哲学与本章一致:每层只处理自己这层的错误,处理不了的原样上抛——你写应用时的 try/except 也应如此分层,而不是一个大 try 包住一切。
本章的异常、调试、测试三块积木,最终都汇进 22-读懂LangChain:语法桥 的总装与自测清单。
小练习
练习 1:读下面的 traceback 回答:(a)异常类型和消息?(b)案发现场是哪一行?(c)users 里有没有 "小刚" 这个键?
Traceback (most recent call last):
File "app.py", line 9, in <module>
print(get_age(users, "小刚"))
File "app.py", line 6, in get_age
return users[name]
KeyError: '小刚'
练习答案
(a) KeyError: '小刚'——从最后一行读起。(b) app.py 第 6 行 return users[name]——往上找属于自己代码的行号,越靠下离现场越近。(c) 没有——KeyError 的消息就是那个没找到的键。
练习 2:写函数 ask_int(prompt) 循环要求输入整数直到合法(第 10 章做过)。新要求:成功时在 else 分支打印”输入合法”;无论成败,每次尝试后都打印”已记录一次尝试”。
练习答案
def ask_int(prompt):
while True:
try:
n = int(input(prompt))
except ValueError:
print("不是整数,再来")
else:
print("输入合法")
return n # return 前也会先执行 finally
finally:
print("已记录一次尝试")
else 保证”输入合法”只在没出错时打印;finally 每次尝试都执行,且在 return n 真正返回前运行。
练习 3:定义 NegativeAmountError(Exception);写 deposit(balance, amount),金额为负时 raise NegativeAmountError(f"金额不能为负: {amount}"),否则返回新余额。用 pytest 验证负数会抛这个异常、正常存入返回正确余额。
练习答案
class NegativeAmountError(Exception):
"""存入金额为负"""
def deposit(balance, amount):
if amount < 0:
raise NegativeAmountError(f"金额不能为负: {amount}")
return balance + amount
import pytest
from bank import NegativeAmountError, deposit
def test_negative_raises():
with pytest.raises(NegativeAmountError):
deposit(100, -1)
def test_normal():
assert deposit(100, 10) == 110
练习 4:在 Python 3.14 上调用下面的 f(0) 和 f(2),各发生什么?为什么?
def f(x):
try:
return 10 / x
finally:
return -1
练习答案
运行先出 SyntaxWarning: 'return' in a 'finally' block(3.14 起 PEP 765 的警告)。f(0):返回 -1 而不是抛 ZeroDivisionError——finally 的 return 半路截杀了正在上抛的异常。f(2):同样返回 -1——finally 无论 try 正常与否都执行,正常算出的 5.0 也被顶掉。修法:删掉 finally 里的 return,兜底写在 except(except ZeroDivisionError: return -1)。