用 Python 读写 JSON

用 Python 读写 JSON

原文： 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 文档的示例。

<?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 表示相同的信息，如下所示：

{
    "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模块，请按以下步骤导入它：

>>>
>>> import json
>>>

json模块主要提供以下用于序列化和反序列化的函数。

dump(obj, fileobj)
dumps(obj)
load(fileobj)
loads(s)

让我们从dump()函数开始。

使用`dump()`进行序列化

dump()函数用于序列化数据。它需要一个 Python 对象，对其进行序列化，然后将输出（它是 JSON 字符串）写入对象之类的文件。

dump()函数的语法如下：

语法：dump(obj, fp)

参数	描述
`obj`	要序列化的对象。
`fp`	一个类似文件的对象，将在其中写入序列化数据。

这是一个例子：

>>> 
>>> 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`

这是另一个序列化两个人的列表的示例：

>>> 
>>> 
>>> 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 对象并返回它。

其语法如下：

load(fp) -> a Python object

参数	描述
`fp`	从中读取 JSON 字符串的类似文件的对象。

Here is an example:

>>> 
>>> 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 字符串，而是从字符串反序列化。

这里有些例子：

>>> 
>>> 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

>>>
>>> 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

>>> 
>>> 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

>>> 
>>> 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参数。

>>> 
>>> print(json.dumps(data, indent=4, skipkeys=True))
{
    "two": 2,
    "one": 1
}
>>> 
>>>

示例 4 ：使用separators

>>>
>>> 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"
}
>>> 
>>>

以上输出中需要注意三件事：

每个键值对使用逗号（,）分隔。
数组中的项（例如cars）也使用逗号（,）分隔。
JSON 对象的键使用': '与值分开（即冒号后跟一个空格）。

前两种情况下的分隔符使用item_separator字符串控制，最后一种情况下使用key_separator控制。以下示例将item_separator和key_separator分别更改为竖线（|）和破折号（-）字符

>>> 
>>> 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字符串中删除空格字符来使输出更紧凑。例如：

>>>
>>> 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异常。例如：

>>>
>>> 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
>>> 
>>>

要序列化自定义对象或内置类型，我们必须创建自己的序列化函数。

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')

以下是有关该函数的一些注意事项。

该函数采用一个名为obj的参数。
在第 5 行中，我们使用isinstance()函数检查对象的类型。如果您的函数仅序列化单个类型，则严格地不必检查类型，但是可以轻松添加其他类型的序列化。
在 6-9 行中，我们使用两个键创建一个字典：__class__和__value__。 __class__键存储该类的原始名称，并将用于反序列化数据。 __value__键存储对象的值，在这种情况下，我们仅需使用内置的str()函数将datetime.datetime对象转换为其字符串表示形式。
在第 18 行中，我们引发了TypeError异常。这是必要的，否则我们的序列化函数不会为无法序列化的对象报告错误。

我们的序列化函数现在可以序列化datetime.datetime对象。

下一个问题是-我们如何将自定义序列化函数传递给dumps()或dump()。

我们可以使用default关键字参数将自定义序列化函数传递给dumps()或dump()。这是一个例子：

>>> 
>>> 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对象。让我们看看如果尝试反序列化会发生什么。

>>> 
>>> 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对象。

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关键字参数。

>>> 
>>> 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 读写 JSON

用 Python 读写 JSON

序列化和反序列化

使用dump()进行序列化

用load()反序列化

使用dumps()和loads()进行序列化和反序列化

自定义序列化器

序列化自定义对象

使用`dump()`进行序列化

用`load()`反序列化

使用`dumps()`和`loads()`进行序列化和反序列化