Day 41 41.1 Python中json模块的loadloads方法实战及参数详解

Python中json模块的load/loads方法实战及参数详解

【一】loads方法与load方法的异同

• 在Python中json是一个非常常用的模块，这个主要有4个方法：

  • json.dumps

  • json.dump

  • json.loads

  • json.load

• 这里主要分析讲解一下json的loads和load方法。

• 这两个方法中都是把其他类型的对象转为Python对象，这里先说明一下Python对象

  • Python对象包括：
    • 所有Python基本数据类型，列表，元组，字典，自己定义的类，等等等等
    • 当然不包括Python的字符串类型，把字符串或者文件流中的字符串转为字符串会报错的

文件流：

​ 像水流一样把一个大的文件分成一段一段的流过去就叫文件流

【1】不同点

• loads
  • 操作的是字符串
• load
  • 操作的是文件流

【2】相同点

• 除了第一个参数(要转换的对象)类型不同，其他所有的参数都相同
• 最终都是转换成Python对象

【3】案例

• 举例来说，除了要转换的对象，其他什么参数都不传：

# -*-coding: Utf-8 -*-
# @File : loads and load .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/5/21
import json

s = '{"name": "dream", "age": 18, "gender": "man"}'
# json.loads读取字符串并转为Python对象
print(f"json.loads将字符串转为Python对象的类型:>>>>type(json.loads(s)) = {type(json.loads(s))}")
print(f"json.loads将字符串转为Python对象的值:>>>>json.loads(s) = {json.loads(s)}")
# json.loads将字符串转为Python对象的类型:>>>>type(json.loads(s)) = <class 'dict'>
# json.loads将字符串转为Python对象的值:>>>>json.loads(s) = {'name': 'dream', 'age': 18, 'gender': 'man'}


# json.load读取文件并将文件内容转为Python对象
# 数据文件要s.json的内容 --> {"name": "wade", "age": 54, "gender": "man"}
with open('text.json', 'r') as f:
    s1 = json.load(f)
    print(f"json.load将文件内容转为Python对象的类型:>>>>type(json.load(f)) = {type(s1)}")
    print(f"json.load将文件内容转为Python对象的值:>>>>json.load(f) = {s1}")
    # json.load将文件内容转为Python对象的类型:>>>>type(json.load(f)) = <class 'dict'>
    # json.load将文件内容转为Python对象的值:>>>>json.load(f) = {'name': 'dream', 'age': 18, 'gender': 'man'}

【二】转化成Python对象

• 由于loads和load两个方法只是处理的数据源不同，其他的参数都是相同的，返回的结果类型也相同，故这是loads和load方法两个只说一个，

• 日常工作中最常见的就是把字符串通过json.loads转为字典

  • 其实json的loads方法不仅可以把字符串转为字典
  • 还可以转为任何Python对象。

• 比如说，转成python基本数据类型：

# -*-coding: Utf-8 -*-
# @File : 转换成Python对象 .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/5/21
import json

print(f'json.loads 将整数类型的字符串转为int类型:>>>> type(json.loads("123456"))) --> {type(json.loads("123456"))}')
print(f'json.loads 将浮点类型的字符串转为float类型:>>>> type(json.loads("123.456")) --> {type(json.loads("123.456"))}')
print('json.loads 将boolean类型的字符串转为bool类型:>>>> type(json.loads("true")) --> {type(json.loads("true"))}')
print('json.loads 将列表类型的字符串转为列表:>>>> type(json.loads(\'["a", "b", "c"]\')) --> {}'.format(type(json.loads('["a", "b", "c"]'))))
print('json.loads 将字典类型的字符串转为字典:>>>> type(json.loads(\'{"a": 1, "b": 1.2, "c": true, "d": "ddd"}\')) --> %s' % str(type(json.loads('{"a": 1, "b": 1.2, "c": true, "d": "ddd"}'))))


# json.loads 将整数类型的字符串转为int类型:>>>> type(json.loads("123456"))) --> <class 'int'>
# json.loads 将浮点类型的字符串转为float类型:>>>> type(json.loads("123.456")) --> <class 'float'>
# json.loads 将boolean类型的字符串转为bool类型:>>>> type(json.loads("true")) --> {type(json.loads("true"))}
# json.loads 将列表类型的字符串转为列表:>>>> type(json.loads('["a", "b", "c"]')) --> <class 'list'>
# json.loads 将字典类型的字符串转为字典:>>>> type(json.loads('{"a": 1, "b": 1.2, "c": true, "d": "ddd"}')) --> <class 'dict'>

• json模块会根据你的字符串自动转为最符合的数据类型
• 但是需要注意的是不能把转为字符串，否则会报json.decoder.JSONDecodeError错误:

json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

【三】json.load(s)的参数

• 我们先看下 json.loads 方法的签名：

def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
        parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
    """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON    # 把一个字符串反序列化为Python对象，这个字符串可以是str类型的，也可以是unicode类型的
    document) to a Python object.


    If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding    # 如果参数s是以ASCII编码的字符串，那么需要手动通过参数encoding指定编码方式，
    other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name         # 不是以ASCII编码的字符串，是不被允许的，你必须把它转为unicode
    must be specified. Encodings that are not ASCII based (such as UCS-2)
    are not allowed and should be decoded to ``unicode`` first.


    ``object_hook`` is an optional function that will be called with the        # object_hook参数是可选的，它会将(loads的)返回结果字典替换为你所指定的类型
    result of any object literal decode (a ``dict``). The return value of        # 这个功能可以用来实现自定义解码器，如JSON-RPC
    ``object_hook`` will be used instead of the ``dict``. This feature
    can be used to implement custom decoders (e.g. JSON-RPC class hinting).


    ``object_pairs_hook`` is an optional function that will be called with the    # object_pairs_hook参数是可选的，它会将结果以key-value列表的形式返回
    result of any object literal decoded with an ordered list of pairs.  The      # 形式如：[(k1, v1), (k2, v2), (k3, v3)]
    return value of ``object_pairs_hook`` will be used instead of the ``dict``.   # 如果object_hook和object_pairs_hook同时指定的话优先返回object_pairs_hook
    This feature can be used to implement custom decoders that rely on the
    order that the key and value pairs are decoded (for example,
    collections.OrderedDict will remember the order of insertion). If
    ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.


    ``parse_float``, if specified, will be called with the string                 # parse_float参数是可选的，它如果被指定的话，在解码json字符串的时候，
    of every JSON float to be decoded. By default this is equivalent to           # 符合float类型的字符串将被转为你所指定的，比如说你可以指定为decimal.Decimal
    float(num_str). This can be used to use another datatype or parser
    for JSON floats (e.g. decimal.Decimal).


    ``parse_int``, if specified, will be called with the string                   # parse_int参数是可选的，它如果被指定的话，在解码json字符串的时候，
    of every JSON int to be decoded. By default this is equivalent to             # 符合int类型的字符串将被转为你所指定的，比如说你可以指定为float
    int(num_str). This can be used to use another datatype or parser
    for JSON integers (e.g. float).


    ``parse_constant``, if specified, will be called with one of the              # parse_constant参数是可选的，它如果被指定的话，在解码json字符串的时候，
    following strings: -Infinity, Infinity, NaN.                                  # 如果出现以以下字符串: -Infinity, Infinity, NaN 那么指定的parse_constant方法将会被调用到
    This can be used to raise an exception if invalid JSON numbers
    are encountered.


    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``         # 你也可以用cls参数通过实现一个JSONDecoder的子类，来代替JSONDecoder,通过这个功能你可以自定义上面的那些parse_xxx参数,这里就不举例了
    kwarg; otherwise ``JSONDecoder`` is used.


    """

【1】s参数

• 把一个字符串反序列化为Python对象，这个字符串可以是str类型的，也可以是unicode类型的
• 如果参数s是以ASCII编码的字符串，那么需要手动通过参数encoding指定编码方式，不是以ASCII编码的字符串，是不被允许的，你必须把它转为unicode
• 对于loads方法来说，s是一个字符串，而对于load方法来说，是一个数据流文件

【2】object_hook参数

• object_hook参数是可选的，它会将(loads的)返回结果字典替换为你所指定的类型,这个功能可以用来实现自定义解码器，如JSON-RPC
• 这里先定义一个Person对象：

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def toJSON(self):
        return {
            "name": self.name,
            "age": self.age,
            "gender": self.gender
        }

    @staticmethod
    def parseJSON(dct):
        if isinstance(dct, dict):
            p = Person(dct["name"], int(dct['age']), dct['gender'])
            return p
        return dct

• 案例：

# -*-coding: Utf-8 -*-
# @File : 参数 .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/5/21

import json


class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def toJSON(self):
        return {
            "name": self.name,
            "age": self.age,
            "gender": self.gender
        }

    @staticmethod
    def parseJSON(dct):
        if isinstance(dct, dict):
            p = Person(dct["name"], int(dct['age']), dct['gender'])
            return p
        return dct


s = '{"name": "dream", "age": 18, "gender": "man"}'
# 测试json.loads方法的object_hook参数
p = json.loads(s, object_hook=Person.parseJSON)
print("json.loads 是否将字符串转为字典了: --> " + str(isinstance(p, dict)))
print("json.loads 是否将字符串转为Person对象了: --> " + str(isinstance(p, Person)))

# json.loads 是否将字符串转为字典了: --> False
# json.loads 是否将字符串转为Person对象了: --> True

【3】object_pairs_hook参数

• object_pairs_hook参数是可选的，它会将结果以key-value有序列表的形式返回
  • 形式如：
    • [(k1, v1), (k2, v2), (k3, v3)]
• 如果object_hook和object_pairs_hook同时指定的话优先返回object_pairs_hook

【4】parse_float参数

• parse_float参数是可选的，它如果被指定的话，在解码json字符串的时候，符合float类型的字符串将被转为你所指定的
• 比如说你可以指定为decimal.Decimal

【5】 parse_int参数

• parse_int参数是可选的，它如果被指定的话，在解码json字符串的时候
  • 符合int类型的字符串将被转为你所指定的
    • 比如说你可以指定为float

【6】parse_constant参数

• parse_constant参数是可选的，它如果被指定的话，在解码json字符串的时候
  • 如果出现以以下字符串:
  • -Infinity，Infinity，NaN
  • 那么指定的parse_constant方法将会被调用到

【7】 cls参数

• 通过官方文档的注释我们可以知道json.load(s)方法具体的实现是通过JSONCoder类实现的，
• 而cls参数是用于自定义一个JSONCoder的子类，用于替换JSONCoder类，
• 通过这个功能你可以自定义上面的那些parse_xxx参数，