本系列主要学习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 输出的内容来进行修改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 。