# 用 Python 读写 JSON
> 原文： [https://thepythonguru.com/reading-and-writing-json-in-python/](https://thepythonguru.com/reading-and-writing-json-in-python/)
* * *
于 2020 年 1 月 7 日更新
* * *
JSON（JavaScript 对象表示法）是与语言无关的数据交换格式。 它是由道格拉斯·克罗克福德（Douglas Crockford）创建和推广的。 在短短的历史中，JSON 已成为事实上的跨网络数据传输标准。
JSON 是从 JavaScript 对象语法派生的基于文本的格式。 但是，它完全独立于 JavaScript，因此您无需知道任何 JavaScript 即可使用 JSON。
Web 应用通常使用 JSON 在客户端和服务器之间传输数据。 如果您使用的是 Web 服务，则很有可能默认情况下以 JSON 格式将数据返回给您。
在 JSON 诞生之前，XML 主要用于在客户端和服务器之间发送和接收数据。 XML 的问题在于它冗长，繁重且不容易解析。 但是，JSON 并非如此，您将很快看到。
以下是描述人的 XML 文档的示例。
```py
<?xml version="1.0" encoding="UTF-8" ?>
<root>
<firstName>John</firstName>
<lastName>Smith</lastName>
<isAlive>true</isAlive>
<age>27</age>
<address>
<streetAddress>21 2nd Street</streetAddress>
<city>New York</city>
<state>NY</state>
<postalCode>10021-3100</postalCode>
</address>
<phoneNumbers>
<type>home</type>
<number>212 555-1234</number>
</phoneNumbers>
<phoneNumbers>
<type>office</type>
<number>646 555-4567</number>
</phoneNumbers>
<phoneNumbers>
<type>mobile</type>
<number>123 456-7890</number>
</phoneNumbers>
<spouse />
</root>
```
可以使用 JSON 表示相同的信息，如下所示：
```py
{
"firstName": "John",
"lastName": "Smith",
"isAlive": true,
"age": 27,
"address": {
"streetAddress": "21 2nd Street",
"city": "New York",
"state": "NY",
"postalCode": "10021-3100"
},
"phoneNumbers": [
{
"type": "home",
"number": "212 555-1234"
},
{
"type": "office",
"number": "646 555-4567"
},
{
"type": "mobile",
"number": "123 456-7890"
}
],
"children": [],
"spouse": null
}
```
我相信您会同意 JSON 副本更容易读写。
另外，请注意，JSON 格式与 Python 中的字典非常相似。
## 序列化和反序列化
* * *
**序列化**：将对象转换为适合通过网络传输或存储在文件或数据库中的特殊格式的过程称为序列化。
**反序列化**：与序列化相反。 它将序列化返回的特殊格式转换回可用的对象。
在 JSON 的情况下，当我们序列化对象时，实际上是将 Python 对象转换为 JSON 字符串，反序列化则通过其 JSON 字符串表示形式构建 Python 对象。
Python 提供了一个称为`json`的内置模块，用于对对象进行序列化和反序列化。 要使用`json`模块，请按以下步骤导入它：
```py
>>>
>>> import json
>>>
```
`json`模块主要提供以下用于序列化和反序列化的函数。
1. `dump(obj, fileobj)`
2. `dumps(obj)`
3. `load(fileobj)`
4. `loads(s)`
让我们从`dump()`函数开始。
## 使用`dump()`进行序列化
* * *
`dump()`函数用于序列化数据。 它需要一个 Python 对象，对其进行序列化，然后将输出（它是 JSON 字符串）写入对象之类的文件。
`dump()`函数的语法如下：
**语法**：`dump(obj, fp)`
| 参数 | 描述 |
| --- | --- |
| `obj` | 要序列化的对象。 |
| `fp` | 一个类似文件的对象，将在其中写入序列化数据。 |
这是一个例子：
```py
>>>
>>> import json
>>>
>>> person = {
... 'first_name': "John",
... "isAlive": True,
... "age": 27,
... "address": {
... "streetAddress": "21 2nd Street",
... "city": "New York",
... "state": "NY",
... "postalCode": "10021-3100"
... },
... "hasMortgage": None
... }
>>>
>>>
>>> with open('person.json', 'w') as f: # writing JSON object
... json.dump(person, f)
...
>>>
>>>
>>> open('person.json', 'r').read() # reading JSON object as string
'{"hasMortgage": null, "isAlive": true, "age": 27, "address": {"state": "NY", "streetAddress": "21 2nd Street", "city": "New York", "postalCode": "10021-3100"}, "first_name": "John"}'
>>>
>>>
>>> type(open('person.json', 'r').read())
<class 'str'>
>>>
>>>
```
请注意，在序列化对象时，Python 的`None`类型将转换为 JSON 的`null`类型。
下表列出了序列化数据时类型之间的转换。
| Python 类型 | JSON 类型 |
| --- | --- |
| `dict` | `object` |
| `list`，`tuple` | `array` |
| `int` | `number` |
| `float` | `number` |
| `str` | `string` |
| `True` | `true` |
| `False` | `false` |
| `None` | `null` |
当我们反序列化对象时，JSON 类型将转换回其等效的 Python 类型。 下表中描述了此操作：
| JSON 类型 | Python 类型 |
| --- | --- |
| `object` | `dict` |
| `array` | `list` |
| `string` | `str` |
| `number (int)` | `int` |
| `number (real)` | `float` |
| `true` | `True` |
| `false` | `False` |
| `null` | `None` |
这是另一个序列化两个人的列表的示例：
```py
>>>
>>>
>>> persons = \
... [
... {
... 'first_name': "John",
... "isAlive": True,
... "age": 27,
... "address": {
... "streetAddress": "21 2nd Street",
... "city": "New York",
... "state": "NY",
... "postalCode": "10021-3100"
... },
... "hasMortgage": None,
... },
... {
... 'first_name': "Bob",
... "isAlive": True,
... "age": 32,
... "address": {
... "streetAddress": "2428 O Conner Street",
... "city": " Ocean Springs",
... "state": "Mississippi",
... "postalCode": "20031-9110"
... },
... "hasMortgage": True,
... }
...
... ]
>>>
>>> with open('person_list.json', 'w') as f:
... json.dump(persons, f)
...
>>>
>>>
>>> open('person_list.json', 'r').read()
'[{"hasMortgage": null, "isAlive": true, "age": 27, "address": {"state": "NY", "streetAddress": "21 2nd Street", "city": "New York", "postalCode": "10021-3100"}, "first_name": "John"}, {"hasMortgage": true, "isAlive": true, "age": 32, "address": {"state": "Mississippi", "streetAddress": "2428 O Conner Street", "city": " Ocean Springs", "postalCode": "20031-9110"}, "first_name": "Bob"}]'
>>>
>>>
```
现在，我们的 Python 对象已序列化到文件。 要将其反序列化回 Python 对象，我们使用`load()`函数。
## 用`load()`反序列化
* * *
`load()`函数从类似于对象的文件中反序列化 JSON 对象并返回它。
其语法如下：
```py
load(fp) -> a Python object
```
| 参数 | 描述 |
| --- | --- |
| `fp` | 从中读取 JSON 字符串的类似文件的对象。 |
Here is an example:
```py
>>>
>>> with open('person.json', 'r') as f:
... person = json.load(f)
...
>>>
>>> type(person) # notice the type of data returned by load()
<class 'dict'>
>>>
>>> person
{'age': 27, 'isAlive': True, 'hasMortgage': None, 'address': {'state': 'NY', 'streetAddress': '21 2nd Street', 'city': 'New York', 'postalCode': '10021-3100'}, 'first_name': 'John'}
>>>
>>>
```
## 使用`dumps()`和`loads()`进行序列化和反序列化
* * *
`dumps()`函数的工作原理与`dump()`完全相同，但是它不是将输出发送到类似文件的对象，而是将输出作为字符串返回。
同样，`loads()`函数与`load()`相同，但是它不是从文件反序列化 JSON 字符串，而是从字符串反序列化。
这里有些例子：
```py
>>>
>>> person = {
... 'first_name': "John",
... "isAlive": True,
... "age": 27,
... "address": {
... "streetAddress": "21 2nd Street",
... "city": "New York",
... "state": "NY",
... "postalCode": "10021-3100"
... },
... "hasMortgage": None
... }
>>>
>>> data = json.dumps(person) # serialize
>>>
>>> data
'{"hasMortgage": null, "isAlive": true, "age": 27, "address": {"state": "NY", "streetAddress": "21 2nd Street", "city": "New York", "postalCode": "10021-3100"}, "first_name": "John"}'
>>>
>>>
>>> person = json.loads(data) # deserialize from string
>>>
>>> type(person)
<class 'dict'>
>>>
>>> person
{'age': 27, 'isAlive': True, 'hasMortgage': None, 'address': {'state': 'NY', 'streetAddress': '21 2nd Street', 'city': 'New York', 'postalCode': '10021-3100'}, 'first_name': 'John'}
>>>
>>>
```
**注意**：
由于字典不保留元素的顺序，因此获取键的顺序可能会有所不同。
## 自定义序列化器
* * *
以下是一些可选的关键字参数，可以将这些参数传递给`dumps`或`dump()`函数以自定义串行器。
| 参数 | 描述 |
| --- | --- |
| `indent` | 一个正整数，用于确定每个级别的键值对的缩进量。 如果您具有深层嵌套的数据结构，则`indent`参数可以方便地美化输出。 `indent`的默认值为`None`。 |
| `sort_keys` | 布尔值标志（如果设置为`True`）将返回按键排序的 JSON 字符串，而不是随机排序的。 其默认值为`False`。 |
| `skipkeys` | JSON 格式期望键为字符串，如果您尝试使用无法转换为字符串的类型（如元组），则会引发`TypeError`异常。 为防止引发异常并跳过非字符串键，请将`skipkeys`参数设置为`True`。 |
| `separators` | 它是指形式为`(item_separator, key_separator)`的元组。 `item_separator`是一个字符串，用于分隔列表中的项目。 `key_separator`也是一个字符串，用于分隔字典中的键和值。 默认情况下，`separators`设置为`(',', ': ')`。 |
以下是一些示例，演示了如何在操作中使用这些参数：
**示例 1** ：使用`indent`
```py
>>>
>>> print(json.dumps(person)) # without indent
{"age": 27, "isAlive": true, "hasMortgage": null, "address": {"state": "NY", "streetAddress": "21 2nd Street", "city": "New York", "postalCode": "10021-3100"}, "first_name": "John"}
>>>
>>>
>>> print(json.dumps(person, indent=4)) # with 4 levels of indentation
{
"age": 27,
"isAlive": true,
"hasMortgage": null,
"address": {
"state": "NY",
"streetAddress": "21 2nd Street",
"city": "New York",
"postalCode": "10021-3100"
},
"first_name": "John"
}
>>>
>>>
```
请记住，增加缩进量也会增加数据的大小。 因此，请勿在生产环境中使用`indent`。
**示例 2** ：使用`sort_keys`
```py
>>>
>>> print(json.dumps(person, indent=4)) # print JSON string in random order
{
"address": {
"state": "NY",
"postalCode": "10021-3100",
"city": "New York",
"streetAddress": "21 2nd Street"
},
"hasMortgage": null,
"first_name": "John",
"isAlive": true,
"age": 27
}
>>>
>>>
>>> print(json.dumps(person, indent=4, sort_keys=True)) # print JSON string in order by keys
{
"address": {
"city": "New York",
"postalCode": "10021-3100",
"state": "NY",
"streetAddress": "21 2nd Street"
},
"age": 27,
"first_name": "John",
"hasMortgage": null,
"isAlive": true
}
>>>
>>>
```
**示例 3** ：使用`skipkeys`
```py
>>>
>>> data = {'one': 1, 'two': 2, (1,2): 3}
>>>
>>> json.dumps(data, indent=4)
Traceback (most recent call last):
...
TypeError: key (1, 2) is not a string
>>>
>>>
```
在这种情况下，键`(1,2)`无法转换为字符串，因此会引发`TypeError`异常。 为防止引发异常并跳过非字符串键，请使用`skipkeys`参数。
```py
>>>
>>> print(json.dumps(data, indent=4, skipkeys=True))
{
"two": 2,
"one": 1
}
>>>
>>>
```
**示例 4** ：使用`separators`
```py
>>>
>>> employee = {
... 'first_name': "Tom",
... "designation": 'CEO',
... "Salary": '2000000',
... "age": 35,
... "cars": ['chevy cavalier', 'ford taurus', 'tesla model x']
... }
>>>
>>>
>>> print(json.dumps(employee, indent=4, skipkeys=True,))
{
"designation": "CEO",
"age": 35,
"cars": [
"chevy cavalier",
"ford taurus",
"tesla model x"
],
"Salary": "2000000",
"first_name": "Tom"
}
>>>
>>>
```
以上输出中需要注意三件事：
1. 每个键值对使用逗号（`,`）分隔。
2. 数组中的项（例如`cars`）也使用逗号（`,`）分隔。
3. JSON 对象的键使用`': '`与值分开（即冒号后跟一个空格）。
前两种情况下的分隔符使用`item_separator`字符串控制，最后一种情况下使用`key_separator`控制。 以下示例将`item_separator`和`key_separator`分别更改为竖线（`|`）和破折号（`-`）字符
```py
>>>
>>> print(json.dumps(employee, indent=4, skipkeys=True, separators=('|', '-')))
{
"designation"-"CEO"|
"age"-35|
"cars"-[
"chevy cavalier"|
"ford taurus"|
"tesla model x"
]|
"Salary"-"2000000"|
"first_name"-"Tom"
}
>>>
>>>
```
现在您知道`separators`的工作原理，我们可以通过从`item_separator`字符串中删除空格字符来使输出更紧凑。 例如：
```py
>>>
>>> print(json.dumps(employee, indent=4, skipkeys=True, separators=(',', ':')))
{
"designation":"CEO",
"age":35,
"cars":[
"chevy cavalier",
"ford taurus",
"tesla model x"
],
"Salary":"2000000",
"first_name":"Tom"
}
>>>
>>>
```
## 序列化自定义对象
* * *
默认情况下，`json`模块仅允许我们序列化以下基本类型：
* `int`
* `float`
* `str`
* `bool`
* `list`
* `tuple`
* `dict`
* `None`
如果您尝试序列化或反序列化自定义对象或任何其他内置类型，将引发`TypeError`异常。 例如：
```py
>>>
>>> from datetime import datetime
>>>
>>> now = datetime.now()
>>>
>>> now
datetime.datetime(2018, 9, 28, 22, 16, 46, 16944)
>>>
>>> d = {'name': 'bob', 'dob': now}
>>>
>>> json.dumps(d)
Traceback (most recent call last):
...
TypeError: datetime.datetime(2018, 9, 28, 22, 7, 0, 622242) is not JSON serializable
>>>
>>>
>>>
>>>
>>> class Employee:
...
... def __init__(self, name):
... self.name = name
...
>>>
>>> e = Employee('John')
>>>
>>> e
<__main__.Employee object at 0x7f20c82ee4e0>
>>>
>>>
>>> json.dumps(e)
Traceback (most recent call last):
...
TypeError: <__main__.Employee object at 0x7f20c82ee4e0> is not JSON serializable
>>>
>>>
```
要序列化自定义对象或内置类型，我们必须创建自己的序列化函数。
```py
def serialize_objects(obj):
# serialize datetime object
if isinstance(obj, datetime):
return {
'__class__': datetime.__name__,
'__value__': str(obj)
}
# serialize Employee object
#
# if isinstance(obj, Employee):
# return {
# '__class__': 'Employee',
# '__value__': obj.name
# }
raise TypeError(str(obj) + ' is not JSON serializable')
```
以下是有关该函数的一些注意事项。
1. 该函数采用一个名为`obj`的参数。
2. 在第 5 行中，我们使用`isinstance()`函数检查对象的类型。 如果您的函数仅序列化单个类型，则严格地不必检查类型，但是可以轻松添加其他类型的序列化。
3. 在 6-9 行中，我们使用两个键创建一个字典：`__class__`和`__value__`。 `__class__`键存储该类的原始名称，并将用于反序列化数据。 `__value__`键存储对象的值，在这种情况下，我们仅需使用内置的`str()`函数将`datetime.datetime`对象转换为其字符串表示形式。
4. 在第 18 行中，我们引发了`TypeError`异常。 这是必要的，否则我们的序列化函数不会为无法序列化的对象报告错误。
我们的序列化函数现在可以序列化`datetime.datetime`对象。
下一个问题是-我们如何将自定义序列化函数传递给`dumps()`或`dump()`。
我们可以使用`default`关键字参数将自定义序列化函数传递给`dumps()`或`dump()`。 这是一个例子：
```py
>>>
>>> def serialize_objects(obj):
... if isinstance(obj, datetime):
... return {
... '__class__': datetime.__name__,
... '__value__': str(obj)
... }
... raise TypeError(str(obj) + ' is not JSON serializable')
...
>>>
>>> employee = {
... 'first_name': "Mike",
... "designation": 'Manager',
... "doj": datetime(year=2016, month=5, day=2), # date of joining
... }
>>>
>>>
>>> emp_json = json.dumps(employee, indent=4, default=serialize_objects)
>>>
>>>
>>> print(emp_json)
{
"designation": "Manager",
"doj": {
"__value__": "2016-05-02 00:00:00",
"__class__": "datetime"
},
"first_name": "Mike"
}
>>>
>>>
```
注意`datetime.datetime`对象如何被序列化为带有两个键的字典。
重要的是要注意，将仅调用`serialize_objects()`函数来序列化不是 Python 基本类型之一的对象。
现在，我们已经成功地序列化了`datetime.datetime`对象。 让我们看看如果尝试反序列化会发生什么。
```py
>>>
>>> emp_dict = json.loads(emp_json)
>>>
>>> type(emp_dict)
<class 'dict'>
>>>
>>> emp_dict
{'designation': 'Manager', 'doj': {'__value__': '2016-05-02 00:00:00', '__class__': 'datetime'}, 'first_name': 'Mike'}
>>>
>>> emp_dict['doj']
{'__value__': '2016-05-02 00:00:00', '__class__': 'datetime'}
>>>
>>>
```
请注意，`doj`键的值作为字典而不是`datetime.datetime`对象返回。
发生这种情况是因为`loads()`函数对首先将`datetime.datetime`对象序列化的`serialize_objects()`函数一无所知。
我们需要的是`serialize_objects()`函数的反面-该函数接受字典对象，检查`__class__`键的存在，并根据`__value__`键中存储的字符串表示形式构建`datetime.datetime`对象。
```py
def deserialize_objects(obj):
if '__class__' in obj:
if obj['__class__'] == 'datetime':
return datetime.strptime(obj['__value__'], "%Y-%m-%d %H:%M:%S")
# if obj['__class__'] == 'Employee':
# return Employee(obj['__value__'])
return obj
```
这里唯一需要注意的是，我们正在使用`datetime.strptime`函数将日期时间字符串转换为`datetime.datetime`对象。
要将自定义反序列化函数传递给`loads()`方法，我们使用`object_hook`关键字参数。
```py
>>>
>>> def deserialize_objects(obj):
... if '__class__' in obj:
... if obj['__class__'] == 'datetime':
... return datetime.strptime(obj['__value__'], "%Y-%m-%d %H:%M:%S")
... # if obj['__class__'] == 'Employee':
... # return Employee(obj['__value__'])
... return obj
...
>>>
>>>
>>> emp_dict = json.loads(emp_json, object_hook=deserialize_objects)
>>>
>>> emp_dict
{'designation': 'Manager', 'doj': datetime.datetime(2016, 5, 2, 0, 0), 'first_name': 'Mike'}
>>>
>>> emp_dict['doj']
datetime.datetime(2016, 5, 2, 0, 0)
>>>
>>>
```
不出所料，这次`doj`键的值是`datetime.datetime`对象而不是字典。
* * *
* * *
- 初级 Python
- python 入门
- 安装 Python3
- 运行 python 程序
- 数据类型和变量
- Python 数字
- Python 字符串
- Python 列表
- Python 字典
- Python 元组
- 数据类型转换
- Python 控制语句
- Python 函数
- Python 循环
- Python 数学函数
- Python 生成随机数
- Python 文件处理
- Python 对象和类
- Python 运算符重载
- Python 继承与多态
- Python 异常处理
- Python 模块
- 高级 Python
- Python *args和**kwargs
- Python 生成器
- Python 正则表达式
- 使用 PIP 在 python 中安装包
- Python virtualenv指南
- Python 递归函数
- __name__ == "__main__"是什么？
- Python Lambda 函数
- Python 字符串格式化
- Python 内置函数和方法
- Python abs()函数
- Python bin()函数
- Python id()函数
- Python map()函数
- Python zip()函数
- Python filter()函数
- Python reduce()函数
- Python sorted()函数
- Python enumerate()函数
- Python reversed()函数
- Python range()函数
- Python sum()函数
- Python max()函数
- Python min()函数
- Python eval()函数
- Python len()函数
- Python ord()函数
- Python chr()函数
- Python any()函数
- Python all()函数
- Python globals()函数
- Python locals()函数
- 数据库访问
- 安装 Python MySQLdb
- 连接到数据库
- MySQLdb 获取结果
- 插入行
- 处理错误
- 使用fetchone()和fetchmany()获取记录
- 常见做法
- Python：如何读取和写入文件
- Python：如何读取和写入 CSV 文件
- 用 Python 读写 JSON
- 用 Python 转储对象