序列化模块：json、pickle、shelve

### 序列模块
什么是序列化
```
'abdsafaslhiewhldvjlmvlvk['
序列化 —— 转向一个字符串数据类型
序列 —— 字符串
{'k':'v'}----->序列化----->"{'k':'v'}"

需要序列化的情况：数据存储、网络上传输的时候

从数据类型 --> 字符串的过程 序列化
从字符串 --> 数据类型的过程 反序列化

```
```
json *****
pickle ****
shelve ***

json模块 数字 字符串 列表 字典 元组(转成列表再序列化)
1. 集合{1,2,3}是无法用json序列化的
2. 通用的序列化格式 （优点）
3. 只有很少的一部分数据类型能够通过json转化成字符串 (缺点)

pickle模块
1. dump出来的数据是bytes类型的，load出来才变成可认出来的字典，故为wb或者rb
2. 所有的python中的数据类型都可以转化成字符串形式 （优点）
3. pickle序列化的内容只有python能理解 （缺点）
4. 且部分反序列化依赖 原python代码 （缺点）

shelve模块
序列化句柄
使用句柄直接操作，非常方便
新式的模块，以前没有
```
f写完后：加f.flush()刷新
#### 一、json模块
json：整体是由单引号 引起来的，里面的字典内容全是单引号 '{"k1":"v1","k2":"v2"}'
##### dumps和 loads
1.内存中的序列化：dumps序列化方法 loads反序列化方法
```python
dic = {1:"a",2:'b'}
print(type(dic),dic)
import json
str_d = json.dumps(dic) # 序列化
print(type(str_d),str_d)

#'{"kkk":"v"}'
dic_d = json.loads(str_d) # 反序列化
print(type(dic_d),dic_d)
```

2.文件操作时用dump load
dump：先把字典序列化，再写到文件
load：先读出序列化的文件，再反序列化，加载到内存

```python
import json
dic = {1:"a",2:'b'}
f = open('fff','w',encoding='utf-8')
json.dump(dic,f)
f.close()

f = open('fff')
res = json.load(f)
f.close()
print(type(res),res)
```

优化：
dumps 写的时候：{} ---> '{}\n' 加换行符换行
```python
l = [{'k':'111'},{'k2':'111'},{'k3':'111'}]
f = open('file','w')
import json
for dic in l:
str_dic = json.dumps(dic)
f.write(str_dic+'\n')
f.close()

# '{}\n'读的时候loads 一行一行的(去掉换行符的)
f = open('file')
import json
l = []
for line in f:
dic = json.loads(line.strip())
l.append(dic)
f.close()
print(l)
```
json dumps的其他参数, 设置后方便自己看，但浪费内存和硬盘
  

#### 二、pickle模块
坑：一个文件dump一次，load一次就能得到全部内容，如果dump多次，需要loud多次才能显示完
数字 字符串 列表 字典 元组 集合都可以
pickle的处理都是二进制的 写的时候要加b
pickle dump时候，打开的时候不加encoding='utf8' !
```python
import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic) #一串二进制内容 是bytes类型的

dic2 = pickle.loads(str_dic)
print(dic2) #把二进制的bytes loads变回 字典

#pickle可以分步dump和load 但json不支持
import time
struct_time1 = time.localtime(1000000000)
struct_time2 = time.localtime(2000000000)

#pickle与文件打交道时，都要加b 因为处理的都是二进制bytes
f = open('pickle_file','wb') #不能加encoding
pickle.dump(struct_time1,f)
pickle.dump(struct_time2,f)
f.close()

f = open('pickle_file','rb')
struct_time1 = pickle.load(f)
struct_time2 = pickle.load(f)
print(struct_time1.tm_year)
print(struct_time2.tm_year)
f.close()
```

#### 三、shelve模块

dump出来的数据跟pickle一样看不懂

```python
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)

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

f.close()

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

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()
```