python之json模块常用方法介绍

一：概述

在python中，json模块可以实现json数据的序列化和反序列化
序列化：将可存放在内存中的python 对象转换成可物理存储和传递的形式
实现方法：load() loads()
反序列化：将可物理存储和传递的json数据形式转换为在内存中表示的python对象
实现方法：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转换成物理表现形式fp流。其中fp的.write()可以支持写入类文件中
2. 如果skipkeys是true，那么在处理json对象的时候，仅支持 (str, int, float, bool, None) 这些基本类型的key，如果有非基本类型，就会抛出TypeError异常；
   如果值为false，那么对于非基本类型，则会抛出TypeError；
   默认值为false
3. 如果ensure_ascii是true，那么obj中字符在写入fp的时候，非ascii字符会被进行转义；
   如果值为false，那么对于这些非ascii字符不会进行转义，会原样写入；
   默认值为true
4. 如果check_circular是false，那么遇到container类型（list，dict，自定义编码类型）的时候，不会循环引用检查，一旦是循环引用，结果就是OverflowError；
   如果值为true，那么会对container类型进行循环引用检查，检查失败会 raise ValueError(“Circular reference detected”)；
   默认值是true
5. 如果allow_nan是false，严格遵守json的规范，对于序列化一些超出float范围的值（nan, inf, -inf）的时候，会抛出ValueError；
   如果值为true，那么超过float范围的值将会使用在JavaScript中的等效值(NaN, Infinity, -Infinity)；
   默认值为true
6. 如果indent是一个non-negative （正）整数，那么json中的数组元素和对象元素都将会使用indent单位缩进格式来进行输出；
   值为0的时候，就只会插入一个换行符；
   值为None的时候，会输出最紧凑的格式
7. separators的指定是以元组(item_separator, key_separator)的方式；
   如果indent=‘None’ 那么该选项的默认值为(', ', ': ')，否则该选项的默认值为(',', ': ')；
   如果想要紧凑的json表达，那么应该使用(',', ': ')来去除空格
8. default(obj)是一个函数，主要是针对于那些无法被直接序列化的对象。该参数可以提供一个默认的序列化版本，否则就会抛出一个TypeError。默认是抛出TypeError
9. 如果sort_keys是true，那么输出的时候会根据key进行排序，默认值是false
   可以指定一个JSONEncoder的子类，来序列化其他的类型，可以通过cls或者是JSONEncoder参数来指定

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

1. 把obj序列化成一个json格式的字符串，并返回该字符串
   支持的python内置可进行json序列化的类型有(str, int, float, bool, None，list，tuple，dict)
   如果无法序列化的类型，会抛出TypeError
   
2. 其他参数同上解释

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. 把物理表现形式fp流（fp.read()的返回需要是一个json格式）反序列化成一个python对象
2. object_hook是一个可选的函数，主要用来对直接反序列化之后的结果进行二次加工；
   object_hook的参数只有一个，是dict，该dict也是反序列化的直接结果；
   object_hook的返回值为load方法的返回值 ；
   这个功能一般是用来自定义解码器，例如JSON-RPC
3. object_pairs_hook是一个可选的函数，主要用来对直接反序列化之后的结果进行二次加工；
   object_pairs_hook的参数只有一个，是list(tuple)，该list(tuple)也是反序列化的直接结果；
   object_pairs_hook的返回值为load方法的返回值 ；
   这个功能一般是用来自定义解码器，例如JSON-RPC;
   在同时指定了object_hook和object_pairs_hook的时候，object_pairs_hook的优先级高于object_hook
   
4. cls的关键字参数，支持使用自定义的JSONDecoder的子类；
   如果不指定，默认使用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进行解码的时候调用；
   默认情况下等价于 float(num_str)；
   也可以使用其他的数据类型，如(e.g. decimal.Decimal)
   
5. parse_int 如果定义了，那么会在对json字符串中的每一个float进行解码的时候调用；
   默认情况下，等价于 int(num_str)；
   也可使用其他针对于json中的integer的datatype或者是parser
   
6. parse_constant 如果定义了，那么在碰到-Infinity, Infinity, NaN.这些的时候会被调用；
   如果遇到无效的json符号，会抛出异常

三：代码实战

1.dumps()

import json

if __name__ == '__main__':
    # 测试格式化非json格式数据
    print('-------------测试格式化非json格式数据----------------')
    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格式数据
    print('-------------测试格式化json格式数据----------------')
    j = {'a': 1, 'b': 6}
    a = json.dumps(j)
    print(a, type(a))
    # 测试skipkeys参数
    print('-------------测试skipkeys参数----------------')
    j = {'a': 1, tuple(): 6}
    a = json.dumps(j, skipkeys=True)
    print(a, type(a))

    # 测试indent参数
    print('-------------测试indent默认参数----------------')
    j = {'a': 1, 'b': 234}
    a = json.dumps(j)
    print(a, type(a))
    print('-------------测试indent=0参数----------------')
    a = json.dumps(j, indent=0)
    print(a, type(a))
    print('-------------测试indent=2参数----------------')
    a = json.dumps(j, indent=2)
    print(a, type(a))

    print('-------------测试separators参数----------------')
    a = json.dumps(j, separators=('[', ']'))
    print(a, type(a))

2.dump()

import json

if __name__ == '__main__':
    # 测试格式化非json格式数据
    fp = open('./json_dump_data', mode='w')
    print('-------------测试格式化非json格式数据----------------')
    a = json.dump(2.0, fp)
    fp.write('\n')
    a = json.dump(tuple(), fp)
    a = json.dump([], fp)
    fp.write('\n')

    # 测试格式化json格式数据
    j = {'a': 1, 'b': 6}
    a = json.dump(j, fp)

cat json_dump_data

1和2中很多参数都是相同的，这里就不再详述

3.load()

import json

if __name__ == '__main__':
    j = open('./json_data', mode='r')
    # 测试默认参数
    a = json.load(j)
    print('-------------测试默认参数----------------')
    print(a)

    # 测试object_hook参数
    j = open('./json_data', mode='r')
    a = json.load(j, object_hook=lambda x: x.get('b'))
    print('-------------测试object_hook参数----------------')
    print(a)

    # 测试object_pairs_hook参数
    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参数----------------')
    print(loads)

    # 测试parse_constant参数
    j = open('./json_data', mode='r')
    loads = json.load(j, parse_constant=lambda x: 'not notification')
    print('-------------测试parse_constant参数----------------')
    print(loads)

    # 测试parse_int参数
    j = open('./json_data', mode='r')
    loads = json.load(j, parse_int=lambda x: 'cutomer int')
    print('-------------测试parse_int参数----------------')
    print(loads)

    # 测试parse_float参数
    j = open('./json_data', mode='r')
    loads = json.load(j, parse_float=lambda x: 'cutomer float')
    print('-------------测试parse_float参数----------------')
    print(loads)

注：
因为load方法的底层是调用了fp.read()，所以每一次重新调用load的时候都需要重新打开文件句柄。不然就会导致在第二次调用load方法的时候，就会因为fp.read()返回的是none就导致异常

4.loads()

import json

if __name__ == '__main__':
    j = '{"a":1,"b":2.0,"c":Infinity}'
    # 测试默认参数
    a = json.loads(j)
    print('-------------测试默认参数----------------')
    print(a)

    # 测试object_hook参数
    a = json.loads(j, object_hook=lambda x: x.get('b'))
    print('-------------测试object_hook参数----------------')
    print(a)

    # 测试object_pairs_hook参数
    loads = json.loads(j, object_pairs_hook=lambda x: print(type(x), type(x[2])))
    print('-------------测试object_pairs_hook参数----------------')
    print(loads)

    # 测试parse_constant参数
    loads = json.loads(j, parse_constant=lambda x: 'not notification')
    print('-------------测试parse_constant参数----------------')
    print(loads)

    # 测试parse_int参数
    loads = json.loads(j, parse_int=lambda x: 'cutomer int')
    print('-------------测试parse_int参数----------------')
    print(loads)

    # 测试parse_float参数
    loads = json.loads(j, parse_float=lambda x: 'cutomer float')
    print('-------------测试parse_float参数----------------')
    print(loads)