Python- JSON使用初探

JSON

在JSON格式中，{} 和 [] 是两种主要的数据结构，分别表示对象（或称为字典、哈希、map）和数组（或称为列表、序列）。

1. {} - 对象

   在JSON中，对象是一组"key": value对的集合。这些键必须是字符串，而值可以是有效的JSON数据类型（字符串、数字、对象、数组、true、false或null）。

   示例:

   {
       "name": "John",
       "age": 30,
       "is_student": false
   }
   1
   2
   3
   4
   5

   这个JSON对象有三个键值对："name", "age", 和 "is_student"。

2. [] - 数组

   在JSON中，数组是有序的值的集合。这些值可以是任何有效的JSON数据类型。

   示例:

   ["apple", "banana", "cherry"]
   1

   这个JSON数组有三个字符串值。

   数组中的值也可以是对象或其他数组，这样可以创建复杂的嵌套结构。例如：

   [
       {
           "name": "John",
           "age": 30
       },
       {
           "name": "Jane",
           "age": 25
       }
   ]
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

   在这个例子中，JSON数组包含两个对象。

总结：在JSON中，{}用于表示对象，而[]用于表示数组。这两种结构可以嵌套和组合，以创建复杂的数据表示。这些结构与Python中的字典（dict）和列表（list）非常相似，因此在Python和JSON之间进行数据转换时，这两种结构通常会相互映射。

---

在 JSON 中，除了对象 {} 和数组 [] 这两种主要的数据结构外，没有其他的复杂数据结构。

JSON 支持的基本数据类型有：

1. 字符串 (String): 由双引号括起来的字符集合。例如："Hello, World!"

2. 数字 (Number): 可以是整数或浮点数。例如：123, 3.14, -42, 0.001

3. 布尔值 (Boolean): 有两个值：true 和 false。

4. null: 表示一个空值或缺失值。

这些基本数据类型可以与对象 {} 和数组 [] 结合使用，形成复杂的数据结构。

例如：

{
    "name": "John",
    "age": 30,
    "is_student": false,
    "scores": [95, 87, 78],
    "address": {
        "city": "New York",
        "zip": "10001"
    },
    "friends": null
}
1
2
3
4
5
6
7
8
9
10
11

在这个 JSON 数据中：

• "name" 的值是一个 字符串。
• "age" 的值是一个 数字。
• "is_student" 的值是一个 布尔值。
• "scores" 的值是一个 数组，其中包含三个数字。
• "address" 的值是一个 对象，其中包含两个键值对。
• "friends" 的值是 null。

这些基本数据类型和数据结构使得 JSON 能够表示大多数常见的数据结构，从简单的标量值到复杂的嵌套对象和数组。

json.loads()

json.loads() 是 Python 标准库中 json 模块提供的一个函数，它用于将一个 JSON 编码的字符串转换为一个 Python 对象。loads 是 “load string” 的缩写。

函数签名

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

参数

1. s - 这是要解析的 JSON 编码的字符串。

以下参数是可选的：

2. encoding - 这个参数是已弃用的，因为 JSON 数据默认为 UTF-8。
3. cls - 自定义的 JSON 解码器。
4. object_hook - 如果指定了此参数，它应该是一个函数，用于将一个字典转换为另一个对象。
5. parse_float - 使用此参数可以指定一个函数来解析浮点数（默认情况下使用 Python 的内置 float() 函数）。
6. parse_int - 使用此参数可以指定一个函数来解析整数（默认情况下使用 Python 的内置 int() 函数）。
7. parse_constant - 使用此参数可以指定一个函数来解析以下字符串：-Infinity, Infinity, NaN。
8. object_pairs_hook - 使用此参数可以指定一个函数，该函数接受一个键值对列表，然后返回一个对象。例如，它可以用于创建有序字典。

示例

import json

json_string = '{"name": "Alice", "age": 25, "is_student": false}'

# 使用 json.loads() 转换字符串为字典
data = json.loads(json_string)

print(type(data))  # 
print(data)        # {'name': 'Alice', 'age': 25, 'is_student': False}
1
2
3
4
5
6
7
8
9

注意事项

• json.loads() 只接受合法的 JSON 字符串。如果提供的字符串不是有效的 JSON，它会引发 json.JSONDecodeError。
• JSON 的 true, false, 和 null 在 Python 中分别对应为 True, False, 和 None。
• 从不受信任的源获取 JSON 数据时，使用 json.loads() 是安全的，因为它不会执行任何潜在的危险代码。这与某些其他语言的解析器不同，这些解析器可能会执行嵌入在数据中的代码。

总的来说，json.loads() 是 Python 中处理 JSON 数据的基本工具，它简单、高效、安全。

json.dumps()

json.dumps() 是 Python 标准库中 json 模块提供的一个函数。它用于将 Python 对象序列化为 JSON 格式的字符串。dumps 是 “dump string” 的缩写。

函数签名

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, **kw)
1

参数

1. obj - 要序列化的 Python 对象。

以下参数是可选的：

2. skipkeys - 默认为 False。如果设置为 True，则字典的键不是基本类型 (str, int, float, bool, None) 将被跳过，而不是引发 TypeError。
3. ensure_ascii - 默认为 True。如果为 True，则输出保证仅包含 ASCII 字符。如果 Python 对象包含非ASCII字符，它们将被转义。如果为 False，则这些字符将以UTF-8编码输出。
4. check_circular - 默认为 True。检查循环引用。
5. allow_nan - 默认为 True。指定是否允许序列化非数值的浮点值（例如：Infinity, -Infinity, NaN）。
6. cls - 自定义的 JSON 编码器。
7. indent - 可以是整数或字符串，指定缩进级别以美化输出的JSON。例如，indent=4 会使输出具有 4 个空格的缩进。
8. separators - 一个元组，指定用于分隔项目和键值对的字符串。
9. default - 指定一个函数，用于序列化那些不能默认序列化的 Python 对象。
10. sort_keys - 默认为 False。如果为 True，则输出的 JSON 字符串的字典键将被排序。

示例

import json

data = {
    "name": "Alice",
    "age": 25,
    "is_student": False
}

# 使用 json.dumps() 将字典转换为字符串
json_string = json.dumps(data, indent=4)

print(json_string)
1
2
3
4
5
6
7
8
9
10
11
12

输出：

{
    "name": "Alice",
    "age": 25,
    "is_student": false
}
1
2
3
4
5

注意事项

• Python 的字典顺序在 Python 3.7+ 中是有保证的，但在此之前的版本中并不保证。如果需要保证键的顺序，可以使用 sort_keys=True。
• 并非所有的 Python 对象都可以被序列化为 JSON。例如，Python 的 set 类型或自定义对象默认是不能被序列化的。但可以提供一个 default 函数来自定义这些类型的序列化方法。
• 在将数据序列化为 JSON 时，请注意大小写。JSON 键通常为小写，而 Python 的命名惯例可能与之不同。

总的来说，json.dumps() 是 Python 中处理 JSON 数据的基本工具，允许开发者以灵活和可控的方式将 Python 对象转换为 JSON 格式的字符串。

综合案例

下面这个例子展示了如何结合使用 json.dumps() 和 json.loads() 在 Python 对象和 JSON 格式的字符串之间进行转换，以及如何将 JSON 数据保存到文件和从文件中读取。

让我们考虑一个简单的场景：有一个 Python 字典，其中包含用户的一些信息，我们想将其保存到一个 JSON 文件中，并从该文件中读取信息。

首先，我们使用 json.dumps() 将字典转换为 JSON 格式的字符串并将其写入文件。然后，我们从文件中读取 JSON 字符串并使用 json.loads() 将其解析回 Python 对象。

示例

import json

# 定义一个字典，其中包含用户的信息
user_data = {
    "name": "John Doe",
    "age": 30,
    "email": "johndoe@example.com",
    "is_member": True
}

# 将 Python 字典转换为 JSON 字符串并写入文件
with open("user_data.json", "w") as file:
    json_string = json.dumps(user_data, indent=4)
    file.write(json_string)

# 从文件中读取 JSON 字符串并转换为 Python 对象
with open("user_data.json", "r") as file:
    data = file.read()
    parsed_data = json.loads(data)
    print(parsed_data)
    print(f"User's name: {parsed_data['name']}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果如下：

majn@tiger:~$ python3 json_demo.py 
{'name': 'Mario', 'age': 30, 'email': 'mario@example.com', 'is_member': True}
User's name: Mario
1
2
3

---

自定义序列化函数

case 1

当我们尝试将一些不能被直接序列化为JSON的Python对象（例如自定义对象或Python的set类型）转换为JSON时，可以使用default参数来指定如何处理这些对象。

下面的例子演示如何使用default参数来序列化一个包含自定义对象的Python列表：

import json

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

def person_encoder(obj):
    """自定义函数，将Person对象转换为可序列化的字典"""
    if isinstance(obj, Person):
        return {"name": obj.name, "age": obj.age}
    raise TypeError("Object of type 'Person' is not JSON serializable")

# 创建一个Person对象列表
people = [Person("Alice", 30), Person("Bob", 25)]

# 使用json.dumps()和default参数将列表转换为JSON字符串
people_json = json.dumps(people, default=person_encoder, indent=4)

print(people_json)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出：

[
    {
        "name": "Alice",
        "age": 30
    },
    {
        "name": "Bob",
        "age": 25
    }
]
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们定义了一个person_encoder函数，用于将Person对象转换为可以序列化为JSON的字典。当json.dumps()遇到Person对象时，它会调用person_encoder函数进行处理。

这种方法允许开发者为任何不可以直接序列化为JSON的Python对象定义自定义的序列化逻辑。

case 2

当我们尝试将Python的set类型转换为JSON时，默认情况下是不支持的，因为JSON格式没有与集合相对应的数据类型。但是，我们可以使用default参数来自定义set的序列化方式。

一个常见的方法是将set转换为列表，因为列表是JSON支持的数据类型。下面是如何使用default参数将set类型转换为JSON的示例：

import json

def set_encoder(obj):
    """自定义函数，将set对象转换为列表"""
    if isinstance(obj, set):
        return list(obj)
    raise TypeError(f"Object of type '{type(obj).__name__}' is not JSON serializable")

# 创建一个set
fruits = {"apple", "banana", "cherry"}

# 使用json.dumps()和default参数将set转换为JSON字符串
fruits_json = json.dumps(fruits, default=set_encoder, indent=4)

print(fruits_json)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出：

[
    "banana",
    "cherry",
    "apple"
]
1
2
3
4
5

注意：由于集合是无序的，所以转换为列表后的元素顺序可能会与原始集合中的顺序不同。

在这个例子中，我们定义了一个set_encoder函数，用于将set对象转换为列表。当json.dumps()遇到set对象时，它会调用set_encoder函数进行处理。这样，我们就可以将set类型成功转换为JSON字符串。