7. 错误、调试和测试

发表于 | 分类于

错误、调试和测试

在程序运行过程中，总会遇到各种各样的错误。

有的错误是程序编写有问题造成的，比如本来应该输出整数结果输出了字符串，这种错误我们通常称之为bug，bug是必须修复的。

有的错误是用户输入造成的，比如让用户输入email地址，结果得到一个空字符串，这种错误可以通过检查用户输入来做相应的处理。

还有一类错误是完全无法在程序运行过程中预测的，比如写入文件的时候，磁盘满了，写不进去了，或者从网络抓取数据，网络突然断掉了。这类错误也称为异常，在程序中通常是必须处理的，否则，程序会因为各种问题终止并退出。

Python内置了一套异常处理机制，来帮助我们进行错误处理。

此外，我们也需要跟踪程序的执行，查看变量的值是否正确，这个过程称为调试。Python的pdb可以让我们以单步方式执行代码。

最后，编写测试也很重要。有了良好的测试，就可以在程序修改后反复运行，确保程序输出符合我们编写的测试。

错误处理

在程序运行过程中，如果发生了错误，可以预先约定返回一个错误代码，这样就知道是否有错，以及错误的原因了。在操作系统提供的调用中，返回错误代码非常常见。比如打开文件的函数open()，成功时返回文件描述符，出错时返回-1。

用错误码来表示是否出错十分不便，因为函数本身该返回的正常结果和错误码混杂在一起，造成调用者必须用大量的代码来判断是否出错：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> def foo():
...     r=some_function()
...     if r==(-1):
...             return (-1)
...     return r
...
>>> def bar():
...     r=foo()
...     if r==(-1):
...             print('Error')
...     else:
...             pass
...

一旦出错，还要一级一级的上报，直到某个函数可以处理该错误。所以高级语言通常内置了一套try...except...finally...的错误处理机制，Python也不例外。

try

让我们用一个例子来看看try的机制：

1
2
3
4
5
6
7
8
9
>>> try:
...     print('trying')
...     r=10/0
...     print('result:',r)
... except ZeroDivisionError as e:
...     print('except:',e)
... finally:
...     print('finally..')
... print('End')

当我们认为某段代码可能会出错的时候，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except 语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕！

上面代码在计算10/0时会产生一个除法运算错误：

1
2
3
4
trying
except: division by zero
finally..
End

从输出可以看出，当错误发生的时候，后续语句print('result:',r)不会被执行，except由于捕获到了ZeroDivisionError，因此被执行。最后，finally语句被执行。然后程序按照流程走下去。

如果把除数0改为2，则执行结果如下：

1
2
3
4
trying
result: 5.0
finally...
end

由于没有错误发生，所以except语句块不会被执行，但是finally如果有，则一定会被执行 。

而且错误应该有很多种类，如果发生了不同类型的错误，应该由不同类型的except语句块处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> try:
...     print('trying')
...     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')
...
trying
ValueError: invalid literal for int() with base 10: 'a'
finally...
END

int()函数可能会抛出ValueError错误，所以我们用一个except捕获ValueError，用另一个except捕获ZeroDivisionError。

此外，如果没有错误发生，可以在except后面语句块加一个else，当没有错误发生时，会自动执行else语句。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> try:
...     print('trying')
...     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')
...
trying
result: 5.0
no error！
finally...
END

Python 的错误其实也是class，所有的错误类型都继承自BaseException，所以在使用except时需要注意的是，它不但捕获该类型的错误，还把其他子类而已捕获了，比如：

1
2
3
4
5
6
7
>>> try:
...     foo()
... except ValueError as e:
...     print('ValueError')
... except UnicodeError as e:
...     print('UnicodeError')
...

第二个except永远也捕获不到UnicodeError，因为UnicodeError是ValueError的子类，如果有也被第一个except捕获了。

Python所有的错误都是从BaseException类派生的，常见的错误类型和继承关系如下：
https://docs.python.org/3/library/exceptions.html#exception-hierarchy

使try...except捕获错误还有一个巨大的好处就是可以跨越多层调用，比如函数main()调用foo()，foo()调用bar()，结果bar()出错了，这时只要main()捕获到了，就可以处理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> 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..')
...

也就是说，不需要再每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try,,,except,,,finally的麻烦。

调用堆栈

如果错误没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个错误信息，然后程序退出，来看看err.py：

1
2
3
4
5
6
7
8
9
def foo(s):
	return 10/int(s)
def bar(s):
	return foo(s)*2
def main():
	bar('0')
main()

执行结果如下：

1
2
3
4
5
6
7
8
9
10
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

解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链：

错误信息第一行：

Traceback (most recent call last):

告诉我们这是错误的跟踪信息。

第二行和第三行：

File “err.py”, line 13, in
main()

调用main()出错了。在 代码文件err.py的第13行代码，但是原因在第11行：

File “err.py”, line 11, in main
bar(‘0’)

调用bar(0)出错了，在代码文件的第11行，但是原因在第8行：

File “err.py”, line 8, in bar
return foo(s)*2

原因是retrun foo(s)*2这个语句出错了，但这不是最终原因：

File “err.py”, line 5, in foo
return 10/int(s)

原因是return 10/int(s)这个语句出错了，这个是错误的源头，因为下面打印了：

ZeroDivisionError: division by zero

根据错误类型ZeroDivisionError，我们判断int(s)本身并没有错，但是int(s)返回0，在计算10/0时出错。

记录错误

如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。既然我们能捕获错误，就可以把错误的堆栈打印出来，然后分析错误原因，同时让程序继续执行下去。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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')

同样是出错，但程序打印完错误信息会继续执行并正常退出：

1
2
3
4
5
6
7
8
9
10
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

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

抛出错误

因为错误是class，捕获一个错误就是捕获该class的一个实例。因此错误不是凭空产生的，而是有意识的创建并抛出的。python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。

如果要抛出错误，首先要根据需要，定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例：

1
2
3
4
5
6
7
8
9
10
class FooError(ValueError):
	pass
def foo(s):
	n=int(s)
	if n==0:
		raise FooError('invald value:%s' % s)
	return 10/n
foo('0')

执行，可以最后追踪到我们定义的错误：

1
2
3
4
5
6
7
D:\笔记\Python\Notepad++>python err_raise.py
Traceback (most recent call last):
  File "err_raise.py", line 13, in <module>
    foo('0')
  File "err_raise.py", line 10, in foo
    raise FooError('invald value:%s' % s)
__main__.FooError: invald value:0

只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型，尽量使用Python内置的错误类型。

最后，我们来看另一种错误处理的方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def foo(s):
	n=int('s')
	if n==0:
		raise ValueError('invalid value: %s' % s)
	return 10/n
def bar(s):
	try:
		foo('0')
	except ValueError as e:
		print('ValueError!')
		raise
bar()

在bar()函数中，我们明明已经捕获了错误，打印了一个ValueError！后，又把错误通过raise语句抛出去了。

捕获错误目的是记录，便于后续追踪。但是由于当前函数不知道应该怎么处理该错误，最恰当的做法就是继续上抛，让顶层调用者去处理。

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

1
2
3
4
try:
	10/0
except ZeroDivisionError:
	raise ValueError('input error!')

只要合理的转换逻辑都可以接受。

调试

程序能一次性写完并正常运行的概率很小，会有各种各样的bug需要修正，因此需要一整套调试程序的手段来修复。

第一种方法简单直接，就是用print()把可能有问题的变量打印出来：

1
2
3
4
5
6
7
8
9
def foo(s):
	n=int(s)
	print('>>>n=%d' %n)
	return 10/int(s)
def main():
	foo('0')
main()

执行后在输出中查找打印的变量值：

1
2
3
4
5
6
7
8
9
>>>n=0
Traceback (most recent call last):
  File "err.py", line 12, in <module>
    main()
  File "err.py", line 10, in main
    foo('0')
  File "err.py", line 7, in foo
    return 10/int(s)
ZeroDivisionError: division by zero

用print()最大的坏处是以后还要删掉他，运行结果中会包含很多垃圾信息。

断言

凡是用print()来辅助查看的地方，都可以用断言（assert）来替代：

1
2
3
4
5
6
7
8
9
def foo(s):
	n=int(s)
	assert n!=0, 'n is zero'
	return 10/int(s)
def main():
	foo('0')
main()

assert的意思是，表达式n!=0应该是真，否则，根据程序运行的逻辑，后面的代码肯定会出错。如果断言失败，assert语句本身就会抛出AssertionError:

1
2
3
4
5
6
7
8
9
D:\笔记\Python\Notepad++>python err.py
Traceback (most recent call last):
  File "err.py", line 12, in <module>
    main()
  File "err.py", line 10, in main
    foo('0')
  File "err.py", line 6, in foo
    assert n!=0, 'n is zero'
AssertionError: n is zero

程序中如果到处都是assert，和print()相比没有好多少。不过启动Python解释器时可以用-0参数来关闭assert。关闭之后，可以把其当做pass来看。

logging

把print()替换为logging是第三种方法，和assert相比，logging不会抛出错误，而是可以输出到文件：

1
2
3
4
5
6
import logging
s='0'
n=int(s)
logging.info('n=%d' %n)
print(10/n)

logging.info()就可以输出一段文本。运行，发现除了ZeroDivisionError，没有任何信息。

1
2
3
4
Traceback (most recent call last):
  File "err.py", line 9, in <module>
    print(10/n)
ZeroDivisionError: division by zero

在import logging之后加上一行配置：

1
2
import logging
logging.basicConfig(level=logging.INFO)

输出为：

1
2
3
4
5
INFO:root:n=0
Traceback (most recent call last):
  File "err.py", line 10, in <module>
    print(10/n)
ZeroDivisionError: division by zero

这就是logging的好处，它允许你指定记录信息的级别，有debug，info，warning，error等几个级别，当我们指定level=INFO时，logging.debug就不起错用了。这样一来，你可以放心的输出不同级别的信息，也不用删除，最后统一控制输出那个级别的信息。

logging的另一个好处是通过简单的配置，一条语句可以同时输出到不同的地方，比如console和文件。

pdb

第四种方式是启动Python的调试器pdb，让程序以单步方式运行，可以随时查看运行状态：

1
2
3
s='0'
n=int(s)
print(10/n)

运行结果：

1
2
3
D:\笔记\Python\Notepad++>python -m pdb err.py
> d:\笔记\python\notepad++\err.py(4)<module>()
-> s='0'

以参数-m pdb启动后，pdb定位到下一步要执行的代码-> s='0'.输入命令l来查看代码：

1
2
3
4
5
6
7
8
(Pdb) l
  1     #!/usr/bin/env python3
  2     #-*- coding: utf-8 -*-
  3
  4  -> s='0'
  5     n=int(s)
  6     print(10/n)
[EOF]

输入命令n可以单步执行代码：

1
2
3
4
5
6
(Pdb) n
> d:\笔记\python\notepad++\err.py(5)<module>()
-> n=int(s)
(Pdb) n
> d:\笔记\python\notepad++\err.py(6)<module>()
-> print(10/n)

任何时候都可以输入命令p 变量名来查看变量：

1
2
3
4
(Pdb) p s
'0'
(Pdb) p n
0

输入命令q结束调制：

1
2
3
(Pdb) q
D:\笔记\Python\Notepad++>

pdb.set_trace()

这个方法也是用pdb，但是不需要单步执行，我们只需要import pdb，然后，可能出错的地方放一个pdb.set_trace()，就可以设置一个断点：

1
2
3
4
5
6
import pdb
s='0'
n=int(s)
pdb.set_trace()        #断点位置
print(10/n)

运行代码，程序会在pdb.set_trace()暂停并进入pdb调试环境，可以用命令p查看变量，或者用命令c继续运行：

1
2
3
4
5
6
7
8
D:\笔记\Python\Notepad++>python -m pdb err.py
> d:\笔记\python\notepad++\err.py(4)<module>()
-> import pdb
(Pdb) c
> d:\笔记\python\notepad++\err.py(9)<module>()
-> print(10/n)
(Pdb) p n
0

IDE

可以用IDE调试，如PyCharm：enter link description here
或者Eclipse加上pydev。

IDE调试很方便，但是logging更适合python调试。

单元测试

单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。比如对函数abs()，我们可以编写出以下几个测试用例：

1.输入正数，1、2.3、0.34，期待返回值和输入值相同
2.输入负数，-1、-1.2、-0.33，期待返回值与输入相反
3.输入0，期待返回0
4.输入非数值类型，比如None、[]、{}，期待抛出TypeError

把上面的测试用例放到一个测试模块里，就是一个完整的单元测试。

如果单元测试通过，说明我们测试的这个函数能够正常工作，如果单元测试不通过，要么函数有bug，要么测试条件输入不正确，需要修复。

单元测试通过后的意义在于如果我们对abs()函数代码做了修改，只需要跑一遍单元测试，如果通过，说明我们的修改不会对abs()函数原有的行为造成影响，如果不通过，说明我们的修改和原有行为不一致，要么修改代码，要么修改测试。

这种以测试为驱动的开发模式最大的好处就是确保一个程序模块的行为符合我们设计的测试用例。在将来修改的时候，可以极大程度的保证该模块行为仍然是正确的。

我们来编写一个Dict类，这个类的行为和dict一致，但是可以通过属性来访问，用起来如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> class Dict(dict):
...     def __init__(self,**kw):
...             super().__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
...
>>> d=Dict(a=1,b=2)
>>> d['a']
1
>>> d.a
1

为了编写单元测试，我们需要引入Python自带的unittest模块，编写mydict_test.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import unittest
from mydict import Dict
class TestDict(unittest.TestCase):
	def test_init(self):
		d=Dict(a=1,b='test')
		self.assertEqual(d.a,1)
		self.assertEqual(d.b,'test')
		self.assertTrue(isinstance(d,dict))
	def test_key(self):
		d=Dict()
		d['key']='value'
		self.assertEqual(d.key,'value')
	def  test_attr(self):
		d=Dict()
		d.key='value'
		self.assertTrue('key' in d)
		self.assertEqual(d[key],'value')
	def test_keyerror(self):
		d=Dict()
		with self.assertRaises(KeyError):
			value=d['empty']
	def test_attrerror(self):
		d=Dict()
		with self.assertRaises(AttributeError):
			value=d.empty

编写单元测试时，我们需要编写一个测试类，从unittest.TestCase继承。

以test开头的方法就是测试方法，不以test开头的方法不被认为是测试方法，测试的时候不会被执行。对每一类测试都需要编写一个test_xxx() 方法。由于unittest.TestCase提供了很多内置的条件判断，我们只需要调用这些方法就可以断言输出是否是我们所期望的。最常用的断言就是assertEqual()：

1
self.assertEqual(abs(-1),1)  #断言函数返回的结果和1相等

另一种重要的断言就是期待抛出指定类型Error，比如通过d['empty']访问不存在的key时，断言会抛出KeyError：

1
2
with self.assertRaises(KeyError):
	value=d['empty']

而通过d.empty访问不存在key时，我们期待抛出AttributeError：

1
2
with self.assertRaises(AttributeError):
	value=d.empty

运行单元测试

一旦编写好单元测试，我们就可以运行单元测试。最简单的方式是在mydict_test.py的最后加上两行代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
D:\笔记\Python\Notepad++>python mydict.py
D:\笔记\Python\Notepad++>python mydict_test.py
EE...
======================================================================
ERROR: test_attr (__main__.TestDict)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "mydict_test.py", line 25, in test_attr
    self.assertEqual(d[key],'value')
NameError: name 'key' is not defined
======================================================================
ERROR: test_attrerror (__main__.TestDict)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:\笔记\Python\Notepad++\mydict.py", line 11, in __getattr__
    return self[key]
KeyError: 'empty'
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
  File "mydict_test.py", line 35, in test_attrerror
    value=d.empty
  File "D:\笔记\Python\Notepad++\mydict.py", line 13, in __getattr__
    raise ArithmeticError(r"'Dict' object has no attrribute '%s'" %key)
ArithmeticError: 'Dict' object has no attrribute 'empty'
----------------------------------------------------------------------
Ran 5 tests in 0.004s

或者在命令行通过参数-m unittest直接运行单元测试。

setUp与tearDown

可以在单元测试中编写两个特殊的setup()和tearDown()有什么用呢，这时，就可以在setUp()方法中连接数据库，在tearDown()方法中关闭数据库，这样不必再每个测试方法中重复相同的代码：

1
2
3
4
5
6
7
class TestDict(unittest.TestCase):
	def setUp(self):
		print('setUp...')
	def tearDown(self):
		print('tearDown...')

文档测试

很多文档都有实例代码，比如re模块：

1
2
3
4
>>> import re
>>> m=re.search('(?<=abc)def','abcdef')
>>> m.group(0)
'def

可以把这些示例代码在Python的交互环境下输入并执行，结果与文档中的实例代码显示一致。

这些代码与其他说明可以写在注释中，然后由一些工具来自动生成文档。也可以自动执行写在注释中的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> def abs(n):
...     '''
...     Function to get absolute value of number.
...     Exampel:
...     >>>abs(1)
...     1
...     >>>abs(-1)
...     1
...     >>>abs(0)
...     0
...     '''
...     return n if n>=0 else (-n)
...

无疑问更明确的告诉函数的调用者该函数的期望输入和输出。并且，Python内置的文档测试（doctest）模块可以直接提取注释中的diamante并执行测试。

doctest严格按照Python交互命令行的输入和输出来判断测试结果是否正确。只有测试异常的时候，可以用...表示中间一大段烦人的输入。

用doctest来测试上次编写的Dict类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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 __int__(self,**kw):
		super().__int__(**kw)
	def __getattr__(self,key):
		try:
			return self[key]
		except KeyError:
			raise ArithmeticError(r"'Dict' object has no attrribute '%s'" %key)
	def __setattr__(self,key,value):
		self[key]=value
if __name__=='__main__':
	import doctest
	doctest.testmod()

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
D:\笔记\Python\Notepad++>python mydict2.py
**********************************************************************
File "mydict2.py", line 23, in __main__.Dict
Failed example:
    d2.empty
Expected:
    Traceback (most recent call last):
        ...
    AttributeError: 'Dict' object has no attribute 'empty'
Got:
    Traceback (most recent call last):
      File "mydict2.py", line 33, in __getattr__
        return self[key]
    KeyError: 'empty'
    <BLANKLINE>
    During handling of the above exception, another exception occurred:
    <BLANKLINE>
    Traceback (most recent call last):
      File "C:\Users\cdxu0\AppData\Local\Programs\Python\Python35\lib\doctest.py", line 1320, in __run
        compileflags, 1), test.globs)
      File "<doctest __main__.Dict[8]>", line 1, in <module>
        d2.empty
      File "mydict2.py", line 35, in __getattr__
        raise ArithmeticError(r"'Dict' object has no attrribute '%s'" %key)
    ArithmeticError: 'Dict' object has no attrribute 'empty'
**********************************************************************
1 items had failures:
   1 of   9 in __main__.Dict
***Test Failed*** 1 failures.

Donate comment here