Python之數據序列化（json、pickle、shelve）

轉載自：https://www.cnblogs.com/yyds/p/6563608.html

本節內容

---

1. 前言
2. json模塊
3. pickle模塊
4. shelve模塊
5. 總結

1、前言

---

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()

2、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)

3、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]

4、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]

5、總結

---

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()