一. 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": "\u5f20\u4e09"}

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": "\u5f20\u4e09"}


# 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, "\u54c8\u54c8", "\u5f20\u4e09"]


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": "\u5f20\u4e09"}# 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'\x80\x03]q\x00(X\x02\x00\x00\x00aaq\x01X\x02\x00\x00\x00bbq\x02X\x02\x00\x00\x00ccq\x03e.'
# <class 'bytes'>

# loads功能
# loads  將pickle數據轉換為python的數據結構
mes = pickle.loads(p_str)
print(mes)
# ['aa', 'bb', 'cc']


 # dump功能
# dump 將數據通過特殊的形式轉換為只有python語言認識的字符串，並寫入文件
with open('D:\learnPython\py5\b.txt', 'w') as f:
        pickle.dump(data, f)

 # load功能
 # load 從數據文件中讀取數據，並轉換為python的數據結構

with open('D:\learnPython\py5\b.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'\x80\x03]q\x00(X\x02\x00\x00\x00aaq\x01X\x02\x00\x00\x00bbq\x02X\x02\x00\x00\x00ccq\x03e.

# 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+'\n')
f.close()

"""
注意寫入b.txt文件中數據內容
{"name": "\u5f20\u4e09"}
{"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': '男'}]