错误、调试和测试

作者: Sun_atom | 来源:发表于2017-11-23 21:31 被阅读0次

错误处理

在程序运行的过程中，如果发生错误，可以事先约定返回一个错误代码，这样就可以知道是否有错，以及出错的原因。在操作系统的调用中，返回错误码非常常见。
for example:打开文件的函数open()，成功时返回文件描述符（也就是一个整数），出错时返回-1 。
但是用错误码的方式返回错误信息不是很好，因为函数一般的返回值会与错误码混合在一起，不便于理解。

#调用者必须用大量的代码来判断是否出错

# -*- coding: utf-8 -*-
def foo():
    r = some_function()
    if r==(-1):
        return (-1) 
    #do something
    return r
def bar():
    r == foo()
    if r==(-1)
        print('error!')
    else:
        pass

高级语言都内置了一套try...except...finally...的错误处理机制，Python也不例外。

try

try:
    print('try...')
    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的时候会出现divisionerror：

try...
except: division by zero
finally...
END

错误也有很多种类，也有不同种类的except语句：

try:
    print('try...')
    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')

此外，如果没有错误发生，可以在except语句块后面加一个else，当没有错误发生时，会自动执行else语句。
Python的错误其实也是class，所有的错误类型都继承自BaseException，所以在使用except时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。
[常见的错误类型和继承关系]：https://docs.python.org/3/library/exceptions.html#exception-hierarchy https://docs.python.org/3/library/exceptions.html#exception-hierarchy
注意：不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。

调用栈

如果错误一直没有被捕捉，它就会一直往上抛，最后被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()
  File "err.py", line 9, in main
    bar('0')
  File "err.py", line 6, in bar
    return foo(s) * 2
  File "err.py", line 3, in foo
    return 10 / int(s)
ZeroDivisionError: division by zero

出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置。

记录错误

我们可以捕捉错误，把错误堆栈打印出来，然后分析错误原因，同时让程序执行。

#使用Python内置的logging Module可以清晰的记录错误信息
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

抛出错误

因为错误是Class，捕捉错误就是捕捉到该Class的一个实例。因此，错误并不是凭空产生的，而是有意被创建并抛出的。Python的内置函数可以抛出错误，我们也可以DIY。

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

class FooError(ValueError):
    pass


def foo(s):
    n = int(s)
    if n == 0:
        raise FooError('invalid value: %s' % s)
    return 10 / n


foo('0')

执行，则可以最后跟踪到我们自己定义的错误：

$ python3 err_raise.py 
Traceback (most recent call last):
  File "err_throw.py", line 11, in <module>
    foo('0')
  File "err_throw.py", line 8, in foo
    raise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0

调试的几种方法

使用print()把打印可能出错的变量

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

def main():
    foo('0')

main()

执行：

$ python err.py
>>> n = 0
Traceback (most recent call last):
  ...
ZeroDivisionError: integer division or modulo by zero

断言

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

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

def main():
    foo('0')

assert是指 assert的式子应该是正确的，否则后面的代码会有错误。
如果断言失败的话，assert语句本身就会抛出AssertionError：

$ python err.py
Traceback (most recent call last):
  ...
AssertionError: n is zero!

可以使用 -0 参数关闭assert：

$ python -O err.py
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

关闭后assert可以看做pass

logging

第三种方式是将print替换成logging，和assert相比，logging不会抛出错误，还可以输出到文件:

import logging
logging.basicConfig(level=logging.INFO) #logging信息可以输出到屏幕

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

输出：

$ 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就不起作用了。这样一来，你可以放心地输出不同级别的信息，也不用删除，最后统一控制输出哪个级别的信息。

pdb

启动Python的调试器pdb，让程序以单步方式运行，可以随时查看运行状态。我们先准备好程序。

# err.py
s = '0'
n = int(s)
print(10 / n)

启动pdb：

$ 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)

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

(Pdb) p s
'0'
(Pdb) p n
0

输入命令q结束调试，退出程序：

(Pdb) q

代码很多的时候你的手指会很累！！！

pdb.set_trace()

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

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

IDE

IDE大法好

单元测试

单元测试是用来对一个Module、一个函数和或者一个类来进行正确性检验的测试工作。
如果单元测试通过，说明我们测试的这个函数能够正常工作。如果单元测试不通过，要么函数有bug，要么测试条件输入不正确。
例子：

>>> d = Dict(a=1, b=2)
>>> d['a']
1
>>> d.a
1

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

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

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

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

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

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

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

运行单元测试

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

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

这样就可以把mydict_test.py当做正常的Python脚本运行：

$ python mydict_test.py

另一种方法是在命令行通过参数-m unittest直接运行单元测试：

$ python -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s

OK

setUp and tearDown

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

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

class TestDict(unittest.TestCase):

    def setUp(self):
        print('setUp...')

    def tearDown(self):
        print('tearDown...')

错误、调试和测试

错误处理

try

调用栈

记录错误

抛出错误

调试的几种方法

使用print()把打印可能出错的变量

断言

logging

pdb

pdb.set_trace()

IDE

单元测试

运行单元测试

setUp and tearDown

文档测试

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读