Python json 中一直搞不清的 load、loads、dump、dumps、eval

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``, ``bytes`` or ``bytearray`` instance    containing a JSON document) to a Python object.
    ``object_hook`` is an optional function that will be called with the    result of any object literal decode (a ``dict``). The return value of    ``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    result of any object literal decoded with an ordered list of pairs.  The    return value of ``object_pairs_hook`` will be used instead of the ``dict``.    This feature can be used to implement custom decoders.  If ``object_hook``    is also defined, the ``object_pairs_hook`` takes priority.
    ``parse_float``, if specified, will be called with the string    of every JSON float to be decoded. By default this is equivalent to    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    of every JSON int to be decoded. By default this is equivalent to    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    following strings: -Infinity, Infinity, NaN.    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``    kwarg; otherwise ``JSONDecoder`` is used.
    The ``encoding`` argument is ignored and deprecated.    """

# -*- coding:utf-8 -*-
import json
json_str = '{"token":"dasgdhasdas", "status":0, "data":{"name":"admin", "password":123456}, "author":null}'
json_dict = json.loads(json_str)
print("====转之前====")print("type(json_str)", type(json_str))print(json_str)print("====转之后====")print("type(json_dict)", type(json_dict))print(json_dict)

# -*- coding:utf-8 -*-
import json
json_str = '{"token":"dasgdhasdas", "status":0, "data":{"name":"admin", "password":123456}, "author":null}'
json_dict = json.loads(json_str)
print("====转之前====")print("type(json_str)", type(json_str))print(json_str)print("====转之后====")print("type(json_dict)", type(json_dict))print(json_dict)
json_eval = eval(json_str)

def load(fp, *, cls=None, object_hook=None, parse_float=None,        parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):    """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing    a JSON document) to a Python object.
    ``object_hook`` is an optional function that will be called with the    result of any object literal decode (a ``dict``). The return value of    ``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    result of any object literal decoded with an ordered list of pairs.  The    return value of ``object_pairs_hook`` will be used instead of the ``dict``.    This feature can be used to implement custom decoders.  If ``object_hook``    is also defined, the ``object_pairs_hook`` takes priority.
    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``    kwarg; otherwise ``JSONDecoder`` is used.    """    return loads(fp.read(),        cls=cls, object_hook=object_hook,        parse_float=parse_float, parse_int=parse_int,        parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)

# -*- coding:utf-8 -*-import json
# json_str = '{"token":"dasgdhasdas", "status":0, "data":{"name":"admin", "password":123456}, "author":null}'# 文件中内容和json_str是一样的with open("file_str.txt", mode="r", encoding="utf-8") as file:    json_dict = json.load(file)
print("====转之前====")print("type(file", type(file))print(file)print("====转之后====")print("type(json_dict)", type(json_dict))print(json_dict)

def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,        allow_nan=True, cls=None, indent=None, separators=None,        default=None, sort_keys=False, **kw):    """Serialize ``obj`` to a JSON formatted ``str``.
    If ``skipkeys`` is true then ``dict`` keys that are not basic types    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped    instead of raising a ``TypeError``.
    If ``ensure_ascii`` is false, then the return value can contain non-ASCII    characters if they appear in strings contained in ``obj``. Otherwise, all    such characters are escaped in JSON strings.
    If ``check_circular`` is false, then the circular reference check    for container types will be skipped and a circular reference will    result in an ``OverflowError`` (or worse).
    If ``allow_nan`` is false, then it will be a ``ValueError`` to    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in    strict compliance of the JSON specification, instead of using the    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
    If ``indent`` is a non-negative integer, then JSON array elements and    object members will be pretty-printed with that indent level. An indent    level of 0 will only insert newlines. ``None`` is the most compact    representation.
    If specified, ``separators`` should be an ``(item_separator, key_separator)``    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,    you should specify ``(',', ':')`` to eliminate whitespace.
    ``default(obj)`` is a function that should return a serializable version    of obj or raise TypeError. The default simply raises TypeError.
    If *sort_keys* is true (default: ``False``), then the output of    dictionaries will be sorted by key.
    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the    ``.default()`` method to serialize additional types), specify it with    the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.
    """

# -*- coding:utf-8 -*-
import json
json_dic = {"token":"dasgdhasdas", "status":0, "data":{"name":"隔壁老王", "password":123456}, "author":None}json_str = json.dumps(json_dic)json_str_str = str(json_dic)
print("====转之前====")print("type(json_dic)", type(json_dic))print(json_dic)
print("====转之后====")print("type(json_str)", type(json_str))print(json_str)print("====使用str====")print("type(json_str_str)", type(json_str_str))print(json_str_str)

# -*- coding:utf-8 -*-
import json
json_dic = {"token":"dasgdhasdas", "status":0, "data":{"name":"隔壁老王", "password":123456}, "author":None}json_str = json.dumps(json_dic)json_str_ensure_ascii = json.dumps(json_dic, ensure_ascii=False)json_str_str = str(json_dic)
print("====转之前====")print("type(json_dic)", type(json_dic))print(json_dic)
print("====转之后====")print("type(json_str)", type(json_str))print("type(json_str_ensure_ascii)", type(json_str_ensure_ascii))print(json_str_ensure_ascii)print(json_str)print("====使用str====")print("type(json_str_str)", type(json_str_str))print(json_str_str)

在这里插入代码片def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,        allow_nan=True, cls=None, indent=None, separators=None,        default=None, sort_keys=False, **kw):    """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a    ``.write()``-supporting file-like object).
    If ``skipkeys`` is true then ``dict`` keys that are not basic types    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped    instead of raising a ``TypeError``.
    If ``ensure_ascii`` is false, then the strings written to ``fp`` can    contain non-ASCII characters if they appear in strings contained in    ``obj``. Otherwise, all such characters are escaped in JSON strings.
    If ``check_circular`` is false, then the circular reference check    for container types will be skipped and a circular reference will    result in an ``OverflowError`` (or worse).
    If ``allow_nan`` is false, then it will be a ``ValueError`` to    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)    in strict compliance of the JSON specification, instead of using the    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
    If ``indent`` is a non-negative integer, then JSON array elements and    object members will be pretty-printed with that indent level. An indent    level of 0 will only insert newlines. ``None`` is the most compact    representation.
    If specified, ``separators`` should be an ``(item_separator, key_separator)``    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,    you should specify ``(',', ':')`` to eliminate whitespace.
    ``default(obj)`` is a function that should return a serializable version    of obj or raise TypeError. The default simply raises TypeError.
    If *sort_keys* is true (default: ``False``), then the output of    dictionaries will be sorted by key.
    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the    ``.default()`` method to serialize additional types), specify it with    the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.
    """

# -*- coding:utf-8 -*-
import json
json_dic = {"token":"dasgdhasdas", "status":0, "data":{"name":"隔壁老王", "password":123456}, "author":None}with open("file.txt", mode="a", encoding="utf-8") as file:    json.dump(json_dic, file, ensure_ascii=False, indent=2)

def eval(*args, **kwargs): # real signature unknown    """    Evaluate the given source in the context of globals and locals.        The source may be a string representing a Python expression    or a code object as returned by compile().    The globals must be a dictionary and locals can be any mapping,    defaulting to the current globals and locals.    If only globals is given, locals defaults to it.    """    pass

# -*- coding:utf-8 -*-
import json
json_str = '{"token":"dasgdhasdas", "status":0, "data":{"name":"admin","password":123456}}'json_eval = eval(json_str)print("====转之前====")print("type(json_str)", type(json_str))print(json_str)print("====转之后====")print("type(json_eval )", type(json_eval ))print(json_eval)