Python之資料序列化（json、pickle、shelve）

　一、前言

　　1. 現實需求

　　每種程式語言都有各自的資料型別，其中物件導向的程式語言還允許開發者自定義資料型別（如：自定義類），Python也是一樣。很多時候我們會有這樣的需求：

• 把記憶體中的各種資料型別的資料通過網路傳送給其它機器或客戶端；
• 把記憶體中的各種資料型別的資料儲存到本地磁碟持久化；

　　2.資料格式

　　如果要將一個系統內的資料通過網路傳輸給其它系統或客戶端，我們通常都需要先把這些資料轉化為字串或位元組串，而且需要規定一種統一的資料格式才能讓資料接收端正確解析並理解這些資料的含義。XML 是早期被廣泛使用的資料交換格式，在早期的系統整合論文中經常可以看到它的身影；如今大家使用更多的資料交換格式是JSON（JavaScript Object Notation），它是一種輕量級的資料交換格式。JSON相對於XML而言，更加加單、易於閱讀和編寫，同時也易於機器解析和生成。除此之外，我們也可以自定義內部使用的資料交換格式。

　　如果是想把資料持久化到本地磁碟，這部分資料通常只是供系統內部使用，因此資料轉換協議以及轉換後的資料格式也就不要求是標準、統一的，只要本系統內部能夠正確識別即可。但是，系統內部的轉換協議通常會隨著程式語言版本的升級而發生變化（改進演算法、提高效率），因此通常會涉及轉換協議與程式語言的版本相容問題，下面要介紹的pickle協議就是這樣一個例子。

　　3. 序列化/反序列化

　　將物件轉換為可通過網路傳輸或可以儲存到本地磁碟的資料格式（如：XML、JSON或特定格式的位元組串）的過程稱為序列化；反之，則稱為反序列化。

　　4.相關模組

　　本節要介紹的就是Python內建的幾個用於進行資料序列化的模組：

模組名稱	描述	提供的api
json	用於實現Python資料型別與通用（json）字串之間的轉換	dumps()、dump()、loads()、load()
pickle	用於實現Python資料型別與Python特定二進位制格式之間的轉換	dumps()、dump()、loads()、load()
shelve	專門用於將Python資料型別的資料持久化到磁碟，shelve是一個類似dict的物件，操作十分便捷	open()

　二、json模組 

　　大部分程式語言都會提供處理json資料的介面，Python 2.6開始加入了json模組，且把它作為一個內建模組提供，無需下載即可使用。

　　1. 序列化與反序列化

　　Python的JSON模組 序列化與反序列化的過程分別叫做：encoding 和 decoding。

• encoding： 把Python物件轉換成JSON字串
• decoding： 把JSON字串轉換成python物件

　　json模組提供了以下兩個方法來進行序列化和反序列化操作：

# 序列化：將Python物件轉換成json字串
dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

# 反序列化：將json字串轉換成Python物件
loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

　　除此之外，json模組還提供了兩個額外的方法允許我們直接將序列化後得到的json資料儲存到檔案中，以及直接讀取檔案中的json資料進行反序列化操作：

# 序列化：將Python物件轉換成json字串並儲存到檔案中
dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

# 反序列化：讀取指定檔案中的json字串並轉換成Python物件
load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

　　2. JSON與Python之間資料型別對應關係

　　Python轉JSON

Python	JSON
dict	Object
list, tuple	array
str	string
int, float, int- & float-derived Enums	numbers
True	true
False	false
None	null

　　JSON轉Python

JSON	Python
object	dict
array	list
string	str
number(int)	int
number(real)	float
true	True
false	False
null	None

說明：

• Python dict中的非字串key被轉換成JSON字串時都會被轉換為小寫字串；
• Python中的tuple，在序列化時會被轉換為array，但是反序列化時，array會被轉化為list；
• 由以上兩點可知，當Python物件中包含tuple資料或者包含dict，且dict中存在非字串的key時，反序列化後得到的結果與原來的Python物件是不一致的；
• 對於Python內建的資料型別（如：str, unicode, int, float, bool, None, list, tuple, dict）json模組可以直接進行序列化/反序列化處理；對於自定義類的物件進行序列化和反序列化時，需要我們自己定義一個方法來完成定義object和dict之間進行轉化。

　　3. 例項：內建資料型別序列化/反序列化

　　序列化

# 序列化
>>> json.dumps({'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)})
'{"a": "str", "c": true, "b": 11.1, "e": 10, "d": null, "g": [4, 5, 6], "f": [1, 2, 3]}'

　　sort_keys引數： 表示序列化時是否對dict的key進行排序（dict預設是無序的）

# 序列化並對key進行排序
>>> json.dumps({'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}, sort_keys=True)
'{"a": "str", "b": 11.1, "c": true, "d": null, "e": 10, "f": [1, 2, 3], "g": [4, 5, 6]}'

　　indent引數： 表示縮排的意思，它可以使得資料儲存的格式變得更加優雅、可讀性更強；如果indent是一個非負整數或字串，則JSON array元素和object成員將會被以相應的縮排級別進行列印輸出；如果indent是0或負數或空字串，則將只會插入換行，不會有縮排。

# 序列化並對key進行排序及格式化輸出
>>> print(json.dumps({'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}, sort_keys=True, indent=4)) 
{
    "a": "str", 
    "b": 11.1, 
    "c": true, 
    "d": null, 
    "e": 10, 
    "f": [
        1, 
        2, 
        3
    ], 
    "g": [
        4, 
        5, 
        6
    ]
}

　　separators引數： 儘管indent引數可以使得資料儲存的格式變得更加優雅、可讀性更強，但是那是通過新增一些冗餘的空白字元進行填充的。當json被用於網路資料通訊時，應該儘可能的減少無用的資料傳輸，這樣可以節省頻寬並加快資料傳輸速度。json模組序列化Python物件後得到的json字串中的','號和':'號分隔符後預設都會附加一個空白字元，我們可以通過separators引數重新指定分隔符，從而去除無用的空白字元；

• 該引數的值應該是一個tuple(item_separator, key_separator)
• 如果indent是None，其預設值為(', ', ': ')
• 如果indent不為None，則預設值為(',', ': ')
• 我們可以通過為separator賦值為(',', ':')來消除空白字元

>>> json.dumps({'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)})
'{"a": "str", "c": true, "b": 11.1, "e": 10, "d": null, "g": [4, 5, 6], "f": [1, 2, 3]}'

>>> json.dumps({'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}, separators=(',',':'))
'{"a":"str","c":true,"b":11.1,"e":10,"d":null,"g":[4,5,6],"f":[1,2,3]}'

　　ensure_ascii引數： 當該引數的值為True（預設值）時，輸出中的所有非ASCII字元（比如中文）都會被轉義成'\uXXXX'組成的序列，得到的結果是一個完全由ASCII字元組成的str例項。如果我們想得到一個人類可讀的輸出結果，需要把ensure_ascii引數的值設定為False。

>>> stu={"name": "小明", "age" : 16}
>>> stu_json = json.dumps(stu)
>>> print(stu_json)
'{"name": "\u5c0f\u660e", "age": 16}'
>>> stu_json01 = json.dumps(stu, ensure_ascii=False)
>>> print(stu_json01)
'{"name": "小明", "age": 16}'

說明： 實際上'\uXXXX'是Unicode字元對應的記憶體編碼值，該記憶體編碼名稱為"unicode-escape",我們可以通過unicodestr.encode('unicode-escape')和decode('unicode-escape')來完成Unicode字串與Unicode記憶體編碼序列進行相互轉換，如下所示：

>>> str1 = "hello 中國"
>>> str2 = str1.encode("unicode_escape")
>>> print(str2)
b'hello \\u4e2d\\u56fd'
>>> str3 = str2.decode("unicode_escape")
>>> print(str3)
hello 中國

　　注意str2是位元組串，不是字串，因此\u前面需要再加一個反斜線做轉義。我們把str2轉換成字串就是我們熟悉的格式了：

>>> str4=str2.decode("utf-8")
>>> print(str4)
hello \u4e2d\u56fd
>>>

　　反序列化

# 反序列化
>>> json.loads('{"a": "str", "c": true, "b": 11.1, "e": 10, "d": null, "g": [4, 5, 6], "f": [1, 2, 3]}')
{'c': True, 'e': 10, 'a': 'str', 'g': [4, 5, 6], 'd': None, 'f': [1, 2, 3], 'b': 11.1}

>>> json.loads('{"a":"str","c":true,"b":11.1,"e":10,"d":null,"g":[4,5,6],"f":[1,2,3]}')
{'c': True, 'e': 10, 'a': 'str', 'g': [4, 5, 6], 'd': None, 'f': [1, 2, 3], 'b': 11.1}

　　dump()與load()函式示例

# 序列化到檔案中
>>> with open('test.json', 'w') as fp:
...     json.dump({'a':'str中國', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}, fp, indent=4)

# 反序列化檔案中的內容
>>> with open('test.json', 'r') as fp:
...     json.load(fp)
{'e': 10, 'g': [4, 5, 6], 'b': 11.1, 'c': True, 'd': None, 'a': 'str中國', 'f': [1, 2, 3]}

需要說明的是： 如果試圖使用相同的fp重複呼叫dump()函式去序列化多個物件（或序列化同一個物件多次），將會產生一個無效的JSON檔案，也就是說對於一個fp只能呼叫一次dump()。

　　4. 例項：自定義資料型別的序列化/反序列化

　　Python是物件導向的程式語言，我們可以自定義需要的資料型別；實際工作中，我們常常會用到自定義資料型別的序列化與反序列化操作。要實現自定義資料型別的序列化與反序列化有兩種方式：

• 通過轉換函式實現
• 通過繼承JSONEncoder和JSONDecoder類實現

　　首先來自定義一個資料型別

class Student(object):
    def __init__(self, name, age, sno):
        self.name = name
        self.age = age
        self.sno = sno
    
    def __repr__(self):
        return 'Student [name: %s, age: %d, sno: %d]' % (self.name, self.age, self.sno)

　　直接呼叫dumps()方法會引發TypeError錯誤：

>>> stu = Student('Tom', 19, 1)
>>> print(stu)
Student [name: Tom, age: 19, sno:   1]
>>>
>>> json.dumps(stu)
...
TypeError: Student [name: Tom, age: 19, sno:   1] is not JSON serializable

　　上面的異常資訊中指出：stu物件不可以被序列化為JSON格式的資料。那麼我們分別通過“編寫轉換函式” 和 “繼承JSONEncoder和JSONDecoder類” 來實現對這個自定義資料型別的JSON序列化和反序列化。

　　方法1：編寫轉換函式

　　那麼這個轉換函式要完成哪兩個資料型別之間的轉換呢？ 從上面列出的JSON與Python資料型別的對應表中可知，JSON中的object對應的是Python中的dict，因此要對Python中的自定義資料型別的物件進行序列化，就需要先把這個物件轉換成json模組可以直接進行序列化dict型別。由此可知，這個轉換函式是要完成的是Python物件（不是JSON物件）與dict之間的相互轉換，且序列化時轉換過程是“Python物件 --> dict --> JSON object”，反序列化的過程是“JSON object -> dict --> Python物件”。所以，我們需要編寫兩個轉換函式來分別實現序列化和反序列化時的轉換過程。

def obj2dict(obj):
    d = {}
    d['__class__'] = obj.__class__.__name__
    d['__module__'] = obj.__module__
    d.update(obj.__dict__)
    return d

def dict2obj(d):
    if '__class__' in d:
        class_name = d.pop('__class__')
        module_name = d.pop('__module__')
        module = __import__(module_name)
        class_ = getattr(module, class_name)
        args = dict((key.encode('ascii'), value) for key, value in d.items())
        instance = class_(**args)
    else:
        instance = d
    return instance

　　序列化測試：

>>> import json

>>> obj2dict(stu)
{'sno': 1, '__module__': '__main__', 'age': 19, '__class__': 'Student', 'name': 'Tom'}

>>> json.dumps(obj2dict(stu))
'{"sno": 1, "__module__": "__main__", "age": 19, "__class__": "Student", "name": "Tom"}'

>>> json.dumps(stu, default=obj2dict)
'{"sno": 1, "__module__": "__main__", "age": 19, "__class__": "Student", "name": "Tom"}'

　　json.dumps(stu, default=obj2dict) 等價於 json.dumps(obj2dict(stu))

　　反序列化測試：

>>> json.loads('{"sno": 1, "__module__": "__main__", "age": 19, "__class__": "Student", "name": "Tom"}')
{u'sno': 1, u'__module__': u'__main__', u'age': 19, u'name': u'Tom', u'__class__': u'Student'}

>>> dict2obj(json.loads('{"sno": 1, "__module__": "__main__", "age": 19, "__class__": "Student", "name": "Tom"}'))
Student [name: Tom, age: 19, sno: 1]

>>> json.loads('{"sno": 1, "__module__": "__main__", "age": 19, "__class__": "Student", "name": "Tom"}', object_hook=dict2obj)
Student [name: Tom, age: 19, sno: 1]

　　json.loads(JSON_STR, object_hook=dict2obj) 等價於 dict2obj(json.loads(JSON_STR))

　　方法2：繼承JSONEncoder和JSONDecoder實現子類

import json

class MyJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        d = {}
        d['__class__'] = obj.__class__.__name__
        d['__module__'] = obj.__module__
        d.update(obj.__dict__)
        return d

class MyJSONDecoder(json.JSONDecoder):
    def __init__(self):
        json.JSONDecoder.__init__(self, object_hook=self.dict2obj)
    
    def dict2obj(self, d):
        if '__class__' in d:
            class_name = d.pop('__class__')
            module_name = d.pop('__module__')
            module = __import__(module_name)
            class_ = getattr(module, class_name)
            args = dict((key.encode('ascii'), value) for key, value in d.items())
            instance = class_(**args)
        else:
            instance = d
        return instance

　　序列化測試：

>>> stu = Student('Tom', 19, 1)

# 方式一：直接呼叫子類MyJSONEncoder的encode()方法進行序列化
>>> MyJSONEncoder().encode(stu)
'{"__class__": "Student", "__module__": "__main__", "name": "Tom", "age": 19, "sno": 1}'
>>> MyJSONEncoder(separators=(',', ':')).encode(stu)
'{"__class__":"Student","__module__":"__main__","name":"Tom","age":19,"sno":1}'

# 方式二：將子類MyJSONEncoder作為cls引數的值傳遞給json.dumps()函式
>>> json.dumps(stu, cls=MyJSONEncoder)
'{"__class__": "Student", "__module__": "__main__", "name": "Tom", "age": 19, "sno": 1}'
>>> json.dumps(stu, cls=MyJSONEncoder, separators=(',', ':'))
'{"__class__":"Student","__module__":"__main__","name":"Tom","age":19,"sno":1}'

　　反序列化測試：

>>> MyJSONDecoder().decode('{"sno": 1, "__module__": "__main__", "age": 19, "__class__": "Student", "name": "Tom"}')
Student [name: Tom, age: 19, sno: 1]

說明： 經過測試發現MyJSONDecoder().decode(JSON_STR) 和 json.loads(JSON_STR, object_hook=dict2obj) 只能在Python 2.7上正確執行，在Python 3.5上無法正確執行；而 json.loads(JSON_STR, cls=MyJSONDecoder) 無論在Python 2.7還是在Python 3.5上都無法正確執行。這說明json模組對於自定義資料型別的反序列化支援還是比較有限的，但是我們也可以通過json.loads(JSON_STR)函式，不指定cls引數來得到一個dict物件，然後自己完成dict到object的轉換。

　　繼承JSONEncoder實現序列化時還有一個額外的作用，就是可以通過iterencode()方法把一個很大的資料物件分多次進行序列化，這對於網路傳輸、磁碟持久化等情景非常有用。

>>> for chunk in MyJSONEncoder().iterencode(stu):
...     print(chunk)
...
{
"__class__"
:
"Student"
,
"name"
:
"Tom"
,
"__module__"
:
"__main__"
,
"sno"
:
1
,
"age"
:
19
}

　　大資料物件序列化網路傳輸虛擬碼：

for chunk in JSONEncoder().iterencode(bigobject):
    mysocket.write(chunk)

　三、pickle模組

　　pickle模組實現了用於對Python物件結構進行 序列化 和 反序列化 的二進位制協議，與json模組不同的是pickle模組序列化和反序列化的過程分別叫做 pickling 和 unpickling：

• pickling： 是將Python物件轉換為位元組流的過程；
• unpickling： 是將位元組流二進位制檔案或位元組物件轉換回Python物件的過程；

　　1. pickle模組與json模組對比

• JSON是一種文字序列化格式（它輸出的是unicode檔案，大多數時候會被編碼為utf-8），而pickle是一個二進位制序列化格式;
• JOSN是我們可以讀懂的資料格式，而pickle是二進位制格式，我們無法讀懂；
• JSON是與特定的程式語言或系統無關的，且它在Python生態系統之外被廣泛使用，而pickle使用的資料格式是特定於Python的；
• 預設情況下，JSON只能表示Python內建資料型別，對於自定義資料型別需要一些額外的工作來完成；pickle可以直接表示大量的Python資料型別，包括自定資料型別（其中，許多是通過巧妙地使用Python內省功能自動實現的；複雜的情況可以通過實現specific object API來解決）

　　2. pickle模組使用的資料流格式

　　上面提到，pickle使用的資料格式是特定於Python的。這使得它不受諸如JSON或XDR的外部標準限值，但是這也意味著非Python程式可能無法重建pickled Python物件。預設情況下，pickle資料格式使用相對緊湊的二進位制表示。如果需要最佳大小特徵，可以有效的壓縮pickled資料。pickletools模組包含可以用於對pickle生成的資料流進行分析的工具。目前有5種不同的協議可以用於pickle。使用的協議越高，就需要更新的Python版本去讀取pickle產生的資料：

• 協議v0是原始的“人類可讀”協議，並且向後相容早期的Python版本；
• 協議v1是一箇舊的二進位制格式，也與早期版本的Python相容；
• 協議v2在Python 2.3中引入，它提供更高效的pickling；
• 協議v3是在Python 3.0新增的協議，它明確支援bytes物件，且不能被Python 2.x 進行unpickle操作；這是預設協議，也是當需要相容其他Python 3版本時被推薦使用的協議；
• 協議4是在Python 3.4新增的協議，它新增了對極大物件的支援，pickling更多種類的物件，以及一些資料格式的優化。

說明： Python 2.x中預設使用的是協議v0，如果協議指定為賦值或HIGHEST_PROTOCOL，將使用當前可用的最高協議版本；Python 3.x中預設使用的是協議v3，它相容其他Python 3版本，但是不相容Python 2。

注意： 序列化（Serialization）是一個比持久化（Persistence）更加原始的概念；雖然pickle可以讀寫檔案物件，但是它不處理持久化物件的命名問題，也不處理對持久化物件的併發訪問問題（甚至更復雜的問題）。pickle模組可以將複雜物件轉換為位元組流，並且可以將位元組流轉換為具有相同內部結構的物件。或許最可能對這些位元組流做的事情是將它們寫入檔案，但是也可以對它們進行網路傳輸或將它們儲存在資料庫中。shelve模組提供了一個簡單的介面用於在DBM風格的資料庫檔案上對物件進行pickle和unpickle操作。

　　3. pickle模組提供的相關函式

　　pickle模組提供的幾個序列化/反序列化的函式與json模組基本一致：

# 將指定的Python物件通過pickle序列化作為bytes物件返回，而不是將其寫入檔案
dumps(obj, protocol=None, *, fix_imports=True)

# 將通過pickle序列化後得到的位元組物件進行反序列化，轉換為Python物件並返回
loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict")

# 將指定的Python物件通過pickle序列化後寫入開啟的檔案物件中，等價於`Pickler(file, protocol).dump(obj)`
dump(obj, file, protocol=None, *, fix_imports=True)

# 從開啟的檔案物件中讀取pickled物件表現形式並返回通過pickle反序列化後得到的Python物件
load(file, *, fix_imports=True, encoding="ASCII", errors="strict")

說明： 上面這幾個方法引數中，*號後面的引數都是Python 3.x新增的，目的是為了相容Python 2.x，具體用法請參看官方文件。

　　4. 例項：內建資料型別的序列化/反序列化

　　Python 2.x

>>> import pickle
>>> 
>>> var_a = {'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}

# 序列化
>>> var_b = pickle.dumps(var_a)
>>> var_b
"(dp0\nS'a'\np1\nS'str'\np2\nsS'c'\np3\nI01\nsS'b'\np4\nF11.1\nsS'e'\np5\nI10\nsS'd'\np6\nNsS'g'\np7\n(I4\nI5\nI6\ntp8\nsS'f'\np9\n(lp10\nI1\naI2\naI3\nas."

# 反序列化
>>> var_c = pickle.loads(var_b)
>>> var_c
{'a': 'str', 'c': True, 'b': 11.1, 'e': 10, 'd': None, 'g': (4, 5, 6), 'f': [1, 2, 3]}

　　Python 3.x

>>> import pickle
>>>
>>> var_a = {'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}

# 序列化
>>> var_b = pickle.dumps(var_a)
>>> var_b
b'\x80\x03}q\x00(X\x01\x00\x00\x00eq\x01K\nX\x01\x00\x00\x00aq\x02X\x03\x00\x00\x00strq\x03X\x01\x00\x00\x00fq\x04]q\x05(K\x01K\x02K\x03eX\x01\x00\x00\x00gq\x06K\x04K\x05K\x06\x87q\x07X\x01\x00\x00\x00bq\x08G@&333333X\x01\x00\x00\x00cq\t\x88X\x01\x00\x00\x00dq\nNu.'

# 反序列化
>>> var_c = pickle.loads(var_b)
>>> var_c
{'e': 10, 'a': 'str', 'f': [1, 2, 3], 'g': (4, 5, 6), 'b': 11.1, 'c': True, 'd': None}

　　dump()與load()

>>> import pickle
>>>
>>> var_a = {'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}

# 持久化到檔案
>>> with open('pickle.txt', 'wb') as f:
...     pickle.dump(var_a, f)
...

# 從檔案中讀取資料
>>> with open('pickle.txt', 'rb') as f:
...     var_b = pickle.load(f)
...
>>> var_b
{'e': 10, 'a': 'str', 'f': [1, 2, 3], 'g': (4, 5, 6), 'b': 11.1, 'c': True, 'd': None}
>>>

說明：

• 預設情況下Python 2.x中pickled後的資料是字串形式，需要將它轉換為位元組物件才能被Python 3.x中的pickle.loads()反序列化；Python 3.x中pickling所使用的協議是v3，因此需要在呼叫pickle.dumps()時指定可選引數protocol為Python 2.x所支援的協議版本（0,1,2），否則pickled後的資料不能被被Python 2.x中的pickle.loads()反序列化；
• Python 3.x中pickle.dump()和pickle.load()方法中指定的檔案物件，必須以二進位制模式開啟，而Python 2.x中可以以二進位制模式開啟，也可以以文字模式開啟。

　　5. 例項：自定義資料型別的序列化/反序列化

　　首先來自定義一個資料型別：

class Student(object):
    def __init__(self, name, age, sno):
        self.name = name
        self.age = age
        self.sno = sno
    
    def __repr__(self):
        return 'Student [name: %s, age: %d, sno: %d]' % (self.name, self.age, self.sno)

　　pickle模組可以直接對自定資料型別進行序列化/反序列化操作，無需編寫額外的處理函式或類。

>>> stu = Student('Tom', 19, 1)
>>> print(stu)
Student [name: Tom, age: 19, sno: 1]

# 序列化
>>> var_b = pickle.dumps(stu)
>>> var_b
b'\x80\x03c__main__\nStudent\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x03\x00\x00\x00Tomq\x04X\x03\x00\x00\x00ageq\x05K\x13X\x03\x00\x00\x00snoq\x06K\x01ub.'

# 反序列化
>>> var_c = pickle.loads(var_b)
>>> var_c
Student [name: Tom, age: 19, sno: 1]

# 持久化到檔案
>>> with open('pickle.txt', 'wb') as f:
...     pickle.dump(stu, f)
...

# 從檔案總讀取資料
>>> with open('pickle.txt', 'rb') as f:
...     pickle.load(f)
...
Student [name: Tom, age: 19, sno: 1]

　四、shelve模組 

　　shelve是一個簡單的資料儲存方案，類似key-value資料庫，可以很方便的儲存python物件，其內部是通過pickle協議來實現資料序列化。shelve只有一個open()函式，這個函式用於開啟指定的檔案（一個持久的字典），然後返回一個shelf物件。shelf是一種持久的、類似字典的物件。它與“dbm”的不同之處在於，其values值可以是任意基本Python物件--pickle模組可以處理的任何資料。這包括大多數類例項、遞迴資料型別和包含很多共享子物件的物件。keys還是普通的字串。

open(filename, flag='c', protocol=None, writeback=False)

　　flag 參數列示開啟資料儲存檔案的格式，可取值與dbm.open()函式一致：

值	描述
'r'	以只讀模式開啟一個已經存在的資料儲存檔案
'w'	以讀寫模式開啟一個已經存在的資料儲存檔案
'c'	以讀寫模式開啟一個資料儲存檔案，如果不存在則建立
'n'	總是建立一個新的、空資料儲存檔案，並以讀寫模式開啟

　　protocol 參數列示序列化資料所使用的協議版本，預設是pickle v3；

　　writeback 參數列示是否開啟回寫功能。

　　我們可以把shelf物件當dict來使用--儲存、更改、查詢某個key對應的資料，當操作完成之後，呼叫shelf物件的close()函式即可。當然，也可以使用上下文管理器（with語句），避免每次都要手動呼叫close()方法。

　　例項：內建資料型別操作

# 儲存資料
with shelve.open('student') as db:
    db['name'] = 'Tom'
    db['age'] = 19
    db['hobby'] = ['籃球', '看電影', '彈吉他']
    db['other_info'] = {'sno': 1, 'addr': 'xxxx'}

# 讀取資料
with shelve.open('student') as db:
    for key,value in db.items():
        print(key, ': ', value)

　　輸出結果：

name :  Tom
age :  19
hobby :  ['籃球', '看電影', '彈吉他']
other_info :  {'sno': 1, 'addr': 'xxxx'}

　　例項：自定義資料型別操作

# 自定義class
class Student(object):
    def __init__(self, name, age, sno):
        self.name = name
        self.age = age
        self.sno = sno
    
    def __repr__(self):
        return 'Student [name: %s, age: %d, sno: %d]' % (self.name, self.age, self.sno)

# 儲存資料
tom = Student('Tom', 19, 1)
jerry = Student('Jerry', 17, 2)

with shelve.open("stu.db") as db:
    db['Tom'] = tom
    db['Jerry'] = jerry

# 讀取資料
with shelve.open("stu.db") as db:
    print(db['Tom'])
    print(db['Jerry'])

輸出結果：

Student [name: Tom, age: 19, sno: 1]
Student [name: Jerry, age: 17, sno: 2]

　五、總結 

　　1. 對比

　　json模組常用於編寫web介面，將Python資料轉換為通用的json格式傳遞給其它系統或客戶端；也可以用於將Python資料儲存到本地檔案中，缺點是明文儲存，保密性差。另外，如果需要儲存非內建資料型別需要編寫額外的轉換函式或自定義類。

　　pickle模組和shelve模組由於使用其特有的序列化協議，其序列化之後的資料只能被Python識別，因此只能用於Python系統內部。另外，Python 2.x 和 Python
3.x 預設使用的序列化協議也不同，如果需要互相相容需要在序列化時通過protocol引數指定協議版本。除了上面這些缺點外，pickle模組和shelve模組相對於json模組的優點在於對於自定義資料型別可以直接序列化和反序列化，不需要編寫額外的轉換函式或類。

　　shelve模組可以看做是pickle模組的升級版，因為shelve使用的就是pickle的序列化協議，但是shelve比pickle提供的操作方式更加簡單、方便。shelve模組相對於其它兩個模組在將Python資料持久化到本地磁碟時有一個很明顯的優點就是，它允許我們可以像操作dict一樣操作被序列化的資料，而不必一次性的儲存或讀取所有資料。

　　2. 建議

• 需要與外部系統互動時用json模組；
• 需要將少量、簡單Python資料持久化到本地磁碟檔案時可以考慮用pickle模組；
• 需要將大量Python資料持久化到本地磁碟檔案或需要一些簡單的類似資料庫的增刪改查功能時，可以考慮用shelve模組。

　　3. 附錄

要實現的功能	可以使用的api
將Python資料型別轉換為（json）字串	json.dumps()
將json字串轉換為Python資料型別	json.loads()
將Python資料型別以json形式儲存到本地磁碟	json.dump()
將本地磁碟檔案中的json資料轉換為Python資料型別	json.load()
將Python資料型別轉換為Python特定的二進位制格式	pickle.dumps()
將Python特定的的二進位制格式資料轉換為Python資料型別	pickle.loads()
將Python資料型別以Python特定的二進位制格式儲存到本地磁碟	pickle.dump()
將本地磁碟檔案中的Python特定的二進位制格式資料轉換為Python資料型別	pickle.load()
以型別dict的形式將Python資料型別儲存到本地磁碟或讀取本地磁碟資料並轉換為資料型別	shelve.open()