python中的json模塊常用方法匯總

更新時間：2022年06月06日 10:43:32 作者：安一缸

這篇文章主要介紹了python中的json模塊常用方法匯總，json模塊可以實現(xiàn)json數(shù)據(jù)的序列化和反序列化，更多相關(guān)資料介紹需要的小伙伴可以參考一下下面文章內(nèi)容

一、概述

推薦使用參考網(wǎng)站： json

在python中，json模塊可以實現(xiàn)json數(shù)據(jù)的序列化和反序列化

序列化：將可存放在內(nèi)存中的python 對象轉(zhuǎn)換成可物理存儲和傳遞的形式
實現(xiàn)方法：load() loads()
反序列化：將可物理存儲和傳遞的json數(shù)據(jù)形式轉(zhuǎn)換為在內(nèi)存中表示的python對象
實現(xiàn)方法：dump() dumps()

二、方法詳解

1.dump()

def 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):

1.把python對象obj轉(zhuǎn)換成物理表現(xiàn)形式fp流。其中fp的.write()可以支持寫入類文件中
2.如果skipkeys是true，那么在處理json對象的時候，僅支持 (str, int, float, bool, None) 這些基本類型的key，如果有非基本類型，就會拋出TypeError異常；如果值為false，那么對于非基本類型，則會拋出TypeError；默認(rèn)值為false
3.如果ensure_ascii是true，那么obj中字符在寫入fp的時候，非ascii字符會被進(jìn)行轉(zhuǎn)義；如果值為false，那么對于這些非ascii字符不會進(jìn)行轉(zhuǎn)義，會原樣寫入；默認(rèn)值為true
4.如果check_circular是false，那么遇到container類型（list，dict，自定義編碼類型）的時候，不會循環(huán)引用檢查，一旦是循環(huán)引用，結(jié)果就是OverflowError；如果值為true，那么會對container類型進(jìn)行循環(huán)引用檢查，檢查失敗會 raise ValueError(“Circular reference detected”)；默認(rèn)值是true
5.如果allow_nan是false，嚴(yán)格遵守json的規(guī)范，對于序列化一些超出float范圍的值（nan, inf, -inf）的時候，會拋出ValueError；如果值為true，那么超過float范圍的值將會使用在JavaScript中的等效值(NaN, Infinity, -Infinity)；默認(rèn)值為true
6.如果indent是一個non-negative （正）整數(shù)，那么json中的數(shù)組元素和對象元素都將會使用indent單位縮進(jìn)格式來進(jìn)行輸出；值為0的時候，就只會插入一個換行符；值為None的時候，會輸出最緊湊的格式
7.separators的指定是以元組(item_separator, key_separator)的方式；如果indent=‘None’ 那么該選項的默認(rèn)值為(', ', ': ')，否則該選項的默認(rèn)值為(',', ': ')；如果想要緊湊的json表達(dá)，那么應(yīng)該使用(',', ': ')來去除空格
8.default(obj)是一個函數(shù)，主要是針對于那些無法被直接序列化的對象。該參數(shù)可以提供一個默認(rèn)的序列化版本，否則就會拋出一個TypeError。默認(rèn)是拋出TypeError
9.如果sort_keys是true，那么輸出的時候會根據(jù)key進(jìn)行排序，默認(rèn)值是false可以指定一個JSONEncoder的子類，來序列化其他的類型，可以通過cls或者是JSONEncoder參數(shù)來指定

2.dumps

def 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):

4.把obj序列化成一個json格式的字符串，并返回該字符串支持的python內(nèi)置可進(jìn)行json序列化的類型有(str, int, float, bool, None，list，tuple，dict)如果無法序列化的類型，會拋出TypeError

2.其他參數(shù)同上解釋

3.load

def load(fp, *, cls=None, object_hook=None, parse_float=None,
? ? ? ? parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):

1.把物理表現(xiàn)形式fp流（fp.read()的返回需要是一個json格式）反序列化成一個python對象
2.object_hook是一個可選的函數(shù)，主要用來對直接反序列化之后的結(jié)果進(jìn)行二次加工；object_hook的參數(shù)只有一個，是dict，該dict也是反序列化的直接結(jié)果；object_hook的返回值為load方法的返回值；這個功能一般是用來自定義解碼器，例如JSON-RPC
3.object_pairs_hook是一個可選的函數(shù)，主要用來對直接反序列化之后的結(jié)果進(jìn)行二次加工；object_pairs_hook的參數(shù)只有一個，是list(tuple)，該list(tuple)也是反序列化的直接結(jié)果；object_pairs_hook的返回值為load方法的返回值；這個功能一般是用來自定義解碼器，例如JSON-RPC;在同時指定了object_hook和object_pairs_hook的時候，object_pairs_hook的優(yōu)先級高于object_hook

4.cls的關(guān)鍵字參數(shù)，支持使用自定義的JSONDecoder的子類；如果不指定，默認(rèn)使用JSONDecoder

4.loads

def loads(s, *, cls=None, object_hook=None, parse_float=None,
? ? ? ? parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):

1.反序列化一個s（包含json文本的str，bytes，bytearray的實例對象）到一個python對象
2.object_hook 同上
3.object_pairs_hook同上
4.parse_float 如果定義了，那么會在對json字符串中的每一個float進(jìn)行解碼的時候調(diào)用；默認(rèn)情況下等價于 float(num_str)；也可以使用其他的數(shù)據(jù)類型，如(e.g. decimal.Decimal)

5.parse_int 如果定義了，那么會在對json字符串中的每一個float進(jìn)行解碼的時候調(diào)用；默認(rèn)情況下，等價于 int(num_str)；也可使用其他針對于json中的integer的datatype或者是parser

6.parse_constant 如果定義了，那么在碰到-Infinity, Infinity, NaN.這些的時候會被調(diào)用；如果遇到無效的json符號，會拋出異常

三、代碼實戰(zhàn)

1.dumps()

import json

if __name__ == '__main__':
? ? # 測試格式化非json格式數(shù)據(jù)
? ? print('-------------測試格式化非json格式數(shù)據(jù)----------------')
? ? a = json.dumps(2.0)
? ? print(a, type(a))
? ? a = json.dumps(tuple())
? ? print(a, type(a))
? ? a = json.dumps([])
? ? print(a, type(a))

? ? # 測試格式化json格式數(shù)據(jù)
? ? print('-------------測試格式化json格式數(shù)據(jù)----------------')
? ? j = {'a': 1, 'b': 6}
? ? a = json.dumps(j)
? ? print(a, type(a))
? ? # 測試skipkeys參數(shù)
? ? print('-------------測試skipkeys參數(shù)----------------')
? ? j = {'a': 1, tuple(): 6}
? ? a = json.dumps(j, skipkeys=True)
? ? print(a, type(a))

? ? # 測試indent參數(shù)
? ? print('-------------測試indent默認(rèn)參數(shù)----------------')
? ? j = {'a': 1, 'b': 234}
? ? a = json.dumps(j)
? ? print(a, type(a))
? ? print('-------------測試indent=0參數(shù)----------------')
? ? a = json.dumps(j, indent=0)
? ? print(a, type(a))
? ? print('-------------測試indent=2參數(shù)----------------')
? ? a = json.dumps(j, indent=2)
? ? print(a, type(a))

? ? print('-------------測試separators參數(shù)----------------')
? ? a = json.dumps(j, separators=('[', ']'))
? ? print(a, type(a))

2.dump()

import json

if __name__ == '__main__':
? ? # 測試格式化非json格式數(shù)據(jù)
? ? fp = open('./json_dump_data', mode='w')
? ? print('-------------測試格式化非json格式數(shù)據(jù)----------------')
? ? a = json.dump(2.0, fp)
? ? fp.write('\n')
? ? a = json.dump(tuple(), fp)
? ? a = json.dump([], fp)
? ? fp.write('\n')

? ? # 測試格式化json格式數(shù)據(jù)
? ? j = {'a': 1, 'b': 6}
? ? a = json.dump(j, fp)

cat json_dump_data：

1和2中很多參數(shù)都是相同的，這里就不再詳述3.load()

import json

if __name__ == '__main__':
? ? j = open('./json_data', mode='r')
? ? # 測試默認(rèn)參數(shù)
? ? a = json.load(j)
? ? print('-------------測試默認(rèn)參數(shù)----------------')
? ? print(a)

? ? # 測試object_hook參數(shù)
? ? j = open('./json_data', mode='r')
? ? a = json.load(j, object_hook=lambda x: x.get('b'))
? ? print('-------------測試object_hook參數(shù)----------------')
? ? print(a)

? ? # 測試object_pairs_hook參數(shù)
? ? j = open('./json_data', mode='r')
? ? loads = json.load(j, object_pairs_hook=lambda x: print(type(x), type(x[2])))
? ? print('-------------測試object_pairs_hook參數(shù)----------------')
? ? print(loads)

? ? # 測試parse_constant參數(shù)
? ? j = open('./json_data', mode='r')
? ? loads = json.load(j, parse_constant=lambda x: 'not notification')
? ? print('-------------測試parse_constant參數(shù)----------------')
? ? print(loads)

? ? # 測試parse_int參數(shù)
? ? j = open('./json_data', mode='r')
? ? loads = json.load(j, parse_int=lambda x: 'cutomer int')
? ? print('-------------測試parse_int參數(shù)----------------')
? ? print(loads)

? ? # 測試parse_float參數(shù)
? ? j = open('./json_data', mode='r')
? ? loads = json.load(j, parse_float=lambda x: 'cutomer float')
? ? print('-------------測試parse_float參數(shù)----------------')
? ? print(loads)

注：
因為load方法的底層是調(diào)用了fp.read()，所以每一次重新調(diào)用load的時候都需要重新打開文件句柄。不然就會導(dǎo)致在第二次調(diào)用load方法的時候，就會因為fp.read()返回的是none就導(dǎo)致異常

4.loads()

import json

if __name__ == '__main__':
? ? j = '{"a":1,"b":2.0,"c":Infinity}'
? ? # 測試默認(rèn)參數(shù)
? ? a = json.loads(j)
? ? print('-------------測試默認(rèn)參數(shù)----------------')
? ? print(a)

? ? # 測試object_hook參數(shù)
? ? a = json.loads(j, object_hook=lambda x: x.get('b'))
? ? print('-------------測試object_hook參數(shù)----------------')
? ? print(a)

? ? # 測試object_pairs_hook參數(shù)
? ? loads = json.loads(j, object_pairs_hook=lambda x: print(type(x), type(x[2])))
? ? print('-------------測試object_pairs_hook參數(shù)----------------')
? ? print(loads)

? ? # 測試parse_constant參數(shù)
? ? loads = json.loads(j, parse_constant=lambda x: 'not notification')
? ? print('-------------測試parse_constant參數(shù)----------------')
? ? print(loads)

? ? # 測試parse_int參數(shù)
? ? loads = json.loads(j, parse_int=lambda x: 'cutomer int')
? ? print('-------------測試parse_int參數(shù)----------------')
? ? print(loads)

? ? # 測試parse_float參數(shù)
? ? loads = json.loads(j, parse_float=lambda x: 'cutomer float')
? ? print('-------------測試parse_float參數(shù)----------------')
? ? print(loads)