PyMOTW: json

• 模組： json
• 目的： JavaScript物件格式序列器
• python版本： 2.6

json模組提供了一個類似於pickle中用於轉換記憶體中python物件為一個序列表示形式(“JavaScript Object Notation”)的API介面. 但和pickle不同的是, JSON在其他很多語言中都有對應實現(特別是在JavaScript中), 使其更適用於內部應用間的通訊. 在一個AJAX應用中, JSON可能對於web伺服器和客戶端間的通訊, 使用最為廣泛, 但它也不僅限於這類應用.

簡單資料型別的編碼和解碼

編碼器預設支援Python的本地型別(如int, float, list, tuple, dict).

import json data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ] print 'DATA:', repr(data) data_string = json.dumps(data) print 'JSON:', data_string 

編碼器處理之後的值和Python的repr()的輸出值很類似.

$ python json_simple_types.py DATA: [{'a': 'A', 'c': 3.0, 'b': (2, 4)}] JSON: [{"a": "A", "c": 3.0, "b": [2, 4]}] 

編碼之後的解碼所獲的的值可能和原先的物件不是完全一致.

import json data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ] data_string = json.dumps(data) print 'ENCODED:', data_string decoded = json.loads(data_string) print 'DECODED:', decoded print 'ORIGINAL:', type(data[0]['b']) print 'DECODED :', type(decoded[0]['b']) 

比如說, 元組會被轉換為JSON的列表.

$ python json_simple_types_decode.py ENCODED: [{"a": "A", "c": 3.0, "b": [2, 4]}] DECODED: [{u'a': u'A', u'c': 3.0, u'b': [2, 4]}] ORIGINAL: <type 'tuple'> DECODED : <type 'list'>

人性化使用 vs 緊湊型輸出

JSON優於pickle的另外一點是其結果具有可讀性. dumps()函式接收多個引數用於更好的輸出結構. 比如說. sort_keys引數告訴編碼器按照順序輸出字典的鍵值, 而不是隨機無序的.

import json data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ] print 'DATA:', repr(data) unsorted = json.dumps(data) print 'JSON:', json.dumps(data) print 'SORT:', json.dumps(data, sort_keys=True) first = json.dumps(data, sort_keys=True) second = json.dumps(data, sort_keys=True) print 'UNSORTED MATCH:', unsorted == first print 'SORTED MATCH :', first == second 

排序之後更容易讓人看出結果, 也使進行JSON的比較輸出成為可能.

$ python json_sort_keys.py DATA: [{'a': 'A', 'c': 3.0, 'b': (2, 4)}] JSON: [{"a": "A", "c": 3.0, "b": [2, 4]}] SORT: [{"a": "A", "b": [2, 4], "c": 3.0}] UNSORTED MATCH: False SORTED MATCH : True 

對於高度巢狀的資料結構, 你會想在輸出結果中增加縮排以更好的顯示其格式.

import json data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ] print 'DATA:', repr(data) print 'NORMAL:', json.dumps(data, sort_keys=True) print 'INDENT:', json.dumps(data, sort_keys=True, indent=2) 

當indent引數是一非負整數時, 輸出的結構和pprint更為接近, 在每個縮排層次上都有前導空格.

$ python json_indent.py DATA: [{'a': 'A', 'c': 3.0, 'b': (2, 4)}] NORMAL: [{"a": "A", "b": [2, 4], "c": 3.0}] INDENT: [ { "a": "A", "b": [ 2, 4 ], "c": 3.0 } ] 

像這種型別輸出的資料在傳輸過程中需佔用更多的位元組, 不過, 在實際生產環境中沒有必要使用縮排格式. 實際上, 你可以設定資料的分隔符來讓結果更為緊湊.

import json data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ] print 'DATA:', repr(data) print 'repr(data) :', len(repr(data)) print 'dumps(data) :', len(json.dumps(data)) print 'dumps(data, indent=2) :', len(json.dumps(data, indent=2)) print 'dumps(data, separators):', len(json.dumps(data, separators=(',',':'))) 

dumps()函式的separators引數是一個元組, 包含分隔列表各項和字典鍵值各項的字串. 預設是(‘, ‘, ‘: ‘). 可以去掉後者中的空格, 我們可以得到較緊湊的輸出.

$ python json_compact_encoding.py DATA: [{'a': 'A', 'c': 3.0, 'b': (2, 4)}] repr(data) : 35 dumps(data) : 35 dumps(data, indent=2) : 76 dumps(data, separators): 29 

編碼字典

JSON格式中, 字典的鍵被限制為字串型別. 如果字典中的鍵是其他型別, 那麼在編碼這個物件時會產生一個TypeError異常. 一種解決這個限制的方法是, 在編碼時, 使用skipkeys引數跳過所有非字串型別的鍵.

import json data = [ { 'a':'A', 'b':(2, 4), 'c':3.0, ('d',):'D tuple' } ] print 'First attempt' try: print json.dumps(data) except TypeError, err: print 'ERROR:', err print print 'Second attempt' print json.dumps(data, skipkeys=True) 

非字串型別的鍵被忽略, 而不丟擲一個異常.

$ python json_skipkeys.py First attempt ERROR: key ('d',) is not a string Second attempt [{"a": "A", "c": 3.0, "b": [2, 4]}] 

自定義型別的處理

上面所有的例子都是用了Python的內建型別作為例子, 因為他們都被json本身支援. 當然, 自定義型別也常常需要正確編碼. 這裡有兩種情況:

第一, 對於一個類的編碼:

class MyObj(object): def __init__(self, s): self.s = s def __repr__(self): return '<MyObj(%s)>' % self.s 

編碼一個MyObj物件的最簡單方式是定義個轉換函式, 用於將位置型別轉換出呢個已知型別. 你沒有必要自己進行編碼, 而僅需要將一個物件轉換成另一個物件.

import json import json_myobj obj = json_myobj.MyObj('instance value goes here') print 'First attempt' try: print json.dumps(obj) except TypeError, err: print 'ERROR:', err def convert_to_builtin_type(obj): print 'default(', repr(obj), ')' # Convert objects to a dictionary of their representation d = { '__class__':obj.__class__.__name__, '__module__':obj.__module__, } d.update(obj.__dict__) return d print print 'With default' print json.dumps(obj, default=convert_to_builtin_type) 

在convert_to_builtin_type()函式中, 不被json識別的類物件被轉換成一個包含足夠能重建這個物件的字典資訊.

$ python json_dump_default.py First attempt ERROR: <MyObj(instance value goes here)> is not JSON serializable With default default( <MyObj(instance value goes here)> ) {"s": "instance value goes here", "__module__": "json_myobj", "__class__": "MyObj"} 

為了能解碼結果資料並建立一個MyObj例項, 我們需要配合解碼器以便可以從模組中匯入類並建立例項. 我們在loads()函式中使用object_hook引數.

在輸入資料流中, 對於解碼獲得的每個字典都會呼叫object_hook, 將這個字典轉換成其他型別的物件. hook函式返回的是呼叫程式所需要的物件, 而不是字典.

import json def dict_to_object(d): if '__class__' in d: class_name = d.pop('__class__') module_name = d.pop('__module__') module = __import__(module_name) print 'MODULE:', module class_ = getattr(module, class_name) print 'CLASS:', class_ args = dict( (key.encode('ascii'), value) for key, value in d.items()) print 'INSTANCE ARGS:', args inst = class_(**args) else: inst = d return inst encoded_object = '[{"s": "instance value goes here", "__module__": "json_myobj", "__class__": "MyObj"}]' myobj_instance = json.loads(encoded_object, object_hook=dict_to_object) print myobj_instance 

由於json將字串值轉換成unicode物件, 所以我們需要將作為類構造器的引數重新編碼為ASCII字串.

$ python json_load_object_hook.py MODULE: <module 'json_myobj' from '/Users/dhellmann/Documents/PyMOTW/src/PyMOTW/json/json_myobj.pyc'> CLASS: <class 'json_myobj.MyObj'> INSTANCE ARGS: {'s': u'instance value goes here'} [<MyObj(instance value goes here)>] 

對於內建型別也都有類似的hooks, 如整型(parse_int), 浮點型(parse_float), 常量(parse_constant).

編碼和解碼類

除了上述的這些函式外, json模組還提供了編碼和解碼類. 直接使用這些類, 你可以訪問到額外的API介面或者定製建立它的子類.

JSONEncoder提供了一個產生編碼資料”塊”的的迭代介面, 這在寫入一個檔案或網路sockets時(不需要在記憶體中完整表示整個資料)是非常方便的,

import json encoder = json.JSONEncoder() data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ] for part in encoder.iterencode(data): print 'PART:', part 

正如你看到的, 資料是以邏輯單位形式輸出的, 而不是按照資料長度輸出.

$ python json_encoder_iterable.py PART: [ PART: { PART: "a" PART: : PART: "A" PART: , PART: "c" PART: : PART: 3.0 PART: , PART: "b" PART: : PART: [ PART: 2 PART: , PART: 4 PART: ] PART: } PART: ] 

encode()方法基本上等價於’‘.join(encoder.iterencode()), 只是多了些附加錯誤檢查.

為了能夠編碼任何型別的物件, 我們可以編寫一類似於上述的convert_to_builtin_type()函式去過載default()方法.

import json import json_myobj class MyEncoder(json.JSONEncoder): def default(self, obj): print 'default(', repr(obj), ')' # Convert objects to a dictionary of their representation d = { '__class__':obj.__class__.__name__, '__module__':obj.__module__, } d.update(obj.__dict__) return d obj = json_myobj.MyObj('internal data') print obj print MyEncoder().encode(obj) 

這裡輸出的結果是和先前的實現一致的.

$ python json_encoder_default.py <MyObj(internal data)> default( <MyObj(internal data)> ) {"s": "internal data", "__module__": "json_myobj", "__class__": "MyObj"} 

解碼後將字典轉換成一個物件, 在先前實現的基礎上稍作修改即可.

import json class MyDecoder(json.JSONDecoder): def __init__(self): json.JSONDecoder.__init__(self, object_hook=self.dict_to_object) def dict_to_object(self, d): if '__class__' in d: class_name = d.pop('__class__') module_name = d.pop('__module__') module = __import__(module_name) print 'MODULE:', module class_ = getattr(module, class_name) print 'CLASS:', class_ args = dict( (key.encode('ascii'), value) for key, value in d.items()) print 'INSTANCE ARGS:', args inst = class_(**args) else: inst = d return inst encoded_object = '[{"s": "instance value goes here", "__module__": "json_myobj", "__class__": "MyObj"}]' myobj_instance = MyDecoder().decode(encoded_object) print myobj_instance 

輸出結果也是和先前例子中輸出的一樣.

$ python json_decoder_object_hook.py MODULE: <module 'json_myobj' from '/Users/dhellmann/Documents/PyMOTW/src/PyMOTW/json/json_myobj.pyc'> CLASS: <class 'json_myobj.MyObj'> INSTANCE ARGS: {'s': u'instance value goes here'} [<MyObj(instance value goes here)>] 

流和檔案的處理

到目前為止的所有例子, 我們都假設待編碼的資料都是一次性完整載入到記憶體中的. 但對於大型資料結構來說, 將編碼資料直接寫入一個類檔案物件, 可能會更好. load()和dump()函式可以接收一個用於讀或寫的類檔案物件的引用.

import json import tempfile data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ] f = tempfile.NamedTemporaryFile(mode='w+') json.dump(data, f) f.flush() print open(f.name, 'r').read() 

對於socket來說, 也和正常檔案控制代碼類似.

$ python json_dump_file.py [{"a": "A", "c": 3.0, "b": [2, 4]}] 

雖然一次性讀取部分資料不是很好, 但是load()函式仍然提供了從流資料輸入中封裝生成物件的功能.

import json import tempfile f = tempfile.NamedTemporaryFile(mode='w+') f.write('[{"a": "A", "c": 3.0, "b": [2, 4]}]') f.flush() f.seek(0) print json.load(f) 

$ python json_load_file.py [{u'a': u'A', u'c': 3.0, u'b': [2, 4]}] 

混合資料流

JSONDecoder包含了raw_decode()方法, 用於解碼在很多資料組成的資料結構, 例如包含多餘文字的JSON資料. 返回的值是從輸入資料中解碼獲得的物件, 資料中的index表示解碼物件結束時所在的位置.

import json decoder = json.JSONDecoder() def get_decoded_and_remainder(input_data): obj, end = decoder.raw_decode(input_data) remaining = input_data[end:] return (obj, end, remaining) encoded_object = '[{"a": "A", "c": 3.0, "b": [2, 4]}]' extra_text = 'This text is not JSON.' print 'JSON first:' obj, end, remaining = get_decoded_and_remainder(' '.join([encoded_object, extra_text])) print 'Object :', obj print 'End of parsed input :', end print 'Remaining text :', repr(remaining) print print 'JSON embedded:' try: obj, end, remaining = get_decoded_and_remainder( ' '.join([extra_text, encoded_object, extra_text]) ) except ValueError, err: print 'ERROR:', err 

不幸的是, 這僅僅在物件出現在輸入流的開始處才有效.

$ python json_mixed_data.py JSON first: Object : [{u'a': u'A', u'c': 3.0, u'b': [2, 4]}] End of parsed input : 35 Remaining text : ' This text is not JSON.' JSON embedded: ERROR: No JSON object could be decoded