一：错误、调试和测试
1 程序运行中的错误：
a 程序编写有问题造成的，这种错误我们通常称之为bug，bug是必须修复的。
b 用户输入造成的,可以通过检查用户输入来做相应的处理。
c 还有一类错误是完全无法在程序运行过程中预测的，比如写入文件的时候，磁盘满了，写不进去了，或者从网络抓取数据，网络突然断掉了。这类错误也称为异常，在程序中通常是必须处理的，否则，程序会因为各种问题终止并退出。
2 调试：我们也需要跟踪程序的执行，查看变量的值是否正确，这个过程称为调试。Python的pdb可以让我们以单步方式执行代码。
3 测试：最后，编写测试也很重要。有了良好的测试，就可以在程序修改后反复运行，确保程序输出符合我们编写的测试。
二：错误处理（用try......except......finally）
1 （用try......except......finally来捕获错误）
1 try: 2 print('try...') 3 r = 10 / 0 4 print('result:', r) 5 except ZeroDivisionError as e: 6 print('except:', e) 7 finally: 8 print('finally...') 9 print('END')
a 当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。
b 错误可能有很多种类，如果发生了不同类型的错误，应该由不同的except语句块处理。没错，可以有多个except来捕获不同类型的错误：
int()函数可能会抛出ValueError，所以我们用一个except捕获ValueError，用另一个except捕获ZeroDivisionError。
此外，如果没有错误发生，可以在except语句块后面加一个else，当没有错误发生时，会自动执行else语句：
1 try: 2 print('try...') 3 r = 10 / int('2') 4 print('result:', r) 5 except ValueError as e: 6 print('ValueError:', e) 7 except ZeroDivisionError as e: 8 print('ZeroDivisionError:', e) 9 else: 10 print('no error!') 11 finally: 12 print('finally...') 13 print('END')
c Python的错误其实也是class，所有的错误类型都继承自BaseException，所以在使用except时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。比如：
1 try: 2 foo() 3 except ValueError as e: 4 print('ValueError') 5 except UnicodeError as e: 6 print('UnicodeError')
第二个except永远也捕获不到UnicodeError，因为UnicodeError是ValueError的子类，如果有，也被第一个except给捕获了。
Python所有的错误都是从BaseException类派生的，常见的错误类型和继承关系看这里：
https://docs.python.org/3/library/exceptions.html#exception-hierarchy
d 使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用foo()，foo()调用bar()，结果bar()出错了，这时，只要main()捕获到了，就可以处理：
1 def foo(s): 2 return 10 / int(s) 3 4 def bar(s): 5 return foo(s) * 2 6 7 def main(): 8 try: 9 bar('0') 10 except Exception as e: 11 print('Error:', e) 12 finally: 13 print('finally...')
也就是说，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try...except...finally的麻烦。
2 调用栈（不用try......except......finally来捕获）
如果错误没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个错误信息，然后程序退出。
1 def foo(s): 2 return 10 / int(s) 3 4 def bar(s): 5 return foo(s) * 2 6 7 def main(): 8 bar('0') 9 10 main()
结果如下：
1 $ python3 err.py 2 Traceback (most recent call last): 3 File "err.py", line 11, in <module> 4 main() 5 File "err.py", line 9, in main 6 bar('0') 7 File "err.py", line 6, in bar 8 return foo(s) * 2 9 File "err.py", line 3, in foo 10 return 10 / int(s) 11 ZeroDivisionError: division by zero
不过要自己分析错误的调用栈信息，定位错误的位置。
3 记录错误
如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继续执行下去。
Python内置的logging模块可以非常容易地记录错误信息：
1 import logging 2 3 def foo(s): 4 return 10 / int(s) 5 6 def bar(s): 7 return foo(s) * 2 8 9 def main(): 10 try: 11 bar('0') 12 except Exception as e: 13 logging.exception(e) 14 15 main() 16 print('END')
同样是出错，但程序打印完错误信息后会继续执行，并正常退出
1 $ python3 err_logging.py 2 ERROR:root:division by zero 3 Traceback (most recent call last): 4 File "err_logging.py", line 13, in main 5 bar('0') 6 File "err_logging.py", line 9, in bar 7 return foo(s) * 2 8 File "err_logging.py", line 6, in foo 9 return 10 / int(s) 10 ZeroDivisionError: division by zero 11 END
通过配置，logging还可以把错误记录到日志文件里，方便事后排查。
4 抛出错误
因为错误是class，捕获一个错误就是捕获到该class的一个实例。因此，错误并不是凭空产生的，而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。
如果要抛出错误，首先根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例
1 # err_raise.py 2 class FooError(ValueError): 3 pass 4 5 def foo(s): 6 n = int(s) 7 if n==0: 8 raise FooError('invalid value: %s' % s) 9 return 10 / n 10 11 foo('0')
执行，可以最后跟踪到我们自己定义的错误
1 $ python3 err_raise.py 2 Traceback (most recent call last): 3 File "err_throw.py", line 11, in <module> 4 foo('0') 5 File "err_throw.py", line 8, in foo 6 raise FooError('invalid value: %s' % s) 7 __main__.FooError: invalid value: 0
只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型（比如ValueError，TypeError），尽量使用Python内置的错误类型。