11-14序列化模块之json、pickle、shelve

序列化的目的

1、以某种存储形式使自定义对象持久化；

2、将对象从一个地方传递到另一个地方。

3、使程序更具维护性。

序列化--转向一个字符串数据类型
序列--及时字符串

何处用到：
　　数据存储
　　网络上传输的时候


从数据类型到字符串的过程，叫做序列化
从字符串到数据类型的过程，叫做反序列化

分类
    json   *****
    pickle ****
    shelve ***

特点
json(可以进行序列化的有：数字，字符串，列表，字典，元组（将元组转成序列表进行序列化）)
    通用的序列化格式
    只有很少的一部分数据类型能够通过json转化成字符串
pickle
    所有Python中的数据类型都可以转化成字符串形式
    pickle序列化的内容只有Python能够理解
    且反序列化依赖代码
shelve
    序列化句柄
    使用句柄直接操作，非常方便

jsonhe和pickle的选择

json是一种所有的语言都可以识别的数据结构。
如果将一个字典或者序列化成了一个json存在文件里，那么java代码或者js代码也可以拿来用。
但是如果我们用pickle进行序列化，其他语言就不能读懂这是什么了～
所以，如果序列化的内容是列表或者字典，非常推荐使用json模块
但如果出于某种原因你不得不序列化其他的数据类型，而未来还会用python对这个数据进行反序列化的话，那么就可以使用pickle

 

1.Json模块

提供了四个功能：dumps（序列化方法）、dump、loads（反序列方法）、load
    对于json来说，可以分步的dump和load
dumps、loads：对内存中的数据进行操作，数据操作完成后还在内存中

dic = {'k1':'v1'}
# dic = (1,2,3)
print(type(dic),dic)    #<class 'dict'> {'k1': 'v1'}
import json
str_d = json.dumps(dic)
print(type(str_d),str_d)    #<class 'str'> {"k1": "v1"}
dic_new = json.loads(str_d)
print(type(dic_new),dic_new)    #<class 'dict'> {'k1': 'v1'}
print(dic==dic_new) #True

dump、load：是与文件相关的操作
import json
dic = {1:'a',2:'b'}
f = open('fff','w',encoding='utf-8')
json.dump(dic,f)  #写入文件
# json.dump(dic,f)  #写入文件
f.close()

f = open('fff')
res=json.load(f)    #从文件读
f.close()
print(type(res),res)


import json
dic = {1:'中国',2:'b'}
f = open('fff','w',encoding='utf-8')
# json.dump(dic,f)  #写入文件
json.dump(dic,f,ensure_ascii=False)  # 写入文件
f.close()

f = open('fff',encoding='utf-8')
res=json.load(f)    #从文件读
f.close()
print(type(res),res)

#分次写入
l = [{'k1':'v1'},{'k2':'v2'},{'k3':'v3'}]
f = open('file','w')
import json
for dic in l:
    str_d = json.dumps(dic)
    f.write(str_d+'\n')
f.close()

#分次读出
f = open('file')
import json
l = []
for line in f:
    dic_new = json.loads(line.strip())
    l.append(dic_new)
print(l)  #[{'k1': 'v1'}, {'k2': 'v2'}, {'k3': 'v3'}]
f.close()

2.pickle模块

pickle序列化之后看不出来有何内容（文件必须以wb或者rb文件打开）
    对于pickle来说，可以分步的dump和load

dic = {'k1':'v1','k2':'v2'}
print(type(dic),dic)    #<class 'dict'> {'k1': 'v1', 'k2': 'v2'}
import pickle
str_d = pickle.dumps(dic)
print(type(str_d),str_d)    #<class 'bytes'> b'\x80\x03}q\x00(X\x02\x00\x00\x00k1q\x01X\x02\x00\x00\x00v1q\x02X\x02\x00\x00\x00k2q\x03X\x02\x00\x00\x00v2q\x04u.
dic_new = pickle.loads(str_d)
print(type(dic_new),dic_new)    #<class 'dict'> {'k1': 'v1', 'k2': 'v2'}
print(dic==dic_new) #True

import pickle
import time
struct_time1  = time.localtime(1000000000)
struct_time2  = time.localtime(2000000000)
print(struct_time1)  #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)
print(struct_time2) #time.struct_time(tm_year=2033, tm_mon=5, tm_mday=18, tm_hour=11, tm_min=33, tm_sec=20, tm_wday=2, tm_yday=138, tm_isdst=0)
f = open('pickle_file','wb')
pickle.dump(struct_time1,f)  #写入文件
pickle.dump(struct_time2,f)  #写入文件
f.close()

f = open('pickle_file','rb')
struct_time1_new = pickle.load(f)   #读文件
struct_time2_new = pickle.load(f)   #读文件
print(struct_time1_new.tm_year) #2001
print(struct_time2_new.tm_year) #2033
f.close()　

3.shelve模块

只提供了一个open方法，用key进行访问，使用起来与字典类似
存文件的方式也是不透明的

import shelve
f = shelve.open('shelve_file')
f['key']={'int':1,'float':0.1,'String':'Sample data'} #直接对文件句柄进行操作就可以直接存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
context = f1['key'] #取出数据的时候也只需要直接用key获取即可，但是如果key不存则会报错
f1.close()
print(context)

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

import shelve
f1 = shelve.open('shelve_file')
# print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file',writeback=True)
# print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
print(f2['key'])
f2.close()