一. python进阶(序列化)

一. 序列化

在网络上都是bytes(字节) 类型

序列化 :--------(Serialization)是指将对象、数据结构的状态信息转换为可以存储或传输的形式的过程

反序列化  --------------- 就是 转换成字符串  可以存储            我们把变量从内存中变成可存储或传输的过程称之为序列化,

用于 数据存储   网络上传输
从数据类型 ---->字符串的过程      序列化
从字符串   -----> 数据类型的过程 反序列化
json
pickle
shelve

json
   通用 的序列化格式
   只有很少的一部分数据据类型 通过json转化成字符串

pickle
     所有的python中的数据类型都可以转化成字符串形式
     pickle 序列化的内容只有python 能理解
      且部分反序列化依赖代码

shelve
     序列化句柄
     使用句柄直接操作 非常方便

1. json dumps 直接对内存中的数据操作(序列化方法     数据类型----->str)

import json
import pickle
# json dumps   序列化方法   数据类型----->str
aa={"name":"张三"}
print(type(aa),aa)            # <class 'dict'> {'name': '张三'}
bb=json.dumps(aa)             # 序列化  dumps  直接对内存中的数据操作
print(type(bb),bb)            # <class 'str'> {"name": "u5f20u4e09"}

i=88
A=json.dumps(i)
print(A)          # 88
print(type(A))   # <class 'str'>



s='holle'
D=json.dumps(s)
print(D)      # "holle"       
print(type(D))   # <class 'str'>




K=[11,22]
C=json.dumps(K)
print(C)         # "[11, 22]"
print(type(C))   # <class 'str'>

1. json.loads直接对内存中的数据操作(反序列化   str-----------数据类型)

import json
import pickle
# json dumps 序列化方法   数据类型----->str
aa={"name":"张三"}
print(type(aa),aa)      #  <class 'dict'> {'name': '张三'}
bb=json.dumps(aa)      # 序列化  dumps  直接对内存中的数据操作
print(type(bb),bb)     # <class 'str'> {"name": "u5f20u4e09"}


# loads反序列化方法
print("****************")
# str------------数据类型

cc=json.loads(bb)  # 反序列化 loads 直接对内存中的数据操作
print(type(cc),cc)  # <class 'dict'> {'name': '张三'}

import json
# json.loads
# json.loads 用于解码 JSON 数据。该函数返回 Python 字段的数据类型。
jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';


text = json.loads(jsonData)

print(text)          # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(type(text))     # <class 'dict'>

数字  字符串  列表  字典   元组（特殊 转换成字列表）

import  json
import pickle

# 数字  字符串  列表  字典   元组（特殊 转换成字列表）

ff=(1,2,"哈哈","张三")
print(type(ff))     #  <class 'tuple'>
# pickle.dumps
g=json.dumps(ff)    # 序列化
print(type(g),g)    # <class 'str'> [1, 2, "u54c8u54c8", "u5f20u4e09"]


print("****************")
r=json.loads(g)     # 反序列化
# pickle.loads
print(type(r),r)    # <class 'list'> [1, 2, '哈哈', '张三']

import json

jsonStr=`{"name":"张三","age":18,
 "hobby":["money","power","english"],"params":{
 "a":1,"b":2}}`



# 将json格式的字符转换成python数据类型对象
jsonData=json.loads(jsonStr)
print(jsonData)
print(type(jsonData))



# 将python 数据类型的对象转换成json 格式字符、
jsonDATA2={"name":"张三","age":18}
jsonStr2=json.dumps(jsonDATA2)
print(jsonStr2)

2.json.dump  是对文件序列化   (序列化方法     数据类型----->str)

import json
import pickle
#        {"age": "u5f20u4e09"}# json
#     dump 是对文件序列化           字典  列表 不能直接写入文件中所有要序列化
st={"age":"张三"}
f=open("a.txt",'w',encoding='utf-8')
# pickle.dump   文件读取序列化要     写"wb"   读"rb"
json.dump(st,f,ensure_ascii=False)        #   dump 是对文件序列化 (写入) 写入到文件是bytes类型(字节)  要把tybes字节类型变看的懂的文字 后面加上  ensure_ascii=False
f.close()      

2.json.load是对文件序列化   (反序列化方法    str----> 数据类型)

import  json
import pickle
k=open("a.txt",'r',encoding="utf-8")
# pickle.load
res=json.load(k)      # load 是对文件反序列化 (读取)
k.close()
print(type(res),res)   # <class 'dict'> {'age': '张三'}

3. pickle模块 数据持久存储
  pickle模块实现了基本的数据序列和反序列化

# dumps功能

import pickle
data = ['aa', 'bb', 'cc']  
 # dumps 将数据通过特殊的形式转换为只有python语言认识的字符串
p_str = pickle.dumps(data)

print(p_str)  
print(type(p_str)) 

# b'x80x03]qx00(Xx02x00x00x00aaqx01Xx02x00x00x00bbqx02Xx02x00x00x00ccqx03e.'
# <class 'bytes'>

# loads功能
# loads  将pickle数据转换为python的数据结构
mes = pickle.loads(p_str)
print(mes)
# ['aa', 'bb', 'cc']


 # dump功能
# dump 将数据通过特殊的形式转换为只有python语言认识的字符串，并写入文件
with open('D:learnPythonpy5.txt', 'w') as f:
        pickle.dump(data, f)

 # load功能
 # load 从数据文件中读取数据，并转换为python的数据结构

with open('D:learnPythonpy5.txt', 'r') as f:
      data = pickle.load(f) 


 # dumps功能
import pickle
data = ['aa', 'bb', 'cc']  
# dumps 将数据通过特殊的形式转换为只有python语言认识的字符串
p_str = pickle.dumps(data)
print(p_str)            
b'x80x03]qx00(Xx02x00x00x00aaqx01Xx02x00x00x00bbqx02Xx02x00x00x00ccqx03e.

# loads功能
# loads  将pickle数据转换为python的数据结构
mes = pickle.loads(p_str)
print(mes)
['aa', 'bb', 'cc']



 # dump功能
 # dump 将数据通过特殊的形式转换为只有python语言认识的字符串，并写入文件
 with open('D:/tmp.pk', 'w') as f:
   pickle.dump(data, f)



# load功能
# load 从数据文件中读取数据，并转换为python的数据结构
with open('D:/tmp.pk', 'r') as f:
    data = pickle.load(f)

import json
import pickle

#使用pickle模块将数据对象保存到文件

# 将文本文件转化为二进制文件

with open('aa.txt')as src,open('bb.txt','wb')as dest:
    lines=src.readline()
    pickle.dump(len(lines),dest)
    for line in lines:
        pickle.dump(line,dest)


with open('bb.txt','rb')as fp:
    n=pickle.load(fp)
    for i in range(n):
        print(pickle.load(fp))

# pickle.dump(obj, file[, protocol])
# 　　序列化对象，并将结果数据流写入到文件对象中。参数protocol是序列化模式，默认值为0，表示以文本的
# 形式序列化。protocol的值还可以是1或2，表示二进制的形式序列化。

#使用pickle模块从文件中重构python对象
# pickle.dump   文件读取序列化要     写"wb"   读"rb"
import pprint
#使用pickle模块将数据对象保存到文件   数据类型------------->字符串
import pickle
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]
aa=selfref_list.append(selfref_list)
print(aa)
output = open('bb.txt', 'wb')
pickle.dump(data1, output)
bb=pickle.dump(selfref_list, output, -1)
print(type(bb))
output.close()



#使用pickle模块从文件中重构python对象  反序列化  str----------->数据类型
pkl_file = open('bb.txt', 'rb')
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()


# pickle.dump(obj, file, [,protocol])
# 　　注解：将对象obj保存到文件file中去。
# 　　　　　protocol为序列化使用的协议版本，0：ASCII协议，所序列化的对象使用可打印的ASCII码表示；1：老式的二进制协议；2：2.3版本引入的新二进制协议，较以前的更高效。其中协议0和1兼容老版本的python。protocol默认值为0。
# 　　　　　file：对象保存到的类文件对象。file必须有write()接口， file可以是一个以'w'方式打开的文件或者一个StringIO对象或者其他任何实现write()接口的对象。如果protocol>=1，文件对象需要是二进制模式打开的。
#
# 　　pickle.load(file)
# 　　注解：从file中读取一个字符串，并将它重构为原来的python对象。
# 　　file:类文件对象，有read()和readline()接口。

4. 序列化案例

import json
li=[{"name":"张三"},{"age":"25"},{"sex":"男"}]
f=open("b.txt","w",encoding="utf-8")
for i in li:
    str_dic=json.dumps(i)
    f.write(str_dic+'
')
f.close()

"""
注意写入b.txt文件中数据内容
{"name": "u5f20u4e09"}
{"age": "25"}
{"sex": "u7537"}

"""


ff=open("b.txt","r",encoding="utf-8")
dice=[]
for ii in ff:
    dec=json.loads(ii.strip())
    # print(dec)
    dice.append(dec)
ff.close()
print(dice)  # [{'name': '张三'}, {'age': '25'}, {'sex': '男'}]