本節(jié)內(nèi)容

  1. 前言

  2. json模塊

  3. pickle模塊

  4. shelve模塊

  5. 總結(jié)

一、前言

1. 現(xiàn)實(shí)需求

每種編程語言都有各自的數(shù)據(jù)類型，其中面向?qū)ο蟮木幊陶Z言還允許開發(fā)者自定義數(shù)據(jù)類型（如：自定義類），Python也是一樣。很多時(shí)候我們會(huì)有這樣的需求：

  • 把內(nèi)存中的各種數(shù)據(jù)類型的數(shù)據(jù)通過網(wǎng)絡(luò)傳送給其它機(jī)器或客戶端；

  • 把內(nèi)存中的各種數(shù)據(jù)類型的數(shù)據(jù)保存到本地磁盤持久化；

2.數(shù)據(jù)格式

如果要將一個(gè)系統(tǒng)內(nèi)的數(shù)據(jù)通過網(wǎng)絡(luò)傳輸給其它系統(tǒng)或客戶端，我們通常都需要先把這些數(shù)據(jù)轉(zhuǎn)化為字符串或字節(jié)串，而且需要規(guī)定一種統(tǒng)一的數(shù)據(jù)格式才能讓數(shù)據(jù)接收端正確解析并理解這些數(shù)據(jù)的含義。XML 是早期被廣泛使用的數(shù)據(jù)交換格式，在早期的系統(tǒng)集成論文中經(jīng)常可以看到它的身影；如今大家使用更多的數(shù)據(jù)交換格式是JSON（JavaScript Object Notation），它是一種輕量級的數(shù)據(jù)交換格式。JSON相對于XML而言，更加加單、易于閱讀和編寫，同時(shí)也易于機(jī)器解析和生成。除此之外，我們也可以自定義內(nèi)部使用的數(shù)據(jù)交換格式。

如果是想把數(shù)據(jù)持久化到本地磁盤，這部分?jǐn)?shù)據(jù)通常只是供系統(tǒng)內(nèi)部使用，因此數(shù)據(jù)轉(zhuǎn)換協(xié)議以及轉(zhuǎn)換后的數(shù)據(jù)格式也就不要求是標(biāo)準(zhǔn)、統(tǒng)一的，只要本系統(tǒng)內(nèi)部能夠正確識(shí)別即可。但是，系統(tǒng)內(nèi)部的轉(zhuǎn)換協(xié)議通常會(huì)隨著編程語言版本的升級而發(fā)生變化（改進(jìn)算法、提高效率），因此通常會(huì)涉及轉(zhuǎn)換協(xié)議與編程語言的版本兼容問題，下面要介紹的pickle協(xié)議就是這樣一個(gè)例子。

3. 序列化/反序列化

將對象轉(zhuǎn)換為可通過網(wǎng)絡(luò)傳輸或可以存儲(chǔ)到本地磁盤的數(shù)據(jù)格式（如：XML、JSON或特定格式的字節(jié)串）的過程稱為序列化；反之，則稱為反序列化。

4.相關(guān)模塊

本節(jié)要介紹的就是Python內(nèi)置的幾個(gè)用于進(jìn)行數(shù)據(jù)序列化的模塊：

模塊名稱描述提供的api
json用于實(shí)現(xiàn)Python數(shù)據(jù)類型與通用（json）字符串之間的轉(zhuǎn)換dumps()、dump()、loads()、load()
pickle用于實(shí)現(xiàn)Python數(shù)據(jù)類型與Python特定二進(jìn)制格式之間的轉(zhuǎn)換dumps()、dump()、loads()、load()
shelve專門用于將Python數(shù)據(jù)類型的數(shù)據(jù)持久化到磁盤，shelve是一個(gè)類似dict的對象，操作十分便捷open()

二、json模塊

大部分編程語言都會(huì)提供處理json數(shù)據(jù)的接口，Python 2.6開始加入了json模塊，且把它作為一個(gè)內(nèi)置模塊提供，無需下載即可使用。

1. 序列化與反序列化

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

  • encoding： 把Python對象轉(zhuǎn)換成JSON字符串

  • decoding： 把JSON字符串轉(zhuǎn)換成python對象

json模塊提供了以下兩個(gè)方法來進(jìn)行序列化和反序列化操作：

# 序列化：將Python對象轉(zhuǎn)換成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字符串轉(zhuǎn)換成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模塊還提供了兩個(gè)額外的方法允許我們直接將序列化后得到的json數(shù)據(jù)保存到文件中，以及直接讀取文件中的json數(shù)據(jù)進(jìn)行反序列化操作：

# 序列化：將Python對象轉(zhuǎn)換成json字符串并存儲(chǔ)到文件中dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, indent=None, separators=None, default=None, sort_keys=False, **kw)# 反序列化：讀取指定文件中的json字符串并轉(zhuǎn)換成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之間數(shù)據(jù)類型對應(yīng)關(guān)系

Python轉(zhuǎn)JSON

PythonJSON
dictObject
list, tuplearray
strstring
int, float, int- & float-derived Enumsnumbers
Truetrue
Falsefalse
Nonenull

JSON轉(zhuǎn)Python

JSONPython
objectdict
arraylist
stringstr
number(int)int
number(real)float
trueTrue
falseFalse
nullNone

說明：

  • Python dict中的非字符串key被轉(zhuǎn)換成JSON字符串時(shí)都會(huì)被轉(zhuǎn)換為小寫字符串；

  • Python中的tuple，在序列化時(shí)會(huì)被轉(zhuǎn)換為array，但是反序列化時(shí)，array會(huì)被轉(zhuǎn)化為list；

  • 由以上兩點(diǎn)可知，當(dāng)Python對象中包含tuple數(shù)據(jù)或者包含dict，且dict中存在非字符串的key時(shí)，反序列化后得到的結(jié)果與原來的Python對象是不一致的；

  • 對于Python內(nèi)置的數(shù)據(jù)類型（如：str, unicode, int, float, bool, None, list, tuple, dict）json模塊可以直接進(jìn)行序列化/反序列化處理；對于自定義類的對象進(jìn)行序列化和反序列化時(shí)，需要我們自己定義一個(gè)方法來完成定義object和dict之間進(jìn)行轉(zhuǎn)化。

3. 實(shí)例：內(nèi)置數(shù)據(jù)類型序列化/反序列化

序列化

# 序列化
>>> 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參數(shù)： 表示序列化時(shí)是否對dict的key進(jìn)行排序（dict默認(rèn)是無序的）

# 序列化并對key進(jìn)行排序
>>> 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參數(shù)： 表示縮進(jìn)的意思，它可以使得數(shù)據(jù)存儲(chǔ)的格式變得更加優(yōu)雅、可讀性更強(qiáng)；如果indent是一個(gè)非負(fù)整數(shù)或字符串，則JSON array元素和object成員將會(huì)被以相應(yīng)的縮進(jìn)級別進(jìn)行打印輸出；如果indent是0或負(fù)數(shù)或空字符串，則將只會(huì)插入換行，不會(huì)有縮進(jìn)。

# 序列化并對key進(jìn)行排序及格式化輸出>>> 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參數(shù)： 盡管indent參數(shù)可以使得數(shù)據(jù)存儲(chǔ)的格式變得更加優(yōu)雅、可讀性更強(qiáng)，但是那是通過添加一些冗余的空白字符進(jìn)行填充的。當(dāng)json被用于網(wǎng)絡(luò)數(shù)據(jù)通信時(shí)，應(yīng)該盡可能的減少無用的數(shù)據(jù)傳輸，這樣可以節(jié)省帶寬并加快數(shù)據(jù)傳輸速度。json模塊序列化Python對象后得到的json字符串中的','號(hào)和':'號(hào)分隔符后默認(rèn)都會(huì)附加一個(gè)空白字符，我們可以通過separators參數(shù)重新指定分隔符，從而去除無用的空白字符；

  • 該參數(shù)的值應(yīng)該是一個(gè)tuple(item_separator, key_separator)

  • 如果indent是None，其默認(rèn)值為(', ', ': ')

  • 如果indent不為None，則默認(rèn)值為(',', ': ')

  • 我們可以通過為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]}'

反序列化

# 反序列化
>>> 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()函數(shù)示例

# 序列化到文件中>>> 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)# 反序列化文件中的內(nèi)容>>> 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重復(fù)調(diào)用dump()函數(shù)去序列化多個(gè)對象（或序列化同一個(gè)對象多次），將會(huì)產(chǎn)生一個(gè)無效的JSON文件，也就是說對于一個(gè)fp只能調(diào)用一次dump()。

4. 實(shí)例：自定義數(shù)據(jù)類型的序列化/反序列化

Python是面向?qū)ο蟮木幊陶Z言，我們可以自定義需要的數(shù)據(jù)類型；實(shí)際工作中，我們常常會(huì)用到自定義數(shù)據(jù)類型的序列化與反序列化操作。要實(shí)現(xiàn)自定義數(shù)據(jù)類型的序列化與反序列化有兩種方式：

  • 通過轉(zhuǎn)換函數(shù)實(shí)現(xiàn)

  • 通過繼承JSONEncoder和JSONDecoder類實(shí)現(xiàn)

首先來自定義一個(gè)數(shù)據(jù)類型

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)

直接調(diào)用dumps()方法會(huì)引發(fā)TypeError錯(cuò)誤：

>>> 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格式的數(shù)據(jù)。那么我們分別通過“編寫轉(zhuǎn)換函數(shù)” 和 “繼承JSONEncoder和JSONDecoder類” 來實(shí)現(xiàn)對這個(gè)自定義數(shù)據(jù)類型的JSON序列化和反序列化。

方法1：編寫轉(zhuǎn)換函數(shù)

那么這個(gè)轉(zhuǎn)換函數(shù)要完成哪兩個(gè)數(shù)據(jù)類型之間的轉(zhuǎn)換呢？ 從上面列出的JSON與Python數(shù)據(jù)類型的對應(yīng)表中可知，JSON中的object對應(yīng)的是Python中的dict，因此要對Python中的自定義數(shù)據(jù)類型的對象進(jìn)行序列化，就需要先把這個(gè)對象轉(zhuǎn)換成json模塊可以直接進(jìn)行序列化dict類型。由此可知，這個(gè)轉(zhuǎn)換函數(shù)是要完成的是Python對象（不是JSON對象）與dict之間的相互轉(zhuǎn)換，且序列化時(shí)轉(zhuǎn)換過程是“Python對象 --> dict --> JSON object”，反序列化的過程是“JSON object -> dict --> Python對象”。所以，我們需要編寫兩個(gè)轉(zhuǎn)換函數(shù)來分別實(shí)現(xiàn)序列化和反序列化時(shí)的轉(zhuǎn)換過程。

def obj2dict(obj):
    d = {}
    d['__class__'] = obj.__class__.__name__
    d['__module__'] = obj.__module__
    d.update(obj.__dict__)    return ddef 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) 等價(jià)于 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) 等價(jià)于 dict2obj(json.loads(JSON_STR))

方法2：繼承JSONEncoder和JSONDecoder實(shí)現(xiàn)子類

import jsonclass MyJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        d = {}
        d['__class__'] = obj.__class__.__name__
        d['__module__'] = obj.__module__
        d.update(obj.__dict__)        return dclass 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)# 方式一：直接調(diào)用子類MyJSONEncoder的encode()方法進(jìn)行序列化>>> 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參數(shù)的值傳遞給json.dumps()函數(shù)>>> 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]

  • http://www.cnblogs.com/yyds/p/6563608.html