Python3(9) Python 错误、调试和测试

2018-01-29 本文已影响368人猿来如痴

本系列主要学习Python的基本使用和语法知识，后续可能会围绕着AI学习展开。
Python3 (1) Python语言的简介
 Python3 (2) Python语法基础
 Python3 (3) Python函数
 Python3 (4) Python高级特性
 Python3(5) Python 函数式编程
 Python3(6) Python 模块
 Python3(7) Python 面向对象编程
 Python3(8) Python 面向对象高级编程
对于编程来说，调试与处理bug占用的时间远远高于开发的时间。所以学会调试bug，分析bug , 解决bug 是编程的一个重要能力，想当初自己刚学java的时候，没人教过自己如何调试，在工作中摸索了小半年才真正的学会如何断点调试，如何分析、解决bug，调试其实各种语言大同小异，但是我觉得有必要专门来写，因为它非常重要。上一篇由于时间和篇幅原因，遗留下一个问题，如何设计ORM框架？现在我们从这里说起。

设计 ORM 框架

上一篇介绍了python 面向对象高级编程，涉及到的内容非常的烧脑，讲到metaclass元类时，脑细胞已经不太够用了，为了少死点脑细胞，就把这个元类的应用：ORM框架搁置了，我们从这里讲起，元类其实字面意思就是类的元老，有资格创建和修改类。

ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库库的字段映射为一个对象，也就是一个类对应一个表。这样我们不必直接使用SQL语句，通过ORM框架来进行映射，ORM框架定义的类必须是动态的，使用者根据自己的表结构来定义自己需要的类。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# 定义Field类，它负责保存数据库表的字段名和字段类型
class Field(object):

    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type

    def __str__(self):
        return '<%s:%s>' % (self.__class__.__name__, self.name)

# 在Field基础上定义 各种类型的xxxField
class StringField(Field):

    def __init__(self, name):
        super(StringField, self).__init__(name, 'varchar(100)')

class IntegerField(Field):

    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'bigint')

# 类的模板定义  ModelMetaclass
class ModelMetaclass(type):

    def __new__(cls, name, bases, attrs):
        # 排除掉对Model类的修改,Model类中有metaclass是具体数据表类的父类,不能自己实现只提供继承
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)
        print('Found model: %s' % name)
        # 保存Field 属性到mappings中
        mappings = dict()
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v
        # 删除attrs中Field属性，防止运行时，实例的属性遮盖类的同名属性出现异常
        for k in mappings.keys():
            attrs.pop(k)
        # 保存属性和列的映射关系
        attrs['__mappings__'] = mappings
        # 假设表名和类名一致
        attrs['__table__'] = name
        return type.__new__(cls, name, bases, attrs)

# 创建具体数据表的基类
class Model(dict, metaclass=ModelMetaclass):

    def __init__(self, **kw):
        super(Model, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value
    # 定义一个操作数据库的方法
    def save(self):
        fields = []
        params = []
        args = []
        for k, v in self.__mappings__.items():
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self, k, None))
        # 拼接sql语句
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))

# 定义一个具体的数据表类，继承Model
class User(Model):
    # 定义类的属性到列的映射：
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

# 创建一个实例：
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
# 保存到数据库：
u.save()

输出结果：

Found model: User
Found mapping: id ==> <IntegerField:id>
Found mapping: name ==> <StringField:username>
Found mapping: email ==> <StringField:email>
Found mapping: password ==> <StringField:password>
SQL: insert into User (id,username,email,password) values (?,?,?,?)
ARGS: [12345, 'Michael', 'test@orm.org', 'my-pwd']

这就是一个ORM框架的基本原理代码，我们实现了一个插入的操作，执行流程：用户根据表的结构定义了一个User类，Python解释器在创建类时会查找是否存在metaclass元类，在Model类中找到ModelMetaclass元类，之后就去创建元类，元类会根据User类的属性生成一个__mappings字典，在Model中根据__mappings__字典创建各种方法去执行与数据库交互。最后就在User类完全不知情的情况下生成了各种与数据库交互的方法。不必去执行各种 sql 语句，这就是一个典型的ORM框架原理。

错误产生的情景

程序编写导致的问题，这个是程序员逻辑考虑不周全造成的。
用户交互导致的问题，没有按设计的规则进行交互。
程序运行时产生的问题，这个异常是硬件、网路等外在因素产生的问题。
Python中内置了一系列的处理错误的机制。是程序永远处于可控的状态。

错误处理

try...except...finally...是python内置的错误处理机制。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

try:
    print('try...')
    r = 10 / 0
    print('result：', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')

输出结果：

try...
ZeroDivisionError: division by zero
finally...
# ----r = 10 / 1 没有发生异常-----
try...
result： 10.0
no error!
finally...

python中try...except...finally...与java中的try...catch...finally...使用规则是相同的。

try...except包含的代码块如果发生异常，根据异常类型执行对应的except代码，只要执行了except语句，代码块就会被截住，不论下面是否还有异常，执行完except语句，如果有finally就会执行finally，finally不是必须的。
try...except含的代码块没有发生异常，如果有else会执行else语句，else不是必须的，接着如果有finally就会执行finally，finally不是必须的。
try...except...finally...可以进行嵌套。

错误类型及继承关系

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

错误栈

python 中错误也会一层层像上抛出，并且不需要像java 等语言通过throw来标识，它会自动向上抛出。如果代码层面没有处理，最后被Python解释器捕获，打印一个错误信息，然后程序退出。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import logging

def foo(s):
    return 10 / s

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

def main():
    try:
        bar('0')
    except Exception as e:
      #  logging.exception(e)
        print('Error:', e)
    finally:
        print('finally...')

main()

输出结果：

Error: unsupported operand type(s) for /: 'int' and 'str'
finally...
# ----如果没有进行异常捕获-----
Traceback (most recent call last):
  File "F:/python/HelloWord/def_func.py", line 19, in <module>
    main()
  File "F:/python/HelloWord/def_func.py", line 11, in main
    bar('0')
  File "F:/python/HelloWord/def_func.py", line 8, in bar
    return foo(s) * 2
  File "F:/python/HelloWord/def_func.py", line 5, in foo
    return 10 / s
TypeError: unsupported operand type(s) for /: 'int' and 'str'
#----通过logging.exception(e)打印错误信息----
ERROR:root:unsupported operand type(s) for /: 'int' and 'str'
Traceback (most recent call last):
  File "F:/python/HelloWord/def_func.py", line 14, in main
    bar('0')
  File "F:/python/HelloWord/def_func.py", line 10, in bar
    return foo(s) * 2
  File "F:/python/HelloWord/def_func.py", line 7, in foo
    return 10 / s
TypeError: unsupported operand type(s) for /: 'int' and 'str'

如果我们在代码中进行错误捕获，我们会看到错误在foo()中产生，但是在main()中捕获，错误进行向上的抛出，如果没有错误捕获，系统会打印出错误栈信息。并退出执行。如果使用logging.exception(e)我们也会打印出全部的错误栈信息。

自定义错误

python中的错误是一个个类的实例，创建并抛出的，所以我们也可以自定义自己的错误类型，并且手动抛出 raise关键字就是手动抛出异常。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

class FooError(ValueError):
    pass

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

foo('0')

输出结果：

Traceback (most recent call last):
  File "F:/python/HelloWord/def_func.py", line 13, in <module>
    foo('0')
  File "F:/python/HelloWord/def_func.py", line 10, in foo
    raise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0

根据自定义的错误，我们可以根据具体的业务逻辑，抛出自定义的错误信息。方便用户或者调用你的代码的人理解。
raise 还可以将错误继续抛出，在except中，使用raise 可以将错误原样抛出，也可以改变错误类型进行抛出。

调试

print

通过print 输出可能出错的变量，我们可以通过错误信息和print 输出的内容来进行修改bug，但是print在测试完成后还需要删除。

assert

断言assert的使用，就是我们在逻辑层面做的一个if判断相当于raise-if-not，如果assert n != 0, 'n is zero!'中的n != 0是True代码继续执行，如果是False会打印出AssertionError: n is zero!错误。断言可以通过python -O err.py来屏蔽。

logging

logging 的使用与 android中的log的使用时大同小异的，分为几种级别，方便过滤信息。logging可以输出到文件如：logging.basicConfig(filename='example.log',level=logging.ERROR) 输出到example.log文件中。

pdb

启动Python的单步调试器pdb，程序一行行执行。可以采用pdb.set_trace()在代码中设置断点。

IDE断点调试

例如 PyCharm 我们可以打断点进行Debug模式下运行。

单元测试

单元测试就是将某一个模块通过编写一个测试用例在测试。

文档测试

根据文档中注释的测试代码来进行测试。

最后总结一下 Python中错误、调试、测试，首先我们要清楚产生bug 的3种情景程序逻辑问题，用户操作问题，硬件、网络等外在因素问题，其次要知道Python 中有内置的错误处理机制，错误类型都继承自BaseException，接着我们可以通过几种方式来打印错误信息，在IDE 上可以通过断点来调试bug 。

参考

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431913726557e5e43e1ee8d54ee486bddc3f607afb75000

Python3(9) Python 错误、调试和测试

设计 ORM 框架

错误产生的情景

错误处理

错误类型及继承关系

错误栈

自定义错误

调试

print

assert

logging

pdb

IDE断点调试

单元测试

文档测试

参考

猜你喜欢

热点阅读