Python异常处理详解 - 好文

在shell脚本中，常用if来判断程序的某个部分是否可能会出错，并在if的分支中做出对应的处理，从而让程序更具健壮性。if判断是异常处理的一种方式，所有语言都通用。对于特性完整的编程语言来说，都有专门的异常处理机制，有些语言用起来可能会很复杂，要求一堆堆的，有些语言则非常简洁，用起来非常通畅。

入门示例

异常处理：try/except

对于索引查找的操作，在索引越界搜索的时候会报错。例如：
>>> s="long" >>> s[4] Traceback (most recent call last): File "<stdin>", line
1, in <module> IndexError: string index out of range
所报的错误是IndexError。如果将索引查找放在一个函数里：
>>> def fetcher(obj,index): ... return obj[index]
那么调用函数的时候，如果里面的索引越界了，异常将汇报到函数调用者。
>>> fetcher(s,3) 'g' >>> fetcher(s,4) Traceback (most recent call last): File
"<stdin>", line 1, in <module> File "<stdin>", line 2, in fetcher IndexError:
string index out of range
可以使用try/except来捕获异常。作为入门示例，下面是简单版的格式：
try: statement1 ... statementN except <ERRORTYPE>: ...statementS...
例如，try中是要监视正确执行与否的语句，ERRORTYPE是要监视的错误类型。

* 只要try中的任何一条语句抛出了错误，try中该异常语句后面的语句都不会再执行；

* 如果抛出的错误正好是except所监视的错误类型，就会执行statementS部分的语句；

* 如果异常正好被except捕获(匹配)到了，程序在执行完statementS后会继续执行下去，如果没有捕获到，程序将终止；
* 换句话说，except捕获到错误后，相当于处理了这个错误，程序不会因为已经被处理过的错误而停止
例如捕获上面的函数调用：
def fetcher(obj, index): return obj[index] s = "long" try: print(fetcher(s, 3)
* 4) print(fetcher(s, 4) * 4) except IndexError: print("something wrong")
print("after Exception, Continue")
输出结果：
gggg something wrong after Exception, Continue
因为上面的fetcher(s, 4)会抛出异常，且正好匹配except监视的异常类型，所以输出something wrong
，异常被处理之后，程序继续执行，即try/except后面的print()。

异常处理：try/finally

finally是try之后一定会执行的语句段落。可以结合except一起使用。
try: statement1 ... statementN finally: ...statementF... try: statement1 ...
statementN except <ERRORTYPE>: ...statementS... finally: ...statementF...
不论try中的语句是否出现异常，不论except是否捕获到对应的异常，finally都会执行：

* 如果异常没有被捕获，则在执行finally之后程序退出

* 如果异常被except捕获，则执行完except的语句之后执行finally的语句，然后程序继续运行下去
一般来说，finally中都会用来做程序善后清理工作。

例如：
def fetcher(obj, index): return obj[index] s = "long" try: print(fetcher(s, 3)
* 4) print(fetcher(s, 4) * 4) except IndexError: print("something wrong")
finally: print("in finally") print("after Exception, Continue")
输出：
gggg something wrong in finally after Exception, Continue
如果把except那段代码删掉，得到的结果将是：
gggg in finally # 输出了finally的内容 Traceback (most recent call last): File
"g:/pycode/list.py", line 8, in <module> print(fetcher(s, 4) * 4) File
"g:/pycode/list.py", line 2, in fetcher return obj[index] IndexError: string
index out of range
产生异常：raise和assert

使用raise或assert可以主动生成异常情况。其中raise可以直接抛出某个异常，assert需要通过布尔值来判断，然后再抛出给定的错误。

例如，在函数里做个没什么用的的判断，用来演示raise：
def fetcher(obj, index): if index >= len(obj): raise IndexError return
obj[index]
这和直接索引越界是以一样的。上面raise抛出的异常IndexError是一个内置异常，可以直接引用这些内置异常。稍后会演示如何自定义自己的异常。

抛出异常后，就可以按照前面介绍的try来处理异常。

assert是一种断言，在计算机语言中表示：如果断言条件为真就跳过，如果为假就抛出异常信息。它可以自定义异常信息。

例如:
def fetcher(obj, index): assert index < len(obj), "one exception" return
obj[index]
很多时候会直接在assert中使用False、True的布尔值进行程序的调试。
assert True, "assert not hit" assert False, "assert hit"
自定义异常

python中的异常是通过类来定义的，而且所有的异常类都继承自Exception类，而Exception又继承自BaseException(这个类不能直接作为其它异常类的父类)。所以自定义异常的时候，也要继承Exception，当然，继承某个中间异常类也可以。

例如，定义索引越界的异常类，注意这个类中直接pass，但因为继承了Exception，它仍然会有异常信息。
class MyIndexError(Exception): pass
例如，判断字母是否是大写，如果是，就抛异常：
def fetcher(obj,index): if index >= len(obj): raise MyIndexError return
obj[index]
测试一下：
s = "long" print(fetcher(s, 3) * 4) print(fetcher(s, 4) * 4)
结果：
gggg Traceback (most recent call last): File "g:/pycode/list.py", line 12, in
<module> print(fetcher(s, 4) * 4) File "g:/pycode/list.py", line 6, in fetcher
raise MyIndexError __main__.MyIndexError
需要注意，因为异常类都继承字Exception，except监视Exception异常的时候，也会匹配其它的异常。更标准地说，
监视异常父类，也会捕获到这个类的子类异常。

如何看抛出的异常

看异常信息是最基本的能力。例如，下面的这段代码会报除0错误：
def a(x, y): return x/y def b(x): print(a(x, 0)) b(1)
执行时，报错信息如下：
Traceback (most recent call last): File "g:/pycode/list.py", line 7, in
<module> b(1) File "g:/pycode/list.py", line 5, in b print(a(x, 0)) File
"g:/pycode/list.py", line 2, in a return x/y ZeroDivisionError: division by zero
这个堆栈跟踪信息中已经明确说明了(most recent call last)
，说明最近产生异常的调用在最上面，也就是第7行。上面的整个过程是这样的：第7行出错，它是因为第5行的代码引起的，而第5行之所以错是第2行的源代码引起的。

所以，从最底部可以看到最终是因为什么而抛出异常，从最顶部可以看到是执行到哪一句出错。

深入异常处理

try/except/else/finally
try: <statements> except <name1>: # 捕获到名为name1的异常 <statements> except (name2,
name3): # 捕获到name2或name3任一异常 <statements> except <name4> as <data>: #
捕获name4异常，并获取异常的示例 <statements> except: # 以上异常都不匹配时 <statements> else: #
没有产生异常时 <statements> finally: # 一定会执行的 <statements>
注意，当抛出的异常无法被匹配时，将归类于空的except:
，但这是很危险的行为，因为很多时候的异常是必然的，比如某些退出操作、内存不足、Ctrl+C等等，而这些都会被捕获。与之大致等价的是捕获异常类的"伪"祖先类
Exception，即except Exception:
，它和空异常匹配类似，但能解决不少不应该匹配的异常。但使用Exception依然是危险的，能不用尽量不用。

如果一个异常既能被name1匹配，又能被name2匹配，则先匹配到的处理这个异常。

通过as关键字可以将except捕获到的异常对象赋值给data变量。用法稍后会解释，现在需要知道的是，在python 3.x中，
变量data只在当前的except块范围内有效，出了范围就会被回收
。如果想要保留异常对象，可以将data赋值给一个变量。例如下面的b在出了try范围都有效，但是a在这个except之后就无效了。
except Exception as a: print(a) b=a
通过else分句可以知道，这段try代码中没有出现任何异常。否则就不会执行到else分句。

raise

raise用于手动触发一个异常。而每一种异常都是一个异常类，所以触发实际上是触发一个异常类的实例对象。
raise <instance> # 直接触发一个异常类的对象 raise <class> # 构建此处所给类的一个异常对象并触发 raise #
触发最近触发的异常 raise <2> from <1> # 将<1>的异常附加在<2>上
其中第二种形式，raise会根据给定类不传递任何参数地自动构建一个异常对象，并触发这个异常对象。第三种直接触发最近触发的异常对象，这在传播异常的时候很有用。

例如，下面两种方式实际上是等价的，只不过第一种方式传递的是类，raise会隐式地自动创建这个异常类的实例对象。
raise IndexError raise IndexError()
可以为异常类构建实例时指定点参数信息，这些参数会保存到名为args的元组。例如：
try: raise IndexError("something wrong") except Exception as E: print(E.args)
输出：
('something wrong',)
不仅如此，只要是异常类或异常对象，不管它们的存在形式如何，都可以放在raise中。例如：
err = IndexErro() raise err errs = [IndexError, TypeError] raise errs[0]
对于第三种raise形式，它主要用来传播异常，一般用在except代码段中。例如：
try: raise IndexError("aaaaa") except IndexError: print("something wrong")
raise

因为异常被except捕获后，就表示这个异常已经处理过了，程序会跳转到finally或整个try块的尾部继续执行下去。但是如果不想让程序继续执行，而是仅仅只是想知道发生了这个异常，并做一番处理，然后继续向上触发异常。这就是异常传播。

因为实际触发的异常都是类的实例对象，所以它有属性。而且，可以通过在except中使用as来将对象赋值给变量：
try: 1/0 except Exception as a: print(a)
变量a在出了except的范围就失效，所以可以将它保留给一个不会失效的变量：
try: 1/0 except Exception as a: print(a) b=a print(b)
如果在一个except中触发了另一个异常，会造成异常链：
try: 1/0 except Exception as E: raise TypeError('Bad')
将会报告两个异常，并提示处理异常E的时候，触发了另一个异常TypeError。
Traceback (most recent call last): File "g:/pycode/list.py", line 2, in
<module> 1/0 ZeroDivisionError: division by zero During handling of the above
exception, another exception occurred: Traceback (most recent call last): File
"g:/pycode/list.py", line 4, in <module> raise TypeError('Bad') TypeError: Bad
使用from关键字，可以让关系更加明确。
try: 1/0 except Exception as E: raise TypeError('Bad') from E
下面是错误报告：
Traceback (most recent call last): File "g:/pycode/list.py", line 2, in
<module> 1/0 ZeroDivisionError: division by zero The above exception was the
direct cause of the following exception: Traceback (most recent call last):
File "g:/pycode/list.py", line 4, in <module> raise TypeError('Bad') from E
TypeError: Bad
实际上，使用from关键字的时候，会将E的异常对象附加到TypeError的__cause__属性上。

但无论如何，这里都触发了多个异常。在python 3.3版本，可以使用from None的方式来掩盖异常的来源，也就是禁止输出异常E，停止异常链：
try: 1/0 except Exception as E: raise TypeError('Bad') from None
错误报告如下：
Traceback (most recent call last): File "g:/pycode/list.py", line 4, in
<module> raise TypeError('Bad') from None TypeError: Bad
可见，异常信息中少了很多内容。

assert

assert断言常用于调试。用法如下：
assert test, data
它实际上等价于是条件判断的raise。它等价于下面的方式：
if __debug__: if not test: raise AssertionError(data)

如果条件test的测试为真，就跳过，否则就抛出异常。这个异常是通过AssertionError类构造的，构造异常对象的参数是data。data会放进名为args的元组属性中。
try: assert False,"something wrong" except Exception as E: print(E.args)
同样，assert产生的是名为AssertionError的异常，如果不捕获这个AssertionError异常，程序将会终止。

除了调试，assert还偶尔用来判断必要的条件，不满足条件就异常，以便让程序更加健壮。例如：
def f(x): assert x >= 0, "x must great or equal than 0" return x ** 2
print(f(2)) print(f(0)) print(f(-2)) # 触发AssertionError异常
需要注意的是，写assert的测试条件时，测试结果为假才触发异常。所以，应该以if not
true的角度去考虑条件，或者以unless的角度考虑。或者说，后面触发的异常信息，和测试条件应该是正相关的，例如示例中异常信息的说法是x必须大于等于0，和测试条件
x >= 0是正相关的。

assert还常用于父类方法的某些方法中，这些方法要求子类必须重写父类的方法。于是：
class cls: ... def f(self): assert False, "you must override method: f"

此外，assert不应该用来触发那些python早已经定义好的异常。例如索引越界、类型错误等等。这些python已经定义好的异常，我们再去用AssertionError触发，这是完全多余的。例如：
def f(obj,index): assert index > len(obj), "IndexError" return obj[index]
sys.exc_info()

该函数用来收集正在处理的异常的信息。

它返回一个包含3个值的元组(type, value, traceback)
，它们是当前正在处理的异常的信息。如果没有正在处理的异常，则返回3个None组成的元组。

其中:

* type表示正在处理的异常类

* value表示正在处理的异常实例

* traceback表示一个栈空间的回调对象(参考官方手册traceback object
<https://docs.python.org/3/library/traceback.html>)
看一个示例即可知道。
class General(Exception):pass def raise0(): x = General() raise x try:
raise0() except Exception: import sys print(sys.exc_info())
执行结果：
(<class '__main__.General'>, General(), <traceback object at 0x0388F2B0>)
结果很明显，第一个返回值是异常类General，第二个返回值是抛出的异常类的实例对象，第三个返回值是traceback对象。

实际上，当需要获取当前处理的异常类时，还可以通过异常对象的__class__来获取，因为异常对象可以在except/as中赋值给变量：
class General(Exception):pass def raise0(): x = General() raise x try:
raise0() except Exception as E: import sys print(sys.exc_info()[0])
print(E.__class__)
它们的的结果是完全一样的：
<class '__main__.General'> <class '__main__.General'>
什么时候要获取异常类的信息？当except所监视的异常类比较大范围，同时又想知道具体的异常类。比如，except:或except Exception:
这两种监视的异常范围都非常大，前者会监视BaseException，也就是python的所有异常，后者监视的是Exception，也就是python的所有普通的异常。正因为监视范围太大，导致不知道具体是抛出的是哪个异常。

区分异常和错误

错误都是异常，但异常并不一定都是错误。

很常见的，文件结尾的EOF在各种语言中它都定义为异常，是异常就能被触发捕获，但在逻辑上却不认为它是错误。

除此之外，还有操作系统的异常，比如sys.exit()引发的SystemeExit异常，ctrl+c引发的的中断异常KeyboardInterrupt都属于异常，但它们和普通的异常不一样。而且python中的普通异常都继承字Exception类，但SystemExit却并非它的子类，而是BaseException的子类。所以能通过空的
except:捕获到它，却不能通过except Exception:来捕获。

异常类的继承

所有异常类都继承自Exception，要编写自定义的异常时，要么直接继承该类，要么继承该类的某个子类。

例如，下面定义三个异常类，General类继承Exception，另外两个继承General类，表示这两个是特定的、更具体的异常类。
class General(Exception):pass class Specific1(General): pass class
Specific2(General): pass def raise0(): x = General() raise x def raise1(): x =
Specific1() raise x def raise2(): x = Specific2() raise x
测试下：
for func in (raise0, raise1, raise2): try: func() except General as E: import
sys print("caught: ", E.__class__)
执行结果：
caught: <class '__main__.General'> caught: <class '__main__.Specific1'>
caught: <class '__main__.Specific2'>
前面说过，except监视父类异常的时候，也会捕获该类的子类异常。正如这里监视的是Gereral类，但触发了Specific子类异常也会被捕获。

异常类的嵌套

这是非常常见的陷阱。有两种异常嵌套的方式：try的嵌套；代码块的异常嵌套(比如函数嵌套)。无论是哪种嵌套模式，异常都只在最近(或者说是最内层)的代码块中被处理，但是finally块是所有try都会执行的。

第一种try的嵌套模式：
try: try: (1) except xxx: (2) finally: (3) except yyy: ... finally: (4)
如果在(1)处抛出了异常，无论yyy是否匹配这个异常，只要xxx能匹配这个异常，就会执行(2)。但(3)、(4)这两个finally都会执行。

第二种代码块嵌套，常见的是函数调用的嵌套，这种情况可能会比较隐式。例如：
def action2(): print(1 + []) def action1(): try: action2() except TypeError:
print('inner try') try: action1() except TypeError: print('outer try')
执行结果：
inner try

上面的action2()会抛出一个TypeError的异常。在action1()中用了try包围action2()的调用，于是action2()的异常汇报给action1()层，然后被捕获。

但是在最外面，使用try包围action1()的调用，看上去异常也会被捕获，但实际上并不会，因为在action2()中就已经通过except处理好了异常，而处理过的异常将不再是异常，不会再触发外层的异常，所以上面不会输出"outer
try"。

except应该捕获哪些异常

在考虑异常捕获的时候，需要注意几点：

* except监视的范围别太大了

* except监视的范围别太小了

* 有些异常本就该让它中断程序的运行，不要去捕获它
第三点很容易理解，有些异常会导致程序无法进行后续的运行，改中断还是得中断。

对于第一点，可能常用的大范围异常监视就是下面两种方式：
except: except Exception:
这两种方式监视的范围都太大了，比如有些不想处理的异常也会被它们监视到。更糟糕的可能是本该汇报给上层的异常，结果却被这种大范围捕获了。例如：
def func(): try: ... except: ... try: func() except IndexErro: ...
本来是想在外层的try中明确捕获func触发的IndexError异常的，但是func()内却使用了空的except:
，使得异常直接在这里被处理，外层的try永远也捕获不到任何该函数的异常。

关于第二点，不应该监视范围太小的异常。范围小，意味着监视的异常太过具体，太过细致，这种监视方式虽然精确，但却不利于维护。例如E1异常类有2个子异常类E2、E3，在代码中监视了E2、E3，但如果未来又添加了一个E1的子异常类E4，那么又得去改代码让它监视E4。如果代码是写给自己用的倒无所谓，但如果像通用模块一样交给别人用的，这意味着让别的模块使用者也去改代码。

自定义异常类

在前面设计异常类的时候，总是使用pass跳过类代码体。但却仍然能使用这个类作为异常类，因为它继承了Exception，在Exception中有相关代码可以输出异常信息。

前面说过，在构造异常类的时候可以传递参数，它们会放进异常实例对象的args属性中：
try: raise IndexError("something wrong") except Exception as E: print(E.args)
try: assert False,"something wrong too" except Exception as E: print(E.args) I
= IndexError('text') print(I.args)
对于用户自定义的类，也一样如此：
class MyError(Exception):pass try: raise MyError('something wrong') except
MyError as E: print(E.args)
不仅如此，虽然异常实例对象是一个对象，但如果直接输出实例对象，那么得到的结果将是给定的异常信息，只不过它不在元组中。
I = IndexError("index wrong") print(I) # 输出"index wrong"
很容易想到，这是因为Exception类中重写了__str__或者__repr__中的某一个或两个都重写了。

自定义异常输出

于是，自定义异常类的时候，也可以重写这两个中的一个，从而可以定制属于自己的异常类的输出信息。一般来说只重写__str__
，因为Exception中也是重写该类，且它的优先级高于__repr__。

例如下面自定义的异常类。当然，这个示例的效果非常简陋，但已足够说明问题。
class MyError(Exception): def __str__(self): return 'output this message for
something wrong' try: raise MyError("hahhaha") except MyError as E: print(E)
输出结果：
output this message for something wrong
提供构造方法

自定义异常类的时候，可以重写构造方法__init__()，这样raise异常的时候，可以指定构造的数据。而且更进一步的，还可以重写__str__
来自定义异常输出。

例如，格式化文件的程序中定义一个异常类，用来提示解析到哪个文件的哪一行出错。
class MyError(Exception): def __init__(self,line,file): self.line = line
self.file = file def __str__(self): return "format failed: %s at %s" %
(self.file, self.line) def format(): ... raise MyError(42, "a.json") ... try:
format() except MyError as E: print(E)
提供异常类的其它方法

异常类既然是类，说明它可以像普通类一样拿来应用。比如添加其它类方法。

例如，可以将异常信息写入到文件中。只需提供一个向文件写入的方法，并在except的语句块中调用这个方法即可。
class MyError(Exception): def __init__(self, line, file): self.line = line
self.file = file def logerr(self): with open('Error.log', 'a') as logfile:
print(self, file=logfile) def __str__(self): return "format failed: %s at %s" %
(self.file, self.line) def format(): raise MyError(42, "a.json") try: format()
except MyError as E: E.logerr()

热门工具换一换