Python之序列化模块

Posted 2021-01-11 serendipity

序列化模块

　　导入：import module

　　序列化：数据类型和str之间的转换，数据持久化（存储），网络交互（传输）本质：将程序中的数据类型转成str

　　反序列化：将字符串转换为其本来的数据类型

　　序列化和反序列化这些操作都是一次性的，一次转换，一次还原　　

(1) json （存文件，网络传输）

json模块只给我们提供了四个功能：

　　序列化：dump，dumps   
　　反序列化：load, loads

　　　　dumps和loads：对数据类型进行序列化和反序列化

 1 import json
 2 
 3 dic = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}
 4 
 5 # 序列化：将一个字典转换成一个字符串
 6 str_dic = json.dumps(dic)  
 7 
 8 print(type(str_dic), str_dic)  
 9 # 结果：
10 # 注意，json转换完的字符串类型的字典中的字符串是由""表示的
11 # <class ‘str‘> {"k3": "v3", "k1": "v1", "k2": "v2"}
12 
13 
14 # 反序列化：将一个字符串格式的字典转换成一个字典
15 # 注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
16 dic2 = json.loads(str_dic)  
17 
18 print(type(dic2), dic2)  
19 # 结果：
20 # <class ‘dict‘> {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}
21 
22 list_dic = [1, [‘a‘, ‘b‘, ‘c‘], 3, {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}]
23 str_dic = json.dumps(list_dic)  # ps:也可以处理嵌套的数据类型
24 print(type(str_dic), str_dic)  
25 # 结果：
26 # <class ‘str‘> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
27 
28 list_dic2 = json.loads(str_dic)
29 print(type(list_dic2), list_dic2)  
30 # 结果：
31 # <class ‘list‘> [1, [‘a‘, ‘b‘, ‘c‘], 3, {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}]

　　　　

　　　　dump和load：对文件句柄进行序列化和反序列化

 1 import json
 2 
 3 f = open(‘json_file‘, ‘w‘)
 4 dic = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}
 5 
 6 # dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
 7 json.dump(dic, f)
 8 f.close()
 9 
10 f = open(‘json_file‘)
11 
12 # load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
13 dic2 = json.load(f)
14 f.close()
15 print(type(dic2), dic2)

　　　　

　　　　ensure_ascii关键字：默认是True,表示按照ascii的形式显示，设置为False的时候，表是按照原来的文本样式显示（主要针对中文）

 1 import json
 2 
 3 f = open(‘file‘, ‘w‘)
 4 json.dump({‘国籍‘: ‘中国‘}, f)
 5 ret = json.dumps({‘国籍‘: ‘中国‘})
 6 f.write(ret + ‘
‘)
 7 json.dump({‘国籍‘: ‘美国‘}, f, ensure_ascii=False)
 8 ret = json.dumps({‘国籍‘: ‘美国‘}, ensure_ascii=False)
 9 f.write(ret + ‘
‘)
10 f.close()
11 
12 # 写到文件中的结果：
13 # {"u56fdu7c4d": "u4e2du56fd"}{"u56fdu7c4d": "u4e2du56fd"}
14 # {"????": "????"}{"????": "????"}（这里是因为文件打开的模式不对）

 

(2) pickle 模块

　　pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load
　 （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）
　   pickle，用于python特有的类型 和 python的数据类型间进行转换

　　pickle--只能写进去，不能追加

　　　　示例1：

 1 import pickle
 2 
 3 dic = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}
 4 str_dic = pickle.dumps(dic)
 5 print(str_dic)  # 一串二进制内容
 6 
 7 dic2 = pickle.loads(str_dic)
 8 print(dic2)  # 字典
 9 
10 # 结果：
11 # b‘x80x03}qx00(Xx02x00x00x00k1qx01Xx02x00x00x00v1qx02Xx02x00x00x00k2qx03Xx02x00x00x00v2qx04Xx02x00x00x00k3qx05Xx02x00x00x00v3qx06u.‘
12 # {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}

　　　　示例2：

 1 import time
 2 import pickle
 3 
 4 struct_time = time.localtime(1000000000)
 5 print(struct_time)
 6 
 7 f = open(‘pickle_file‘, ‘wb‘)
 8 pickle.dump(struct_time, f)
 9 f.close()
10 
11 f = open(‘pickle_file‘, ‘rb‘)
12 struct_time2 = pickle.load(f)
13 f.close()
14 
15 print(struct_time2.tm_year)
16 
17 
18 # 结果：
19 # time.struct_time(tm_year=2001, tm_mon=9, tm_mday=9, tm_hour=9, tm_min=46, tm_sec=40, tm_wday=6, tm_yday=252, tm_isdst=0)
20 # 2001

 

　　json和pickle模块对比：

　　　　json，用于字符串 和 python数据类型间进行转换
　　　　pickle，用于python特有的类型 和 python的数据类型间进行转换（可以把python中任意的数据类型序列化）

　　　　json--能处理的很少
　　　　pickle--可以序列化python里没有的，自己定义的数据类型

　　　　json---是所有p编程语言通用的一种数据类型---网络编程
　　　　pickle---可以序列化一些自定义的数据类型---游戏

 

（3）shelve---只提供了open 方法

   shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。
   shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。

 1 import shelve
 2 
 3 f = shelve.open(‘shelve_file‘)
 4 f[‘key‘] = {‘int‘: 10, ‘float‘: 9.5, ‘string‘: ‘Sample data‘}  # 直接对文件句柄操作，就可以存入数据
 5 f.close()
 6 
 7 import shelve
 8 
 9 f1 = shelve.open(‘shelve_file‘)
10 existing = f1[‘key‘]  # 取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
11 f1.close()
12 print(existing)
13 
14 # 结果：
15 # {‘int‘: 10, ‘float‘: 9.5, ‘string‘: ‘Sample data‘}

　　　　这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。
　　　　所以当我们知道我们的应用如果只进行读操作，可以让shelve通过只读方式打开DB

1 import shelve
2 
3 f = shelve.open(‘shelve_file‘, flag=‘r‘)
4 existing = f[‘key‘]
5 f.close()
6 print(existing)

　　　　由于shelve在默认情况下是不会记录待持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存。

 1 import shelve
 2 f1 = shelve.open(‘shelve_file‘)
 3 print(f1[‘key‘])
 4 f1[‘key‘][‘new_value‘] = ‘this was not here before‘
 5 f1.close()
 6 
 7 f2 = shelve.open(‘shelve_file‘, writeback=True)
 8 print(f2[‘key‘])
 9 f2[‘key‘][‘new_value‘] = ‘this was not here before‘
10 f2.close()

　　　　writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；
　　　　但这种方式并不是所有的情况下都需要，
　　　　首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。
　　　　因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入