十年测试经验的阿里p10讲解【python高阶：面对象编程】 python全栈自动化测试系类4-3_阿里 p10 api

每种编程语言都有各自的数据类型，其中面向对象的编程语言还允许开发者自定义数据类型（如：自定义类），Python也是一样。很多时候我们会有这样的需求：

• 把内存中的各种数据类型的数据通过网络传送给其它机器或客户端；
• 把内存中的各种数据类型的数据保存到本地磁盘持久化；

2.数据格式

如果要将一个系统内的数据通过网络传输给其它系统或客户端，我们通常都需要先把这些数据转化为字符串或字节串，而且需要规定一种统一的数据格式才能让数据接收端正确解析并理解这些数据的含义。XML 是早期被广泛使用的数据交换格式，在早期的系统集成论文中经常可以看到它的身影；如今大家使用更多的数据交换格式是JSON（JavaScript Object Notation），它是一种轻量级的数据交换格式。JSON相对于XML而言，更加加单、易于阅读和编写，同时也易于机器解析和生成。除此之外，我们也可以自定义内部使用的数据交换格式。

如果是想把数据持久化到本地磁盘，这部分数据通常只是供系统内部使用，因此数据转换协议以及转换后的数据格式也就不要求是标准、统一的，只要本系统内部能够正确识别即可。但是，系统内部的转换协议通常会随着编程语言版本的升级而发生变化（改进算法、提高效率），因此通常会涉及转换协议与编程语言的版本兼容问题，下面要介绍的pickle协议就是这样一个例子。

3. 序列化/反序列化

将对象转换为可通过网络传输或可以存储到本地磁盘的数据格式（如：XML、JSON或特定格式的字节串）的过程称为序列化；反之，则称为反序列化。

4.相关模块

本节要介绍的就是Python内置的几个用于进行数据序列化的模块：

模块名称	描述	提供的api
json	用于实现Python数据类型与通用（json）字符串之间的转换	dumps()、dump()、loads()、load()
pickle	用于实现Python数据类型与Python特定二进制格式之间的转换	dumps()、dump()、loads()、load()
shelve	专门用于将Python数据类型的数据持久化到磁盘，shelve是一个类似dict的对象，操作十分便捷	open()

回到顶部

二、json模块

---

大部分编程语言都会提供处理json数据的接口，Python 2.6开始加入了json模块，且把它作为一个内置模块提供，无需下载即可使用。

1. 序列化与反序列化

Python的JSON模块 序列化与反序列化的过程分别叫做：encoding 和 decoding。

• encoding： 把Python对象转换成JSON字符串
• decoding： 把JSON字符串转换成python对象

json模块提供了以下两个方法来进行序列化和反序列化操作：

序列化：将Python对象转换成json字符串

dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

反序列化：将json字符串转换成Python对象

loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

除此之外，json模块还提供了两个额外的方法允许我们直接将序列化后得到的json数据保存到文件中，以及直接读取文件中的json数据进行反序列化操作：

序列化：将Python对象转换成json字符串并存储到文件中

dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

反序列化：读取指定文件中的json字符串并转换成Python对象

load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

2. JSON与Python之间数据类型对应关系

Python转JSON

Python	JSON
dict	Object
list, tuple	array
str	string
int, float, int- & float-derived Enums	numbers
True	true
False	false
None	null

JSON转Python

JSON	Python
object	dict
array	list
string	str
number(int)	int
number(real)	float
true	True
false	False
null	None

说明：

• Python dict中的非字符串key被转换成JSON字符串时都会被转换为小写字符串；
• Python中的tuple，在序列化时会被转换为array，但是反序列化时，array会被转化为list；
• 由以上两点可知，当Python对象中包含tuple数据或者包含dict，且dict中存在非字符串的key时，反序列化后得到的结果与原来的Python对象是不一致的；
• 对于Python内置的数据类型（如：str, unicode, int, float, bool, None, list, tuple, dict）json模块可以直接进行序列化/反序列化处理；对于自定义类的对象进行序列化和反序列化时，需要我们自己定义一个方法来完成定义object和dict之间进行转化。

3. 实例：内置数据类型序列化/反序列化

序列化

序列化

json.dumps({‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)})
‘{“a”: “str”, “c”: true, “b”: 11.1, “e”: 10, “d”: null, “g”: [4, 5, 6], “f”: [1, 2, 3]}’

sort_keys参数： 表示序列化时是否对dict的key进行排序（dict默认是无序的）

序列化并对key进行排序

json.dumps({‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)}, sort_keys=True)
‘{“a”: “str”, “b”: 11.1, “c”: true, “d”: null, “e”: 10, “f”: [1, 2, 3], “g”: [4, 5, 6]}’

indent参数： 表示缩进的意思，它可以使得数据存储的格式变得更加优雅、可读性更强；如果indent是一个非负整数或字符串，则JSON array元素和object成员将会被以相应的缩进级别进行打印输出；如果indent是0或负数或空字符串，则将只会插入换行，不会有缩进。

序列化并对key进行排序及格式化输出

print(json.dumps({‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)}, sort_keys=True, indent=4))
{
“a”: “str”,
“b”: 11.1,
“c”: true,
“d”: null,
“e”: 10,
“f”: [
1,
2,
3
],
“g”: [
4,
5,
6
]
}

separators参数： 尽管indent参数可以使得数据存储的格式变得更加优雅、可读性更强，但是那是通过添加一些冗余的空白字符进行填充的。当json被用于网络数据通信时，应该尽可能的减少无用的数据传输，这样可以节省带宽并加快数据传输速度。json模块序列化Python对象后得到的json字符串中的’,‘号和’:'号分隔符后默认都会附加一个空白字符，我们可以通过separators参数重新指定分隔符，从而去除无用的空白字符；

• 该参数的值应该是一个tuple(item_separator, key_separator)
• 如果indent是None，其默认值为(', ', ': ')
• 如果indent不为None，则默认值为(‘,’, ': ')
• 我们可以通过为separator赋值为(‘,’, ‘:’)来消除空白字符

json.dumps({‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)})
‘{“a”: “str”, “c”: true, “b”: 11.1, “e”: 10, “d”: null, “g”: [4, 5, 6], “f”: [1, 2, 3]}’

json.dumps({‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)}, separators=(‘,’,‘:’))
‘{“a”:“str”,“c”:true,“b”:11.1,“e”:10,“d”:null,“g”:[4,5,6],“f”:[1,2,3]}’

ensure_ascii参数： 当该参数的值为True（默认值）时，输出中的所有非ASCII字符（比如中文）都会被转义成’\uXXXX’组成的序列，得到的结果是一个完全由ASCII字符组成的str实例。如果我们想得到一个人类可读的输出结果，需要把ensure_ascii参数的值设置为False。

stu={“name”: “小明”, “age” : 16}
stu_json = json.dumps(stu)
print(stu_json)
‘{“name”: “\u5c0f\u660e”, “age”: 16}’
stu_json01 = json.dumps(stu, ensure_ascii=False)
print(stu_json01)
‘{“name”: “小明”, “age”: 16}’

说明： 实际上’\uXXXX’是Unicode字符对应的内存编码值，该内存编码名称为"unicode-escape",我们可以通过unicodestr.encode('unicode-escape')和decode('unicode-escape')来完成Unicode字符串与Unicode内存编码序列进行相互转换，如下所示：

str1 = “hello 中国”
str2 = str1.encode(“unicode_escape”)
print(str2)
b’hello \u4e2d\u56fd’
str3 = str2.decode(“unicode_escape”)
print(str3)
hello 中国

注意str2是字节串，不是字符串，因此\u前面需要再加一个反斜线做转义。我们把str2转换成字符串就是我们熟悉的格式了：

str4=str2.decode(“utf-8”)
print(str4)
hello \u4e2d\u56fd

反序列化

反序列化

json.loads(‘{“a”: “str”, “c”: true, “b”: 11.1, “e”: 10, “d”: null, “g”: [4, 5, 6], “f”: [1, 2, 3]}’)
{‘c’: True, ‘e’: 10, ‘a’: ‘str’, ‘g’: [4, 5, 6], ‘d’: None, ‘f’: [1, 2, 3], ‘b’: 11.1}

json.loads(‘{“a”:“str”,“c”:true,“b”:11.1,“e”:10,“d”:null,“g”:[4,5,6],“f”:[1,2,3]}’)
{‘c’: True, ‘e’: 10, ‘a’: ‘str’, ‘g’: [4, 5, 6], ‘d’: None, ‘f’: [1, 2, 3], ‘b’: 11.1}

dump()与load()函数示例

序列化到文件中

with open(‘test.json’, ‘w’) as fp:
… json.dump({‘a’:‘str中国’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)}, fp, indent=4)

反序列化文件中的内容

with open(‘test.json’, ‘r’) as fp:
… json.load(fp)
{‘e’: 10, ‘g’: [4, 5, 6], ‘b’: 11.1, ‘c’: True, ‘d’: None, ‘a’: ‘str中国’, ‘f’: [1, 2, 3]}

需要说明的是： 如果试图使用相同的fp重复调用dump()函数去序列化多个对象（或序列化同一个对象多次），将会产生一个无效的JSON文件，也就是说对于一个fp只能调用一次dump()。

4. 实例：自定义数据类型的序列化/反序列化

Python是面向对象的编程语言，我们可以自定义需要的数据类型；实际工作中，我们常常会用到自定义数据类型的序列化与反序列化操作。要实现自定义数据类型的序列化与反序列化有两种方式：

• 通过转换函数实现
• 通过继承JSONEncoder和JSONDecoder类实现

首先来自定义一个数据类型

class Student(object):
def init(self, name, age, sno):
self.name = name
self.age = age
self.sno = sno

def repr(self):
return ‘Student [name: %s, age: %d, sno: %d]’ % (self.name, self.age, self.sno)

直接调用dumps()方法会引发TypeError错误：

stu = Student(‘Tom’, 19, 1)
print(stu)
Student [name: Tom, age: 19, sno: 1]

json.dumps(stu)
…
TypeError: Student [name: Tom, age: 19, sno: 1] is not JSON serializable

上面的异常信息中指出：stu对象不可以被序列化为JSON格式的数据。那么我们分别通过“编写转换函数” 和 “继承JSONEncoder和JSONDecoder类” 来实现对这个自定义数据类型的JSON序列化和反序列化。

方法1：编写转换函数

那么这个转换函数要完成哪两个数据类型之间的转换呢？ 从上面列出的JSON与Python数据类型的对应表中可知，JSON中的object对应的是Python中的dict，因此要对Python中的自定义数据类型的对象进行序列化，就需要先把这个对象转换成json模块可以直接进行序列化dict类型。由此可知，这个转换函数是要完成的是Python对象（不是JSON对象）与dict之间的相互转换，且序列化时转换过程是“Python对象 --> dict --> JSON object”，反序列化的过程是“JSON object -> dict --> Python对象”。所以，我们需要编写两个转换函数来分别实现序列化和反序列化时的转换过程。

def obj2dict(obj):
d = {}
d[‘class’] = obj.class.name
d[‘module’] = obj.module
d.update(obj.dict)
return d

def dict2obj(d):
if ‘class’ in d:
class_name = d.pop(‘class’)
module_name = d.pop(‘module’)
module = import(module_name)
class_ = getattr(module, class_name)
args = dict((key.encode(‘ascii’), value) for key, value in d.items())
instance = class_(**args)
else:
instance = d
return instance

序列化测试：

import json

obj2dict(stu)
{‘sno’: 1, ‘module’: ‘main’, ‘age’: 19, ‘class’: ‘Student’, ‘name’: ‘Tom’}

json.dumps(obj2dict(stu))
‘{“sno”: 1, “module”: “main”, “age”: 19, “class”: “Student”, “name”: “Tom”}’

json.dumps(stu, default=obj2dict)
‘{“sno”: 1, “module”: “main”, “age”: 19, “class”: “Student”, “name”: “Tom”}’

json.dumps(stu, default=obj2dict) 等价于 json.dumps(obj2dict(stu))

反序列化测试：

json.loads(‘{“sno”: 1, “module”: “main”, “age”: 19, “class”: “Student”, “name”: “Tom”}’)
{u’sno’: 1, u’module’: u’main’, u’age’: 19, u’name’: u’Tom’, u’class’: u’Student’}

dict2obj(json.loads(‘{“sno”: 1, “module”: “main”, “age”: 19, “class”: “Student”, “name”: “Tom”}’))
Student [name: Tom, age: 19, sno: 1]

json.loads(‘{“sno”: 1, “module”: “main”, “age”: 19, “class”: “Student”, “name”: “Tom”}’, object_hook=dict2obj)
Student [name: Tom, age: 19, sno: 1]

json.loads(JSON_STR, object_hook=dict2obj) 等价于 dict2obj(json.loads(JSON_STR))

方法2：继承JSONEncoder和JSONDecoder实现子类

import json

class MyJSONEncoder(json.JSONEncoder):
def default(self, obj):
d = {}
d[‘class’] = obj.class.name
d[‘module’] = obj.module
d.update(obj.dict)
return d

class MyJSONDecoder(json.JSONDecoder):
def init(self):
json.JSONDecoder.init(self, object_hook=self.dict2obj)

def dict2obj(self, d):
if ‘class’ in d:
class_name = d.pop(‘class’)
module_name = d.pop(‘module’)
module = import(module_name)
class_ = getattr(module, class_name)
args = dict((key.encode(‘ascii’), value) for key, value in d.items())
instance = class_(**args)
else:
instance = d
return instance

序列化测试：

stu = Student(‘Tom’, 19, 1)

方式一：直接调用子类MyJSONEncoder的encode()方法进行序列化

MyJSONEncoder().encode(stu)
‘{“class”: “Student”, “module”: “main”, “name”: “Tom”, “age”: 19, “sno”: 1}’
MyJSONEncoder(separators=(‘,’, ‘:’)).encode(stu)
‘{“class”:“Student”,“module”:“main”,“name”:“Tom”,“age”:19,“sno”:1}’

方式二：将子类MyJSONEncoder作为cls参数的值传递给json.dumps()函数

json.dumps(stu, cls=MyJSONEncoder)
‘{“class”: “Student”, “module”: “main”, “name”: “Tom”, “age”: 19, “sno”: 1}’
json.dumps(stu, cls=MyJSONEncoder, separators=(‘,’, ‘:’))
‘{“class”:“Student”,“module”:“main”,“name”:“Tom”,“age”:19,“sno”:1}’

反序列化测试：

MyJSONDecoder().decode(‘{“sno”: 1, “module”: “main”, “age”: 19, “class”: “Student”, “name”: “Tom”}’)
Student [name: Tom, age: 19, sno: 1]

说明： 经过测试发现MyJSONDecoder().decode(JSON_STR) 和 json.loads(JSON_STR, object_hook=dict2obj) 只能在Python 2.7上正确执行，在Python 3.5上无法正确执行；而 json.loads(JSON_STR, cls=MyJSONDecoder) 无论在Python 2.7还是在Python 3.5上都无法正确执行。这说明json模块对于自定义数据类型的反序列化支持还是比较有限的，但是我们也可以通过json.loads(JSON_STR)函数，不指定cls参数来得到一个dict对象，然后自己完成dict到object的转换。

继承JSONEncoder实现序列化时还有一个额外的作用，就是可以通过iterencode()方法把一个很大的数据对象分多次进行序列化，这对于网络传输、磁盘持久化等情景非常有用。

for chunk in MyJSONEncoder().iterencode(stu):
… print(chunk)
…
{
“class”
:
“Student”
,
“name”
:
“Tom”
,
“module”
:
“main”
,
“sno”
:
1
,
“age”
:
19
}

大数据对象序列化网络传输伪代码：

for chunk in JSONEncoder().iterencode(bigobject):
mysocket.write(chunk)

三、pickle模块

---

pickle模块实现了用于对Python对象结构进行 序列化 和 反序列化 的二进制协议，与json模块不同的是pickle模块序列化和反序列化的过程分别叫做 pickling 和 unpickling：

• pickling： 是将Python对象转换为字节流的过程；
• unpickling： 是将字节流二进制文件或字节对象转换回Python对象的过程；

1. pickle模块与json模块对比

• JSON是一种文本序列化格式（它输出的是unicode文件，大多数时候会被编码为utf-8），而pickle是一个二进制序列化格式;
• JOSN是我们可以读懂的数据格式，而pickle是二进制格式，我们无法读懂；
• JSON是与特定的编程语言或系统无关的，且它在Python生态系统之外被广泛使用，而pickle使用的数据格式是特定于Python的；
• 默认情况下，JSON只能表示Python内建数据类型，对于自定义数据类型需要一些额外的工作来完成；pickle可以直接表示大量的Python数据类型，包括自定数据类型（其中，许多是通过巧妙地使用Python内省功能自动实现的；复杂的情况可以通过实现specific object API来解决）

2. pickle模块使用的数据流格式

上面提到，pickle使用的数据格式是特定于Python的。这使得它不受诸如JSON或XDR的外部标准限值，但是这也意味着非Python程序可能无法重建pickled Python对象。默认情况下，pickle数据格式使用相对紧凑的二进制表示。如果需要最佳大小特征，可以有效的压缩pickled数据。pickletools模块包含可以用于对pickle生成的数据流进行分析的工具。目前有5种不同的协议可以用于pickle。使用的协议越高，就需要更新的Python版本去读取pickle产生的数据：

• 协议v0是原始的“人类可读”协议，并且向后兼容早期的Python版本；
• 协议v1是一个旧的二进制格式，也与早期版本的Python兼容；
• 协议v2在Python 2.3中引入，它提供更高效的pickling；
• 协议v3是在Python 3.0添加的协议，它明确支持bytes对象，且不能被Python 2.x 进行unpickle操作；这是默认协议，也是当需要兼容其他Python 3版本时被推荐使用的协议；
• 协议4是在Python 3.4添加的协议，它添加了对极大对象的支持，pickling更多种类的对象，以及一些数据格式的优化。

说明： Python 2.x中默认使用的是协议v0，如果协议指定为赋值或HIGHEST_PROTOCOL，将使用当前可用的最高协议版本；Python 3.x中默认使用的是协议v3，它兼容其他Python 3版本，但是不兼容Python 2。

注意： 序列化（Serialization）是一个比持久化（Persistence）更加原始的概念；虽然pickle可以读写文件对象，但是它不处理持久化对象的命名问题，也不处理对持久化对象的并发访问问题（甚至更复杂的问题）。pickle模块可以将复杂对象转换为字节流，并且可以将字节流转换为具有相同内部结构的对象。或许最可能对这些字节流做的事情是将它们写入文件，但是也可以对它们进行网络传输或将它们存储在数据库中。shelve模块提供了一个简单的接口用于在DBM风格的数据库文件上对对象进行pickle和unpickle操作。

3. pickle模块提供的相关函数

pickle模块提供的几个序列化/反序列化的函数与json模块基本一致：

将指定的Python对象通过pickle序列化作为bytes对象返回，而不是将其写入文件

dumps(obj, protocol=None, *, fix_imports=True)

将通过pickle序列化后得到的字节对象进行反序列化，转换为Python对象并返回

loads(bytes_object, *, fix_imports=True, encoding=“ASCII”, errors=“strict”)

将指定的Python对象通过pickle序列化后写入打开的文件对象中，等价于Pickler(file, protocol).dump(obj)

dump(obj, file, protocol=None, *, fix_imports=True)

从打开的文件对象中读取pickled对象表现形式并返回通过pickle反序列化后得到的Python对象

load(file, *, fix_imports=True, encoding=“ASCII”, errors=“strict”)

说明： 上面这几个方法参数中，*号后面的参数都是Python 3.x新增的，目的是为了兼容Python 2.x，具体用法请参看官方文档。

4. 实例：内置数据类型的序列化/反序列化

Python 2.x

import pickle

var_a = {‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)}

序列化

var_b = pickle.dumps(var_a)
var_b
“(dp0\nS’a’\np1\nS’str’\np2\nsS’c’\np3\nI01\nsS’b’\np4\nF11.1\nsS’e’\np5\nI10\nsS’d’\np6\nNsS’g’\np7\n(I4\nI5\nI6\ntp8\nsS’f’\np9\n(lp10\nI1\naI2\naI3\nas.”

反序列化

var_c = pickle.loads(var_b)
var_c
{‘a’: ‘str’, ‘c’: True, ‘b’: 11.1, ‘e’: 10, ‘d’: None, ‘g’: (4, 5, 6), ‘f’: [1, 2, 3]}

Python 3.x

import pickle

var_a = {‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)}

序列化

var_b = pickle.dumps(var_a)
var_b
b’\x80\x03}q\x00(X\x01\x00\x00\x00eq\x01K\nX\x01\x00\x00\x00aq\x02X\x03\x00\x00\x00strq\x03X\x01\x00\x00\x00fq\x04]q\x05(K\x01K\x02K\x03eX\x01\x00\x00\x00gq\x06K\x04K\x05K\x06\x87q\x07X\x01\x00\x00\x00bq\x08G@&333333X\x01\x00\x00\x00cq\t\x88X\x01\x00\x00\x00dq\nNu.’

反序列化

var_c = pickle.loads(var_b)
var_c
{‘e’: 10, ‘a’: ‘str’, ‘f’: [1, 2, 3], ‘g’: (4, 5, 6), ‘b’: 11.1, ‘c’: True, ‘d’: None}

dump()与load()

import pickle

var_a = {‘a’:‘str’, ‘c’: True, ‘e’: 10, ‘b’: 11.1, ‘d’: None, ‘f’: [1, 2, 3], ‘g’:(4, 5, 6)}

持久化到文件

with open(‘pickle.txt’, ‘wb’) as f:
… pickle.dump(var_a, f)
…

从文件中读取数据

with open(‘pickle.txt’, ‘rb’) as f:
… var_b = pickle.load(f)
…
var_b
{‘e’: 10, ‘a’: ‘str’, ‘f’: [1, 2, 3], ‘g’: (4, 5, 6), ‘b’: 11.1, ‘c’: True, ‘d’: None}

说明：

• 默认情况下Python 2.x中pickled后的数据是字符串形式，需要将它转换为字节对象才能被Python 3.x中的pickle.loads()反序列化；Python 3.x中pickling所使用的协议是v3，因此需要在调用pickle.dumps()时指定可选参数protocol为Python 2.x所支持的协议版本（0,1,2），否则pickled后的数据不能被被Python 2.x中的pickle.loads()反序列化；
• Python 3.x中pickle.dump()和pickle.load()方法中指定的文件对象，必须以二进制模式打开，而Python 2.x中可以以二进制模式打开，也可以以文本模式打开。

5. 实例：自定义数据类型的序列化/反序列化

首先来自定义一个数据类型：

class Student(object):
def init(self, name, age, sno):
self.name = name
self.age = age
self.sno = sno

def repr(self):
return ‘Student [name: %s, age: %d, sno: %d]’ % (self.name, self.age, self.sno)

pickle模块可以直接对自定数据类型进行序列化/反序列化操作，无需编写额外的处理函数或类。

stu = Student(‘Tom’, 19, 1)
print(stu)
Student [name: Tom, age: 19, sno: 1]

序列化

var_b = pickle.dumps(stu)
var_b
b’\x80\x03c__main__\nStudent\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x03\x00\x00\x00Tomq\x04X\x03\x00\x00\x00ageq\x05K\x13X\x03\x00\x00\x00snoq\x06K\x01ub.’

反序列化

var_c = pickle.loads(var_b)
var_c
Student [name: Tom, age: 19, sno: 1]

持久化到文件

with open(‘pickle.txt’, ‘wb’) as f:
… pickle.dump(stu, f)
…

从文件总读取数据

with open(‘pickle.txt’, ‘rb’) as f:
… pickle.load(f)
…
Student [name: Tom, age: 19, sno: 1]

回到顶部

四、shelve模块

---

shelve是一个简单的数据存储方案，类似key-value数据库，可以很方便的保存python对象，其内部是通过pickle协议来实现数据序列化。shelve只有一个open()函数，这个函数用于打开指定的文件（一个持久的字典），然后返回一个shelf对象。shelf是一种持久的、类似字典的对象。它与“dbm”的不同之处在于，其values值可以是任意基本Python对象–pickle模块可以处理的任何数据。这包括大多数类实例、递归数据类型和包含很多共享子对象的对象。keys还是普通的字符串。

open(filename, flag=‘c’, protocol=None, writeback=False)

flag 参数表示打开数据存储文件的格式，可取值与dbm.open()函数一致：

值	描述
‘r’	以只读模式打开一个已经存在的数据存储文件
‘w’	以读写模式打开一个已经存在的数据存储文件
‘c’	以读写模式打开一个数据存储文件，如果不存在则创建
‘n’	总是创建一个新的、空数据存储文件，并以读写模式打开

protocol 参数表示序列化数据所使用的协议版本，默认是pickle v3；

writeback 参数表示是否开启回写功能。

我们可以把shelf对象当dict来使用–存储、更改、查询某个key对应的数据，当操作完成之后，调用shelf对象的close()函数即可。当然，也可以使用上下文管理器（with语句），避免每次都要手动调用close()方法。

实例：内置数据类型操作

保存数据

with shelve.open(‘student’) as db:
db[‘name’] = ‘Tom’
db[‘age’] = 19
db[‘hobby’] = [‘篮球’, ‘看电影’, ‘弹吉他’]
db[‘other_info’] = {‘sno’: 1, ‘addr’: ‘xxxx’}

读取数据

with shelve.open(‘student’) as db:
for key,value in db.items():
print(key, ': ', value)

输出结果：

name : Tom
age : 19
hobby : [‘篮球’, ‘看电影’, ‘弹吉他’]
other_info : {‘sno’: 1, ‘addr’: ‘xxxx’}

实例：自定义数据类型操作

自定义class

class Student(object):
def init(self, name, age, sno):
self.name = name
self.age = age
self.sno = sno

def repr(self):
return ‘Student [name: %s, age: %d, sno: %d]’ % (self.name, self.age, self.sno)

保存数据

tom = Student(‘Tom’, 19, 1)
jerry = Student(‘Jerry’, 17, 2)

with shelve.open(“stu.db”) as db:
db[‘Tom’] = tom
db[‘Jerry’] = jerry

读取数据

with shelve.open(“stu.db”) as db:
print(db[‘Tom’])
print(db[‘Jerry’])

输出结果：

Student [name: Tom, age: 19, sno: 1]
Student [name: Jerry, age: 17, sno: 2]

五、阶段总结

---

1. 对比

json模块常用于编写web接口，将Python数据转换为通用的json格式传递给其它系统或客户端；也可以用于将Python数据保存到本地文件中，缺点是明文保存，保密性差。另外，如果需要保存非内置数据类型需要编写额外的转换函数或自定义类。

pickle模块和shelve模块由于使用其特有的序列化协议，其序列化之后的数据只能被Python识别，因此只能用于Python系统内部。另外，Python 2.x 和 Python
3.x 默认使用的序列化协议也不同，如果需要互相兼容需要在序列化时通过protocol参数指定协议版本。除了上面这些缺点外，pickle模块和shelve模块相对于json模块的优点在于对于自定义数据类型可以直接序列化和反序列化，不需要编写额外的转换函数或类。

shelve模块可以看做是pickle模块的升级版，因为shelve使用的就是pickle的序列化协议，但是shelve比pickle提供的操作方式更加简单、方便。shelve模块相对于其它两个模块在将Python数据持久化到本地磁盘时有一个很明显的优点就是，它允许我们可以像操作dict一样操作被序列化的数据，而不必一次性的保存或读取所有数据。

2. 建议

• 需要与外部系统交互时用json模块；
• 需要将少量、简单Python数据持久化到本地磁盘文件时可以考虑用pickle模块；
• 需要将大量Python数据持久化到本地磁盘文件或需要一些简单的类似数据库的增删改查功能时，可以考虑用shelve模块。

3. 附录

要实现的功能	可以使用的api
将Python数据类型转换为（json）字符串	json.dumps()
将json字符串转换为Python数据类型	json.loads()
将Python数据类型以json形式保存到本地磁盘	json.dump()
将本地磁盘文件中的json数据转换为Python数据类型	json.load()
将Python数据类型转换为Python特定的二进制格式	pickle.dumps()
将Python特定的的二进制格式数据转换为Python数据类型	pickle.loads()
将Python数据类型以Python特定的二进制格式保存到本地磁盘	pickle.dump()
将本地磁盘文件中的Python特定的二进制格式数据转换为Python数据类型	pickle.load()
以类型dict的形式将Python数据类型保存到本地磁盘或读取本地磁盘数据并转换为数据类型	shelve.open()

【第五节：python 反射机制在实际的应用场景讲解】

剖析python语言中 “反射” 机制的本质和实际应用场景 一. 前言

1. def s1():
2. print(“s1是这个函数的名字！”)
4. s = “s1”
5. print(“%s是个字符串” % s)

在上面的代码中，我们必须区分两个概念，f1和“f1"。前者是函数f1的函数名，后者只是一个叫”f1“的字符串，两者是不同的事物。我们可以用f1()的方式调用函数f1，但我们不能用"f1"()的方式调用函数。说白了就是，不能通过字符串来调用名字看起来相同的函数！

二、web实例

考虑有这么一个场景，根据用户输入的url的不同，调用不同的函数，实现不同的操作，也就是一个url路由器的功能，这在web框架里是核心部件之一。下面有一个精简版的示例：

首先，有一个commons模块，它里面有几个函数，分别用于展示不同的页面，代码如下：

1. def login():
2. print(“这是一个登陆页面！”)
3. • def logout():

• print(“这是一个退出页面！”)
• • def home():
• print(“这是网站主页面！”)

其次，有一个visit模块，作为程序入口，接受用户输入，展示相应的页面，代码如下：（这段代码是比较初级的写法）

1. import commons
2. • def run():

• inp = input("请输入您想访问页面的url： ").strip()
• if inp == “login”:
• commons.login()
• elif inp == “logout”:
• commons.logout()
• elif inp == “home”:
• commons.home()
• else:
• print(“404”)
• • if __name__ == ‘__main__’:
• run()

我们运行visit.py，输入：home，页面结果如下：

1. 请输入您想访问页面的url： home
2. 这是网站主页面！

这就实现了一个简单的WEB路由功能，根据不同的url，执行不同的函数，获得不同的页面。

然而，让我们考虑一个问题，如果commons模块里有成百上千个函数呢(这非常正常)?。难道你在visit模块里写上成百上千个elif?显然这是不可能的！那么怎么破？

三、反射机制

仔细观察visit中的代码，我们会发现用户输入的url字符串和相应调用的函数名好像！如果能用这个字符串直接调用函数就好了！但是，前面我们已经说了字符串是不能用来调用函数的。为了解决这个问题，python为我们提供一个强大的内置函数：getattr!我们将前面的visit修改一下，代码如下：

1. import commons
2. • def run():

• inp = input("请输入您想访问页面的url： ").strip()
• func = getattr(commons,inp)
• func()
• if __name__ == ‘__main__’:
• run()

首先说明一下getattr函数的使用方法：它接收2个参数，前面的是一个对象或者模块，后面的是一个字符串，注意了！是个字符串！

例子中，用户输入储存在inp中，这个inp就是个字符串，getattr函数让程序去commons这个模块里，寻找一个叫inp的成员（是叫，不是等于），这个过程就相当于我们把一个字符串变成一个函数名的过程。然后，把获得的结果赋值给func这个变量，实际上func就指向了commons里的某个函数。最后通过调用func函数，实现对commons里函数的调用。这完全就是一个动态访问的过程，一切都不写死，全部根据用户输入来变化。

执行上面的代码，结果和最开始的是一样的。

这就是python的反射，它的核心本质其实就是利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！

这段话，不一定准确，但大概就是这么个意思。

四、进一步完善

上面的代码还有个小瑕疵，那就是如果用户输入一个非法的url，比如jpg，由于在commons里没有同名的函数，肯定会产生运行错误，具体如下：

1. 请输入您想访问页面的url： jpg
2. Traceback (most recent call last):
3. File “F:/Python/pycharm/s13/reflect/visit.py”, line 16, in 
4. run()
5. File “F:/Python/pycharm/s13/reflect/visit.py”, line 11, in run
6. func = getattr(commons,inp)
7. AttributeError: module ‘commons’ has no attribute ‘jpg’

那怎么办呢？其实，python考虑的很全面了，它同样提供了一个叫hasattr的内置函数，用于判断commons中是否具有某个成员。我们将代码修改一下：

1. import commons
3. def run():
4. inp = input("请输入您想访问页面的url： ").strip()
5. if hasattr(commons,inp):
6. func = getattr(commons,inp)
7. func()
8. else:
9. print(“404”)
11. if __name__ == ‘__main__’:
12. run()

通过hasattr的判断，可以防止非法输入错误，并将其统一定位到错误页面。

其实，研究过python内置函数的朋友，应该注意到还有delattr和setattr两个内置函数。从字面上已经很好理解他们的作用了。

python的四个重要内置函数：getattr、hasattr、delattr和setattr较为全面的实现了基于字符串的反射机制。他们都是对内存内的模块进行操作，并不会对源文件进行修改。

五、动态导入模块

上面的例子是在某个特定的目录结构下才能正常实现的，也就是commons和visit模块在同一目录下，并且所有的页面处理函数都在commons模块内。如下图：

但在现实使用环境中，页面处理函数往往被分类放置在不同目录的不同模块中，也就是如下图：

难道我们要在visit模块里写上一大堆的import 语句逐个导入account、manage、commons模块吗？要是有1000个这种模块呢？

刚才我们分析完了基于字符串的反射，实现了动态的函数调用功能，我们不禁会想那么能不能动态导入模块呢？这完全是可以的！

python提供了一个特殊的方法：__import__(字符串参数)。通过它，我们就可以实现类似的反射功能。__import__()方法会根据参数，动态的导入同名的模块。

我们再修改一下上面的visit模块的代码。

1. def run():
2. inp = input("请输入您想访问页面的url： ").strip()
3. modules, func = inp.split(“/”)
4. obj = __import__(modules)
5. if hasattr(obj, func):
6. func = getattr(obj, func)
7. func()
8. else:
9. print(“404”)
11. if __name__ == ‘__main__’:
12. run()

运行一下：

1. 请输入您想访问页面的url： commons/home
2. 这是网站主页面！
3. 请输入您想访问页面的url： account/find
4. 这是一个查找功能页面！

我们来分析一下上面的代码：

首先，我们并没有定义任何一行import语句；

其次，用户的输入inp被要求为类似“commons/home”这种格式，其实也就是模拟web框架里的url地址，斜杠左边指向模块名，右边指向模块中的成员名。

然后，modules,func = inp.split(“/”)处理了用户输入，使我们获得的2个字符串，并分别保存在modules和func变量里。

接下来，最关键的是obj = __import__(modules)这一行，它让程序去导入了modules这个变量保存的字符串同名的模块，并将它赋值给obj变量。

最后的调用中，getattr去modules模块中调用func成员的含义和以前是一样的。

总结：通过__import__函数，我们实现了基于字符串的动态的模块导入。

同样的，这里也有个小瑕疵！

如果我们的目录结构是这样的：

那么在visit的模块调用语句中，必须进行修改，我们想当然地会这么做：

1. def run():
2. inp = input("请输入您想访问页面的url： ").strip()
3. modules, func = inp.split(“/”)
4. obj = __import__(“lib.” + modules) #注意字符串的拼接
5. if hasattr(obj, func):
6. func = getattr(obj, func)
7. func()
8. else:
9. print(“404”)
11. if __name__ == ‘__main__’:
12. run()

改了这么一个地方:obj = __import__(“lib.” + modules)，看起来似乎没什么问题，和import lib.commons的传统方法类似，但实际上运行的时候会有错误。

1. 请输入您想访问页面的url： commons/home
2. 404
3. 请输入您想访问页面的url： account/find
4. 404

为什么呢？因为对于lib.xxx.xxx.xxx这一类的模块导入路径，__import__默认只会导入最开头的圆点左边的目录，也就是“lib”。我们可以做个测试，在visit同级目录内新建一个文件，代码如下：

1. obj = __import__(“lib.commons”)
2. print(obj)

执行结果：

1. <module ‘lib’<span=“” font-size:14px;white-space:pre;“=”">(namespace)>

这个问题怎么解决呢？加上fromlist = True参数即可！

1. def run():
2. inp = input("请输入您想访问页面的url： ").strip()
3. modules, func = inp.split(“/”)
4. obj = __import__(“lib.” + modules, fromlist=True) # 注意fromlist参数
5. if hasattr(obj, func):
6. func = getattr(obj, func)
7. func()
8. else:
9. print(“404”)
11. if __name__ == ‘__main__’:
12. run()

至此，动态导入模块的问题基本都解决了，只剩下最后一个，那就是万一用户输入错误的模块名呢？比如用户输入了somemodules/find，由于实际上不存在somemodules这个模块，必然会报错！那有没有类似上面hasattr内置函数这么个功能呢？答案是没有！碰到这种，你只能通过异常处理来解决。

六、最后的思考

可能有人会问python不是有两个内置函数exec和eval吗？他们同样能够执行字符串。比如：

1. exec(“print(‘haha’)”)

结果：

1. haha

那么直接使用它们不行吗？非要那么费劲地使用getattr， __import__干嘛？

其实，在上面的例子中，围绕的核心主题是如何利用字符串驱动不同的事件，比如导入模块、调用函数等等，这些都是python的反射机制，是一种编程方法、设计模式的体现，凝聚了高内聚、松耦合的编程思想，不能简单的用执行字符串来代替。当然，exec和eval也有它的舞台，在web框架里也经常被使用。

【第六节：Python函数装饰器原理与用法详解】

这篇文章主要介绍了Python函数装饰器原理与用法,结合实例形式详细分析了Python装饰器的原理、功能、分类、常见操作技巧与使用注意事项,需要的朋友可以参考下

本文实例讲述了Python函数装饰器原理与用法。分享给大家供大家参考，具体如下：

装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

严格来说，装饰器只是语法糖，装饰器是可调用的对象，可以像常规的可调用对象那样调用，特殊的地方是装饰器的参数是一个函数

现在有一个新的需求，希望可以记录下函数的执行时间，于是在代码中添加日志代码：

1 2 3 4 5 6 7 8 9	import time #遵守开放封闭原则 def foo(): start = time.time() # print(start) # 1504698634.0291758从1970年1月1号到现在的秒数，那年Unix诞生 time.sleep(``3``) end = time.time() print``(``'spend %s'``%``(end - start)) foo()

bar()、bar2()也有类似的需求，怎么做？再在bar函数里调用时间函数？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门设定时间:

1 2 3 4 5 6 7 8 9 10	import time def show_time(func): start_time``=``time.time() func() end_time``=``time.time() print``(``'spend %s'``%``(end_time``-``start_time)) def foo(): print``(``'hello foo'``) time.sleep(``3``) show_time(foo)

但是这样的话,你基础平台的函数修改了名字，容易被业务线的人投诉的，因为我们每次都要将一个函数作为参数传递给show_time函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行foo()，但是现在不得不改成show_time(foo)。那么有没有更好的方式的呢？当然有，答案就是装饰器。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	def show_time(f): def inner(): start = time.time() f() end = time.time() print``(``'spend %s'``%``(end - start)) return inner @show_time #foo=show_time(f) def foo(): print``(``'foo...'``) time.sleep(``1``) foo() def bar(): print``(``'bar...'``) time.sleep(``2``) bar()

输出结果：

foo…
spend 1.0005607604980469
bar…

函数show_time就是装饰器，它把真正的业务方法f包裹在函数里面，看起来像foo被上下时间函数装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

装饰器有２个特性，一是可以把被装饰的函数替换成其他函数，　二是可以在加载模块时候立即执行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def decorate(func): print``(``'running decorate'``, func) def decorate_inner(): print``(``'running decorate_inner function'``) return func() return decorate_inner @decorate def func_1(): print``(``'running func_1'``) if __name__ =``= '__main__'``: print``(func_1) #running decorate <function func_1 at 0x000001904743DEA0> # <function decorate.<locals>.decorate_inner at 0x000001904743DF28> func_1() #running decorate_inner function # running func_1

通过args 和　*kwargs 传递被修饰函数中的参数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def decorate(func): def decorate_inner(``*``args, *``*``kwargs): print``(``type``(args), type``(kwargs)) print``(``'args'``, args, 'kwargs'``, kwargs) return func(``*``args, *``*``kwargs) return decorate_inner @decorate def func_1(``*``args, *``*``kwargs): print``(args, kwargs) if __name__ =``= '__main__'``: func_1(``'1'``, '2'``, '3'``, para_1``=``'1'``, para_2``=``'2'``, para_3``=``'3'``) #返回结果 #<class 'tuple'> <class 'dict'> # args ('1', '2', '3') kwargs {'para_1': '1', 'para_2': '2', 'para_3': '3'} # ('1', '2', '3') {'para_1': '1', 'para_2': '2', 'para_3': '3'}

带参数的被装饰函数

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数软件测试工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年软件测试全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上软件测试开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注软件测试）

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

wargs) return func(*args, *kwargs) return decorate_inner @decorate def func_1(*args, *kwargs): print(args, kwargs)` `if` `__name__` `== ‘main’:` `func_1(‘1’,` `'2', ‘3’, para_1='1', para_2=‘2’, para_3='3') #返回结果 #<class ‘tuple’> <class ‘dict’> # args (‘1’, ‘2’, ‘3’) kwargs {‘para_1’: ‘1’, ‘para_2’: ‘2’, ‘para_3’: ‘3’} # (‘1’, ‘2’, ‘3’) {‘para_1’: ‘1’, ‘para_2’: ‘2’, ‘para_3’: ‘3’}` |

带参数的被装饰函数

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数软件测试工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年软件测试全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-oMoP3yoG-1713017550082)]
[外链图片转存中…(img-LouyaiU2-1713017550083)]
[外链图片转存中…(img-WHjZrbuT-1713017550084)]
[外链图片转存中…(img-7GVgQ11Y-1713017550084)]
[外链图片转存中…(img-kPqpjBi8-1713017550085)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上软件测试开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注软件测试）
[外链图片转存中…(img-JVE7KRLh-1713017550085)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！