JSON模块使用_json.dumps separators-优快云博客

本文链接：https://blog.youkuaiyun.com/cswhl/article/details/111730764

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。

JSON建构于两种结构：

“名称/值”对的集合（A collection of name/value pairs）
不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组（associative array）。
值的有序列表（An ordered list of values）
在大部分语言中，它被理解为数组（array）

这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。

对简单数据类型的encoding 和 decoding

import json
obj = [[1,2,3],123,123.123,'abc',{'key1':(1,2,3),'key2':(4,5,6)}] # 转换列表为JSON字符串
encodedjson = json.dumps(obj)
print(repr(obj))
print(encodedjson)
print(json.loads(encodedjson)) # loads方法返回了原始的对象，但是仍然发生了一些数据类型的转化

output:

[[1, 2, 3], 123, 123.123, 'abc', {'key1': (1, 2, 3), 'key2': (4, 5, 6)}]
[[1, 2, 3], 123, 123.123, "abc", {"key1": [1, 2, 3], "key2": [4, 5, 6]}]
[[1, 2, 3], 123, 123.123, 'abc', {'key1': [1, 2, 3], 'key2': [4, 5, 6]}]

简单类型通过encode之后跟其原始的repr()输出结果非常相似，但是有些数据类型进行了改变，例如上例中的元组则转换为了列表。在json的编码过程中，会存在从python原始类型向json类型的转化过程; 而解码时仍然会发生一些数据类型变化
具体的转化对照如下：

json.load()

原型:json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

object_hook
object_hook是可选函数，会被反序列后的dict调用(形式ocject_hook(dict))，其它返回的结果会取代dict作为json.loads()的返回结果。
指定object_hook后，该函数会取代JSONDecoder类或其子类的default()方法被调用
cls
用于指定自定义的JSONDecoder子类，用于对JSON字符串进行反序列化。没有指定时，默认使用JSONDecoder类。

对应JSONDecoder子类来说，如果指定json.JSONDecoder的object_hook： json.JSONDecoder.init(self, object_hook=function)
则将使用每个解码的JSON对象的结果来调用object_hook，其返回值取代dict作为返回结果

json.dumps的参数使用

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

cls:自定义JSONEncoder子类(一般会重写default()方法以序列化其他类型对象)；没有指定cls时，默认使用JSONEncoder类编码
default: 针对无法序列化的对象的调用函数。

其指定的函数会被obj调用,形如:default(obj)，通常应返回一个可序列化对象(如:dict)；JSONEncoder.encode将可序列化对象解码后作为json.dump()的返回值

指定default函数后，该函数会取代JSONencoder类或其子类的default()方法被调用，验证代码如下:

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person('{self.name}',{self.age})"
person = Person('ccc', 25)
def obj_to_dict(obj):
    print(f'call obj_to_dict')
    dd ={}
    dd['__class__'] = obj.__class__.__name__
    dd['__module__'] = obj.__module__
    dd.update(obj.__dict__)
    return dd

class MyEncoder(json.JSONEncoder):
    def default(self, obj):
        print(f"call MyEncoder's default")
        dd ={}
        dd['__class__'] = obj.__class__.__name__
        dd['__module__'] = obj.__module__
        dd.update(obj.__dict__)
        return dd

dump = json.dumps(person, cls=MyEncoder, default=obj_to_dict)
print(dump)
# output
'''
call obj_to_dict
{"__class__": "Person", "__module__": "__main__", "name": "ccc", "age": 25}
'''

sort_key - 为真时，字典的输出按key排序
indent - 指定序列化时每个元素的缩进(分行缩进)

data = {'b':789,'c':456,'a':123}
print(json.dumps(data, sort_keys=True, indent=4))

# output
'''
{
    "a": 123,
    "b": 789,
    "c": 456
}
'''

seperators：指定序列化时使用的分隔符，默认(’,’, ': '), 是(item_separator, key_separator)元组

data = {'b':789,'c':456,'a':123}
json.dumps(data, separators=(',', ':'))

#output
'''
'{"b":789,"c":456,"a":123}'
'''

skipkeys为True时，key不是基础类型(str, int, float, bool, None)就会跳过，而不会抛出TypeError

data = {'b':789,'c':456,(1,2):123}
print(json.dumps(data,skipkeys=True))
'''
{"b": 789, "c": 456}
'''

处理自己的数据类型

JSON模块也可以将自定义的数据类型、自定义对象转换为JSON字符串。
JSON.dumps并不能直接将自定义对象转化为JSON字符串，因为json不支持这样的自动化.
由于JSON的Object类和dict类相关联，所以应先将自定义对象转化为dict，然后再进行转化处理

如:将复数序列化为JSON格式字符串, 然后再反序列化

def df(obj): 
    if isinstance(obj, complex): 
        return {'__complex__': True, 'real': obj.real, 'imag': obj.imag}
    return json.JSONEncoder.default(obj) 

data = json.dumps(1+2j, default=df)
print(data)

def as_complex(dct):
    try:
        if dct['__complex__']:
            return complex(dct['real'], dct['imag'])
    except KeyError:
        pass
    return dct

print(json.loads(data, object_hook=as_complex))

# output
'''
{"__complex__": true, "real": 1.0, "imag": 2.0}
(1+2j)
'''

一个自定义的Person对象,定义在person.py模块中，如下:

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person('{self.name}',{self.age})"

将自定义对象序(如Person)列化为JSON格式的字符串，有两种方法可以使用

自定义default转化函数

default转化函数
如果指定了default，则其应该是针对无法序列化的对象调用的函数。default(object)应该返回一个JSON可编码版本的python数据类型(见转化表)，或者抛出TypeError。

import json
import person

def obj_to_dict(obj): # 将对象转为dict
    dd ={}
    dd['__class__'] = obj.__class__.__name__
    dd['__module__'] = obj.__module__
    dd.update(obj.__dict__)
    return dd
    
person = Person('ccc', 25)
print(obj_to_dict(person))  

def dict_to_obj(dd): # 将dict转为对象
    try:
        class_name = dd.pop('__class__')
        module_name = dd.pop('__module__')
        
        # 下两句是动态导入person.py模块并获取Person对象，如果已经person模块已经导入当然使用'cls = globals()[class_name]'更好了
        module = __import__(module_name, fromlist=[class_name]) 
        cls = getattr(module, class_name) # 获取person.Person类对象
        
        # Person类的实例化
        instan = cls(**dd)
    except KeyError:
        instan = dd
    
    return instan
    
dict_to_obj(obj_to_dict(person))

dump = json.dumps(person, default=obj_to_dict) # 使用obj_to_dict转化person对象为dict, 再将对应与person对象的dict序列化为JSON字符串
print(dump)

load = json.loads(dump, object_hook=dict_to_obj) # 将JSON字符串反序列为dict，调用dict_to_obj将dict转化为person对象
print(load)

#output
'''
{'__class__': 'Person', '__module__': '__main__', 'name': 'ccc', 'age': 25}
{"__class__": "Person", "__module__": "__main__", "name": "ccc", "age": 25}
Person('ccc',25)
'''

自定义JSON编码和解码子类

自定义继承JSONEncoder和JSONDecoder的子类, 用自定义的编码器和解码器进行编码(将py对象转为JSON序列)，解码(将JSON序列转为python对象)

import json
import person

class MyEncoder(json.JSONEncoder):
    '''自定义编码类，重写JSONEncoder的default方法'''
    def default(self, obj):  
        dd ={}
        dd['__class__'] = obj.__class__.__name__
        dd['__module__'] = obj.__module__
        dd.update(obj.__dict__)
        return dd
    
class MyDecoder(json.JSONDecoder):
    '''自定义解码类'''
    def __init__(self):
        super().__init__(object_hook=self.dict_to_obj) # 指定父类JSONDecoder的object_hook转化函数:转化dict为自定义的obj对象
    
    def dict_to_obj(self,dd):
        try:
            class_name = dd.pop('__class__')
            module_name = dd.pop('__module__')
            module = __import__(module_name, fromlist=[class_name])
            cls = getattr(module, class_name)
            instan = cls(**dd)
        except KeyError:
            instan = dd

        return instan

person = Person('ccc', 25)

dump = json.dumps(person, cls=MyEncoder)
print(dump)

# load = json.loads(dump, cls=MyDecoder, object_hook=dict_to_obj)  # 不能同时指定cls和object_hook，会出现冲突
load = json.loads(dump, cls=MyDecoder)
print(load)

参考

Introducing JSON