异常、调试和测试

异常处理

Python提供了try...except...finally异常处理机制。

try

try用于运行可能出错的代码，执行流程：

1. try运行包裹的代码
2. 若执行出错，后续代码停止执行
   1. 跳转至异常处理代码，即except语句块，执行完except
   2. 如果有finally语句块，则执行finally语句块
3. 若没有出错，执行完try语句块
   1. 如果有finally语句块，则执行finally语句块

实例代码：

try:
    print('try...')
    r = 10 / 0       # 除0异常，停止运行 
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

# 运行结果
# try...
# except: division by zero
# finally...
# END

except

异常有很多种类，如果发生了不同类型的异常，应该由不同的except语句块处理。
所以，可以有多个except来捕获不同类型的异常：

try:
    print('try...')
    r = 10 / int('a')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
finally:
    print('finally...')
print('END')

else

如果没有异常发生，可以在except语句块后面加一个else，当没有异常发生时，会自动执行else语句：

try:
    print('try...')
    r = 10 / 2
    print('result:', r)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

Error

Python的异常其实也是class，所有的异常类型都继承自BaseException，具体继承关系可见官方文档。
所以except捕获异常类型时，不但捕获该类型的异常，同时还会捕获其子类：

try:
    foo()
except ValueError as e:
    print('ValueError')
except UnicodeError as e:
    print('UnicodeError')

UnicodeError作为ValueError的子类，一定会被第一个except捕获

多层调用

使用try...except捕获异常可以跨越多层调用，比如函数调用顺序为：main() > bar() > foo()，当foo()出时，只要main()捕获到了，就可以处理：

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        print('Error:', e)
    finally:
        print('finally...')

所以，不需要在每个可能出错的地方去捕获异常，只要在合适的层次去捕获异常就可以了。

调用栈

如果异常没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个异常信息，然后程序退出。

出错的时候，一定要分析异常的调用栈信息，才能定位异常的位置。

异常代码：

# err.py:
def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    bar('0')

main()

执行结果：

$ python3 err.py
Traceback (most recent call last):
  File "err.py", line 11, in <module>
    main()
  File "err.py", line 9, in main
    bar('0')
  File "err.py", line 6, in bar
    return foo(s) * 2
  File "err.py", line 3, in foo
    return 10 / int(s)
ZeroDivisionError: division by zero

从上往下可以看到整个异常的调用函数链：

1. Traceback (most recent call last):说明以下为异常的跟踪信息
2. File "err.py", line 11, in <module> main()说明调用main()出错，在代码文件err.py的第11行代码
3. File "err.py", line 9, in main bar('0')说明调用bar('0')出错，在代码文件err.py的第9行代码
4. File "err.py", line 6, in bar return foo(s) * 2说明return foo(s) * 2语句出错，在代码文件err.py的第6行代码
5. File "err.py", line 3, in foo return 10 / int(s)说明return 10 / int(s)语句出错，在代码文件err.py的第3行代码
6. ZeroDivisionError: integer division or modulo by zero说明异常类型ZeroDivisionError
7. 根据异常类型判断，int(s)没有出错，但是int(s)返回0，计算10 / 0时出错，找到异常源头

记录异常

• 若不捕获异常，Python解释器会打印出异常堆栈，但程序会被结束
• 若捕获异常，可以把异常堆栈打印出来，分析异常原因，同时，让程序继续执行下去

Python内置的logging模块可以非常容易地记录异常信息：

import logging

try:
    10 / 0
except Exception as e:
    logging.exception(e)

print('END')

捕获了异常后，程序打印完异常信息后会继续执行，并正常退出：

$ python3 err_logging.py
ERROR:root:division by zero
Traceback (most recent call last):
  File "err_logging.py", line 4, in <module>
    10 / 0
ZeroDivisionError: division by zero
END

通过配置，logging还可以把异常记录到日志文件里，方便事后排查。

抛出异常

异常是class，捕获一个异常就是捕获到该class的一个实例。因此，异常并不是凭空产生的，而是有意创建并抛出的。自己编写的函数也可以抛出异常。

如果要抛出异常，首先根据需要，定义异常的class，选择好继承关系，然后，用raise语句抛出异常：

class FooError(ValueError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

foo('0')

执行结果：

$ python3 err_raise.py 
Traceback (most recent call last):
  File "err_throw.py", line 11, in <module>
    foo('0')
  File "err_throw.py", line 8, in foo
    raise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0

只有在必要的时候才定义我们自己的异常类型。
一般都会选择Python已有的内置的异常类型（比如ValueError，TypeError）。

异常处理

在一些情况下，捕获异常，并打印异常信息后，又把异常通过raise语句抛出去。
这是因为当前函数不知道应该怎么处理该异常，所以，最恰当的方式是继续往上抛，让顶层调用者去处理：

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n

def bar():
    try:
        foo('0')
    except ValueError as e:
        print('ValueError!')
        raise

bar()

raise语句如果不带参数，就会把当前异常原样抛出。此外，在except中raise一个Error，还可以把一种类型的异常转化成另一种类型：

try:
    10 / 0
except ZeroDivisionError:
    raise ValueError('input error!')

但是转换逻辑必须合理，不应该把IOError转换成一个无关的ValueError。