跳转到主要内容

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 / UnicodeDecodeErrorValueError 家族类型对但值非法:int("abc")、乱码解码
KeyError / IndexErrorLookupError 家族容器里查不到:键不存在 / 序号越界
AttributeError / NameError—名字层面:属性不存在 / 名字根本没定义
FileNotFoundError / PermissionErrorOSError 家族文件层面:路径错 / 没权限
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'   ← 案件定性

精读三步口诀:

  1. 从最后一行读起:先知道”是什么错”——int() 收到了 'abc'。
  2. 往上找最后一个属于你自己代码的行号:越往下离现场越近,这里 line 2, in parse_score 就是第一案发现场。真实项目的 traceback 中间常夹着几百行框架内部(site-packages)调用,跳过它们,找文件路径是你项目的那一行。
  3. 记住栈是倒着长的: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 机制对应本章概念处理什么错
解析级OutputFixingParserexcept 里换方式自救模型输出格式不对
请求级max_retriesexcept + 重试循环网络抖动、限流(瞬时)
链路级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)。