Python | import json模块详解

json是Python内置的一个用于处理JSON数据的模块。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于Web应用程序之间的数据传输。

json模块提供了四个主要的方法：

json.dumps() - 将Python对象转换为JSON格式的字符串。
json.loads() - 将JSON格式的字符串转换为Python对象。
json.dump() - 将Python对象转换为JSON格式的字符串并写入文件。
json.load() - 从文件中读取JSON格式的字符串并将其转换为Python对象。

json.dumps()

作用：将Python对象转换为JSON格式的字符串。

json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False)

obj：需要转换为JSON格式的Python对象。
skipkeys：如果为True，则跳过那些包含非字符串键的字典项，否则会引发TypeError，默认为False。
ensure_ascii：如果为True，则所有非ASCII字符都将被转义为Unicode转义序列，否则就像原样输出，默认为True。
check_circular：如果为True，则检查循环引用，否则会引发ValueError，默认为True。
allow_nan：如果为True，则允许NaN、Infinity和-Infinity等非有限数的存在，否则会引发ValueError，默认为True。
cls：用于自定义JSON编码器的类。
indent：为生成的JSON格式字符串设置缩进格式，可以是整数或字符串类型，默认为None。
separators：用于指定分隔符，可以包含以下两个字符的任意组合：',', ': '，默认为(',', ': ').
default：用于指定一个自定义函数，用于将非JSON类型的数据转换为JSON可序列化的对象。
sort_keys：如果为True，则按照字典键的升序排列输出，否则按照插入顺序输出，默认为False。

这些参数的详细说明：

obj参数：需要转换为JSON格式的Python对象。
skipkeys参数：如果为True，则跳过那些包含非字符串键的字典项，否则会引发TypeError，默认为False。
ensure_ascii参数：如果为True，则所有非ASCII字符都将被转义为Unicode转义序列（比如"\uXXXX"），否则就像原样输出，默认为True。
check_circular参数：如果为True，则检查循环引用，否则会引发ValueError，默认为True。
allow_nan参数：如果为True，则允许NaN、Infinity和-Infinity等非有限数的存在，否则会引发ValueError，默认为True。
cls参数：用于自定义JSON编码器的类。如果指定了该参数，则json模块将使用指定的编码器类来编码Python对象，默认为None。
indent参数：为生成的JSON格式字符串设置缩进格式，可以是整数或字符串类型。如果指定为整数，则表示缩进的空格数；如果指定为字符串类型，则该字符串将作为缩进符号。如果不指定该参数，则不进行缩进，默认为None。
separators参数：用于指定分隔符，可以包含以下两个字符的任意组合：','（用于分隔各个元素）和': '（用于分隔键和值）。默认为(',', ': ')。
default参数：用于指定一个自定义函数，用于将非JSON类型的数据转换为JSON可序列化的对象。如果指定了该参数，则在编码Python对象时，json模块会调用该函数对非JSON类型的数据进行转换，默认为None。
sort_keys参数：如果为True，则按照字典键的升序排列输出，否则按照插入顺序输出，默认为False。

例子：

json.dumps()方法用于将Python对象转换为JSON格式的字符串。假设我们有一个Python字典对象，内容如下：

data = {
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "languages": ["English", "Spanish", "French"],
    "isMarried": True,
    "education": {
        "degree": "Master's Degree",
        "school": "New York University"
    }
}

我们可以使用json.dumps()方法将该Python字典对象转换为JSON格式的字符串，示例代码如下：

import json

# 使用json.dumps()方法将Python字典对象转换为JSON格式的字符串
json_str = json.dumps(data)

# 输出转换后的JSON格式的字符串
print(json_str)

运行上述代码，输出结果如下：

{
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "languages": ["English", "Spanish", "French"],
    "isMarried": true,
    "education": {
        "degree": "Master's Degree",
        "school": "New York University"
    }
}

可以看到，使用json.dumps()方法将Python字典对象转换为了JSON格式的字符串，并输出了该字符串。

json.loads()

作用：将JSON格式的字符串转换为Python对象。

json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

s：需要转换的JSON格式的字符串。
cls：用于自定义JSON解码器的类。
object_hook：用于自定义对象的解码函数。
parse_float：用于自定义浮点数解码的函数。
parse_int：用于自定义整数解码的函数。
parse_constant：用于自定义常量解码的函数。
object_pairs_hook：用于自定义对象解码的函数。
**kw：其他关键字参数。

这些参数的详细说明：

cls参数：该参数接受一个自定义的解码器类。如果指定了该参数，则json模块将使用指定的解码器类来解码JSON格式的字符串。该类必须是JSONDecoder的子类，它可以重载decode()方法来定制解码方式。如果未指定该参数，则默认使用JSONDecoder。
object_hook参数：该参数接受一个可调用对象，用于自定义Python对象的解码方式。当解码器解码JSON格式的字符串时，它会遇到一个JSON对象（即一个键值对），并将其转换为Python字典对象。如果指定了该参数，则解码器会将Python字典对象传递给该可调用对象，以便用户可以自定义它的解码方式。
parse_float参数：该参数接受一个可调用对象，用于自定义浮点数的解码方式。如果指定了该参数，则解码器会将JSON格式的浮点数转换为Python浮点数，然后将其传递给该可调用对象，以便用户可以自定义它的解码方式。
parse_int参数：该参数接受一个可调用对象，用于自定义整数的解码方式。如果指定了该参数，则解码器会将JSON格式的整数转换为Python整数，然后将其传递给该可调用对象，以便用户可以自定义它的解码方式。
parse_constant参数：该参数接受一个可调用对象，用于自定义常量的解码方式。如果指定了该参数，则解码器会将JSON格式的常量（即true、false和null）转换为Python对象，然后将其传递给该可调用对象，以便用户可以自定义它的解码方式。
object_pairs_hook参数：该参数接受一个可调用对象，用于自定义Python对象的解码方式。当解码器解码JSON格式的字符串时，它会遇到一个JSON对象（即一个键值对），并将其转换为Python元组对象。如果指定了该参数，则解码器会将Python元组对象传递给该可调用对象，以便用户可以自定义它的解码方式。
**kw参数：该参数用于接收其他关键字参数，如encoding（指定编码方式）、parse_float（指定浮点数格式）等。

例子：

json.loads()方法用于将JSON格式的字符串转换为Python对象。假设我们有一个JSON格式的字符串，内容如下：

{
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "languages": ["English", "Spanish", "French"],
    "isMarried": true,
    "education": {
        "degree": "Master's Degree",
        "school": "New York University"
    }
}

我们可以使用json.loads()方法将该JSON格式的字符串转换为Python对象，示例代码如下：

import json

# 定义JSON格式的字符串
json_str = '''
{
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "languages": ["English", "Spanish", "French"],
    "isMarried": true,
    "education": {
        "degree": "Master's Degree",
        "school": "New York University"
    }
}
'''

# 使用json.loads()方法将JSON格式的字符串转换为Python对象
data = json.loads(json_str)

# 输出转换后的Python对象
print(data)

运行上述代码，输出结果如下：

{
    'name': 'John Smith',
    'age': 30,
    'city': 'New York',
    'languages': ['English', 'Spanish', 'French'],
    'isMarried': True,
    'education': {
        'degree': "Master's Degree",
        'school': 'New York University'
    }
}

可以看到，使用json.loads()方法将JSON格式的字符串转换为了一个Python字典对象，并输出了该对象。

json.dump()

作用：将Python对象转换为JSON格式的字符串并写入文件。

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

obj：需要转换的Python对象。
fp：文件对象，用于写入JSON格式的字符串。
skipkeys：如果为True，则会跳过不能被JSON序列化的键值对。
ensure_ascii：如果为True（默认值），则所有非ASCII字符都将被转义为\uXXXX序列；如果为False，则保留原样。
check_circular：如果为True（默认值），则检查循环引用；如果为False，则不检查。
allow_nan：如果为True（默认值），则可以序列化NaN, Infinity和-Infinity；如果为False，则会抛出ValueError错误。
cls：用于自定义JSON编码器的类。
indent：用于控制缩进的空白字符串，可以是整数或字符串。
separators：用于指定项之间的分隔符，可以是一个元组。
default：用于自定义对象的编码函数。
sort_keys：如果为True，则按键的字母顺序排序输出。
**kw：其他关键字参数。

这些参数的详细说明：

obj参数：需要转换的Python对象，可以是字典、列表、元组等可序列化的对象。
fp参数：文件对象，用于写入JSON格式的字符串，可以是打开的文件对象或者支持文件操作的对象。
skipkeys参数：如果为True，则会跳过不能被JSON序列化的键值对，默认为False。
ensure_ascii参数：如果为True（默认值），则所有非ASCII字符都将被转义为\uXXXX序列；如果为False，则保留原样。
check_circular参数：如果为True（默认值），则检查循环引用；如果为False，则不检查。
allow_nan参数：如果为True（默认值），则可以序列化NaN, Infinity和-Infinity；如果为False，则会抛出ValueError错误。
cls参数：用于自定义JSON编码器的类。如果指定了该参数，则json模块将使用指定的编码器类来编码Python对象，默认为None。
indent参数：用于控制缩进的空白字符串，可以是整数或字符串。如果是整数，则表示缩进的空格数；如果是字符串，则表示缩进的字符，默认为None，表示不缩进。
separators参数：用于指定项之间的分隔符，可以是一个元组。该元组包含两个字符串，第一个字符串表示项之间的分隔符，第二个字符串表示键值对之间的分隔符，默认为(',', '😂。
default参数：用于自定义对象的编码函数。如果指定了该参数，则json模块在序列化对象时，会调用该函数对对象进行编码，默认为None。
sort_keys参数：如果为True，则按键的字母顺序排序输出，默认为False。
**kw参数：其他关键字参数，如encoding（指定编码方式）、allow_nan（是否允许NaN, Infinity和-Infinity）等。

例子：

设我们有一个Python字典对象，内容如下：

data = {
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "languages": ["English", "Spanish", "French"],
    "isMarried": True,
    "education": {
        "degree": "Master's Degree",
        "school": "New York University"
    }
}

我们可以使用json.dump()方法将该Python字典对象转换为JSON格式的字符串，并将其写入到文件中，示例代码如下：

import json

# 将Python字典对象转换为JSON格式的字符串
json_str = json.dumps(data)

# 将JSON格式的字符串写入文件
with open('data.json', 'w') as f:
    json.dump(data, f)

运行上述代码后，会在当前目录下生成一个名为data.json的文件，其内容为：

{
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "languages": ["English", "Spanish", "French"],
    "isMarried": true,
    "education": {
        "degree": "Master's Degree",
        "school": "New York University"
    }
}

可以看到，使用json.dump()方法将Python字典对象转换为了JSON格式的字符串，并将其写入到了文件中。

json.load()

作用：从文件中读取JSON格式的字符串并将其转换为Python对象。

json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

fp：文件对象，用于读取JSON格式的字符串。
cls：用于自定义JSON解码器的类。
object_hook：用于自定义对象的解码函数。
parse_float：用于自定义浮点数解码的函数。
parse_int：用于自定义整数解码的函数。
parse_constant：用于自定义常量解码的函数。
object_pairs_hook：用于自定义对象解码的函数。
**kw：其他关键字参数。

这些参数的详细说明：

fp参数：文件对象，用于读取JSON格式的字符串。
cls参数：用于自定义JSON解码器的类。如果指定了该参数，则json模块将使用指定的解码器类来解码JSON格式的字符串，默认为None。
object_hook参数：用于自定义对象的解码函数。如果指定了该参数，则json模块在解码JSON格式的字符串时，会调用该函数对Python字典对象进行解码，默认为None。
parse_float参数：用于自定义浮点数解码的函数。如果指定了该参数，则json模块在解码JSON格式的字符串时，会调用该函数对浮点数进行解码，默认为None。
parse_int参数：用于自定义整数解码的函数。如果指定了该参数，则json模块在解码JSON格式的字符串时，会调用该函数对整数进行解码，默认为None。
parse_constant参数：用于自定义常量解码的函数。如果指定了该参数，则json模块在解码JSON格式的字符串时，会调用该函数对常量（即true、false和null）进行解码，默认为None。
object_pairs_hook参数：用于自定义对象解码的函数。如果指定了该参数，则json模块在解码JSON格式的字符串时，会调用该函数对Python元组对象进行解码，默认为None。
**kw参数：其他关键字参数，如encoding（指定编码方式）、parse_float（指定浮点数格式）等。

例子：

假设我们有一个JSON文件data.json，内容如下：

{
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "languages": ["English", "Spanish", "French"],
    "isMarried": true,
    "education": {
        "degree": "Master's Degree",
        "school": "New York University"
    }
}

我们可以使用json.load()方法将该文件中的JSON格式的字符串转换为Python对象，示例代码如下：

import json

# 打开JSON文件
with open('data.json', 'r') as f:
    # 使用json.load()方法将文件中的JSON格式的字符串转换为Python对象
    data = json.load(f)

# 输出转换后的Python对象
print(data)

运行上述代码，输出结果如下：

{
    'name': 'John Smith',
    'age': 30,
    'city': 'New York',
    'languages': ['English', 'Spanish', 'French'],
    'isMarried': True,
    'education': {
        'degree': "Master's Degree",
        'school': 'New York University'
    }
}

可以看到，使用json.load()方法将文件中的JSON格式的字符串转换为了一个Python字典对象，并输出了该对象。

posted @ 2023-06-22 11:26 张Zong在修行阅读(1640) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

zhangxuegold

Python | import json模块详解

json.dumps()

json.loads()

json.dump()

json.load()

公告