错误和异常区别：
1.错误 Syntax Error：
指语法错误(syntax error)、输入错误或者逻辑错误造成的(类似除以零、数组越界)，这类错误会导致程序无法执行。
报错时机： python解释器立马报错，指出问题所在，程序无法执行。
解决办法：在程序执行前被纠正
2.异常Exceptions：
异常(Exceptions)指的是程序运行过程中出现的错误。通常不会导致程序崩溃，但是会干扰程序正常执行流程。
报错时机： 程序运行过程中
解决办法：python提供了一套异常处理机制，运行捕获、分析处理这些异常。
1.异常处理
Python的错误是class，所有的错误类型都继承自BaseException 。
常见的错误类型和继承关系
1.1try…except…finally
try:
print('try...')
r = 10 / int('2')
print('result:', r)
except ValueError as e:
print('ValueError:', e)
except ZeroDivisionError as e:
print('ZeroDivisionError:', e)
else:
print('no error!') ---没有错误的时候执行
finally:
print('finally...')
print('END')
所以在使用except 时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。比如：
try:
foo()
except ValueError as e:
print('ValueError')
except UnicodeError as e:
print('UnicodeError')
第二个except 永远也捕获不到UnicodeError ，因为UnicodeError 是ValueError 的子类，如果有，也被第一个except 给捕获了。
可以在调用多个其他函数的函数方法里捕获错误(不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了)
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...')
1.2 调用栈 Traceback
如果错误没有被捕获，它就会一直往上抛，最后被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()出错了，在代码文件err.py的第11行代码，
main() ---但原因是第9行：
File "err.py", line 9, in main ----调用bar('0')出错了，在代码文件err.py的第9行代码
bar('0') ---但原因是第6行：
File "err.py", line 6, in bar
return foo(s) * 2
File "err.py", line 3, in foo ---原因是return 10 / int(s)这个语句出错了，这是错误产生的源头，因
return 10 / int(s) --为下面打印了：ZeroDivisionError: division by zero
ZeroDivisionError: division by zero
1.3记录错误 logging.exception(e)
# err_logging.py
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')
同样是出错，但程序打印完错误信息后会继续执行，并正常退出：
$ python3 err_logging.py
ERROR:root:division by zero
Traceback (most recent call last):
File "err_logging.py", line 13, in main
bar('0')
File "err_logging.py", line 9, in bar
return foo(s) * 2
File "err_logging.py", line 6, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
END
通过配置，logging 还可以把错误记录到日志文件里，方便事后排查。
1.4抛出错误 raise
因为错误是class，捕获一个错误就是捕获到该class的一个实例。
因此，错误并不是凭空产生的，而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。——程序也可以主动抛出错误，让调用者来处理相应的错误。但是，应该在文档中写清楚可能会抛出哪些错误，以及错误产生的原因。
只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型（比如ValueError ，TypeError ），尽量使用Python内置的错误类型。
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 --错误通过raise语句抛出去了
bar()
在bar()函数中，我们明明已经捕获了错误，但是，打印一个ValueError!后，又把错误通过raise语句抛出去了，这不有病么？
其实这种错误处理方式不但没病，而且相当常见。捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。好比一个员工处理不了一个问题时，就把问题抛给他的老板，如果他的老板也处理不了，就一直往上抛，最终会抛给CEO去处理。
raise语句
raise 语句如果不带参数，就会把当前错误原样抛出。
此外，在except 中raise 一个Error，还可以把一种类型的错误转化成另一种类型：
try:
10 / 0
except ZeroDivisionError:
raise ValueError('input error!')
要是合理的转换逻辑就可以，但是，决不应该把一个IOError 转换成毫不相干的ValueError 。
2.调试
2.1 print
print() 最大的坏处是将来还得删掉它，想想程序里到处都是print() ，运行结果也会包含很多垃圾信息。
2.2 断言 assert
def foo(s):
n = int(s)
assert n != 0, 'n is zero!'
return 10 / n
def main():
foo('0')
如果断言失败，assert 语句本身就会抛出AssertionError ：
$ python err.py
Traceback (most recent call last):
...
AssertionError: n is zero!
程序中如果到处充斥着assert ，和print() 相比也好不到哪去。不过，启动Python解释器时可以用-O 参数来关闭assert ：
$ python -O err.py
Traceback (most recent call last):
...
ZeroDivisionError: division by zero
关闭后，你可以把所有的assert 语句当成pass 来看。
2.3 logging ——终极武器
和assert 比，logging 不会抛出错误，而且可以输出到文件：
import logging
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)
logging.info()就可以输出一段文本。运行，发现除了ZeroDivisionError，没有任何信息。怎么回事？
别急，在import logging之后添加一行配置再试试：
import logging
logging.basicConfig(level=logging.INFO)
看到输出了：
$ python err.py
INFO:root:n = 0
Traceback (most recent call last):
File "err.py", line 8, in <module>
print(10 / n)
ZeroDivisionError: division by zero
这就是logging的好处，它允许你指定记录信息的级别，有debug，info，warning，error等几个级别，当我们指定level=INFO时，logging.debug就不起作用了。同理，指定level=WARNING后，debug和info就不起作用了。这样一来，你可以放心地输出不同级别的信息，也不用删除，最后统一控制输出哪个级别的信息。
logging的另一个好处是通过简单的配置，一条语句可以同时输出到不同的地方，比如console和文件。
2.4python调试器pdb
让程序以单步方式运行，可以随时查看运行状态.
例子：
# err.py
s = '0'
n = int(s)
print(10 / n)
然后启动
$ python -m pdb err.py
> /Users/michael/Github/learn-python3/samples/debug/err.py(2)<module>()
-> s = '0'
以参数-m pdb 启动后，pdb定位到下一步要执行的代码-> s = '0' 。输入命令l 来查看代码：
(Pdb) l
1 # err.py
2 -> s = '0'
3 n = int(s)
4 print(10 / n)
输入命令n 可以单步执行代码：
(Pdb) n
> /Users/michael/Github/learn-python3/samples/debug/err.py(3)<module>()
-> n = int(s)
(Pdb) n
> /Users/michael/Github/learn-python3/samples/debug/err.py(4)<module>()
-> print(10 / n)
2.5 pdb.set_trace()
这个方法也是用pdb，但是不需要单步执行，我们只需要import pdb ，然后，在可能出错的地方放一个pdb.set_trace() ，就可以设置一个断点：
# err.py
import pdb
s = '0'
n = int(s)
pdb.set_trace() # 运行到这里会自动暂停
print(10 / n)
运行代码，程序会自动在pdb.set_trace() 暂停并进入pdb调试环境，可以用命令p 查看变量，或者用命令c 继续运行：
$ python err.py
> /Users/michael/Github/learn-python3/samples/debug/err.py(7)<module>()
-> print(10 / n)
(Pdb) p n
0
(Pdb) c
Traceback (most recent call last):
File "err.py", line 7, in <module>
print(10 / n)
ZeroDivisionError: division by zero
这个方式比直接启动pdb单步调试效率要高很多，但也高不到哪去。
2.6 IDE
如果要比较爽地设置断点、单步执行，就需要一个支持调试功能的IDE。目前比较好的Python IDE有：
Visual Studio Code：https://code.visualstudio.com/，需要安装Python插件。
PyCharm：PyCharm: the Python IDE for data science and web development
另外，Eclipse加上pydev插件也可以调试Python程序。
3.单元测试
“测试驱动开发”（TDD：Test-Driven Development）
单元测试通过意义： 如果我们对 函数代码做了修改，只需要再跑一遍单元测试，如果通过，说明我们的修改不会对 函数原有的行为造成影响，如果测试不通过，说明我们的修改与原有行为不一致，要么修改代码，要么修改测试。
这种以测试为驱动的开发模式最大的好处就是确保一个程序模块的行为符合我们设计的测试用例。在将来修改的时候，可以极大程度地保证该模块行为仍然是正确的。
运行单元测试方式
方式1：
import unittest
class TestDict(unittest.TestCase):
def setUp(self):
print('setUp...')
def tearDown(self):
print('tearDown...'
....
if __name__ == '__main__':
unittest.main()
方式2：
python -m unittest mydict_test
4.文档测试
Python的官方文档，可以看到很多文档都有示例代码。把这些示例代码在Python的交互式环境下输入并执行，结果与文档中的示例代码显示的一致。
那么，可不可以自动执行写在注释中的这些代码呢？答案是肯定的。——Python内置的文档测试（doctest）模块可以直接提取注释中的代码并执行测试。
doctest严格按照Python交互式命令行的输入和输出来判断测试结果是否正确。只有测试异常的时候，可以用... 表示中间一大段烦人的输出。
# mydict2.py
class Dict(dict):
'''
Simple dict but also support access as x.y style.
>>> d1 = Dict()
>>> d1['x'] = 100
>>> d1.x
100
>>> d1.y = 200
>>> d1['y']
200
>>> d2 = Dict(a=1, b=2, c='3')
>>> d2.c
'3'
>>> d2['empty']
Traceback (most recent call last):
...
KeyError: 'empty'
>>> d2.empty
Traceback (most recent call last):
...
AttributeError: 'Dict' object has no attribute 'empty'
'''
def __init__(self, **kw):
super(Dict, self).__init__(**kw)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError(r"'Dict' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key] = value
if __name__=='__main__':
import doctest
doctest.testmod()