python 序列化及其相關模塊（json,pickle,shelve,xml）詳解

什么是序列化對象？

　　我們把對象（變量）從內存中編程可存儲或傳輸的過程稱之為序列化，在python中稱為pickle，其他語言稱之為serialization ,marshalling ,flatterning 等等，都是一個意思。

　　序列化之后，就可以把序列化后的內容寫入磁盤，或者通過網絡傳輸到別的機器上（因為硬盤或網絡傳輸時只接受bytes）。

　　反過來，把變量內容從序列化的對象重新讀到內存里稱之為反序列化，即unpacking。

為什么要序列化？

　　舉個例子，你在打游戲過程中，打累了，停下來，想過兩天再玩，兩天之后，游戲又從你上次停止的地方繼續運行，你上次游戲的進度肯定保存到硬盤上了，那么是以何種形式呢？游戲過程中產生的很多臨時數據是不規律的，可能在你關掉游戲時正好是10個列表，3個嵌套字典的數據集合在內存里面，需要存下來，你如何存？把列表變成文件里的多行多列形式？那嵌套字典呢？根本沒法存吧，所以，若是有種辦法可以直接把內存數據存到硬盤上，下次程序再啟動，再從硬盤上讀出來，還是原來的格式，那是最好的，所以這就是我們要說的序列化。

1、持久保存狀態

　　一個軟件/程序的執行就在處理一系列狀態的變化，在編程語言中，‘狀態’會以各種各樣有結構的數據類型（也可以簡單的理解為變量）的形式被保存在內存中
　　內存是無法永久保存數據的，當程序運行了一段時間，我們斷電或者重啟程序，內存中關於這個程序的之前一段時間的數據（有結構）都被清空了。

　　在斷電或重啟程序之前將程序當前內存中所有的數據都保存下來（保存到文件中），以便於下次程序執行能夠從文件中載入之前的數據，然后繼續執行，這就是序列化。

2、跨平台數據交互

　　序列化之后，不僅可以把序列化后的內容寫入磁盤，還可以通過網絡傳輸到別的機器上，如果收發的雙方約定好使用一種序列化的格式，那么變打破了平台/語言差異化帶來的限制，實現了跨平台的數據交互。
　　反過來，把變量內容從序列化的對象重新讀到內存里稱之為反序列化，即unpickling.

什么可以序列化操作？

　　在python中，可以使用pickle和json兩個模塊對數據進行序列化操作

其中：

• json可以用於字符串或者字典等與python數據類型之間的序列化與反序列化操作
• pickle可以用於python特有類型與python數據類型之間的序列化與反序列化操作

提問：這時候有人肯定要問，兩個都可以對數據進行序列化，為什么不只學習一個就好了，非要學習兩個呢？

　　

    這個問題問的好，我們下面詳細講一下兩個的區別。
    關於json
        優點：跨語言，體積小
        缺點：只能支持int(整形)，str(字符串)，list(列表)，tuple（元祖），dict（字典）

    關於pickle
        優點：專門為python設計，只支持python所有的數據類型
        缺點：只能在python中使用，存儲數據占空間大

　　下面主要說一下json和pickle模塊

json模塊

什么是json？

　　JSON(JavaScript Object Notation) 是一種輕量級的數據交換格式。它使得人們很容易的進行閱讀和編寫。同時也方便了機器進行解析和生成。它是基於 JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999 的一個子集。 JSON采用完全獨立於程序語言的文本格式，但是也使用了類C語言的習慣（包括C, C++, C#, Java, JavaScript, Perl, Python等）。這些特性使JSON成為理想的數據交換語言。

　　如果我們要在不同的編程語言中傳遞對象，就必須把對象序列化稱為標准格式，比如XML，但是更好的方法是序列化為JSON，因為JSON表示出來就是一個字符串，可以被所有的語言讀取，也可以方便的存儲到磁盤或者通過網絡傳輸。JSON不僅是標准格式，而且比XML更快，而且可以在web頁面直接讀取，非常方便。

1.查看json模塊內的方法

import json
dir(json)
['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__',
 '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', 
'__spec__', '__version__', '_default_decoder', '_default_encoder', 'codecs', 'decoder',
 'detect_encoding', 'dump', 'dumps', 'encoder', 'load', 'loads', 'scanner']

2.json模塊提供了四個常用的功能：dumps，dump，loads，load

　　其中：json.dumps()方法可以將字典等數據（特殊的形式）格式化成一個所有語言認識的字符串，這樣可以方便別的編程語言調用

import json
data = {
    'roles':[
        {'role':'monster','type':'pig','life':50},
        {'role':'donkey','type':'dog','life':60},
    ]
}
j_str = json.dumps(data)
print("以前的數據類型：",type(data),data)
print("通過json轉化后的數據類型",type(j_str),j_str)
# 以前的數據類型： <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}
# 通過json轉化后的數據類型 <class 'str'> {"roles": [{"role": "monster", "type": "pig", "life": 50}, {"role": "donkey", "type": "dog", "life": 60}]}

　　

　　　　json.loads()方法可以進行反序列化

import json
data = {
    'roles':[
        {'role':'monster','type':'pig','life':50},
        {'role':'donkey','type':'dog','life':60},
    ]
}
j_str = json.dumps(data)
ww = json.loads(j_str)
print("原來的格式：",type(j_str),j_str)   #json把字典讀成字符串
print("反序列化：",type(ww),ww)              #通過loads反序列化成字典
# 原來的格式： <class 'str'> {"roles": [{"role": "monster", "type": "pig", "life": 50}, {"role": "donkey", "type": "dog", "life": 60}]}
# 反序列化： <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}

　　

　　　　json.dump()方法可以把字典等數據類型（特殊的形式）序列化成所有程序語言認識的字符串，進入一個文件中，等待別的程序進行調用

import json

f = open('study.json','w')
dd = json.dump(data,f)
print(dd,type(dd))
#None <class 'NoneType'>   因為這個是在python讀取的，它本來是大家都認識的，所以沒有任何類型，
#json.dump將數據通過特殊的形式轉化為所有語言都認識的字符串，並寫入文件

　　

　　　　json.load()方法可以讀取文件中的內容

import json
f = open('study.json','r')
read_load = json.load(f)
print("讀取的類型和內容 ",type(read_load),read_load)
結果：
讀取的類型和內容  <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}

　　

易錯點：如何把一個文件內的字符串形式通過json轉化為相應的字典格式？

　　常見錯誤：

#account_file是文件的絕對路徑
with open(account_file, "r", encoding="utf-8") as f:   #打開文件
　　file_data = json.load(account_file)
    print(file_data)

這樣竟然出錯了！！
錯誤信息：AttributeError: 'str' object has no attribute 'read'

　　改正后為：

#改正：
if os.path.isfile(account_file):     #如果用戶文件存在(即用戶存在)
    with open(account_file, "r", encoding="utf-8") as f:   #打開文件
        file_data = json.load(f)
        print(file_data)

　　

下面我們來測試一下json字符串和json對象到底是什么？

import json
i=10
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':"james"}
 
json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)
 
print(json_str1)   #'10'
print(json_str2)   #'"hello"'
print(json_str3)   #'[1, 4, 6]'
print(json_str4)   #'[3, 5, 7]'
print(json_str5)   #'{"name": "james"}'

　　這里面的json_str就是json字符串。

JSON字符串內的值：

• 數字    （整數或浮點數）
• 字符串 （在雙引號中）
• 邏輯值 （true 或 false）
• 數組    （在方括號中）
• 對象    （在花括號中，引號用雙引）
• null     

　　請大家記住一句話：json字符串就是js對象的一種表現形式（字符串的形式）

　　JSON表示的對象就是標准的Javascripts語言的對象，JSON和Python內置的數據類型如下：

JSON類型	python類型
{}	dict
[]	list
"string"	str
"123456"	int或float
true/false	True/False
null	None

或者看下表，更清晰：

        python     -->         json

        dict                        object
        list,tuple                 array
        str,unicode             string
        int,long,float           number
        True                       true
        False                      false
        None                       null

　　下面看一個帶方法的json對象：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>

<script>
    var person = {
        "name":"james",
        "sex":"men",
        "teacher":{
            "name":"denken",
            "sex":"male",
        },
        "boddy":["basketball","running"],
        "getName":function () {
            return 80;
        }
    };
    alert(person.name);
    alert(person.getName());
    alert(person.teacher.name);
    alert(person.boddy[0]);

</script>
</html>

parse() 

parse()  用於從一個json字符串中解析出json對象
    
如：var str = '{"name":"james","age":"23"}'

結果：JSON.parse(str)     ------>  Object  {age: "23",name: "james"}　

.stringify()

stringify() 用於從一個json對象解析成json字符串

如   var c = {a:1 , b:2 }

結果： JSON.stringify(c)     ------>      '{"a":1,"b":2}'

　　

注意事項

注意1：單引號寫在{}外，每個屬性名都必須用雙引號，否則會拋出異常。

 
a={name:"james"};   //ok
b={'name':'james'}; //ok
c={"name":"james"}; //ok
 
alert(a.name);  //ok
alert(a[name]); //undefined
alert(a['name']) //ok

　　

pickle模塊

 1.查看pickle模塊內的方法

import pickle
dir(pickle)
['ADDITEMS', 'APPEND', 'APPENDS', 'BINBYTES', 'BINBYTES8', 'BINFLOAT', 'BINGET', 
'BININT', 'BININT1', 'BININT2', 'BINPERSID', 'BINPUT', 'BINSTRING', 'BINUNICODE', 
'BINUNICODE8', 'BUILD', 'DEFAULT_PROTOCOL', 'DICT', 'DUP', 'EMPTY_DICT', 'EMPTY_LIST', 
'EMPTY_SET', 'EMPTY_TUPLE', 'EXT1', 'EXT2', 'EXT4', 'FALSE', 'FLOAT', 'FRAME', 'FROZENSET',
 'FunctionType', 'GET', 'GLOBAL', 'HIGHEST_PROTOCOL', 'INST', 'INT', 'LIST', 'LONG',
 'LONG1', 'LONG4', 'LONG_BINGET', 'LONG_BINPUT', 'MARK', 'MEMOIZE', 'NEWFALSE',
 'NEWOBJ', 'NEWOBJ_EX', 'NEWTRUE', 'NONE', 'OBJ', 'PERSID', 'POP', 'POP_MARK', 'PROTO', 
'PUT', 'PickleError', 'Pickler', 'PicklingError', 'PyStringMap', 'REDUCE', 'SETITEM', 'SETITEMS',
 'SHORT_BINBYTES', 'SHORT_BINSTRING', 'SHORT_BINUNICODE', 'STACK_GLOBAL', 'STOP', 
'STRING', 'TRUE', 'TUPLE', 'TUPLE1', 'TUPLE2', 'TUPLE3', 'UNICODE', 'Unpickler',
 'UnpicklingError', '_Framer', '_Pickler', '_Stop', '_Unframer', '_Unpickler', '__all__', 
'__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__',
 '__spec__', '_compat_pickle', '_dump', '_dumps', '_extension_cache', '_extension_registry', 
'_getattribute', '_inverted_registry', '_load', '_loads', '_test', '_tuplesize2code', 'bytes_types',
 'codecs', 'compatible_formats', 'decode_long', 'dispatch_table', 'dump', 'dumps',
 'encode_long', 'format_version', 'io', 'islice', 'load', 'loads', 'maxsize', 'pack', 'partial', 
're', 'sys', 'unpack', 'whichmodule']

2.想查看某個方法的幫助文檔

help(pickle.modules_name)  #就是help（）+pickle.模塊名
#這樣就可以得到模塊方法的幫助文檔

3.pickle模塊常用的方法有：dumps,loads,dump,load

 　　pickle.dumps對數據進行序列化操作

import pickle
data = {
    'roles':[
        {'role':'monster','type':'pig','life':50},
        {'role':'donkey','type':'dog','life':60},
    ]
}
lis = [1,2,3,4,'rain']
res_lis = pickle.dumps(lis)
res_dic = pickle.dumps(data)
print(type(res_lis),res_lis)
print(type(res_dic),res_dic)
# <class 'bytes'> b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04X\x04\x00\x00\x00rainq\x01e.'
# <class 'bytes'> b'\x80\x03}q\x00X\x05\x00\x00\x00rolesq\x01]q\x02(}q\x03(X\x04\x00\x00\x00roleq\x04X\x07\x00\x00\x00monsterq\x05X\x04\x00\x00\x00typeq\x06X\x03\x00\x00\x00pigq\x07X\x04\x00\x00\x00lifeq\x08K2u}q\t(h\x04X\x06\x00\x00\x00donkeyq\nh\x06X\x03\x00\x00\x00dogq\x0bh\x08K<ues.'
#將data寫入文件中
pk = open('data.pkl','wb')
print(type(pk),pickle.dump(data,pk))
# <class '_io.BufferedWriter'> None

　　使用pickle.loads進行反序列化操作

import pickle
data = {
    'roles':[
        {'role':'monster','type':'pig','life':50},
        {'role':'donkey','type':'dog','life':60},
    ]
}
lis = [1,2,3,4,'rain']
res_lis = pickle.dumps(lis)
res_dic = pickle.dumps(data)
back_reslis = pickle.loads(res_lis)
back_resdic = pickle.loads(res_dic)
print(type(back_reslis),back_reslis)
print(type(back_resdic),back_resdic)
# <class 'list'> [1, 2, 3, 4, 'rain']
# <class 'dict'> {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}

　　pickle.dump() 將數據通過特殊的形式轉化為只有python語言認識的字符串，並寫入文件

import pickle
data = {
    'roles':[
        {'role':'monster','type':'pig','life':50},
        {'role':'donkey','type':'dog','life':60},
    ]
}
pk = open('data.pkl','wb')
print(type(pk),pickle.dump(data,pk))

　　

　　pickle.load()對文件進行反序列化，得到文件里面保存的數據

import pickle
data = {
    'roles':[
        {'role':'monster','type':'pig','life':50},
        {'role':'donkey','type':'dog','life':60},
    ]
}

with open('data.pkl','rb') as f:
    result  = pickle.load(f)
    print(result)
    # {'roles': [{'role': 'monster', 'type': 'pig', 'life': 50}, {'role': 'donkey', 'type': 'dog', 'life': 60}]}

　

shelve模塊

　shelve模塊是一個簡單的k,v將內存數據通過文件持久化的模塊，返回類似於字典的對象，可讀可寫；key必須是字符串，二值可以持久化任何pickle可支持的python數據格式　　

　　shelve模塊很簡單，只有一個open函數，json和pickle模塊只能dumps和loads只能一次，但是shelve就能dumps多次。這就是shelve存在的必要性，其中shelve對pickle進行了包裝，是一個鍵值對的形式。

序列化

import shelve
f = shelve.open('shelve_test')
names = ['laex','howard','batumu']
info = {'name':'howard','age':22}

f['names'] = names     #持久化列表
f['info_dic'] = info

f.close()

反序列化

import shelve

d = shelve.open('shelve_test')   #打開一個文件

print(d['name'])
print(d['info_dic'])

# del d['test']  #還可以刪除
# ['laex', 'howard', 'batumu']
# {'name': 'howard', 'age': 22}

　　

xml模塊

什么是xml模塊呢？

　　xml是實現不同語言或程序之間進行數據交換的協議，跟json差不多，但json使用起來更簡單，不過，古時候，在json還沒誕生的黑暗年代，大家只能選擇用xml呀，至今很多傳統公司如金融行業的很多系統的接口還主要是xml。

xml的格式如下，就是通過<>節點來區別數據結構的：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml數據

xml協議在各個語言里的都 是支持的，在python中可以用以下模塊操作xml：

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍歷xml文檔
for child in root:
    print(child.tag, child.attrib)
    for i in child:
        print(i.tag,i.text)
 
#只遍歷year 節點
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):
    new_year = int(node.text) + 1
    node.text = str(new_year)
    node.set("updated","yes")
 
tree.write("xmltest.xml")
 
 
#刪除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')

　　

自己創建的xml文檔

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml) #生成文檔對象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

創建xml文檔

 　　注意：自己創建xml文檔的時候一定不要把代碼文件名稱命名為xml.py，不然會報錯，因為Python引用包的時候應該是先在代碼文件所在的文件夾查找，把文件名命名為xml.py時，import xml.etree.Element 這一句就在當前文件夾找到了自身源文件，自己寫的xml.py里面根本就沒有etree.Element這些模塊，當然是要報錯了。

Json和XML的比較

一，可讀性

　　JSON和XML的可讀性可謂不相上下，一邊是簡易的語法，一邊是規范的標簽形式，很難分出勝負。

二，可擴展性

　　XML天生有很好的擴展性，JSON當然也有，沒有什么是XML可以擴展而JSON卻不能擴展的。不過JSON在Javascript主場作戰，可以存儲Javascript復合對象，有着xml不可比擬的優勢。

三，編碼難度

　　XML有豐富的編碼工具，比如Dom4j、JDom等，JSON也有提供的工具。無工具的情況下，相信熟練的開發人員一樣能很快的寫出想要的xml文檔和JSON字符串，不過，xml文檔要多很多結構上的字符。

四，解碼難度

XML的解析方式有兩種：

• 一是通過文檔模型解析，也就是通過父標簽索引出一組標記。例如：xmlData.getElementsByTagName("tagName")，但是這樣是要在預先知道文檔結構的情況下使用，無法進行通用的封裝。
• 另外一種方法是遍歷節點（document 以及 childNodes）。這個可以通過遞歸來實現，不過解析出來的數據仍舊是形式各異，往往也不能滿足預先的要求。

凡是這樣可擴展的結構數據解析起來一定都很困難。

　　JSON也同樣如此。如果預先知道JSON結構的情況下，使用JSON進行數據傳遞簡直是太美妙了，可以寫出很實用美觀可讀性強的代碼。如果你是純粹的前台開發人員，一定會非常喜歡JSON。但是如果你是一個應用開發人員，就不是那么喜歡了，畢竟xml才是真正的結構化標記語言，用於進行數據傳遞。

　　而如果不知道JSON的結構而去解析JSON的話，那簡直是噩夢。費時費力不說，代碼也會變得冗余拖沓，得到的結果也不盡人意。但是這樣也不影響眾多前台開發人員選擇JSON。因為json.js中的toJSONString()就可以看到JSON的字符串結構。當然不是使用這個字符串，這樣仍舊是噩夢。常用JSON的人看到這個字符串之后，就對JSON的結構很明了了，就更容易的操作JSON。

　　以上是在Javascript中僅對於數據傳遞的xml與JSON的解析。在Javascript地盤內，JSON畢竟是主場作戰，其優勢當然要遠遠優越於xml。如果JSON中存儲Javascript復合對象，而且不知道其結構的話，我相信很多程序員也一樣是哭着解析JSON的。

　　除了上述之外，JSON和XML還有另外一個很大的區別在於有效數據率。JSON作為數據包格式傳輸的時候具有更高的效率，這是因為JSON不像XML那樣需要有嚴格的閉合標簽，這就讓有效數據量與總數據包比大大提升，從而減少同等數據流量的情況下，網絡的傳輸壓力。