日知录（六）：python的bug捕捉和测试

最新推荐文章于 2021-12-21 21:04:06 发布

王duan

最新推荐文章于 2021-12-21 21:04:06 发布

阅读量853

点赞数 1

分类专栏：笔记文章标签： python 单元测试

本文链接：https://blog.csdn.net/weixin_43883903/article/details/107264576

版权

笔记专栏收录该内容

18 篇文章 2 订阅

订阅专栏

一、关于日知录

1.自省：
一开始写博客是想把自己的学习记录都放在一个地方，这样也不用存在电脑里分n个文件夹找来找去，现在写完5篇，确实有达到我给自己电脑管理文件减负的目的。不过，前面五篇博客只能说部分是直接塞图片，而且排版方面感觉不是很好。希望自己以后的博客还是多点自己的看法和思考，可以集各家之所长，站在巨人的肩膀上去看待问题去认识世界，也可以不那么急的想要契合“日知”每天一篇，给博客一点沉淀的时间，暂定小目标一周一篇吧。
2.接下来进入本篇：
先要肯定一点，debug是一个非常重要的能力，一个优秀的有逻辑的程序猿，思维严谨是一方面，他的debug能力绝对要好。其实也可以引申来看，遇到bug，去主动分析、自己解决，而不是自怨自艾，选择面对而不是选择逃避。
3.python的bug捕捉和测试：
在python中写代码中还有对bug的提前预判，以使程序正常进行，也有对部分内容进行的单元测试，以保证各个模块内部是正常的。之前对python错误处理机制的
try–except–finally语句一直看不懂，直到某day看到了廖雪峰教程内对这个语句的讲解我才明白，顿悟python真的妙！以及在本篇文章内可能大量引用教程中的例子，外加一些自己的理解。
5.关于后续的博客应该是记录爬虫或者飞机大战来深入理解python了。

二、错误处理

1.产生错误

显然，除数不能为0，即ZeroDivisionError

>>> r=10/0

Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    r=10/0
ZeroDivisionError: division by zero

2.增加错误处理代码后

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

结果是：

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

（1）可见当程序运行到打印出 ‘try…’ 之后，遇到了 r=10/0这句有bug的代码，无法继续向下执行，于是跳到错误处理代码— except 语句块，当程序的错误类型与except内写的 ZeroDivisionError相符时，继续执行并打印’ except: ‘，并将e的错误内容’divison by zero’ 也打印出来。执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。
（2）出错时，会分析错误信息并定位错误发生的代码位置才是最关键的。
（3）这样的错误处理机制可以正常打印出错误原因，正确找到错误的地方，而不至于在别的模块白花力气找错。

3.当程序无误时的错误处理代码

当我们把0改成2之后，程序正常运行。

try:
    print('try...')
    r = 10 / 2
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

结果：

try...
result: 5.0
finally...
END

（1）此处要讲一下的是 finally语句
由于没有错误发生，所以except语句块不会被执行，但是finally如果有，则一定会被执行（可以没有finally语句）。所以finally可以理解为不论错误发生与否，都会执行。

4.捕捉多种错误

这个也可以理解啊，因为你不确定会发生什么样的错误，有些常见的，有些基本的（手误引起的）,如果发生了不同类型的错误，应该由不同的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')

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

try...
ValueError: invalid literal for int() with base 10: 'a'
finally...
END

（1）错误是ValueError
（2）同时还要注意：错误其实也是class，所有的错误类型都继承自BaseException。所以在使用except 时要注意，避免捕捉的错误类型之间的从属关系和交叉关系，可以先确定一个大类，之后再在大类里面找小类。
（3）常见的错误类型和继承关系看这里：

https://docs.python.org/3/library/exceptions.html#exception-hierarchy

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

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

正常运行的结果：

try...
result: 5.0
no error!
finally...
END

5.在合适的层次捕捉

不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。使用try…except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用bar()，bar()调用foo()，结果foo()出错了，这时，只要main()捕获到了，就可以处理。

# err.py:
def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    bar('0')

main()

此处是错误信息：

Traceback (most recent call last):     #这是错误的跟踪信息
  File "err.py", line 11, in <module>   #调用main()出错了，在代码文件err.py的第11行代码，但原因是第9行
    main()
  File "err.py", line 9, in main  #调用bar('0')出错了，在代码文件err.py的第9行代码，但原因是第6行：
    bar('0')
  File "err.py", line 6, in bar  #原因是return foo(s) * 2这个语句出错了，但这还不是最终原因，继续往下看
    return foo(s) * 2
  File "err.py", line 3, in foo #原因是return 10 / int(s)这个语句出错了，这是错误产生的源头，因为下面打印了：
    return 10 / int(s)
ZeroDivisionError: division by zero#根据错误类型ZeroDivisionError，我们判断，int(s)本身并没有出错，但是int(s)返回0，在计算10 / 0时出错，至此，找到错误源头。

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

6.记录错误

既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继续执行下去。

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

7.抛出错误

因为错误是class，捕获一个错误就是捕获到该class的一个实例。自己定义一个关于错误的class，选择好继承关系，然后用raise语句抛出一个错误的实例，不过一般我们都使用python内置的错误类型。
接下来看一下raise语句

# err_reraise.py

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

bar()

Traceback (most recent call last):
ValueError!
  File "err_reraise.py", line 16, in <module>
    bar()
  File "err_reraise.py", line 11, in bar
    foo('0')
  File "err_reraise.py", line 6, in foo
    raise ValueError('invalid value: %s' % s)
ValueError: invalid value: 0

捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。
程序也可以主动抛出错误，让调用者来处理相应的错误。但是，应该在文档中写清楚可能会抛出哪些错误，以及错误产生的原因。

例：根据异常信息进行分析，定位出错误源头，并修复

题：

# -*- coding: utf-8 -*-
from functools import reduce

def str2num(s):
    return int(s)

def calc(exp):
    ss = exp.split('+')
    ns = map(str2num, ss)
    return reduce(lambda acc, x: acc + x, ns)

def main():
    r = calc('100 + 200 + 345')
    print('100 + 200 + 345 =', r)
    r = calc('99 + 88 + 7.6')
    print('99 + 88 + 7.6 =', r)

main()

（1）此处解读一下源程序：
reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。
这里的reduce(lambda acc, x: acc + x, ns)，可以等价于：

def a(acc,x):        
    return acc+x    
return reduce(a,ns)

报错信息：

100 + 200 + 345 = 645 
Traceback (most recent call last): 
  File "main.py", line 18, in <module> 
    main() 
  File "main.py", line 15, in main 
    r = calc('99 + 88 + 7.6') 
  File "main.py", line 10, in calc 
    return reduce(lambda acc, x: acc + x, ns) 
  File "main.py", line 5, in str2num 
    return int(s) 
ValueError: invalid literal for int() with base 10: ' 7.6'

修改：

# -*- coding: utf-8 -*-
from functools import reduce

def str2num(s):
    if isinstance(s, int):
        return int(s)
    else:
        return float(s)

def calc(exp):
    ss = exp.split('+')
    ns = map(str2num, ss)
    return reduce(lambda acc, x: acc + x, ns)

def main():
    r = calc('100 + 200 + 345')
    print('100 + 200 + 345 =', r)
    r = calc('99 + 88 + 7.6')
    print('99 + 88 + 7.6 =', r)

main()
# 结果
100 + 200 + 345 = 645.0 
99 + 88 + 7.6 = 194.6

（2）利用 isinstance判断真假分别返整数或浮点数，即程序修改的部分

三、调试

1.用print()把可能有问题的变量打印出来看看

在这里插入图片描述
在win10 控制台操作

2.断言(assert)

不是很理解，但它最后会和使用print后，产生很多assert（在print里面是print）

3.logging

logging不会抛出错误，而且可以输出到文件

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

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

C:\Users\Desktop>python 1.txt
INFO:root:n = 0
Traceback (most recent call last):
  File "1.txt", line 7, in <module>
    print(10 / n)
ZeroDivisionError: division by zero

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

4. pdb

启动Python的调试器pdb，让程序以单步方式运行，可以随时查看运行状态。
在win10 控制台操作，是一种单步调试的方法，但调试效率偏低，是一句一句的看，

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

终端操作：

C:\Users\Desktop>python -m pdb 1.txt
> c:\users\desktop\1.txt(2)<module>()
-> s = '0'
(Pdb) 1        # 输入命令l来查看代码，第一次输的是数字1，没反应。应该是小写字母l
  1     # err.py
  2  -> s = '0'
  3     n = int(s)
  4     print(10 / n)
[EOF]
(Pdb) n          #  输入命令n可以单步执行代码
> c:\users\desktop\1.txt(3)<module>()
-> n = int(s)
(Pdb) n                
> c:\users\desktop\1.txt(4)<module>()
-> print(10 / n)
(Pdb) p s          #  任何时候都可以输入命令p 变量名来查看变量
'0'
(Pdb) p n
0
(Pdb) q             # 输入命令q结束调试，退出程序

5.pdb.set_trace()

在win10 控制台操作
这个方法也是用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继续运行：

C:\Users\Desktop>python 1.txt
> c:\users\desktop\1.txt(7)<module>()
-> print(10 / n)
(Pdb) p n
0
(Pdb) c
Traceback (most recent call last):
  File "1.txt", line 7, in <module>
    print(10 / n)
ZeroDivisionError: division by zero

相比之下，IDE 的调试过程要和蔼很多了。

四、单元测试

1.定义：

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

2.理解

因为是学生，我打个比方，就是老师在期末考前出的一套测试卷，里面包含了检验是否掌握各个知识点的习题，如果都做对了，那么测试通过。如果有部分知识点不清楚有含糊或者理解有偏差，那么测试卷不能完整做出来，那么需要再回头复习巩固一遍知识点，再来做一遍测试题。

3.作用

现在来看看这个单元测试通过后有什么意义呢？如果我们对源程序的abs()函数代码做了修改，只需要再跑一遍单元测试，如果通过，说明我们的修改不会对abs()函数原有的行为造成影响，如果测试不通过，说明我们的修改与原有行为不一致，要么修改代码，要么修改测试。

4.实例

使用的IDE是pycharm。

（1）一个注意事项

在一个文件夹下建两个.py文件，一个是mydict.py，一个是单元测试程序mydict_test.py，在mydict_test.py中引入python自带的unittest模块。注意.py 文件名不要和模块名一样，不然会报错，如下：

pycharm AttributeError: module ‘unittest’ has no attribute ‘TestCase’

这是脚本名称冲突所导致的报错。
脚本取名最好不要与模块和方法名一致，避免不必要的冲突。
改正方法就是把.py的文件名修改一下。

（2）代码

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

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

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)    # 断言函数返回的结果与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):     #期待抛出指定类型的Error，比如通过d['empty']访问不存在的key时，断言会抛出KeyError：
            value = d['empty']

    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):    #期待抛出指定类型的Error，通过d.empty访问不存在的key时，我们期待抛出AttributeError
            value = d.empty

#运行单元测试
if __name__ == '__main__':
    unittest.main()

·以test开头的方法就是测试方法，不以test开头的方法不被认为是测试方法，测试的时候不会被执行。
··在命令行中运行python单元测试脚本

运行方式1
$ python mydict_test.py

运行方式2
$ python -m unittest mydict_test
运行结果
…
---------------------------------------------------------------------- Ran 5 tests in 0.000s

OK

（3）交作业

eg.对Student类编写单元测试，结果发现测试不通过，请修改Student类，让测试通过：
原题：

# -*- coding: utf-8 -*-
import unittest
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def get_grade(self):
        if self.score >= 60:
            return 'B'
        if self.score >= 80:
            return 'A'
        return 'C'

原题进行单元测试后的报错：
分析出是Student 类中的 get_grade()出错，一个是成绩的分类没分好，一个是成绩数值范围没确定。

..FF 
====================================================================== 
FAIL: test_80_to_100 (__main__.TestStudent) 
---------------------------------------------------------------------- 
Traceback (most recent call last): 
  File "main.py", line 19, in test_80_to_100 
    self.assertEqual(s1.get_grade(), 'A') 
AssertionError: 'B' != 'A' 
- B 
+ A 


====================================================================== 
FAIL: test_invalid (__main__.TestStudent) 
---------------------------------------------------------------------- 
Traceback (most recent call last): 
  File "main.py", line 38, in test_invalid 
    s1.get_grade() 
AssertionError: ValueError not raised 

---------------------------------------------------------------------- 
Ran 4 tests in 0.001s 

FAILED (failures=2)

修改：

# -*- coding: utf-8 -*-
import unittest
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def get_grade(self):
        if self.score > 100:
            raise ValueError
        if self.score >= 80:
            return 'A'
        if self.score >= 60:
            return 'B'
        if self.score >=0:
            return 'C'
        else:
            raise ValueError

进行单元测试：

class TestStudent(unittest.TestCase):

    def test_80_to_100(self):
        s1 = Student('Bart', 80)
        s2 = Student('Lisa', 100)
        self.assertEqual(s1.get_grade(), 'A')
        self.assertEqual(s2.get_grade(), 'A')

    def test_60_to_80(self):
        s1 = Student('Bart', 60)
        s2 = Student('Lisa', 79)
        self.assertEqual(s1.get_grade(), 'B')
        self.assertEqual(s2.get_grade(), 'B')

    def test_0_to_60(self):
        s1 = Student('Bart', 0)
        s2 = Student('Lisa', 59)
        self.assertEqual(s1.get_grade(), 'C')
        self.assertEqual(s2.get_grade(), 'C')

    def test_invalid(self):
        s1 = Student('Bart', -1)
        s2 = Student('Lisa', 101)
        with self.assertRaises(ValueError):
            s1.get_grade()
        with self.assertRaises(ValueError):
            s2.get_grade()

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

结果：

.... 
---------------------------------------------------------------------- 
Ran 4 tests in 0.000s 

OK

五、文档测试

1.Python内置的“文档测试”（doctest）模块可以直接提取python 写在注释中的代码并执行测试。

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

1.示例

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

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

C:\Users\金瑞阳\Desktop>python 1.txt
**********************************************************************
File "1.txt", line 8, in __main__.Dict
Failed example:
    d1.x
Exception raised:
    Traceback (most recent call last):
      File "D:\python\lib\doctest.py", line 1330, in __run
        compileflags, 1), test.globs)
      File "<doctest __main__.Dict[2]>", line 1, in <module>
        d1.x
    AttributeError: 'Dict' object has no attribute 'x'
**********************************************************************
File "1.txt", line 14, in __main__.Dict
Failed example:
    d2.c
Exception raised:
    Traceback (most recent call last):
      File "D:\python\lib\doctest.py", line 1330, in __run
        compileflags, 1), test.globs)
      File "<doctest __main__.Dict[6]>", line 1, in <module>
        d2.c
    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会在非测试环境下执行。

2.练习

对函数fact(n)编写doctest并执行：

# -*- coding: utf-8 -*-
def fact(n):
    '''
    Calculate 1*2*...*n
    
    >>> fact(1)
    1
    >>> fact(10)
    ?
    >>> fact(-1)
    ?
    '''
    if n < 1:
        raise ValueError()
    if n == 1:
        return 1
    return n * fact(n - 1)

if __name__ == '__main__':
    import doctest
    doctest.testmod()

报错信息：

********************************************************************** 
File "main.py", line 8, in __main__.fact 
Failed example: 
    fact(10) 
Expected: 
    ? 
Got: 
    3628800 
********************************************************************** 
File "main.py", line 10, in __main__.fact 
Failed example: 
    fact(-1) 
Exception raised: 
    Traceback (most recent call last): 
      File "/usr/local/lib/python3.8/doctest.py", line 1329, in __run 
        exec(compile(example.source, filename, "single", 
      File "<doctest __main__.fact[2]>", line 1, in <module> 
        fact(-1) 
      File "main.py", line 14, in fact 
        raise ValueError() 
    ValueError 
********************************************************************** 
1 items had failures: 
   2 of   3 in __main__.fact 
***Test Failed*** 2 failures.

修改：

def fact(n):
    '''
    Calculate 1*2*...*n
    
    >>> fact(1)
    1
    >>> fact(10)
    3628800
    >>> fact(-1)
    Traceback (most recent call last):
     ...
    ValueError
    '''
    if n < 1:
        raise ValueError()
    if n == 1:
        return 1
    return n * fact(n - 1)