在本教程中，您将学习各种 JSON 处理技术，例如加载 JSON 对象、写入、排序 JSON 或解析 JSON 等。
JSON 代表JavaScript Object N代表结构化数据的otation。 JSON 数据用于交换信息。
在Python中，我们可以通过导入名为json的内置Python模块来使用JSON。 json 模块对 JSON 数据进行编码和解码。
为什么使用 JSON？
JSON 包含人类和机器可以读取的数据。在Python中使用JSON的主要目的是存储和检索列表、元组和词典。
大多数API使用JSON格式来传递信息。同样，如果您有大量数据，可以将数据编码为 JSON 格式并将其存储在数据库中。
加载该包的语法如下：
Syntax:
import json
读取 JSON 文件
要从 JSON 文件读取数据，我们可以使用 load() 方法。
在Python中读取JSON数据意味着将JSON对象转换为Python对象。 JSON对象到Python对象的转换称为反序列化。例如，JSON 数组相当于 Python 中的列表。
load() 的语法如下：
Syntax:
data = json.load(object)
- “object”是在执行语句后将加载的 JSON 对象，并将作为 Python 对象存储在变量“data”中。
考虑以下 JSON 对象：
Code:
{
"date": "2021-07-17",
"firstname": "Hamza",
"lastname": "Sher",
"city": "Kyoto",
"array": [
"Carmela",
"Ashlee",
"Alisha"
],
"array of objects": [
{
"index": 0,
"index start at 5": 5
},
{
"index": 1,
"index start at 5": 6
},
{
"index": 2,
"index start at 5": 7
}
]
}
以下代码打印 JSON 对象内键“array”的值：
Code:
import json
jsonFile = open('jsonData.json')
data = json.load(jsonFile)
print(data)
jsonFile.close()
Output:
如果我们有一个存储 JSON 对象的字符串，我们可以使用loads() 方法来读取该字符串。
Syntax:
data = json.loads(jsonString)
以下代码打印 JSON 字符串：
Code:
import json
jsonData = '{"Name": "Hamza", "ID":"12345"}'
data = json.loads(jsonData)
print(data)
Output:
获取 JSON 值
JSON 对象以键值对的形式构建，这使得从对象获取特定值变得非常简单。我们可以使用字典索引来访问与键关联的值。
Syntax:
data['firstname']
下面的代码演示了我们如何使用它来获得我们想要的结果。
Code:
import json
jsonFile = open('jsonData.json')
data = json.load(jsonFile)
print(data['firstname'])
jsonFile.close()
Output:
更新和删除 JSON 对象
在 Python 中更新 JSON 对象就像使用我们导入的 json 包中的内置 update() 函数一样简单。
update 方法用于将新的键值对添加到我们在代码中声明的 JSON 字符串中。我们可以添加单个键值对或添加将附加到之前的 JSON 字符串的整个字典。
Syntax:
jsonObject.update(KeyValuePair)
以下代码实现 update() 方法。
Code:
import json
jsonData = '{"ID":"123", "Name": "Hamza"}'
data = json.loads(jsonData)
newData = {"DOB": "22-10-2001"}
data.update(newData)
print(data)
Output:
字典“newData”已添加到“jsonData”对象中。这就是 update() 方法执行其功能的方式。
转到删除功能。 json包中没有内置函数来删除键值对。因此，我们必须编写更多的代码来执行此功能。
以下是我们如何在 JSON 对象上实现删除。请记住，我们使用的是与本教程开头提到的相同的 JSON 文件。
Code:
import json
file = open('jsonData.json', 'r')
data = json.load(file)
file.close()
if 'firstname' in data:
del data['firstname']
print(data)
Output:
让我们看看这里到底发生了什么。当我们检查字典中是否存在“firstname”时，Python 会检查字典，如果键存在，我们可以使用 del 关键字删除该键值对。
按键更新 JSON 值
以下是通过键更新值的方法：
json_object = {
"name": "John",
"age": 30,
"city": "New York"
}
json_object["age"] = 35
print(json_object)
Output:
{
"name": "John",
"age": 35,
"city": "New York"
}
与键关联的值"age"更新自30 to 35.
重命名 JSON 键
以下是在 Python 中执行此操作的常见方法：
json_object = {
"firstname": "John",
"age": 30
}
json_object["name"] = json_object.pop("firstname")
print(json_object)
Output:
{
"age": 30,
"name": "John"
}
该代码使用pop移除钥匙的方法"firstname"并同时检索其值。然后，它将该值分配给一个新键"name".
结果是关键"firstname"被有效地重命名为"name".
删除重复项
您可以使用 set() 方法从 JSON 中删除重复项。
Code:
import json
json_array = [
{"name": "John", "age": 30},
{"name": "Jane", "age": 25},
{"name": "John", "age": 30}
]
# Convert JSON objects to strings to make them hashable
json_strings = [json.dumps(item, sort_keys=True) for item in json_array]
# Use set to remove duplicates
unique_json_strings = set(json_strings)
# Convert back to JSON objects
unique_json_array = [json.loads(item) for item in unique_json_strings]
print(unique_json_array)
Output:
[
{"name": "Jane", "age": 25},
{"name": "John", "age": 30}
]
首先，我们使用以下命令将数组中的每个 JSON 对象转换为字符串json.dumps，确保对键进行排序以确保顺序一致。
然后，我们使用集合来删除重复项，因为集合不能包含重复元素。
最后，我们使用以下方法将唯一的 JSON 字符串转换回 JSON 对象：json.loads.
对 JSON 进行排序
我们可以根据键按字母顺序对 JSON 对象进行排序。为此，我们使用 json.dumps() 方法以及该方法的一些参数。使用该方法的语法如下：
Syntax:
json.dumps(data, sort_keys=True)
这里我们将两个参数传递给函数 json.dumps()。第一个“数据”包含我们存储在 Python 变量中的 JSON 对象。
第二个是 sort_keys 参数，当设置为 True 时，按字母顺序对数据进行排序并以字符串形式返回 JSON 对象。以下代码使用此功能：
Code:
import json
file = open('jsonData.json', 'r')
data = json.load(file)
file.close()
print(json.dumps(data, sort_keys=True))
Output:
查看代码，很容易理解发生了什么。首先，我们加载数据并将其存储到变量“data”中，然后关闭文件。
然后，在单个语句中，我们借助函数 json.dumps() 和 sort_keys=True 参数打印排序后的数据。
创建 JSON 对象
要创建 JSON 对象，我们需要一个包含数据的 Python 字典。我们将使用与之前使用的方法相同的方法，即 json.dump() 和 json.loads()。下面的代码实现了这个功能：
Code:
import json
data = {"Name":"John Doe", "ID":"123"}
json_dump = json.dumps(data)
json_data = json.loads(json_dump)
print(json_data)
Output:
这里我们将一些数据定义为Python字典。然后我们使用 json.dumps() 方法并将 Python 字典作为参数传递。
这会将我们的 Python 字典转换为可以传递给 json.loads() 方法的字符串。然后 json.loads() 方法将此字符串转换为 JSON 对象，我们可以在打印时看到输出。
将 JSON 写入文件
要将 JSON 对象写入 JSON 文件，我们可以使用 json.dump() 方法。此方法获取我们将写入文件的数据以及我们将写入数据的文件。下面的代码解释了我们如何做到这一点！
Code:
import json
file = open('jsonData.json', 'r')
data = json.load(file)
file.close()
newData = {"DOB": "22-10-2001"}
data.update(newData)
file = open('jsonData.json', 'w')
json.dump(data, file)
file.close()
print(data)
Output:
首先，我们以读取模式打开文件并将文件内容存储到变量“data”中。然后我们更新“数据”并将新的键值对添加到该变量中。
之后，我们再次以写入模式打开文件。我们使用 json.dump() 函数并将其作为参数传递给数据和文件，然后关闭文件。
输出显示数据已更新，我们可以通过查看 json 文件来确认这一点。
漂亮的打印 JSON
您可以使用indent参数以使输出 JSON 更好地打印。
Code:
import json
data = {
"name": "John",
"age": 30,
"city": "New York",
"hasChildren": False,
"titles": ["engineer", "programmer"]
}
pretty_json = json.dumps(data, indent=4)
print(pretty_json)
Output:
{
"name": "John",
"age": 30,
"city": "New York",
"hasChildren": false,
"titles": [
"engineer",
"programmer"
]
}
该代码使用json.dumps函数与indent参数设置为4。
这会导致输出 JSON 字符串的格式为每个级别缩进四个空格，使其更具可读性。
使用分隔符参数
您可以使用separators参数来控制 JSON 输出中项目之间的分隔符。
这在各种格式化情况下都很有帮助。
Code:
import json
data = {
"name": "John",
"age": 30,
"city": "New York"
}
custom_separators_json = json.dumps(data, separators=(',', ':'))
print(custom_separators_json)
Output:
{"name":"John","age":30,"city":"New York"}
在这里，separators参数设置为元组(',', ':')，它指定 JSON 字符串中的项目和键值对之间使用的分隔符。
通过使用此自定义，您可以减少 JSON 输出中的空白量，使其更加紧凑。
解析 JSON
我们可以简单地使用 json.loads() 方法来解析 Python 中的 JSON 字符串。此方法将 JSON 字符串转换为 Python 字典，可以根据字典中存在的键进行索引。
Syntax:
json.loads(jsonString)
这里“jsonString”是作为参数传递到方法中的 JSON 字符串。该方法将解析 JSON 字符串并返回一个可以进一步存储在变量中的 Python 字典。
我们还可以对该变量执行所有字典方法。下面的代码实现了这个功能。
Code:
import json
data = '{"Name":"John Doe", "ID":"123"}'
json_data = json.loads(data)
print(json_data['Name'])
Output:
在此代码中，我们将 JSON 字符串“data”作为参数传递给方法 json.loads()，该方法返回存储在变量“json_data”中的字典。打印函数验证该方法是否成功运行。
验证 JSON
JSON 验证是检查 JSON 对象是否符合预定义模式或结构的过程。
您可以使用诸如jsonschema验证 JSON 数据。这是一个例子：
安装 jsonschema 库：
pip install jsonschema
验证 JSON 对象：
from jsonschema import validate
schema = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer"}
},
"required": ["name", "age"]
}
data = {"name": "John", "age": 30}
validate(instance=data, schema=schema)
Output:
没有抛出异常；数据符合架构。
该代码片段定义了一个架构，该架构需要具有字符串名称和整数年龄的对象。
The validate函数从jsonschema然后使用库来检查是否data对象满足此模式。
自从data对象符合定义的模式，代码运行没有任何错误。
合并 JSON 对象
在 Python 中，可以使用标准字典合并技术来合并 JSON 对象，因为 Python 中的 JSON 对象表示为字典。以下是组合两个 JSON 对象的方法：
json_object1 = {
"name": "John",
"age": 30
}
json_object2 = {
"city": "New York",
"hasChildren": False
}
merged_json_object = {**json_object1, **json_object2}
print(merged_json_object)
Output:
{
"name": "John",
"age": 30,
"city": "New York",
"hasChildren": false
}
这里有两个 JSON 对象，json_object1 and json_object2，使用扩展语法合并{**json_object1, **json_object2}.
所结果的merged_json_object包含两个原始对象的所有键值对。
对象到 JSON
可以使用我们之前讨论过的相同 json.dumps() 方法将 Python 对象转换为 JSON。让我们看看这是如何完成的。
Code:
import json
class Car:
def __init__(self, model, make, engine_capacity):
self.model = model
self.make = make
self.engine_capacity = engine_capacity
car_1 = Car('2001', 'Honda', '1.8L')
json_data = json.dumps(car_1.__dict__)
print(json_data)
Output:
在这段代码中，我们首先创建一个 Car 类，然后创建该类的一个对象。
然后我们将使用 json.dumps() 函数并将汽车对象作为“car.__dict__”传递。 ‘__dict__’将所有成员变量转换为字典并将其传递给 json.dumps() 方法。
从输出中我们可以看到该对象已转换为 JSON。
JSON 到对象
要将 JSON 字符串转换为 Python 对象，我们需要一个类，我们必须创建该类的对象并使用 json.loads() 方法，如下所示：
Code:
import json
class Car:
def __init__(self, model, make, engine_capacity):
self.model = model
self.make = make
self.engine_capacity = engine_capacity
json_data = '{"model": "2001", "make": "Honda", "engine_capacity": "1.8L"}'
data = json.loads(json_data)
car_1 = Car(**data)
print(car_1.engine_capacity, car_1.make, car_1.model)
Output:
这里我们将数据加载到变量“data”中，然后将该字典作为关键字参数传递给汽车类。我们可以在输出中看到该对象已创建。
字节到 JSON
将字节字符串或字典转换为 JSON 非常简单。我们只需要使用内置的 json.dumps() 函数即可。
Syntax:
json.dumps(bytesString)
以下代码说明了此功能。
Code:
import json
byte_str = b'{"Name":"Hamza", "ID":"123"}'
dec_str = byte_str.decode('utf-8')
data = json.dumps(dec_str)
print(data)
Output:
这里我们首先定义了一个字节串，然后将其解码为‘utf-8’字符集。之后，我们简单地使用 json.dumps() 将字符串转换为 JSON 字符串。
将 HTML 转换为 JSON
要将 HTML 转换为 JSON 对象，我们必须使用另一个名为 html-to-json 的 Python 包。该包的作用基本上是获取 HTML 文件并将其转换为 JSON 对象。
我们可以在命令提示符或终端中使用以下命令来安装此软件包：
Syntax:
pip install html-to-json
首先，我们需要将其导入到我们的程序中。
Syntax:
import html_to_json
导入后，我们现在可以编写代码将 HTML 文件转换为 JSON 对象。这是我们将使用的示例 HTML 文件：
Code:
<!doctype html>
<html lang="en-US">
<head>
<title>Sample Html Doc</title>
</head>
<body>
<div>
<h1>First Heading</h2>
<p>This is a sample HTML Doc</p>
</div>
</body>
</html>
现在，我们将继续编写代码以将此 HTML 转换为 JSON。
Code:
import json
import html_to_json
file = open("sample.html", "r")
html = file.read()
file.close()
output_json = html_to_json.convert(html)
print(output_json)
Output:
在此代码中，我们使用 html-to-json 包将 HTML 转换为 json。为此，我们使用 html_to_json.convert() 方法并传递包含所需 HTML 的字符串。
JSON 到 SQL
将 JSON 对象转换为 SQL 表需要一些额外的步骤，而不仅仅是使用单一方法。这里我们使用了两个以前没有使用过的新包。
首先是 Pandas 包，它是一个数据分析工具。我们将使用它将 JSON 对象转换为 Pandas DataFrame。
第二个包是 sqlalchemy。该软件包是一个数据库工具包和一个对象关系映射器（ORM）。以下是我们导入这些包的方法：
Syntax:
import pandas as pd
from sqlalchemy import create_engine
这里create_engine是一个帮助我们连接到的方法SQLite数据库。以下代码说明了此功能：
Code:
import json
import pandas as pd
from sqlalchemy import create_engine
with open("jsonsample.json") as f:
data = json.load(f)
df = pd.DataFrame(data)
engine = create_engine("sqlite:///my_data.db")
df.to_sql("Sample_Data", con=engine)
当我们运行此代码时，会创建一个名为“my_data.db”的数据库。之后，数据将被插入到数据库中，表名为“Sample_Data”。
我们可以通过在命令提示符或终端中运行以下命令来确认这一点：
Code:
$ sqlite my_data.db
sqlite> .schema
根据 JSON 对象，您可以看到表已创建并且数据已插入。
JSON load() VS load()
两者之间的区别在于，使用 load() 方法，我们传递 JSON 文件作为参数，然后我们可以将其存储在变量中。
虽然loads()方法我们传递一个 JSON 字符串它被定义为 Python 变量并将该字符串序列化为 JSON 对象。以下代码示例显示了此功能。
代码：（加载（））
import json
jsonFile = open('jsonData.json')
data = json.load(jsonFile)
print(data)
jsonFile.close()
Output:
代码：（负载（））
import json
jsonData = '{"Name": "Hamza", "ID":"12345"}'
data = json.loads(jsonData)
print(data)
Output:
JSON 转储() VS 加载()
json.loads() 和 json.dumps() 方法是相反的。 json.loads() 方法接受一个字符串并返回一个 JSON 对象可以进一步使用。
而 json.dumps() 方法接受一个 JSON 对象并返回一个字符串包含所有数据。
以下代码示例说明了此功能：
Code:
import json
json_data = '{"Name":"Hamza", "ID":"123"}'
data = json.loads(json_data)
print("loads method: ", data)
dumps_data = json.dumps(data)
print("dumps method: ", dumps_data)
Output:
我希望你喜欢这个教程。继续回来。
