s = '{"name": "wade", "age": 54, "gender": "man"}'
# json.loads讀取字符串并轉(zhuǎn)為Python對象
print("json.loads將字符串轉(zhuǎn)為Python對象: type(json.loads(s)) = {}".format(type(json.loads(s))))
print("json.loads將字符串轉(zhuǎn)為Python對象: json.loads(s) = {}".format(json.loads(s)))

# json.load讀取文件并將文件內(nèi)容轉(zhuǎn)為Python對象
# 數(shù)據(jù)文件要s.json的內(nèi)容 --> {"name": "wade", "age": 54, "gender": "man"}
with open('s.json', 'r') as f:
    s1 = json.load(f)
    print("json.load將文件內(nèi)容轉(zhuǎn)為Python對象: type(json.load(f)) = {}".format(type(s1)))
    print("json.load將文件內(nèi)容轉(zhuǎn)為Python對象: json.load(f) = {}".format(s1))

print('json.loads 將整數(shù)類型的字符串轉(zhuǎn)為int類型: type(json.loads("123456"))) --> {}'.format(type(json.loads("123456"))))
print('json.loads 將浮點類型的字符串轉(zhuǎn)為float類型: type(json.loads("123.456")) --> {}'.format(type(json.loads("123.456"))))
print('json.loads 將boolean類型的字符串轉(zhuǎn)為bool類型: type(json.loads("true")) --> {}'.format((type(json.loads("true")))))
print('json.loads 將列表類型的字符串轉(zhuǎn)為列表: type(json.loads(\'["a", "b", "c"]\')) --> {}'.format(type(json.loads('["a", "b", "c"]'))))
print('json.loads 將字典類型的字符串轉(zhuǎn)為字典: 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    # 如果參數(shù)s是以ASCII編碼的字符串，那么需要手動通過參數(shù)encoding指定編碼方式，
    other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name         # 不是以ASCII編碼的字符串，是不被允許的，你必須把它轉(zhuǎn)為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參數(shù)是可選的，它會將（loads的)返回結(jié)果字典替換為你所指定的類型
    result of any object literal decode (a ``dict``). The return value of        # 這個功能可以用來實現(xiàn)自定義解碼器，如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參數(shù)是可選的，它會將結(jié)果以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同時指定的話優(yōu)先返回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參數(shù)是可選的，它如果被指定的話，在解碼json字符串的時候，
    of every JSON float to be decoded. By default this is equivalent to           # 符合float類型的字符串將被轉(zhuǎn)為你所指定的，比如說你可以指定為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參數(shù)是可選的，它如果被指定的話，在解碼json字符串的時候，
    of every JSON int to be decoded. By default this is equivalent to             # 符合int類型的字符串將被轉(zhuǎn)為你所指定的，比如說你可以指定為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參數(shù)是可選的，它如果被指定的話，在解碼json字符串的時候，
    following strings: -Infinity, Infinity, NaN.                                  # 如果出現(xiàn)以以下字符串: -Infinity, Infinity, NaN 那么指定的parse_constant方法將會被調(diào)用到
    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參數(shù)通過實現(xiàn)一個JSONDecoder的子類，來代替JSONDecoder,通過這個功能你可以自定義上面的那些parse_xxx參數(shù),這里就不舉例了
    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參數(shù)
p = json.loads(s, object_hook=Person.parseJSON)
print("json.loads 是否將字符串轉(zhuǎn)為字典了: --> " + str(isinstance(p, dict)))
print("json.loads 是否將字符串轉(zhuǎn)為Person對象了: --> " + str(isinstance(p, Person)))

s = '{"name": "馬云", "age": 54, "gender": "man"}'
# 測試json.loads方法的object_pairs_hook參數(shù)
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,最終調(diào)用哪個參數(shù): --> " + str(type(p)))
print("json.loads 指定object_pairs_hook結(jié)果將會返回一個有序列表 --> {}".format(p))

# 測試json.loads方法的parse_float參數(shù)
print("-" * 30 + "> test parse_float <" + "-" * 30)
p = json.loads("123.456", parse_float=decimal.Decimal)
print("json.loads 通過parse_float參數(shù)將原本應(yīng)該轉(zhuǎn)為float類型的字符串轉(zhuǎn)為decimal類型: type(json.loads(\"123.456\", parse_float=decimal.Decimal)) --> " + str(type(p)))
print("")

# 測試json.loads方法的parse_int參數(shù)
print("-" * 30 + "> test parse_int <" + "-" * 30)
p = json.loads("123", parse_int=float)
print("json.loads 通過parse_int參數(shù)將原本應(yīng)該轉(zhuǎn)為int類型的字符串轉(zhuǎn)為float類型: type(json.loads(\"123\", parse_int=float)) --> " + str(type(p)))

def transform(s):
    """
    此方法作為參數(shù)傳給json.load(s)方法的parse_轉(zhuǎn)譯NAN, -Infinity,Infinity
    :param s:
    :return:
    """
    # NaN --> not a number
    if "NaN" == s:
        return "Not a Number"
    # 將負(fù)無窮大轉(zhuǎn)為一個非常小的數(shù)
    elif "-Infinity" == s:
        return -999999
    # 將正無窮大轉(zhuǎn)為一個非常大的數(shù)
    elif "Infinity" == s:
        return 999999
    else:
        return s

# 測試json.loads方法的parse_constant參數(shù)
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("")