Python json模块load/loads方法

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

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"}'))))

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.

    """

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": "马云", "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)))

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

# 测试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("")

# 测试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)))

def transform(s):
    """
    此方法作为参数传给json.load(s)方法的parse_转译NAN, -Infinity,Infinity
    :param s:
    :return:
    """
    # NaN --> not a number
    if "NaN" == s:
        return "Not a Number"
    # 将负无穷大转为一个非常小的数
    elif "-Infinity" == s:
        return -999999
    # 将正无穷大转为一个非常大的数
    elif "Infinity" == s:
        return 999999
    else:
        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("")