【0017】Python数据类型-字典类型详解（全网最细教程）

如果你觉得我的文章写的不错，请关注我哟，请点赞、评论，收藏此文章，谢谢！

本文内容体系结构如下：

Python字典是一种内置的数据结构，它以键值对（key-value pair）的形式存储数据。字典是Python中非常强大且灵活的数据类型之一，广泛应用于各种编程场景中。掌握它的使用对于提高编程效率和解决实际问题具有重要意义。无论是初学者还是有经验的程序员，都应该熟练掌握字典的相关操作和应用场景。

一、什么是字典？

1.1 字典的定义

字典（Dictionary）是Python中一种内置的数据结构，它以键值对（key-value pair）的形式存储数据。字典中的每个元素都是一个键值对，键（key）是唯一的，而值（value）则可以是任何数据类型。

1.2 字典的特点

• 无序性：字典中的元素是无序的，即无法通过索引来访问元素。
• 可变性：字典是可变的，可以随时增加、删除或修改元素。
• 键唯一性：字典中的键是唯一的，不可变类型，不允许重复。

1.3 字典的应用场景

字典在Python编程中有着广泛的应用，常见的应用场景包括：

• 存储配置信息：可以使用字典来存储应用程序的配置信息，如数据库连接参数、API密钥等。
• 表示实体对象：可以使用字典来表示一个实体对象，如学生、商品等，其中键为属性名，值为属性值。
• 计数统计：可以使用字典来进行计数统计，如统计字符串中每个字符出现的次数。
• 缓存数据：可以使用字典作为缓存来存储已经计算过的结果，以提高程序性能。

二、字典的创建

要创建一个字典，可以使用大括号 {} 将一系列键值对元素包围起来，元素之间用英文逗号 , 分隔，键值对里的键和值之间使用英文冒号:分隔。或者使用dict()函数创建字典。

2.1 使用大括号创建字典

可以直接使用大括号 {} 来创建一个空字典，或者在大括号内添加键值对来创建一个有初始值的字典。

具体格式如下：

dictname = {key:value, key:value,...,key:value}

其中，dictname表示字典变量名，key表示字典键值对元素的键，value表示字典键值对元素的值。

# 创建空字典
empty_dict = {}
print(empty_dict) # {}
print(type(empty_dict)) # <class 'dict'>

# 创建有初始值的字典
student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}
print(type(student)) # <class 'dict'>

2.2 使用 dict() 函数创建字典

可以使用 dict() 函数来创建一个空字典，或者通过传入一个包含键值对的序列（如列表或元组）来创建字典。

# 创建空字典
empty_dict = dict()
print(empty_dict) # {}
print(type(empty_dict)) # <class 'dict'>

# 通过键值对序列创建字典
dict01 = dict(name="小明", age=20, gender="男")
print(dict01) # {'name': '小明', 'age': 20, 'gender': '男'}
print(type(dict01)) # <class 'dict'>

# 使用列表创建字典
list01 = [['name', 'Alice']]
dict02 = dict(list01)
print(dict02)  # {'name': 'Alice'}
list02 = [['name', 'Alice'], ['age', 30], ['city', 'New York']]
dict03 = dict(list02)
print(dict03)  # {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 使用元组创建字典
tuple01 = (('name', 'Bob'),) # 注意：这里('name', 'Bob')后面必须写一个,，不然房使用dict(tuple01)函数创建字典会报错，这个很有意思
dict04 = dict(tuple01)
print(dict04)  # {'name': 'Bob'}
tuple02 = (('name', 'Bob'), ('age', 25), ('city', 'Los Angeles'))
dict05= dict(tuple02)
print(dict05)  # {'name': 'Bob', 'age': 25, 'city': 'Los Angeles'}

# 使用JSON格式的字符串创建字典
import json
json_string = '{"name": "Charlie", "age": 22, "city": "Chicago"}'
dict06 = json.loads(json_string)
print(dict06)  # {'name': 'Charlie', 'age': 22, 'city': 'Chicago'}

# 从简单字符串创建单键值字典
key = 'name'
value = 'David'
dict07 = dict({key: value})
print(dict07)  # {'name': 'David'}

2.3 使用fromkeys()方法创建字典

fromkeys() 方法使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。该方法一般不会使用字典对象调用（没什么意义），通常会使用 dict 类直接调用。

# 使用列表创建包含2个key的字典
dict01 = dict.fromkeys(['a', 'b'])
print(dict01) # {'a': None, 'b': None}
# 使用元组创建包含2个key的字典
dict02 = dict.fromkeys((13, 17))
print(dict02) # {13: None, 17: None}
# 使用元组创建包含2个key的字典，指定默认的value
dict03 = dict.fromkeys((13, 17), 'good')
print(dict03) # {13: 'good', 17: 'good'}

三、删除字典

当字典不再使用时，使用del命令删除整个字典。删除字典后，再次使用字典会报NameError错误。

# 创建字典
dict01 = dict({"name":"张三","age":30})
print(dict01) # {'name': '张三', 'age': 30}
# 删除字典
del dict01
# 删除后使用字典
print(dict01) # NameError: name 'dict01' is not defined

代码执行效果如下：

四、访问字典元素的值

因为字典中的元素是无序的，所以字典中的元素不能通过索引来访问。字典中的元素可以直接根据键来访问，也可以使用字典中的get()方法来访问。

4.1 通过键访问值

可以使用字典的键来访问对应的值。如果键不存在，会抛出 KeyError 异常。语法格式如下：

值=字典名["键名"]

演示代码如下所示：

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}

# 访问字典中的值
print(student["name"])  # 小明
print(student["age"])   # 20
print(student["gender"]) # 男
# 访问字典中不存在的键
print(student["score"]) # KeyError: 'score'

运行结果如下图所示：

4.2 使用 get() 方法访问值

可以使用 get() 方法来访问字典中的值。如果键不存在，get() 方法会返回 None，而不会抛出异常。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}

# 使用 get() 方法访问值
# 访问字典中的键
print(student.get("name"))
print(student.get("age"))
print(student.get("gender"))# 输出：小明
# 访问字典中不存在的键
print(student.get("score")) # 键不存在，返回None

运行结果如下图所示：

4.3 使用 setdefault() 方法访问值

setdefault() 方法也用于根据 key 来获取对应 value 的值。如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 对应的值设置值为None，并将这个键值对存储到字典中，返回None。如果不想使用系统设置的None值，可以在使用setdefault() 方法时传递一个指定的值，注意，如果获取的键有对应的值，你还设置了默认值，默认值不会覆盖原来键对应的值。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}

# 使用 get() 方法访问值
# 访问字典中的存在的键
print(student.setdefault("name")) # 小明
print(student.setdefault("age")) # 20
print(student.setdefault("gender")) # 男
# 访问字典中的存在的键，并赋值，赋值不会覆盖字典中原来键对应的值
print(student.setdefault("name","张三")) # 小名

# 访问字典中不存在的键，不给键赋值，返回None，并且将这个键对应的值设置为None，让后将键值对添加进字典，
print(student.setdefault("score")) # None
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None}
# 访问字典中不存在的键，给键赋值，返回这个赋予的值，并将这个键值对添加进字典
print(student.setdefault("grade","大一")) # 大一
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None, 'grade': '大一'}

运行结果如下图所示：

五、遍历字典元素

遍历字典，可以分为遍历字典的键、字典的值和字典的键值对。

5.1 遍历字典的键

（1）for 循环来遍历字典的键

直接使用for循环遍历字典，输出的是字典中所有的键

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 遍历字典的键
for key in student:
    print(key)  # name, age, gender（顺序可能不同）

运行结果如下图所示：

（2）使用keys()方法获取所有的键

通过字典对象调用keys()方法可以获取字典中所有的键，存储在一个视图对象类型dict_keys中，dict_keys 不是列表，不支持列表的所有操作。然后可以使用for循环、enumerate()方法等方式遍历这个列表，获取所有的键。

演示代码如下所示：

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 获取所有的键
keys = student.keys()
print(keys) # dict_keys(['name', 'age', 'gender'])
print(type(keys)) # <class 'dict_keys'>
# 使用for循环遍历列表keys
for key in keys:
    print(key)

print("-------------------------------------------")

# 使用while循环遍历列表keys
for index,key in enumerate(keys):
    print(f"{index}：{key}")

运行结果如下图所示：

5.2 遍历字典的值

在 Python 中，遍历字典的值有多种方法。以下是一些常用的方法。

（1）使用 values() 方法获取所有的值。

通过字典对象调用values()方法可以获取字典中所有的值，存储在一个视图对象类型dict_values中，dict_keys 不是列表，不支持列表的所有操作。然后可以使用for循环、enumerate()方法等方式遍历这个列表，获取所有的值。最常用的是 .values() 方法，因为它直接且清晰。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 获取所有的值
values = student.values()
print(values)
print(type(values))
# 使用for循环遍历列表values
for value in values:
    print(value)

print("-------------------------------------------")

# 使用while循环遍历列表values
for index,value in enumerate(values):
    print(f"{index}：{value}")

运行结果如下图所示：

（2）使用 for 循环直接遍历字典

先获取键，然后通过键访问值。这种方法虽然不是直接遍历值，但在需要键和值都用的情况下很常用。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

for key in student:
    print(student[key]) # 使用print(student.get(key))也可以

运行结果如下图所示：

（3）使用字典解包（Python 3.5+）

如果你使用的是 Python 3.5 或更高版本，可以利用 ** 解包操作符。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 使用字典解包
for value in student.values():
    print(value)

运行结果如下图所示：

（4）将字典转换为列表或其他可迭代对象

如果需要对值进行进一步的处理，可以先将其转换为列表。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 将字典转换为列表或其他可迭代对象
value_list=list(student.values())
for value in value_list:
    print(value)

运行结果如下图所示：

这些方法各有其适用场景，选择哪种方法主要取决于你的具体需求和代码风格偏好。

5.3 遍历字典的键值对

（1）使用 items() 方法来遍历字典键值对

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 遍历字典的键值对
for key, value in student.items():
    print(f"{key}: {value}")  # 输出：name: 小明, age: 21, gender: 男（顺序可能不同）

运行结果如下图所示：

（2）使用 for 循环遍历字典键值对

使用for先获取键，然后通过键访问值。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

for key in student:
    print(key,"：",student[key]) # 使用student.get(key)也可以

运行结果如下图所示：

六、增加字典元素

在 Python 中，可以通过多种方式向字典中添加元素。以下是一些常用的方法。

6.1 使用赋值运算符

这是最直接的方法，通过键来添加或更新字典中的值。如果键不存在，九添加新的键值对，如果键已经存在，则会覆盖原有的值。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}

# 增加新元素
student["score"] = 90
print(student)  # {'name': '小明', 'age': 20, 'gender': '男', 'score': 90}
# 增加已经存在的键，新增的值会覆盖字典中已经存在的键
student["age"] = 21
print(student) # {'name': '小明', 'age': 21, 'gender': '男', 'score': 90}

运行结果如下图所示：

6.2 使用 update() 方法

update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。update() 方法可以用来添加多个键值对。它接受另一个字典或可迭代的键值对。

dict01 = {'key1': 'value1'}
print(dict01) # {'key1': 'value1'}
# 添加1个不存在的键值对
dict01.update({'key2': 'value2'})
print(dict01) # {'key1': 'value1', 'key2': 'value2'}
# 添加2个键值对，一个字典中已经存在，一个不存在
dict01.update(({"key2":"值2","key3":"value3"}))
print(dict01) # {'key1': 'value1', 'key2': '值2', 'key3': 'value3'}

# 也可以使用一个可迭代的键值对
dict01.update(key4='value4', key5='value5')
print(dict01) # {'key1': 'value1', 'key2': '值2', 'key3': 'value3', 'key4': 'value4', 'key5': 'value5'}

运行结果如下图所示：

6.4 使用 setdefault() 方法

setdefault() 方法也用于根据 key 来获取对应 value 的值。如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 对应的值设置值为None，并将这个键值对存储到字典中，返回None。如果不想使用系统设置的None值，可以在使用setdefault() 方法时传递一个指定的值，注意，如果获取的键有对应的值，你还设置了默认值，默认值不会覆盖原来键对应的值。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}

# 使用 get() 方法访问值
# 访问字典中的存在的键
print(student.setdefault("name")) # 小明
print(student.setdefault("age")) # 20
print(student.setdefault("gender")) # 男
# 访问字典中的存在的键，并赋值，赋值不会覆盖字典中原来键对应的值
print(student.setdefault("name","张三")) # 小名

# 访问字典中不存在的键，不给键赋值，返回None，并且将这个键对应的值设置为None，让后将键值对添加进字典，
print(student.setdefault("score")) # None
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None}
# 访问字典中不存在的键，给键赋值，返回这个赋予的值，并将这个键值对添加进字典
print(student.setdefault("grade","大一")) # 大一
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None, 'grade': '大一'}

运行结果如下图所示：

6.5 解包语法（Python 3.5+）

如果你有两个字典，并希望将它们合并成一个新字典，你可以使用解包语法（**）。这不会更新原有字典，而是返回一个新字典。

dict01 = {'key1': 'value1'}
dict02 = {'key2': 'value2'}
print("操作前字典dict01：",dict01) # 操作前字典dict01： {'key1': 'value1'}
print("操作前字典dict01：",dict02) # 操作前字典dict01： {'key2': 'value2'}

merged_dict = {**dict01, **dict02}
print(merged_dict) # {'key1': 'value1', 'key2': 'value2'}

print("操作后字典dict01：",dict01) # 操作后字典dict01： {'key1': 'value1'}
print("操作后字典dict01：",dict02) # 操作后字典dict01： {'key2': 'value2'}

运行结果如下图所示：

6.6 字典合并运算符（Python 3.9+）

从 Python 3.9 开始，可以使用合并运算符（|）来合并两个字典，生成一个新字典。

dict01 = {'key1': 'value1'}
dict02 = {'key2': 'value2'}
print("操作前字典dict01：",dict01) # 操作前字典dict01： {'key1': 'value1'}
print("操作前字典dict01：",dict02) # 操作前字典dict01： {'key2': 'value2'}

# 合并两个字典
merged_dict = dict01 | dict02
print(merged_dict) #{'key1': 'value1', 'key2': 'value2'}

print("操作后字典dict01：",dict01) # 操作后字典dict01： {'key1': 'value1'}
print("操作后字典dict01：",dict02) # 操作后字典dict01： {'key2': 'value2'}

运行结果如下图所示：

七、删除字典元素

在 Python 中，可以通过几种方法从字典中删除元素。以下是常用的方法。

7.1 pop()方法删除字典元素

• 使用 pop() 方法可以通过指定键来删除字典中的元素，并返回该键对应的值。
• 如果指定的键不存在，可以提供一个默认值，这样就不会引发错误。不然得话，程序会报KeyError错误。

dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 删除字典中存在的键
value01 = dict01.pop('b')  # 删除键 'b'
print(value01) # 2
print(dict01) # {'a': 1, 'c': 3}
# 如果键不存在，提供默认值
defaultvalue = dict01.pop('d', 'default_value')
print(defaultvalue) # default_value
print(dict01) # {'a': 1, 'c': 3}
# 如果键不存在，不提供默认值，报错
value02 = dict01.pop('d') # KeyError: 'd'
print(value02)
print(dict01)

运行结果如下图所示：

7.2 del语句删除字典元素

• 使用 del 语句可以直接删除字典中的键值对。
• 如果指定的键不存在，会引发 KeyError。

dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 删除字典中存在的键值对
del dict01["b"]
print(dict01) # {'a': 1, 'c': 3}

# 删除字典中不存在的键值对
del dict01["d"] # KeyError: 'd'
print(dict01) 

运行结果如下图所示：

7.3 popitem()方法删除字典元素

• popitem() 方法用于在不需要指定键的情况下删除字典中的最后一个元素（在 Python 3.7+ 中保证是 LIFO 顺序）。
• 它返回一个包含键和值的元组。

dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 删除字典中最后一个键值对
item01 = dict01.popitem()  # 删除并返回最后一个元素
print(item01) # ('c', 3)
print(dict01) # {'a': 1, 'b': 2}

item02 = dict01.popitem()  # 删除并返回最后一个元素
print(item02) # ('b', 2)
print(dict01) # {'a': 1}

运行结果如下图所示：

7.4 clear()方法删除字典元素

clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。

dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 清空字典,字典变为一个空字典
dict01.clear()
print(dict01) # {}

运行结果如下图所示：

在实际使用中，选择哪种方法取决于具体的需求，例如是否需要返回值等。

八、修改字典元素

修改字典元素可以采用赋值运算符来给字典中已经存在的键值对重新赋值，或者用update()方法实现给字典中已经存在的键重新赋值，从而达到修改字典元素的目的。方法具体操作参照6.1和6.2小节。

九、查找字典元素

可以使用运算符in和notin查找字典中的元素是否存在，in和not in查找的都是对字典中的键是否存在做出判断，返回True或者False。

9.1 in运算符查询元素在字典中是否存在

使用in运算符查询某个元素在字典是否存在，如果存在返回True，如果不在返回False。

语法格式如下：

result = 元素值 in 字典名

演示代码如下：

dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 使用运算符in查找键是否存在
print("键a在字典中存在：","a" in dict01) # 键a在字典中存在： True
print("键d在字典中存在：","d" in dict01) # 键d在字典中存在： False

运行结果如下图所示：

9.2 not in运算符查询元素在字典中是否不存在

使用not in运算符查询某个元素在字典中是否不存在，如果不存在返回True，如果存在返回False。

语法格式如下：

result = 元素值 not in 字典名

演示代码如下：

dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 使用运算符not in查找键是否不存在
print("键a在字典中不存在：","a" not in dict01) # 键a在字典中不存在： False
print("键d在字典中不存在：","d" not in dict01) # 键d在字典中不存在： True

运行结果如下图所示：

十、排序字典元素

在 Python 中，对字典进行排序的方法有多种，具体取决于您想要根据字典的键还是值进行排序。以下是几种常用的字典排序方法。

10.1 按键排序

10.1.1 使用 sorted()函数

• sorted() 函数返回一个新的列表，列表中的元素是排序后的字典项（即键值对）。
• 可以使用 lambda 函数指定排序键。

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=lambda x: x[0])
print(sorted_items)  # 输出: [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]

• 若需要降序排序，可以将 reverse 参数设置为 True。

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items_desc = sorted(my_dict.items(), key=lambda x: x[0], reverse=True)
print(sorted_items_desc)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]

10.1.2 使用 operator.itemgetter()函数

• itemgetter() 函数是 operator 模块中的一个函数，用于获取对象的多个属性。
• 它可以简化代码，提高可读性。

from operator import itemgetter

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=itemgetter(0))
print(sorted_items)  # 输出: [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]

10.1.3 使用 collections.OrderedDict

• OrderedDict 是一个有序的字典，它保持了元素插入的顺序。
• 可以通过先排序再转换为 OrderedDict 来实现按键排序。

from collections import OrderedDict

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_dict = OrderedDict(sorted(my_dict.items(), key=lambda x: x[0]))
print(sorted_dict)  # 输出: OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

10.2 按值排序

10.2.1 使用 sorted() 函数

• 与按键排序类似，只需调整 lambda 函数中的参数。

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=lambda x: x[1])
print(sorted_items)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]

10.2.2 使用 operator.itemgetter()函数

• 同样可以简化代码。

from operator import itemgetter

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=itemgetter(1))
print(sorted_items)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]

10.2.3 使用 collections.OrderedDict

• 同样可以转换为 OrderedDict 来保持排序后的顺序。

from collections import OrderedDict

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_dict = OrderedDict(sorted(my_dict.items(), key=lambda x: x[1]))
print(sorted_dict)  # 输出: OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

注意事项：

• 排序后的结果是一个列表，其中每个元素是一个元组（键值对）。
• 如果需要将排序后的结果转换回字典，可以使用 dict() 函数。
• 字典本身是无序的，排序操作不会改变原字典的顺序，而是返回一个新的有序序列。

这些方法可以根据具体需求选择使用，以实现按键或按值对字典进行排序。

十一、字典的复制

在 Python 中，复制字典的方法有多种，根据具体需求和 Python 版本的不同，可以选择以下几种方法。

11.1 使用 copy 方法

• dict.copy()：这会创建一个浅复制（shallow copy）的新字典。

original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 2097791629312
copied = original.copy()
print(copied,id(copied)) # {'a': 1, 'b': 2} 2097792040768

11.2 使用 dict`函数

• 可以通过 dict() 函数直接创建一个新字典。

original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 1572641044480
copied = dict(original)
print(copied,id(copied)) # {'a': 1, 'b': 2} 1572641578368

11.3 使用 dict 的解包语法（Python 3.5+）

• 利用字典解包（dictionary unpacking）特性。

original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 1521142003712
copied = {**original}
print(copied,id(copied)) # {'a': 1, 'b': 2} 1521142415168

11.4 使用 collections.ChainMa()

该方法只适用于创建合并视图，不是真正的复制）

• collections.ChainMap 可以用于将多个字典视为一个字典，但这不产生实际的副本。

from collections import ChainMap

original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 2792366798848
copied = dict(ChainMap(original))
print(copied,id(copied)) # {'a': 1, 'b': 2} 2792367330368

11.5 使用 copy 模块中的 deepcopy 函数

• copy.deepcopy()：用于创建深复制（deep copy），对字典中包含的嵌套对象也进行复制。

import copy

original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 2454908452672
copied = copy.deepcopy(original)
print(copied,id(copied)) # {'a': 1, 'b': 2} 2454908569280

需要注意的是，浅复制只是复制了字典的顶层结构，如果字典中包含可变对象（如另一个字典或列表），浅复制之后修改内部可变对象会影响到原字典。而深复制则会递归复制对象内部的所有层级，确保复制后的对象和原对象完全独立。选择合适的复制方法需要根据具体的使用场景来决定。

十二、字典的合并

在 Python 中，合并字典的方法有多种，以下是一些常用的方法

12.1 使用update()方法

• 描述：update() 方法将一个字典的键值对更新到另一个字典中。

• 示例：

  dict01 = {'a': 1, 'b': 2}
  dict02 = {'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  
  dict01.update(dict02)
  print(dict01) # {'a': 1, 'b': 3, 'c': 4}
  print(dict02) # {'b': 3, 'c': 4}
  

• 注意事项：此方法会直接修改 dict1，不会创建新的字典。如果希望保留 dict1 的原始内容，可以先复制 dict1。

12.2使用解包语法（Python 3.5+）

• 描述：使用 ** 运算符解包字典，将多个字典合并为一个新的字典。

• 示例：

  dict01 = {'a': 1, 'b': 2}
  dict02 = {'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  
  merged_dict = {**dict01, **dict02}
  print(merged_dict)  # {'a': 1, 'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  

12.3 使用 | 运算符（Python 3.9+）

• 描述：| 运算符用于合并两个字典，生成一个新的字典。

• 示例：

  dict01 = {'a': 1, 'b': 2}
  dict02 = {'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  
  merged_dict = dict01 | dict02
  print(merged_dict)  # {'a': 1, 'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  

12.4 使用ChainMap

• 描述：ChainMap 是 collections 模块中的一个类，允许将多个字典链接在一起，创建一个单一的视图。对 ChainMap 所做的任何更新或更改都会反映在底层字典中。适用于需要保留字典层级的情况

• 示例：

  from collections import ChainMap
  
  dict01 = {'a': 1, 'b': 2}
  dict02 = {'c': 3, 'd': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'c': 3, 'd': 4}
  
  merged_dict = ChainMap(dict01, dict02)
  print(merged_dict) # ChainMap({'a': 1, 'b': 2}, {'c': 3, 'd': 4})
  print(merged_dict['a'])  # 1
  print(merged_dict['b'])  # 2
  print(merged_dict['c'])  # 3
  print(merged_dict['d'])  # 4
  dict03 = dict(merged_dict)
  print(dict03) # {'c': 3, 'd': 4, 'a': 1, 'b': 2}
  
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'c': 3, 'd': 4}
  

• 注意事项：ChainMap 本身不是一个字典，而是一个字典视图。如果需要获取合并后的字典，可以使用 dict() 函数转换。

12.5 使用 dict.items()和集合操作（Python 3.9+）

• 描述：利用 dict.items() 方法获取字典的键值对视图，然后使用集合操作合并这些键值对。

• 示例：

  dict01 = {'a': 1, 'b': 2}
  dict02 = {'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  
  merged_dict = dict(dict01.items() | dict02.items())
  print(merged_dict)  # {'c': 4, 'b': 3, 'a': 1}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  

• 注意事项：这种方法在 Python 3.9 及更高版本中可用，因为 | 运算符在 Python 3.9 中被引入用于字典项的合并。

12.6 使用字典解析式

• 描述：通过字典解析式将多个字典合并为一个新的字典。

• 示例：

  dict01 = {'a': 1, 'b': 2}
  dict02 = {'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  
  merged_dict = {k: v for d in [dict01, dict02] for k, v in d.items()}
  print(merged_dict)  # {'a': 1, 'b': 3, 'c': 4}
  
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  

12.7 使用 for循环和 keys()方法

• 描述：通过 for 循环遍历第二个字典的键，将键值对添加到第一个字典中。

• 示例：

  dict01 = {'a': 1, 'b': 2}
  dict02 = {'b': 3, 'c': 4}
  print(dict01) # {'a': 1, 'b': 2}
  print(dict02) # {'b': 3, 'c': 4}
  
  for k in dict02.keys():
      dict01[k] = dict02[k]
  print(dict01)  # {'a': 1, 'b': 3, 'c': 4}
  
  print(dict01) # {'a': 1, 'b': 3, 'c': 4}
  print(dict02) # {'b': 3, 'c': 4}
  

• 注意事项：这种方法会直接修改 dict1，不会创建新的字典。

选择合适的方法

• 如果希望保留原始字典：可以使用解包语法、| 运算符或字典解析式，这些方法会创建新的字典。
• 如果需要在合并过程中保留字典层级：可以使用 ChainMap。
• 如果希望代码简洁易读：可以使用 update() 方法（如果不需要保留原始字典）或 | 运算符（Python 3.9+）。

根据具体的需求和 Python 版本，可以选择最适合的方法来合并字典。

十三、字典推导式

13.1 什么是推导式

Python推导式（comprehension）是一种简洁而高效的构建容器（如列表、集合、字典）的方法。它允许你用一行代码来创建容器，并且可以通过循环和条件语句来生成容器中的元素。

推导式分为列表推导式（list comprehension）、集合推导式（set comprehension）、字典推导式（dictionary comprehension）以及生成器表达式（generator expression）。

推导式是Python中非常强大和常用的特性，可以使代码更加简洁和高效。

13.2 字典推导式

字典推导式（dictionary comprehension）是一种简洁而优雅的方式，用于从一个可迭代对象中创建字典。它的语法类似于列表推导式，但使用花括号 {} 而不是方括号 []。

13.3 基本语法

new_dict = {key_expression: value_expression for item in iterable if condition}

• key_expression：用于生成字典的键的表达式。
• value_expression：用于生成字典的值的表达式。
• iterable：一个可迭代对象，如列表、元组、字典等。
• condition（可选）：一个过滤条件，用于筛选哪些元素应该包含在字典中。

13.4 演示示例

以下是一些使用字典推导式的示例：

13.4.1 简单的字典推导式

从一个列表创建一个字典，其中键是列表中的元素，值是元素的平方：

numbers = [1, 2, 3, 4, 5]
squared_dict = {num: num ** 2 for num in numbers}
print(squared_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

13.4.2 带有条件的字典推导式

从一个列表创建一个字典，其中键是列表中的偶数元素，值是元素的平方：

numbers = [1, 2, 3, 4, 5]
even_squared_dict = {num: num ** 2 for num in numbers if num % 2 == 0}
print(even_squared_dict)  # {2: 4, 4: 16}

13.4.3 从字典创建新的字典

从一个字典创建一个新的字典，交换键和值：

original_dict = {'a': 1, 'b': 2, 'c': 3}
inverted_dict = {value: key for key, value in original_dict.items()}
print(inverted_dict)  # {1: 'a', 2: 'b', 3: 'c'}

13.4.4 使用嵌套推导式

从一个嵌套列表创建一个字典，其中键是子列表的第一个元素，值是子列表的第二个元素：

nested_list = [['a', 1], ['b', 2], ['c', 3]]
nested_dict = {key: value for key, value in nested_list}
print(nested_dict)  # {'a': 1, 'b': 2, 'c': 3}

13.5 使用场景

• 数据转换：从一个数据结构（如列表、元组）快速创建字典。
• 过滤和筛选：在创建字典时，根据条件筛选元素。
• 简化代码：将多行代码简化为单行，提高代码的可读性和可维护性。

13.6 注意事项

• 可读性：虽然字典推导式可以简化代码，但过于复杂的推导式可能会降低代码的可读性。
• 性能：字典推导式通常比传统的循环方式更高效，尤其是在处理大量数据时。
• Python 版本：字典推导式在 Python 2.7 及更高版本中可用。

字典推导式是一种强大的工具，可以帮助开发者以简洁而高效的方式创建和操作字典。

十四、总结

本文我们详细学习了Python字典的基本概念、创建和访问方法、增删改查操作、遍历方法、复制、合并以及字典推导式等内容。字典是Python中一种非常强大的数据结构，掌握字典的使用对于提高编程效率和解决实际问题具有重要意义。希望大家能够认真练习，熟练掌握字典的相关操作。