序列化模块

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

#序列化
dic = {'k1':'v1'}
print(type(dic),dic)

使用场景：写文件（数据存储）、网络上传输的时候
过程：从数据类型 --> 字符串的过程   （序列化）
过程：从字符串 ---> 数据类型的过程   （反序列化）

json 模块
pickle 模块
shelve 模块

json --
    优点：通用的序列化格式
    缺点：只有很少的一部分数据类型能够通过json转化成字符串

# json 方法：dumps序列化方法 loads反序列化方法----直接再内存里操作
# 注意：json本身使用的就是单引号'',但是序列化后，''单引号里所有的单引号都会变为双引号""
# 适用场景：数字、字符串、列表、字典、元组
# 元组是特殊的序列化，序列化后转为了str([1,2,3,4])，反序列化后变成了列表数据类型
import json
str_d = json.dumps(dic) # 序列化
print(type(str_d),str_d)
dic_d = json.loads(str_d) # 反序列化
print(type(dic_d),dic_d)

tup = (1,2,3,4)
str_t = json.dumps(tup)  # 序列化
print(type(str_t),str_t)
tup_t = json.loads(str_t) # 反序列化
print(type(tup_t),tup_t)

json 方法：dump序列化方法 load反序列化方法 --- 在文件里操作，将数据类型转换后写入到文件，或者从文件里读出来
# 写入到文件
dic1 = {1:'a',2:'b'}
with open('ffff','w',encoding='utf-8') as f:
    json.dump(dic1,f)
# 从文件里读取出来
# with open('ffff','r',encoding='utf-8') as f:
#     res = json.load(f)
#     print(type(res),res)

# 当向文件里写入中文时，写入文件里的其实是bytes类型的
dic1 = {1:'中国',2:'广东'}
with open('ffff','w',encoding='utf-8') as f:
    json.dump(dic1,f)

# 解决方法 添加方法ensure_ascii=False
dic1 = {1:'中国',2:'广东'}
with open('ffff','w',encoding='utf-8') as f:
    json.dump(dic1,f,ensure_ascii=False)

# 问题：load是一次性往外读取，还是一条条往外读取
# 解答：取决于dump是一次性写入，还是dump多次写入
# 正解：只能dump一次性写入，才能load一次性往外读
# 解决方式：使用dumps循环写入，使用loads循环读出
# dic1 = {1:'中国',2:'广东'}
# with open('ffff','w',encoding='utf-8') as f:
#     json.dump(dic1,f,ensure_ascii=False)
#     json.dump(dic1, f, ensure_ascii=False)

# 上面是两次写入，你一次只读取一次，程序报错
# with open('ffff','r',encoding='utf-8') as f:
#     ret = json.load(f)
#     print(ret)
# 正确操作方法一：使用dumps循环写入到文件，接着使用loads循环读出
import json
# l = [{'k1':111},{'k2':111},{'k2':111},]
# with open('file','w',encoding='utf-8') as f:
#     for i in l:
#         str_d = json.dumps(i)
#         f.write(str_d+'\n')

with open('file','r',encoding='utf-8') as f:
    l = []
    for i in f:
        print(i.strip())
        dic_d = json.loads(i.strip())
        l.append(dic_d)
    print(l)

pickle
    所有的python中的数据类型都可以转化成字符串形式
    缺点：pickle序列化的内容只有python能理解，且部分反序列化依赖代码
    常用场景：比如保存人物游戏状态下的所有信息

# pickle
# 方法和json 一样：dumps loads dump load
# 注意：pickle进行序列化的时候都是序列化成bytes,所以dumps后的内容都是bytes类型的，且调用dump、load时，使用的是wb\rb的方法
# pickle 支持分次load,json 不支持

import pickle

# # 因为dumps后的是bytes数据类型
dic = {'k1': 111}
str_d = pickle.dumps(dic)  # 序列化
print(type(str_d), str_d)
dic_d = pickle.loads(str_d)  # 反序列化
print(type(dic_d), dic_d)

# 可以分次dump 写入文件，也可以分次load读出文件,注意文件操作时使用wb/rb
# with open("test", 'wb') as f:
#     pickle.dump(dic,f)
#     pickle.dump(dic,f)
#     pickle.dump(dic,f)

with open('test','rb') as f:
    ret = pickle.load(f)
    ret1 = pickle.load(f)
    print(ret)
    print(ret1)

shelve
    shelve 句柄，序列号句柄
    优点：使用句柄直接操作，非常方便
    缺点：不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()
 
import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

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

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

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

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'
f2.close()