Python 错误处理

1.1 错误处理

1.1.1 try

>>> try:
... print('try...')
... r = 10 / 0
... print('result:', r)
... except ZeroDivisionError as e:
... print('except:', e)
... finally:
... print('finally...')
... print('END')
...
try...
except: division by zero
finally...
END
当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。
finally语句块无论是否执行except，都会被执行的。

同时定义多个except
>>> try:
... print('try...')
... r = 10 / int('a')
... print('result:', r)
... except ValueError as e: --异常1
... print('ValueError:', e)
... except ZeroDivisionError as e: --异常2
... print('except:', e)
... else: --无异常时执行else
... print('no error')
... finally:
... print('finally...')
... print('END')
...
try...
ValueError: invalid literal for int() withbase 10: 'a'
finally...
END

跨越多层调用
使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用foo()，foo()调用bar()，结果bar()出错了，这时，只要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...')
...
>>> main()
Error: division by zero
finally...
只要在合适的层次去捕获错误就可以了。

1.1.2 调用堆栈

[root@daidai python]# cat err.py
#!/bin/bash/python
# -*- coding:utf-8 -*-

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

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

def main():
bar('0')

main()

[root@daidai python]# python err.py
Traceback (most recent call last):
File "err.py", line 13, in <module>
main()
File "err.py", line 11, in main
bar('0')
File "err.py", line 8, in bar
return foo(s) * 2
File "err.py", line 5, in foo
return 10 / int(s)
ZeroDivisionError: division by zero --最后便是错误的根源

1.1.3 记录错误

捕捉错误，把错误堆栈记录，让程序继续运行。
Python内置的logging模块可以非常容易地记录错误信息。
[root@daidai python]# cat err_logging.py
#!/usr/bin/python
# -*- coding:utf-8 -*-

import logging

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

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

def main():
try:
bar('0')
except Exception as e:
logging.exception(e)

main()
print('END')
[root@daidai python]# python err_logging.py
ERROR:root:division by zero
Traceback (most recent call last):
File "err_logging.py", line 14, in main
bar('0')
File "err_logging.py", line 10, in bar
return foo(s) * 2
File "err_logging.py", line 7, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
END

1.1.4 抛出错误

尽量使用python内置的错误类型。
错误是class，捕获一个错误就是捕获到该class的一个实例。
定义一个错误class，选择好继承关系。
>>> class FooError(ValueError):
... pass
...
>>> def foo(s):
... n = int(s)
... if n == 0:
... raise FooError('invalid value: %s' % s)
... return 10 / n
...
>>> foo('0')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in foo
__main__.FooError: invalid value: 0 --自己定义的错误

另一种错误处理方式――错误上抛
>>> def foo(s):
... n = int(s)
... if n == 0:
... raise ValueError('invalid value: %s' %s) --python内置错误
... return 10 /n
...
>>> def bar():
... try:
... foo('0')
... except ValueError as e:
... print('ValueError')
... raise --raise语句如果不带参数，就会把当前错误原样抛出。
...
>>> bar()
ValueError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in bar
File "<stdin>", line 4, in foo
ValueError: invalid value: 0
其实这种错误处理方式不但没病，而且相当常见。捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。好比一个员工处理不了一个问题时，就把问题抛给他的老板，如果他的老板也处理不了，就一直往上抛，最终会抛给CEO去处理。

在except中raise一个Error，还可以把一种类型的错误转化成另一种类型
>>> try:
... 10 / 0
... except ZeroDivisionError:
... raise ValueError('input error')
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
ZeroDivisionError: division by zero

During handling of the above exception,another exception occurred:

Traceback (most recent call last):
File "<stdin>", line 4, in <module>
ValueError: input error

本文出自 “90SirDB” 博客，请务必保留此出处http://90sirdb.blog.51cto.com/8713279/1826213