程序翻车别慌,先把错接住:Python 异常处理
异常不是程序坏了,是 Python 在用有名字的办法告诉你哪里出了问题。本文按 Python 官方教程第 8 章讲清楚:语法错误与异常、try/except、except 按继承匹配、哪些错该接哪些不该接、raise、else、finally、with、自定义异常、异常链与 ExceptionGroup,另附虚构晨光书店记账脚本第四个月 100 次翻车的分布。

先把这篇的边界说清楚。这是「Python 基础」系列第四篇,接着前三篇往下走:第一篇讲了变量、类型和流程控制,第二篇讲了函数与模块,第三篇讲了类与继承。这篇讲异常处理:程序翻车的时候,怎么把错接住、怎么自己喊停、怎么保证收尾一定跑。它和第三篇是互相独立的两套本事,但有一个交点:这篇最后讲的自定义异常,本身就是用类写出来的——到时候你会发现,类那篇不是白学的。下面用到的「晨光书店」还是那个虚构的练手项目:一家街边小书店,店主的记账小脚本已经会算库存、会打折、会用类管书了。这篇要解决的新问题是:脚本跑着跑着总会遇到意外——店主输错一个数、要读的文件不存在、库存不够还要硬卖——以前这些意外一来程序就直接崩掉,什么都不剩。所有关于异常的说法,都来自 Python 官方教程第 8 章《Errors and Exceptions》,来源见每篇的 meta 信息与 evidence 记录;本文所有以晨光书店为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。读完这篇,你应该能做到四件事:分得清语法错误和异常,会读报错的最后一行;会写 try/except 接住指定的错,知道多个 except 子句按什么顺序匹配;会用 raise 自己抛错、用 else 和 finally 分清「没出错才跑」和「不管怎样都跑」;会给书店的错起个自己的异常名字,知道什么时候该用 with 收尾。
第一步:两种错——语法错是写错了,异常是跑错了
官方教程第 8 章开头先分了两种错,至少有两种可以区分的错误:语法错误和异常。语法错误也叫解析错误,是学 Python 时最常见的抱怨:程序还没跑,解析器先不干了。官方例子是少了个冒号:
>>> while True print('Hello world')
File "<stdin>", line 1
while True print('Hello world')
^^^^^
SyntaxError: invalid syntax
解析器会把出错的那行重复一遍,用小箭头指着它发现问题的地方。注意箭头指的地方不一定是该改的地方:这个例子里错是在 print 前面少了个冒号,但箭头指在 print 上。文件名和行号会一起印出来,告诉你该去哪找。
异常不一样:语句本身写得没错,跑起来才出问题。官方例子一口气给了三个:
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
10 * (1/0)
~^~
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
4 + spam*3
^^^^
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
'2' + 2
~~~~^~~
TypeError: can only concatenate str (not "int") to str
三个错的名字各不相同:ZeroDivisionError 是除以零,NameError 是用了没定义的名字,TypeError 是把字符串和整数直接相加。报错的最后一行告诉你发生了什么,前面那几行叫「回溯」,列出出错时的调用栈。我的判断是:新手读报错先看最后一行就够了——它直接告诉你错的类型和原因;回溯是顺着找「错从哪一行开始」的地图,程序越长越用得上。记住这句话:异常不是「程序坏了」,它是 Python 在用一种有名字的办法告诉你「这里出问题了」。有名字,就能接住它,这就是下一篇……不,这就是这一篇要讲的事。
第二步:try/except——先接住再说
官方教程 8.3 节的办法是:写一段能处理指定异常的程序。官方例子是反复问用户要一个整数,直到拿到合法的数为止,同时允许用户用 Ctrl-C 中断程序(中断会以 KeyboardInterrupt 异常的形式发出来):
>>> while True:
... try:
... x = int(input("Please enter a number: "))
... break
... except ValueError:
... print("Oops! That was no valid number. Try again...")
...
官方把 try 语句的工作方式列了四条:先执行 try 子句;没出异常就跳过 except 子句,整条 try 语句结束;try 子句里出了异常,剩下的部分跳过,如果异常类型和 except 后面写的类型对得上,就执行 except 子句,然后继续往下跑;如果对不上,就交给外层的 try 语句,要是一直没人接,就是未处理的异常,程序停下来并打印报错信息。
书店的版本:店主在终端里输价格,输错了不该整个脚本崩掉,该提示一句再问一遍。为了不用真的等人敲键盘,下面的例子用一个列表假装是店主先后输的东西:
def parse_price(text):
"""把店主输的价格转成数字,转不成返回 None。"""
try:
return float(text)
except ValueError:
return None
>>> parse_price('59.0')
59.0
>>> parse_price('五十九')
>>> parse_price('39.5')
39.5
parse_price('五十九') 打印出来是空的,因为返回的是 None。一个 try 语句可以有多个 except 子句,给不同的异常各配一个处理办法,但最多只有一个处理办法会被执行。官方教程还提醒:处理办法只处理对应 try 子句里发生的异常,同一个 try 语句的其他处理办法里出的异常,它不管。多个异常可以写进一个元组里一起接:
try:
n = int(text)
total = 100 / n
except (ValueError, ZeroDivisionError):
total = None
输的不是数,或者输了 0,都会让 total 变成 None。我的判断是:try 里只放「可能出这一种错的那几行」,别把整个函数都塞进 try——塞得越多,出错时越不知道是哪一行出的错。这条规矩在第十步的图里排第三。
第三步:异常也有亲戚——except 的匹配按继承来
except 后面写的类,会接住这个类本身和它的派生类的实例,反过来不行:写了派生类的 except 子句,接不住基类的实例。官方教程用三个异常类把这件事讲得很干净:
class B(Exception):
pass
class C(B):
pass
class D(C):
pass
for cls in [B, C, D]:
try:
raise cls()
except D:
print("D")
except C:
print("C")
except B:
print("B")
这段代码会按顺序打印 B、C、D。官方还补了一句:如果把 except 子句的顺序颠倒过来,先写 except B,那就会打印 B、B、B——因为第一个匹配上的 except 子句就被触发了。B 是 C 和 D 的长辈,写在前面就把后辈的全接走了,后面的子句永远轮不上。所以规矩是:具体的异常写前面,宽泛的写后面。这和第三篇讲的继承查找是一个道理:越具体的越先匹配。
异常发生时还可以带上一些值,叫异常的「参数」。except 子句可以在异常名后面指定一个变量,这个变量会绑到异常实例上;异常实例通常有个 args 属性存着这些参数。官方例子:
>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
... print(type(inst)) # the exception type
... print(inst.args) # arguments stored in .args
... print(inst) # __str__ allows args to be printed directly
... x, y = inst.args # unpack args
... print('x =', x)
... print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs
内建异常类型都定义了 __str__(),可以直接把参数打印出来,不用显式取 .args。书店的例子:卖书时库存不够,异常里带上书名、要的数量和实际库存,处理的人一眼就知道差多少——第九步会写这个例子。我的判断是:except Xxx as err 这个写法要养成习惯,不写 as err 就等于把错因扔了;报错信息是留给处理代码和以后查账的人看的,不是摆设。
第四步:哪些错该接,哪些不该接
不是所有异常都该被接住。官方教程 8.3 节讲了异常家族的家谱:BaseException 是所有异常的共同基类;它的一个子类 Exception 是所有非致命异常的基类;不是 Exception 子类的异常通常不处理,因为它们表示程序应该终止,包括 sys.exit() 抛出的 SystemExit 和用户想中断程序时抛出的 KeyboardInterrupt。
这就是「裸 except」和「except Exception」的区别所在。except Exception 能接住几乎所有非致命异常,但接不住 KeyboardInterrupt 和 SystemExit——用户按 Ctrl-C 还是能停掉程序。而不写异常名的裸 except: 什么都接,连中断都拦下来,程序就停不掉了。官方教程的建议是:处理异常时,类型写得越具体越好,让没想到的异常继续往上传。我的判断是:把这句话当成这篇的中心思想——接异常不是为了「让程序永远不崩」,而是为了「让预料之中的错有预料之中的处理,让预料之外的错继续往上走、被人看见」。
官方教程给了一个处理 Exception 的最常见模式:打印或记录异常,然后重新抛出来,让调用者也有机会处理:
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("OS error:", err)
except ValueError:
print("Could not convert data to an integer.")
except Exception as err:
print(f"Unexpected {err=}, {type(err)=}")
raise
文件打不开是 OSError,内容转不成整数是 ValueError,别的意外先记下来再用裸 raise 原样抛出去。注意最后的 raise 后面什么都不写——它会把当前正在处理的那个异常重新抛出去,调用链上层的人还能再接一次。书店的版本:读进货单文件时文件不存在,提示一句「进货单文件没找到」;文件里某一行不是数字,提示「第几行不是数字」;别的意外先记下来再抛出去,别悄悄吞掉。
异常处理还有一个容易被忽略的点:处理办法不只处理 try 子句里直接发生的异常,也处理 try 子句里调的函数(哪怕是间接调的)里发生的异常。官方例子:
>>> def this_fails():
... x = 1/0
...
>>> try:
... this_fails()
... except ZeroDivisionError as err:
... print('Handling run-time error:', err)
...
Handling run-time error: division by zero
1/0 写在 this_fails 里,错却被外面的 try 接住了。异常是会「冒泡」的:哪一层都没接住,它就一路冒到最外层,程序停下。这也是为什么「在 try 里只放可能出错的那几行」重要——放得越多,冒泡的源头越难找。
第五步:raise——自己喊停
有时候不是等错发生,而是程序自己发现不对劲,主动让一个指定的异常发生。官方教程 8.4 节:raise 语句让程序员强制一个指定的异常发生。官方例子:
>>> raise NameError('HiThere')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
raise NameError('HiThere')
NameError: HiThere
raise 唯一的参数说明要抛的异常,必须是异常实例或异常类(从 BaseException 派生的类,比如 Exception 或它的子类)。如果传的是类,Python 会隐式地用无参构造把它实例化:raise ValueError 就是 raise ValueError() 的简写。
书店的例子:卖书之前先检查库存,库存不够就主动喊停,而不是等到库存变成负数才发现账错了:
def check_stock(stock, wanted):
"""库存不够就主动抛错,别等账算错了才发现。"""
if wanted > stock:
raise ValueError(f"只要 {wanted} 本,库存只有 {stock} 本")
return stock - wanted
>>> check_stock(7, 2)
5
>>> check_stock(7, 99)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
check_stock(7, 99)
File "<stdin>", line 4, in check_stock
ValueError: 只要 99 本,库存只有 7 本
7 本卖 2 本剩 5 本;要 99 本,库存只有 7 本,直接抛 ValueError,错因写在异常的消息里。第三篇里 sell() 用的是「不够就返回 False」;两种写法各有用的地方:返回 False 是把决定权交给调用的人,调用的人忘了检查返回值,错就悄悄过去了;抛异常是「这件事不能就这么过去」,调用的人必须处理,不处理程序就停下。我的判断是:调用的人「必须知道」的事,用 raise;调用的人「可以自己决定怎么办」的事,用返回值。库存不够硬卖,账会错,属于前者。
还有一种 raise 是不带参数的:如果你只需要知道异常发生了、但不打算处理它,可以用这种更简单的形式重新抛出:
>>> try:
... raise NameError('HiThere')
... except NameError:
... print('An exception flew by!')
... raise
...
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise NameError('HiThere')
NameError: HiThere
先打印一句「有个异常飞过去了」,再原样抛出去。第四步那个「记下来再抛」的模式,用的就是这个写法。
第六步:else——没出错才跑的代码
try...except 还有一个可选的 else 子句,放在所有 except 子句之后:只有 try 子句没抛异常时,它才执行。官方例子是打开几个文件、数行数:
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except OSError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
文件打不开,打印一句打不开;打得开,就数行数、关文件。官方还说了一句关键的话:用 else 子句比把额外代码加进 try 子句更好,因为这样可以避免不小心接住那些「本来不在 try 保护范围里」的异常。举个书店的例子:读价格文件,转数字这一步要是放在 try 里,转数字出的 ValueError 会被当成「文件打不开」处理,错上加错;放在 else 里,转数字的错就不会被文件那一层的 except 误接。
def read_first_price(path):
"""读进货单第一行的价格:文件打不开提示文件问题,数字转不成提示数字问题。"""
try:
f = open(path, 'r')
except OSError:
return '文件打不开'
else:
with f:
text = f.readline().strip()
try:
return float(text)
except ValueError:
return '数字转不成'
这里的 with f: 是第八步要讲的写法,先看个样子。我的判断是:else 是 try 语句里最容易被跳过的一节,但它解决的是一个真问题——「成功之后要做的事」和「可能出错的事」得分开写。写 try 的时候先问一句:这段代码是「可能出错」,还是「出错了才不用跑」?前者放 try,后者放 else。
第七步:finally——不管怎样都要收尾
try 语句还有一个可选子句 finally,专门用来定义「在任何情况下都必须执行的收尾动作」。官方例子:
>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise KeyboardInterrupt
KeyboardInterrupt
KeyboardInterrupt 没人接,但 finally 里的「Goodbye, world!」还是先打印了,异常随后才继续往上抛。官方把规则列得很细:如果 try 子句里出了异常,异常可能被 except 接住;如果没被接住,异常会在 finally 执行完之后重新抛出来;如果 except 或 else 子句里又出了异常,同样先跑 finally 再重新抛;如果 finally 子句里执行了 break、continue 或 return,异常就不会重新抛出来——这容易让人糊涂,所以不提倡,文档还注明从 3.14 版起编译器会对它发出 SyntaxWarning;如果 try 语句走到了 break、continue 或 return,finally 会先执行,再执行那个 break、continue 或 return。
官方还给了两个会让人愣一下的例子。第一个是 bool_return():
>>> def bool_return():
... try:
... return True
... finally:
... return False
...
>>> bool_return()
False
try 里要返回 True,finally 里又返回 False,最后拿到的就是 False:如果 finally 子句里有 return,返回的就是 finally 那个 return 的值,不是 try 那个。第二个是官方的 divide 例子,把 except、else、finally 全用上了:
>>> def divide(x, y):
... try:
... result = x / y
... except ZeroDivisionError:
... print("division by zero!")
... else:
... print("result is", result)
... finally:
... print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
divide("2", "1")
File "<stdin>", line 3, in divide
result = x / y
TypeError: unsupported operand type(s) for /: 'str' and 'str'
2 除以 1 得 2.0,else 打印结果,finally 照常跑;2 除以 0,except 打印「除以零」,finally 照常跑;两个字符串相除,except 只接 ZeroDivisionError,接不住 TypeError,finally 先跑,然后异常重新抛出来。我的判断是:finally 只干一件事——收尾。关文件、关连接、把「正在处理」的牌子摘下来,这些事不管成功失败都得做,就写进 finally;别在 finally 里写业务逻辑,更别在 finally 里写 return,官方文档明确说不提倡,3.14 版起还会警告。
第八步:with——自带收尾的写法
有些对象自带标准的收尾动作:不管用它的操作成功还是失败,不再需要它的时候都该收尾。官方例子是读文件:
for line in open("myfile.txt"):
print(line, end="")
这段代码的问题是,文件会在这部分代码跑完之后、一段不确定的时间里一直开着。小脚本没事,大应用就可能出问题。with 语句让文件这样的对象保证及时、正确地收尾:
with open("myfile.txt") as f:
for line in f:
print(line, end="")
这条语句跑完之后,文件 f 一定是关着的,哪怕处理这些行的时候出了问题也一样。官方原话:像文件这样提供预定义收尾动作的对象,会在自己的文档里说明这一点。书店的例子:读进货单、写日报,统统用 with open(...) as f,文件一定会被关上,不用自己写 finally 去关。我的判断是:with 就是「自带 finally 的简写」,但它只管收尾、不管接错——文件里某一行转不成数字,该接的 ValueError 还得在 with 里面或外面另写 try。收尾和接错是两件事,别指望一个 with 全包了。
第九步:自定义异常——给书店的错起个名字
程序可以自己定义异常:新建一个异常类。官方教程 8.6 节说,异常通常应该直接或间接从 Exception 类派生;异常类可以做任何别的类能做的事,但通常保持简单,往往只提供一些属性,让异常的处理者能提取到关于错误的信息。大多数标准异常的名字都以 Error 结尾。
书店的例子:库存不够是个「业务上的错」,不是 Python 自带的哪种错,值得起个自己的名字:
class OutOfStockError(Exception):
"""库存不够:想卖的数量超过了现有库存。"""
def __init__(self, title, wanted, stock):
super().__init__(f"{title} 只要 {wanted} 本,库存只有 {stock} 本")
self.title = title
self.wanted = wanted
self.stock = stock
def sell_book(title, stock, wanted):
"""卖书:够卖返回剩下的库存,不够就抛 OutOfStockError。"""
if wanted > stock:
raise OutOfStockError(title, wanted, stock)
return stock - wanted
>>> sell_book('三体', 7, 2)
5
>>> try:
... sell_book('三体', 7, 99)
... except OutOfStockError as err:
... print(err)
... print(err.title, err.wanted, err.stock)
...
三体 只要 99 本,库存只有 7 本
三体 99 7
7 本卖 2 本剩 5 本;要 99 本,抛 OutOfStockError,异常消息里写着「三体 只要 99 本,库存只有 7 本」,异常对象身上还挂着 title、wanted、stock 三个属性,处理代码想拿哪个拿哪个。因为 OutOfStockError 是从 Exception 派生的,except Exception 也能接住它;反过来,要是自定义异常没从 Exception 派生(比如直接从 BaseException 派生),except Exception 就接不住——这是第十步图里的一类翻车。
起名字也有讲究:异常类名以 Error 结尾是惯例,OutOfStockError 比 OutOfStock 一眼就能看出是个异常。我的判断是:别什么错都自定义——文件打不开、数字转不成,Python 自带的 OSError、ValueError 已经够用了;只有「这个错是你的业务独有的、调用的人需要专门处理」的时候,才值得新起一个名字。书店的「库存不够」就是这样的错:调用的人要根据它决定是提示缺货、还是去进货,和「数字转不成」完全是两回事。
第十步:错上加错——异常链、notes 与 ExceptionGroup,以及一张翻车分布图
最后三件官方教程里的进阶工具,各讲一句,知道有这回事就行。第一件是异常链:如果在 except 里面又抛了新的异常,没处理的旧异常会被附在新异常上一起显示。官方例子是打开数据库文件失败,又抛了个 RuntimeError:
>>> try:
... open("database.sqlite")
... except OSError:
... raise RuntimeError("unable to handle error")
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
open("database.sqlite")
FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
raise RuntimeError("unable to handle error")
RuntimeError: unable to handle error
想明确说「新异常就是旧异常直接导致的」,用 raise ... from ...:raise RuntimeError('Failed to open database') from exc,报错里会写「The above exception was the direct cause of the following exception」;想关掉自动链,用 raise RuntimeError from None。我的判断是:转换异常的时候写上 from 是个好习惯——不写的话,查错的人看到两个异常,还得猜它们有没有关系;写了 from,关系就写在报错里了。
第二件是 add_note:异常创建之后,还能往上加信息。官方例子:
>>> try:
... raise TypeError('bad type')
... except Exception as e:
... e.add_note('Add some information')
... e.add_note('Add some more information')
... raise
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise TypeError('bad type')
TypeError: bad type
Add some information
Add some more information
两条备注按加的顺序出现在异常后面。第三件是 ExceptionGroup:把一串异常实例包在一起一次抛出来,专门用来「一次收集多个错、而不是抛第一个就停」。官方例子:
>>> def f():
... excs = [OSError('error 1'), SystemError('error 2')]
... raise ExceptionGroup('there were problems', excs)
...
>>> try:
... f()
... except Exception as e:
... print(f'caught {type(e)}: {e}')
...
caught <class 'ExceptionGroup'>: there were problems (2 sub-exceptions)
用 except* 代替 except,还能从组里按类型挑着接:except* OSError 只接组里的 OSError,剩下的继续往上传。书店脚本用不上异常组——一次只卖一本书;但批量处理进货单、一批里好几行都有错的时候,攒起来一次报,比第一行错了就停要实用得多。
最后是这篇的翻车分布图。示例:虚构晨光书店记账脚本学 Python 第四个月,100 次和异常处理有关的翻车,原因分布如下。图里排第一的错,是不写异常名、什么都接的裸 except——连用户按 Ctrl-C 想停程序都被拦下来了。

回头看这篇的十步,其实只讲了三件事。第一,错分两种:语法错是写错了,跑之前就被拦下;异常是跑错了,有名字、能接住,读报错先看最后一行。第二,接错有分寸:类型写具体,具体的写前面、宽泛的写后面;该接的接,不该接的(比如 KeyboardInterrupt)放它走;记下来再抛,别悄悄吞掉。第三,收尾有保证:没出错才跑的放 else,不管怎样都跑的放 finally,自带收尾的用 with;业务独有的错值得起个自己的异常名字。下一篇留给文件读写:进货单和日报总不能只存在内存里——到时候这篇的 try/except/finally 和 with 会再回来,因为读文件和写文件是最常出异常的地方。
评论 (0)
原始来源
相关文章
类是把数据和规矩打包在一起的办法:一个 Book 类做出每本书自己的状态,方法让对象自己干活,继承让电子书站在纸书肩膀上。本文按 Python 官方教程第 9 章讲清楚:class 与 __init__、self、方法、类变量与实例变量、属性查找、继承与覆盖、super()、下划线私有约定、dataclass、__iter__ 与 __next__,另附虚构晨光书店记账脚本第三个月 100 次翻车的分布。
函数是把重复的活收进一个名字,模块是把定义装进文件、用 import 拿出来。本文按 Python 官方教程第 4 章 4.8–4.9 节与第 6 章讲清楚:def 与 return、局部与全局、默认参数只算一次、关键字参数、*args 与 **kwargs、/ 与 *、lambda、文档字符串与注解、模块的几种引用、__main__ 守卫、包与搜索路径,另附虚构晨光书店记账脚本第二个月 100 次翻车的分布。
变量是放东西的盒子,列表和字典是装一堆东西的盒子,if、for、while 让程序自己做决定、自己重复干活。本文按 Python 官方教程第 3、4、5 章讲清楚:数字的四种除法与浮点数小毛病、字符串的索引与切片、列表的赋值不复制、字典的 get 与 KeyError、真假判断与短路、if/elif/else、for 与 range、while 与 break/continue/循环 else,另附虚构晨光书店记账脚本一个月 100 次翻车的分布。