Python 中的嵌套字典

在 Python 编程语言中，我们有字典的概念。字典是可变的，我们可以轻松地在字典中添加和删除条目。它是无序数据项的集合。

• 字典由两部分组成，第一部分是数据集，第二部分是其对应的键值。
• 它也不允许重复。
• 这里的嵌套字典是指字典内部的字典。
• 简单来说就是指字典，由一套多本字典组成。
• 用于存储键值对中的数据值。
• 嵌套字典意味着将一个字典放在另一个字典中。嵌套非常有用，因为我们可以在程序中建模的信息种类大大扩展了。
• 嵌套字典包含各种字典的无序集合。
• 与普通字典相比，它还包含键及其值对。
• 我们可以用它的钥匙查字典。
• 通过将逗号分隔的字典放在大括号内，可以在 Python 中创建嵌套字典。
• 切片嵌套字典是不可能的。
• 我们可以根据需要缩小或扩大嵌套字典。

用于将各种字典添加到特定字典中的嵌套字典语法:

向嵌套字典添加元素可以通过多种方式完成。在嵌套字典中添加字典的一种方法是添加一对一的值，嵌套字典[dict][key] = 'value '。另一种方法是一次性添加整个字典，nested dict[dict]= { ' key ':' value ' }。

嵌套字典示例

让我们借助一些例子来理解:

例 1:

# Let us first create a normal dictionary that contains data items with their 
# corresponding key-value pairs in a python programming language.
# It contains an integer key with the corresponding string values
dict = {1: 'Rina', 2: 'Gita', 3: 'Sita'}
print("\n Printing the dictionary that contains integer keys with their corresponding values")
print(dict)

说明:

在上面的例子中，我们创建了一个包含整数键值和相应字符串值的字典。这里我们用班级中的学生数据进行了符号化，每个学生的名字对应一个学号。此外，我们将在这个字典中执行嵌套操作。

以下程序的输出

Printing the dictionary that contains integer keys with their corresponding values
{1: 'Rina', 2: 'Gita', 3: 'Sita'}

例 2:

# In the example we will create a simple empty dictionary using python 
# programming language
dict = {}
print("Simple empty Dictionary: ")
print(dict)

说明:

我们已经创建了一个不包含任何具有相应值的键的字典。此外，我们将在这个字典中执行嵌套操作。

以下程序的输出

Simple empty dictionary:
{ }

例 3:

# Python program to print Empty nested dictionary
dict = { 'dict1': { },                              # Nested dictionary syntax
        'dict2': { }, 'dict3': { }}
print("Nested dictionary are as follows -")
print(dict)

说明:

我们创建了一个嵌套字典，它包含空的数据集，或者一个空字典，它不包含任何带有相应键值的数据项。

以下程序的输出

Nested dictionary are as follows -
{'dict1': {}, 'dict2': {}, 'dict3': {}}

例 4:

# Let us first create a normal dictionary that contains data items with their 
# corresponding key value pairs in python programming language.
# It contains string key with the corresponding key values
dict = {'A': 1, 'B': 2, 'C': 3, 'D':4, 'E':5}
print("\n Printing the dictionary that contains string keys with their corresponding integer values")
print(dict)

说明:

在上面的例子中，我们创建了一个包含字符串键值和相应整数值的字典。这里我们用学生的数据符号化了有年级的班级中每个学生对应的学号。此外，我们将在这个字典中执行嵌套操作。

以下程序的输出

Printing the dictionary that contains string keys with their corresponding integer values
{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}

例 5:

# Let us first create a normal dictionary that contains data items with their 
# corresponding key-value pairs in a python programming language.
# Here, each item has formed a pair 
Dict = dict([(1, 'silk'), (2, 'one')])
print("\nDictionary with each item as a pair: ")
print(Dict)

说明:

我们创建了一个包含成对数据项的字典。我们已经创建了一个配对项目的列表，并将其作为字典。

以下程序的输出

Dictionary with each item as a pair: 
{1: 'silk', 2: 'one'}

例 6:

# Let us first create a dictionary that contains data items with their corresponding 
# key value pairs, and here we would assign the values to the keys separately in 
# Python programming language.

Dict={}
Dict[1] = 'Java'
Dict[2] = 'Tpoint'
Dict[3] = 1
print("\nDictionary after adding 3 elements: ")
print(Dict)

说明:

我们已经创建了三个独立的字典，并在相应的键值处逐一分配了元素。该字典包含整数键值和相应的字符串值。尽管如此，我们还是单独创建了它，之后，我们添加了这些字典。因此，我们可以在字典中执行加法运算。我们还将在这个字典中执行嵌套操作。

以下程序的输出

Dictionary after adding 3 elements: 
{1: 'Java', 2: 'Tpoint', 3: 1}

例 7:

# Let us first create a dictionary that contains data items with their corresponding 
# key value pairs in a python programming language.
# Here, we would perform the addition and update operation in the nested dictionary
# to a single Key
Dict['Value'] = 5, 3, 6
print("\nDictionary after adding 3 elements: ")
print(Dict)

# Updating existing Key's Value
Dict[2] = 'JavaTpoint'
print("\nUpdated key value: ")
print(Dict)

# Adding Nested Key value to Dictionary
Dict[5] = {'Nested' :{'5' : 'Java', '3' : 'T'}}
print("\n Adding a Nested Key: ")
print(Dict)

说明:

我们创建了一个字典，其中包含整数键值和相应的字符串值。这里，我们已经在字典中执行了更新和添加操作。我们还对它进行了一些修改，并将其转换为嵌套字典。

以下程序的输出

Dictionary after adding 3 elements: 
{'Name': 'JavaTpoint', 1: [11, 12, 13], 'Value': (5, 3, 6)}
Updated key value: 
{'Name': 'JavaTpoint', 1: [11, 12, 13], 'Value': (5, 3, 6), 2: 'JavaTpoint'}
Adding a Nested Key: 
{'Name': 'JavaTpoint', 1: [11, 12, 13], 'Value': (5, 3, 6), 2: 'JavaTpoint', 5: {'Nested': {'5': 'Java', '3': 'T'}}}

例 8:

# Let us first create a nested dictionary that contains data items with their 
# corresponding key-value pairs in a python programming language.
# Nested dictionary having the mixed keys 
Dict = {'Name': 'JavaTpoint', 1: [11, 12, 13]}
print("\nDictionary with the use of Mixed Keys: ")
print(Dict)

说明:

我们已经创建了一个嵌套字典，其中包含了键值和相应的值。在这里，我们使用了混合键的概念，其中键是不一样的。我们将扩展它，并使用相同的键但不同的值创建一个嵌套字典。

以下程序的输出

Dictionary with the use of Mixed Keys: 
{'Name': 'JavaTpoint', 1: [11, 12, 13]}

例 9:

# Let us first create a nested dictionary that contains data items with their 
# corresponding key-value pairs in a python programming language.
# Nested dictionary having the same keys 
Dict = { 'Dict1': {'Name': 'Reena', 'age': '22'},
        'Dict2': {'Name': 'Jatin', 'age': '19'}}
print("\n Nested dictionary 2-")
print(Dict)

说明:

在上面的例子中，我们创建了一个嵌套的字典，其中包含了键值和对应的值，这里我们使用了相同键的概念，其中键是相同的，但是对应的数据值是不同的。

以下程序的输出

Nested dictionary 2-
{'Dict1': {'Name': 'Reena', 'age': '22'}, 'Dict2': {'Name': 'Jatin', 'age': '19'}}

例 10:

# Let us first create a nested dictionary that contains data items with their 
# corresponding key-value pairs in a python programming language.
# Nested dictionary having the mixed keys 
Dict = { 'Dict1': {1: 'J', 2: 'T', 3: 'P'},
        'Dict2': {'Name': 'JTP', 1: [1, 2]} }
print("\n Nested dictionary 3-")
print(Dict)
Dict3 = { }
print("Initial nested dictionary:-")
print(Dict3)

Dict3['Dict1'] = {}

# Adding elements one at a time
Dict3['Dict1']['name'] = 'Boby'
Dict3['Dict1']['age'] = 21
print("\n After adding dictionary Dict1")
print(Dict3)

说明:

我们已经创建了一个嵌套字典，其中包含整数键值和相应的字符串值。在这里，我们首先打印了嵌套字典和一个空的嵌套字典。我们做了一些更改，将嵌套字典放在空字典中。我们还添加了两个嵌套字典。

以下程序的输出

Nested dictionary 3-
{'Dict1': {1: 'J', 2: 'T', 3: 'P'}, 'Dict2': {'Name': 'JTP', 1: [1, 2]}}
Initial nested dictionary:-
{}
After adding dictionary Dict1
{'Dict1': {'name': 'Boby', 'age': 21}}

让我们举一个固定的例子，然后看看其中的一些变化，这样我们就可以很容易很容易地理解:

例 11:

# creating a nested dictionary named as student
student = {1: {'name': 'Shivam', 'age': '22', 'Id': 10023},
          2: {'name': 'Anjali', 'age': '20', 'Id': 10024}}

print(student)

说明:

这里我们创建了一个简单的嵌套字典；此外，我们将做出一些改变。

以下程序的输出

{1: {'name': 'Shivam', 'age': '22', 'Id': 10023}, 2: {'name': 'Anjali', 'age': '20', 'Id': 10024}}

例 12:

# creating a nested dictionary named as student and accesing the elements using [] syntax
student = {1: {'name': 'Shivam', 'age': '22', 'Id': 10023},
          2: {'name': 'Anjali', 'age': '20', 'Id': 10024}}

print(student[1]['name'])
print(student[1]['age'])
print(student[1]['Id'])

说明:

在这里，我们创建了一个嵌套字典，并使用[ ]语法从字典中访问元素，在这里，当我们在您想要获取的元素的这个[ ]方括号位置提供字典的名称，然后在附加[ ]方括号中提供您想要为特定元素获取的属性或键值时，使用它。

以下程序的输出

Shivam
22
10023

例 13:

# creating a nested dictionary named as student and here we are adding one more 
# element in the dictionary
student = {1: {'name': 'Shivam', 'age': '22', 'Id': 10053},
          2: {'name': 'Anjali', 'age': '20', 'Id': 10004}}

student[3] = {}

student[3]['name'] = 'Tina'
student[3]['age'] = '19'
student[3]['Id'] = '10034'

print(student[3])

说明:

在这里，我们已经创建了一个嵌套的字典，我们希望向该字典中添加更多的元素。这一切都是通过使用[ ]方括号语法来完成的，首先我们在字典中的位置 3 创建了一个空集合，然后我们一个接一个地向其中填充数据，在这里当我们提供字典的名称时使用它，然后在您想要添加的元素的这个[ ]方括号位置和附加[ ]方括号中的 than 之后，使用等号来提供您想要为特定元素分配的属性或键值。

以下程序的输出

{'name': 'Tina', 'age': '19', 'Id': '10034'}

例 14:

# creating a nested dictionary named as student and here we are adding one more  
# element in the dictionary, after than we want to perform delete operation into it 
# for deleting particular elements from a particular dictionary indide the nested 
# dictionary.
student = {1: {'name': 'Shivam', 'age': '22', 'Id': 10053},
          2: {'name': 'Anjali', 'age': '20', 'Id': 10004}}

student[3] = {}

student[3]['name'] = 'Tina'
student[3]['age'] = '19'
student[3]['Id'] = '10034'

print(student[3])
del student[3][ 'Id']
print(student[3])

说明:

在这里，我们已经创建了一个嵌套的字典，我们希望向该字典中添加更多的元素。这都是通过使用[ ]方括号语法完成的。首先，我们在字典中的位置 3 创建了一个空集合，然后我们一个接一个地将数据填入其中。

在这里，当我们提供字典的名称，然后在您想要添加的元素的这个[ ]方括号位置，然后在附加的[ ]方括号中提供您想要使用等于符号为特定元素分配的属性或键值时，使用它。

现在删除特定的元素，比如说从嵌套字典中删除学生 3 的 id；我们必须在其中使用‘del’关键字；通过使用它，我们可以很容易地删除我们想要的特定值。

以下程序的输出

{'name': 'Tina', 'age': '19', 'Id': '10034'}
{'name': 'Tina', 'age': '19'}

例 15:

# creating a nested dictionary named as student and here we are adding one more  
# element in the dictionary, after than we want to perform delete operation into it 
# for deleting particular elements from a particular dictionary inside the nested 
# dictionary.
student = {1: {'name': 'Shivam', 'age': '22', 'Id': 10053},
          2: {'name': 'Anjali', 'age': '20', 'Id': 10004}}

student[3] = {}

student[3]['name'] = 'Tina'
student[3]['age'] = '19'
student[3]['Id'] = '10034'

print(student[3])
del student[3]
print(student)

说明:

在这里，我们已经创建了一个嵌套的字典，我们希望向该字典中添加更多的元素。这都是通过使用[ ]方括号语法完成的。首先，我们在字典中的位置 3 创建了一个空集合，然后我们一个接一个地将数据填充到其中，在这里，当我们提供字典的名称时使用它，然后在您想要添加的元素的这个[ ]方括号位置中，然后在附加的[ ]方括号中提供您想要使用等号为特定元素分配的属性或键值。

为了删除嵌套字典中的特定字典，我们使用了' del '关键字，并从学生嵌套字典中删除了学生 3 的整个字典。

以下程序的输出

{'name': 'Tina', 'age': '19', 'Id': '10034'}
{1: {'name': 'Shivam', 'age': '22', 'Id': 10053}, 2: {'name': 'Anjali', 'age': '20', 'Id': 10004}}