Python中的嵌套字典

Python中的嵌套字典

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

• 字典由两部分组成，第一部分是数据集合，第二部分是对应的键值。
• 它不允许重复。
• 这里的嵌套字典指的是字典中的字典。
• 简单来说，它是指由多个字典组成的字典集合。
• 它用于存储数据值以 键值对 的形式。
• 嵌套字典意味着将一个字典放在另一个字典中。嵌套在程序中的信息种类得到了极大的扩展。
• 嵌套字典包含 无序集合 的各种字典。
• 与普通字典相比，它还包含键和它们的值。
• 我们可以使用键来访问字典。
• 可以通过将逗号分隔的字典放在大括号中来创建嵌套字典。
• 不可能对嵌套字典进行切片。
• 我们可以根据需要缩小或扩大嵌套字典。

嵌套字典的语法，将各种字典添加到特定字典中：

可以使用多种方式将元素添加到嵌套字典中。一种方法是逐个添加值，Nesteddict[dict][key] = ‘value’。另一种方法是一次性添加整个字典，Nesteddict[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处创建了一个空集合，然后逐个填充数据到其中。在这里，当我们提供字典的名称时，在此[ ]方括号位置添加要添加的元素，并在附加的[ ]方括号中使用等号来指定要为特定元素分配的属性或键值。

以下程序的输出

{'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}}