Python自学笔记D8——错误、调试和测试

错误、调试和测试

错误处理

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

python使用try…except…finally来进行一个方便的错误处理

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

try:
    print('try...')
    r = 10 / int('2')
    a = 10 / int('0')#ZeroDivisionError
    b = 10 / int('abc')#ValueError,int无法判别abc
    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时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。

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...')
#以下是结果
Error: division by zero
finally...

import logging可以将错误写到日志方便查询

抛出错误

错误是一个class，而不同类型的错误就是一个个实例，因此可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例，但是尽量使用内置的好！

遇到错误同样可以使用raise进行抛出！

#吧zeor错误变成value错误（憨憨行为不要用hh）
try:
    10 / 0
except ZeroDivisionError:
    raise ValueError('input error!')
#将错误抛出给上级处理
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()

作业：根据问题解决，有两种解决方法，第二种很巧妙

#第一种
def str2num(s):
    return float(s)
#第二种：
def str2num(s):
    try:
        return int(s)
    except ValueError:
       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 =', r)

调试

第一种方法：
print出来！但是很麻烦 要删掉！

第二种方法：
断言(assert)！assert后面的表达式一定要是True才继续

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n
def main():
    foo('0')
$ python -O err.py#可以关闭assert（不是0哦！）

第三种方法：
logging。可以规定错误的级别

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

有debug，info，warning，error等几个级别，当我们指定level=INFO时，logging.debug就不起作用了，warning则前俩不起作用。

并且通过logging还可以将一条语句输出到console和文件等多个地方。

第四种方法：
pdb。非常好用，可以一步步执行并随时看变量的值，但只能用命令行，因此不展开。

import pdb 后在可能错误的地方pdb.set_trace()，可以设置断点！

# err.py
import pdb
s = '0'
n = int(s)
pdb.set_trace() # 运行到这里会自动暂停
print(10 / n)
#结果
print(10 / n)
(pdb)p n#查看n值
(pdb)c#继续运行

单元测试

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

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

以下为一个测试的例子：

#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
#开始测试，assertequal等都是unittest自带的断言
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):#当引用了不存在的键时返回keyerror
        d = Dict()
        with self.assertRaises(KeyError):
            value = d['empty']
    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty
if __name__ == '__main__':#运行测试脚本
    unittest.main()
    #第二种方法，在命令行通过参数-m unittest直接运行单元测试：
$ python -m unittest mydict_test

以test开头的方法就是测试方法，不以test开头的方法不被认为是测试方法，测试的时候不会被执行。

setUp与tearDown
可以在单元测试中编写两个特殊的setUp()和tearDown()方法。这两个方法会分别在每调用一个测试方法的前后分别被执行。（例如可以打开和关闭数据库）

作业：进行成绩等第判定的测试：

# -*- 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 < 0 or self.score > 100:
            raise ValueError
        if self.score >= 60 and self.score < 80:
            return 'B'
        if self.score >= 80:
            return 'A'
        return 'C'
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()

文档测试(doctest)

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

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)

关键点：错误的地方写
Traceback (most recent call last):
…
具体错误