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

文章目录

前言
正文
- 1. loads方法与load方法的异同
- - 1.1不相同点：
  - 1.2 相同点
  - 1.3 例子
- 2. 转换成Python对象
- 3. json.load(s)的参数
- - 3.1 s参数
  - 3.2 object_hook参数
  - 3.3 object_pairs_hook参数
  - 3.4 parse_float参数
  - 3.5 parse_int参数
  - 3.6 parse_constant参数
  - 3.7 cls参数

前言

适用于python2和python3

正文

1. loads方法与load方法的异同

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

json.dumps
json.dump
json.loads
json.load

这里主要分析讲解一下json的loads和load方法。
这两个方法中都是把其他类型的对象转为Python对象，这里先说明一下Python对象，
Python对象包括：
所有Python基本数据类型，列表，元组，字典，自己定义的类，等等等等，当然不包括Python的字符串类型，把字符串或者文件鎏中的字符串转为字符串会报错的

1.1不相同点：

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

1.2 相同点

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

1.3 例子

先来一个例子，除了要转换的对象，其他什么参数都不传：

s = '{"name": "wade", "age": 54, "gender": "man"}'
# json.loads读取字符串并转为Python对象
print("json.loads将字符串转为Python对象: type(json.loads(s)) = {}".format(type(json.loads(s))))
print("json.loads将字符串转为Python对象: json.loads(s) = {}".format(json.loads(s)))# json.load读取文件并将文件内容转为Python对象
# 数据文件要s.json的内容 --> {"name": "wade", "age": 54, "gender": "man"}
with open('s.json', 'r') as f:s1 = json.load(f)print("json.load将文件内容转为Python对象: type(json.load(f)) = {}".format(type(s1)))print("json.load将文件内容转为Python对象: json.load(f) = {}".format(s1))

2. 转换成Python对象

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

日常工作中最常见的就是把字符串通过json.loads转为字典，其实json的loads方法不仅可以把字符串转为字典，还可以转为任何Python对象。
比如说，转成python基本数据类型：

print('json.loads 将整数类型的字符串转为int类型: type(json.loads("123456"))) --> {}'.format(type(json.loads("123456"))))
print('json.loads 将浮点类型的字符串转为float类型: type(json.loads("123.456")) --> {}'.format(type(json.loads("123.456"))))
print('json.loads 将boolean类型的字符串转为bool类型: type(json.loads("true")) --> {}'.format((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模块会根据你的字符串自动转为最符合的数据类型，
但是需要注意的是不能把转为字符串，否则会报json.decoder.JSONDecodeError错误:

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

3. 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编码的字符串，是不被允许的，你必须把它转为unicodemust 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 featurecan 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_hookThis feature can be used to implement custom decoders that rely on theorder 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.Decimalfloat(num_str). This can be used to use another datatype or parserfor 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类型的字符串将被转为你所指定的，比如说你可以指定为floatint(num_str). This can be used to use another datatype or parserfor 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 numbersare encountered.To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``         # 你也可以用cls参数通过实现一个JSONDecoder的子类，来代替JSONDecoder,通过这个功能你可以自定义上面的那些parse_xxx参数,这里就不举例了kwarg; otherwise ``JSONDecoder`` is used."""

以下参数说明是根据官方文档翻译的

3.1 s参数

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

对于loads方法来说，s是一个字符串，而对于load方法来说，是一个数据流文件

3.2 object_hook参数

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

class Person:def __init__(self, name, age, gender):self.name = nameself.age = ageself.gender = genderdef toJSON(self):return {"name": self.name,"age": self.age,"gender": self.gender}@staticmethoddef parseJSON(dct):if isinstance(dct, dict):p = Person(dct["name"], int(dct['age']), dct['gender'])return preturn dct

OK，试下object_hook参数吧：

s = '{"name": "马云", "age": 54, "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)))

3.3 object_pairs_hook参数

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

s = '{"name": "马云", "age": 54, "gender": "man"}'
# 测试json.loads方法的object_pairs_hook参数
print("-" * 30 + "> test object_pairs_hook <" + "-" * 30)
p = json.loads(s, object_hook=Person.parseJSON, object_pairs_hook=collections.OrderedDict)
# p = json.loads(s, object_hook=Person.parseJSON, object_pairs_hook=Person.parseJSON)
print("json.loads 测试同时指定object_hook和object_pairs_hook,最终调用哪个参数: --> " + str(type(p)))
print("json.loads 指定object_pairs_hook结果将会返回一个有序列表 --> {}".format(p))

3.4 parse_float参数

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

# 测试json.loads方法的parse_float参数
print("-" * 30 + "> test parse_float <" + "-" * 30)
p = json.loads("123.456", parse_float=decimal.Decimal)
print("json.loads 通过parse_float参数将原本应该转为float类型的字符串转为decimal类型: type(json.loads(\"123.456\", parse_float=decimal.Decimal)) --> " + str(type(p)))
print("")

3.5 parse_int参数

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

# 测试json.loads方法的parse_int参数
print("-" * 30 + "> test parse_int <" + "-" * 30)
p = json.loads("123", parse_int=float)
print("json.loads 通过parse_int参数将原本应该转为int类型的字符串转为float类型: type(json.loads(\"123\", parse_int=float)) --> " + str(type(p)))

3.6 parse_constant参数

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

def transform(s):"""此方法作为参数传给json.load(s)方法的parse_转译NAN, -Infinity,Infinity:param s::return:"""# NaN --> not a numberif "NaN" == s:return "Not a Number"# 将负无穷大转为一个非常小的数elif "-Infinity" == s:return -999999# 将正无穷大转为一个非常大的数elif "Infinity" == s:return 999999else:return s# 测试json.loads方法的parse_constant参数
print("-" * 30 + "> test parse_constant <" + "-" * 30)
print("json.loads Infinity: --> " + str(json.loads('Infinity')))
print("json.loads parse_constant convert Infinity: --> " + str(json.loads('Infinity', parse_constant=transform_constant)))print("json.loads -Infinity: --> " + str(json.loads('-Infinity')))
print("json.loads parse_constant convert -Infinity: --> " + str(json.loads('-Infinity', parse_constant=transform_constant)))print("json.loads NaN: --> " + str(json.loads('NaN')))
print("json.loads parse_constant convert NaN : --> " + str(json.loads('NaN', parse_constant=transform_constant)))
print("")

3.7 cls参数

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