Python序列化模块 json和pickle

1 序列化模块

1. 文件的存和取遇到的矛盾：
   目前我们将数据结构（list，dict）转化成字符串可以直接存储在文件中，但是读取出来时，遇到麻烦了，不能将读取到的字符串类型数据转回原来的数据类型（列表、字典），取出来的是字符串类型，不好操作。

l = [1,2,3]
with open('test', encoding='utf-8', mode='a') as f:
    f.write(str(l))  # 写进文件的都是字符型类型

with open('test', encoding='utf-8', mode='r') as f:
    ret = f.read()  # 读取出来的也是字符串，很难转回原来的数据类型

2. 网络传输：凡是数据通过网络传出去，最终的格式必须是bytes类型
   网络传输，我们最终得到数据类型是字符串类型，不能转回网络传输前的数据类型（列表、字典）。

lst = [i for i in range(100)]
lst_str = str(lst)
bt = lst_str.encode('utf-8')  # bt为bytes类型的数据，可以通过网络发送出去

s = bt.decode('utf-8')
print(s, type(s))  # s是字符串类型的数据，不能转化成原数据类型（列表），对其进行操作很麻烦

3. 目前需要解决 文件存取 和 网络传输 得到的字符串不能转回原数据类型问题：
   如果有一种特殊的字符串，这种特殊字符串可以与任何的数据结构互相转换，这个问题就解决了。
4. 序列化模块：将一种数据结构转化成特殊的序列（特殊的字符串、bytes）,并且还可以反转回原数据类型。
   • json模块：json是所有语言公认的一种序列.(最常用的)，但是json支持的Python数据结构有限。
     （仅支持int,str,True,False,dict,list,tuple,None,float等数据类型）
   • pickle模块：pickle只能是Python语言中使用的序列化模块，支持Python所有的数据类型和对象。
   • shelve模块

2 json模块

1、dumps、loads：主要用于网络传输,也可以用于文件的存取

# dumps、loads：主要用于网络传输,可以用于文件的存取。
"""
只有str类型才可以直接与bytes类型相互转换
"""
import json

mydict = {'name': '苏秦', 'age': 17}
res = json.dumps(mydict)
print(res, type(res))  # {"name": "\u82cf\u79e6", "age": 17} <class 'str'>
# 不改变中文
res_test = json.dumps(mydict, ensure_ascii=False)
print(res_test, type(res_test))  # {"name": "苏秦", "age": 17} <class 'str'>

res_dict = json.loads(res)
print(res_dict, type(res_dict))  # {'name': '苏秦', 'age': 17} <class 'dict'>


lst = [i**2 for i in range(10)]
ret = json.dumps(lst)
with open('myjn.json', encoding='utf-8', mode='a') as f1:
    f1.write(ret)

with open('myjn.json', encoding='utf-8', mode='r') as f2:
    content = f2.read()
    ret_lst = json.loads(content)
    print(ret_lst, type(ret_lst))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>

2、dump、load：单个数据的文件存取，不能用于网络传输。

# dump、load：单个数据的文件存取，不能用于网络传输。 
import json
dic = {'name': '哈哈', 'age': 15}

with open('myjnyy.json', encoding='utf-8', mode='a') as f3:
    json.dump(dic, f3)

with open('myjnyy.json', encoding='utf-8', mode='r') as f4:
    dic1 = json.load(f4)
    print(dic1, type(dic1))  # {'name': '哈哈', 'age': 15} <class 'dict'>

3、多个数据如何存储到一个文件中? 一个dumps对应一个loads.(dumps几次，则loads几次)

# 多个数据如何存储到一个文件中? 一个dumps对应一个loads.(dumps几次，则loads几次)
import json
mydict1 = {'name': '苏秦', 'age': 17}
mydict2 = {'name': '李白', 'age': 27}
mydict3 = {'name': '李广', 'age': 21}

with open('moredata.json', encoding='utf-8', mode='w') as f5:
    f5.write(json.dumps(mydict1)+'\n')  #注意换行
    f5.write(json.dumps(mydict2)+'\n')
    f5.write(json.dumps(mydict3)+'\n')
    # 或者f5.write(f'{json.dumps(mydict1)}\n{json.dumps(mydict2)}\n{json.dumps(mydict3)}')
with open('moredata.json', encoding='utf-8', mode='r') as f6:
    for line in f6:
        ret = json.loads(line)
        print(ret, type(ret))
"""
{'name': '苏秦', 'age': 17} <class 'dict'>
{'name': '李白', 'age': 27} <class 'dict'>
{'name': '李广', 'age': 21} <class 'dict'>
"""

3 pickle模块

1、dumps、loads 只能用于网络传输

# 1、 dumps、loads 只能用于网络传输
import pickle
lst = [i for i in range(2)]
res = pickle.dumps(lst)
print(res, type(res))  # b'\x80\x04\x95\t\x00\x00\x00\x00\x00\x00\x00]\x94(K\x00K\x01e.' <class 'bytes'>

res_lst = pickle.loads(res)
print(res_lst, type(res_lst))  # [0, 1] <class 'list'>

2、dump、load 文件存取。（注意pickle.dump将数据转化成了特殊的bytes类型，写文件时mode模式要注意，不用encoding）

import pickle
dit = {'name': 'hugo', 'age': 17}
with open('mypic.pickle', mode='wb') as f1:
    pickle.dump(dit, f1)

with open('mypic.pickle', mode='rb') as f2:
    ret = pickle.load(f2)
    print(ret, type(ret))  # {'name': 'hugo', 'age': 17} <class 'dict'>

3、多个数据写入文件, 一个dump对应一个load

dit1 = {'name': 'hugo', 'age': 27}
dit2 = {'name': 'albert', 'age': 26}
dit3 = {'name': 'don', 'age': 22}

with open('moredapi.pickle', mode='wb') as f3:
    # 写入数据时，可不用换行
    pickle.dump(dit1, f3)
    pickle.dump(dit2, f3)
    pickle.dump(dit3, f3)

with open('moredapi.pickle', mode='rb') as f4:
    ret1 = pickle.load(f4)
    ret2 = pickle.load(f4)
    ret3 = pickle.load(f4)
    print(ret1,ret2,ret3,type(ret1))  # <class 'dict'>

4、Python函数写入文件

# 4、Python函数写入文件
import pickle

def myfunc():
    print('Hello World')

with open('func.pickle', mode='wb') as ff:
    pickle.dump(myfunc, ff)

with open('func.pickle', mode='rb') as fff:
    ret5 = pickle.load(fff)
    ret5()  # Hello World