Python学习（八）—— 错误、调试和测试

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/q1449516487/article/details/87919085

一、错误处理

（1）try

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

#try...except...else...finally...格式如下：
try:
    print('try...')
    r = 10 / 0                         #错误处
    print('result:', r)                
except ZeroDivisionError as e:         #除数为零错误
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')


#输出如下：
try...
except: division by zero
finally...
END

由输出可以看出，当错误发生时，后续语句print('result:', r)不会被执行；except由于捕获到ZeroDivisionError，因此被执行；最后，finally语句必须被执行（除非不包含finally语句）。当错误未发生时，else语句和finally语句将会被执行。

Python的错误其实是class，都继承自BaseException，因此在使用except时要注意，它不但一个该类型的错误，还捕获其所有子类的错误。例如：

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

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

Python所有的错误都是从BaseException类派生的，常见的错误类型和继承关系看这里：

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

（2）调用栈

如果错误没有被捕获，它就会一会往上抛，最后被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):       #错误信息第1行：告诉我们这是错误的跟踪信息
  File "err.py", line 11, in <module>    #第2~3行：调用main()出错了，在代码文件err.py的第11行代码，但原因是第9行
    main()
  File "err.py", line 9, in main         #第4~5行：调用bar('0')出错了，在代码文件err.py的第9行代码，但原因是第6行
    bar('0')
  File "err.py", line 6, in bar          #第6~7行：调用return foo(s) * 2出错了，在代码文件err.py的第6行代码，但原因在第3行
    return foo(s) * 2
  File "err.py", line 3, in foo          #第8~9行：原因是return 10 / int(s)这个语句出错了，这是错误产生的源头，因为下面打印了ZeroDivisionError: division by zero
    return 10 / int(s)
ZeroDivisionError: division by zero

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

（3）记录错误

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

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

# 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还可以把错误记录到日志文件里，方便事后排查。

（4）抛出错误

Python中通过raise关键字抛出异常。如下：

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

foo('0')

也可以在except中抛出错误，从而将一种类型的错误转化成另一种类型：

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

二、调试

（1）print()

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

def foo(s):
    n = int(s)
    print('>>> n = %d' % n)
    return 10 / n
def main():
    foo('0')

main()

用print()最大的坏处是将来还得删掉它，想想程序里到处都是print()，运行结果也会包含很多垃圾信息。

（2）断言

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

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'  #断言表示表达式n != 0必须是True，否则抛出AssertionError并打印'n is zero'
    return 10 / n
def main():
    foo('0')

PS：如果要关闭断言assert，可以在启动Python解释器时用-o参数来关闭。关闭的assert语句可以当作pass来看待。

（3）logging

logging可以把信息输出到文件：

import logging
logging.basicConfig(level=logging.INFO) #指定记录信息的级别

s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)


输出，如下：
$ python err.py
INFO:root:n = 0                         #logging输出信息
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就不起作用。

（4）pdb

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

$ python -m pdb err.py

pdb的操作如下所示：

操作	说明	示例
l	输入命令l查看代码	(Pdb) l     1       # err.py     2  ->  s = '0'     3       n = int(s)     4       print(10 / n)
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)
p	输入命令p 变量名来查看变量	(Pdb) p s '0' (Pdb) p n 0
q	输入命令q结束调试，推出程序	(Pdb) q

（5）pdb.set_trace()

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

# err.py
import pdb      # 导入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单步调试效率要高很多，但也高不到哪去。

（6）IDE

如果要比较爽地设置断点、单步执行，就需要一个支持调试功能的IDE。目前比较好的Python IDE有：

Visual Studio Code：https://code.visualstudio.com/，需要安装Python插件。

PyCharm：http://www.jetbrains.com/pycharm/

另外，Eclipse加上pydev插件也可以调试Python程序。

三、单元测试

（1）单元测试定义：是用来对一个模块、一个函数或者一个类进行正确性检验的测试工作。

比如对函数abs()，我们可以编写出以下几个测试用例：

1.输入正数，比如1、1.2、0.99，期待返回值与输入相同；

2.输入负数，比如-1、-1.2、-0.99，期待返回值与输入相反；

3.输入0，期待返回0；

4.输入非数值类型，比如None、[]、{}，期待抛出TypeError。

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

（2）单元测试演示：

首先编写一个Dict类，这个类的行为和dict一致，但是可以通过属性来访问。mydict.py代码如下：

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   

然后编写单元测试：为编写单元测试，我们需要引入Python自带的unittest模块，编写mydict_test.py如下：

import unittest
from mydict import Dict

class TestDict(unitest.TestCase)：            #测试类，从unittest.TestCase继承
    def test_init(self):                      #必须以test开头，否则不被执行
        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):                       #对一类测试都需要编写一个test_xxx()方法
        d = Dict()
        d['key'] = 'value'
        self.assertEqual(d.key, 'value')      #断言d.key的结果为'value'
    def test_attr(self):
        d = Dict()
        d.key = 'value'
        self.assertTrue('key' in d)           #断言'key'存在于d中，且结果为True
        self.assertEqual(d['key'], 'value')   #断言d['key']的结果为'value'
    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):     #断言执行value=d['empty']时会抛出keyError错误
            value = d['empty']
    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError): #断言执行value=d.empty时会抛出AttributeError错误
            value = d.empty

最后运行该单元测试：（两种方法）

（1）在单元测试最后加入两行代码：

if __name__ == '__main__':
    unittest.main()

 这样就可以把mydict_test.py（单元测试）当作正常的python脚本运行：

$ ptyhon mydict_test.py

（2）在命令行通过参数-m unittest直接运行单元测试(推荐)：

$ python -m unitest mydict_test
.....

执行结果，如下：
Ran 5 tests in 0.000s

OK

（3）setUp与tearDown

可以在单元测试中编写两个特殊的setUp()和tearDown()方法。这两个方法会分别在每调用一个测试方法的前后分别被执行。

setUp()和tearDown()方法的作用：设想你的测试需要启动一个数据库，这时就可以在setUp()方法中连接数据库，在tearDown()方法中关闭数据库，这样不必在每个测试方法中重复相同的代码：

class TestDict(unitest.TestCase):
    def setUp(self):
        print('setUp...')
    def tearDown(self):
        print('tearDown...')

四、文档测试

（1）含义：

我们在编写函数时，可以在函数中编写注释，明确地告诉函数的调用者该函数的期望输入和输出：

def abs(n):
    '''
    Function to get absolute value of number.
    Example:
    >>> abs(1)
    1
    >>> abs(-1)
    1
    >>> abs(0)
    0
    '''
    return n if n >= 0 else (-n)

Python内置的“文档测试”（doctest）模块可以直接提取注释中的代码并执行测试，其严格按照Python交互命令行的输入和输出来判断测试结果是否正确。只有测试异常的时候，可以用...表示中间一大段烦人的输出。

（2）实例：用doctest测试上一节编写的Dict类

#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()

运行python mydict2.py:

$ python mydict2.py

如果什么输出也没有，则表明doctest运行都是正确的。如果程序有问题，比如把__getattr__()方法注释掉，再运行就会报错：

$ python mydict2.py
**********************************************************************
File "/Users/michael/Github/learn-python3/samples/debug/mydict2.py", line 10, in __main__.Dict
Failed example:
    d1.x
Exception raised:
    Traceback (most recent call last):
      ...
    AttributeError: 'Dict' object has no attribute 'x'
**********************************************************************
File "/Users/michael/Github/learn-python3/samples/debug/mydict2.py", line 16, in __main__.Dict
Failed example:
    d2.c
Exception raised:
    Traceback (most recent call last):
      ...
    AttributeError: 'Dict' object has no attribute 'c'
**********************************************************************
1 items had failures:
   2 of   9 in __main__.Dict
***Test Failed*** 2 failures.

注意到最后3行代码。当模块正常导入时，doctest不会被执行。只有在命令行直接运行时，才执行doctest。所以，不必担心doctest会在非测试环境下执行。