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        # 這個功能可以用來實現(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參數是可選的，它會將結果以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參數是可選的，它如果被指定的話，在解碼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.                                  # 如果出現(xiàn)以以下字符串: -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參數通過實現(xiàn)一個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("")