【Python-Day 15】深入探索 Python 字典 (下)：常用方法、遍历、推导式与嵌套实战

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘
08-【万字长文】MCP深度解析：打通AI与世界的“USB-C”，模型上下文协议原理、实践与未来

Python系列文章目录

PyTorch系列文章目录

机器学习系列文章目录

深度学习系列文章目录

Java系列文章目录

JavaScript系列文章目录

Python系列文章目录

01-【Python-Day 1】告别编程恐惧：轻松掌握 Python 安装与第一个程序的 6 个步骤
02-【Python-Day 2】掌握Python基石：变量、内存、标识符及int/float/bool数据类型
03-【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)
04-【Python-Day 4】玩转文本：Python 字符串常用方法深度解析 (下篇)
05-【Python-Day 5】Python 格式化输出实战：%、format()、f-string 对比与最佳实践
06- 【Python-Day 6】从零精通 Python 运算符（上）：算术、赋值与比较运算全解析
07-【Python-Day 7】从零精通 Python 运算符（下）：逻辑、成员、身份运算与优先级规则全解析
08-【Python-Day 8】从入门到精通：Python 条件判断 if-elif-else 语句全解析
09-【Python-Day 9】掌握循环利器：for 循环遍历序列与可迭代对象详解
10-【Python-Day 10】Python 循环控制流：while 循环详解与 for 循环对比
11-【Python-Day 11】列表入门：Python 中最灵活的数据容器 (创建、索引、切片)
12-【Python-Day 12】Python列表进阶：玩转添加、删除、排序与列表推导式
13-【Python-Day 13】Python 元组 (Tuple) 详解：从创建、操作到高级应用场景一网打尽
14-【Python-Day 14】玩转Python字典(上篇)：从零开始学习创建、访问与操作
15-【Python-Day 15】深入探索 Python 字典 (下)：常用方法、遍历、推导式与嵌套实战

---

---

前言

在上一篇 【Python-Day 14】键值对的世界 - 字典 (Dictionary) 详解 (上) 中，我们初步认识了 Python 中的字典，学习了如何创建字典、访问、添加、修改和删除键值对。字典作为一种极其重要的数据结构，其强大之处还远不止于此。本篇我们将继续深入，详细探讨字典的常用方法、高效的遍历方式、简洁的字典推导式以及如何处理更复杂的嵌套字典。掌握这些内容，你将能更自如地运用字典解决实际问题。

一、获取字典的视图：keys(), values(), items()

字典提供了三个非常实用的方法，用于获取其内部元素的特定“视图”(View Objects)：keys() 返回所有键的视图，values() 返回所有值的视图，而 items() 返回所有键值对（元组形式）的视图。这些视图对象是动态的，意味着如果原始字典发生改变，视图也会相应地反映这些变化。

1.1 概览与特性

字典视图对象有以下几个关键特性：

• 动态性：它们提供的是字典内容的动态视图，而不是静态副本。如果字典更新，视图会实时反映这些变化。
• 可迭代性：所有视图对象都是可迭代的，因此可以直接用于 for 循环。
• 类集合操作：keys() 和 items() 视图支持一些集合操作，如并集、交集（如果元素可哈希）。values() 视图通常不支持这些操作，因为它可能包含重复且不可哈希的元素。

让我们通过一个例子来直观感受一下：

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}
print(f"原始字典: {student_scores}") # 原始字典: {'Alice': 95, 'Bob': 88, 'Charlie': 92}keys_view = student_scores.keys()
values_view = student_scores.values()
items_view = student_scores.items()print(f"键视图: {keys_view}")     # 键视图: dict_keys(['Alice', 'Bob', 'Charlie'])
print(f"值视图: {values_view}")   # 值视图: dict_values([95, 88, 92])
print(f"项视图: {items_view}")   # 项视图: dict_items([('Alice', 95), ('Bob', 88), ('Charlie', 92)])# 修改字典
student_scores["David"] = 78
print(f"修改后字典: {student_scores}") # 修改后字典: {'Alice': 95, 'Bob': 88, 'Charlie': 92, 'David': 78}# 视图会自动更新
print(f"更新后键视图: {keys_view}")   # 更新后键视图: dict_keys(['Alice', 'Bob', 'Charlie', 'David'])
print(f"更新后值视图: {values_view}") # 更新后值视图: dict_values([95, 88, 92, 78])
print(f"更新后项视图: {items_view}") # 更新后项视图: dict_items([('Alice', 95), ('Bob', 88), ('Charlie', 92), ('David', 78)])

1.2 获取所有键：keys() 方法

keys() 方法返回一个包含字典所有键的视图对象 (dict_keys)。

1.2.1 基本用法与示例

my_dict = {'name': 'CodeMaster', 'version': '1.0', 'language': 'Python'}
all_keys = my_dict.keys()
print(all_keys) # 输出: dict_keys(['name', 'version', 'language'])# 可以将视图转换为列表
keys_list = list(all_keys)
print(keys_list) # 输出: ['name', 'version', 'language']

1.2.2 keys() 返回的对象类型

返回的 dict_keys 对象是可迭代的，并且支持成员测试（in）。

if 'version' in all_keys:print("字典中包含 'version' 键。") # 输出: 字典中包含 'version' 键。

1.3 获取所有值：values() 方法

values() 方法返回一个包含字典所有值的视图对象 (dict_values)。

1.3.1 基本用法与示例

my_dict = {'name': 'CodeMaster', 'version': '1.0', 'language': 'Python', 'score': 100}
all_values = my_dict.values()
print(all_values) # 输出: dict_values(['CodeMaster', '1.0', 'Python', 100])# 同样可以转换为列表
values_list = list(all_values)
print(values_list) # 输出: ['CodeMaster', '1.0', 'Python', 100]

1.3.2 values() 返回的对象类型

返回的 dict_values 对象也是可迭代的。需要注意的是，值视图中可能包含重复的元素。

grades = {'math': 90, 'english': 95, 'history': 90}
student_values = grades.values()
print(student_values) # 输出: dict_values([90, 95, 90])
print(list(student_values).count(90)) # 输出: 2

1.4 获取所有键值对：items() 方法

items() 方法返回一个包含字典所有键值对（以元组形式 (key, value)）的视图对象 (dict_items)。

1.4.1 基本用法与示例

my_dict = {'name': 'CodeMaster', 'version': '1.0'}
all_items = my_dict.items()
print(all_items) # 输出: dict_items([('name', 'CodeMaster'), ('version', '1.0')])# 转换为列表，列表中的每个元素是一个元组
items_list = list(all_items)
print(items_list) # 输出: [('name', 'CodeMaster'), ('version', '1.0')]

1.4.2 items() 返回的对象类型

dict_items 对象也是可迭代的，常用于同时遍历键和值。

item_tuple = ('name', 'CodeMaster')
if item_tuple in all_items:print(f"{item_tuple} 存在于字典项中。") # 输出: ('name', 'CodeMaster') 存在于字典项中。

二、玩转字典遍历

遍历字典是日常编程中非常常见的操作。Python 提供了多种灵活的方式来遍历字典的键、值或键值对。

2.1 遍历字典的键

（1） 直接遍历字典 (默认行为)

当你直接在 for 循环中使用字典时，默认遍历的是字典的键。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("遍历键 (默认行为):")
for name in student_scores:print(f"学生: {name}, 成绩: {student_scores[name]}")
# 输出:
# 遍历键 (默认行为):
# 学生: Alice, 成绩: 95
# 学生: Bob, 成绩: 88
# 学生: Charlie, 成绩: 92

（2） 使用 keys() 方法遍历

显式使用 keys() 方法也能达到同样的效果，代码意图更清晰。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("\n使用 keys() 遍历键:")
for name in student_scores.keys():print(f"学生: {name}")
# 输出:
# 使用 keys() 遍历键:
# 学生: Alice
# 学生: Bob
# 学生: Charlie

这种方式在需要先对键进行某些操作（如排序）后再遍历时特别有用。

2.2 遍历字典的值

（1） 使用 values() 方法遍历

如果你只关心字典中的值，可以使用 values() 方法。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("\n遍历值:")
for score in student_scores.values():print(f"成绩: {score}")
# 输出:
# 遍历值:
# 成绩: 95
# 成绩: 88
# 成绩: 92

2.3 遍历字典的键值对

（1） 使用 items() 方法遍历 (推荐)

当需要同时访问键和值时，items() 方法是最佳选择。它返回键值对元组，可以在 for 循环中直接解包。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("\n遍历键值对 (推荐):")
for name, score in student_scores.items(): # 解包元组print(f"学生: {name}, 成绩: {score}")
# 输出:
# 遍历键值对 (推荐):
# 学生: Alice, 成绩: 95
# 学生: Bob, 成绩: 88
# 学生: Charlie, 成绩: 92

（2） 解包键值对

上面的 for name, score in student_scores.items(): 就是一个解包操作。items() 返回的每个元素是 (key, value) 形式的元组，通过 name, score 这样的形式，Python 会自动将元组的第一个元素赋给 name，第二个元素赋给 score。

2.4 遍历时的注意事项

在 Python 3.x 中，keys(), values(), items() 返回的是视图对象。如果在遍历字典视图的同时修改字典（添加或删除键），可能会导致 RuntimeError: dictionary changed size during iteration 错误，或者迭代行为不可预测。

通常建议的做法是：

1. 如果需要修改，先将视图转换为列表（如 list(my_dict.keys())），然后遍历这个静态列表。
2. 或者，创建一个新字典来存储修改，而不是在原地修改。

# 错误示例：在遍历时修改字典大小
# data = {'a': 1, 'b': 2, 'c': 3}
# for key in data.keys(): # data.keys() 是动态视图
#     if data[key] % 2 == 0:
#         del data[key] # 这会改变字典大小，可能引发 RuntimeError# 正确做法1：遍历键的副本
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
keys_to_delete = []
for key, value in data.items():if value % 2 == 0:keys_to_delete.append(key)for key in keys_to_delete:del data[key]
print(f"删除偶数值后的字典: {data}") # 删除偶数值后的字典: {'a': 1, 'c': 3}# 正确做法2: 创建新字典 (通常更推荐)
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
new_data = {}
for key, value in data.items():if value % 2 != 0: # 保留奇数值new_data[key] = value
print(f"只包含奇数值的新字典: {new_data}") # 只包含奇数值的新字典: {'a': 1, 'c': 3}

三、字典常用操作方法

除了视图方法和基本的增删改查，字典还有其他一些有用的内建方法。

3.1 检查键是否存在：in 和 not in 运算符

我们已经在前面多次使用过 in 运算符来检查一个键是否存在于字典中。这是判断键是否存在的推荐方式，比尝试访问并捕获 KeyError 更 Pythonic。

3.1.1 基本用法与示例

config = {"host": "localhost", "port": 8080, "debug_mode": True}key_to_check = "port"
if key_to_check in config:print(f"键 '{key_to_check}' 存在于字典中，值为: {config[key_to_check]}")
else:print(f"键 '{key_to_check}' 不存在于字典中。")
# 输出: 键 'port' 存在于字典中，值为: 8080key_to_check = "username"
if key_to_check not in config:print(f"键 '{key_to_check}' 确实不存在于字典中。")
else:print(f"键 '{key_to_check}' 存在于字典中。")
# 输出: 键 'username' 确实不存在于字典中。

3.1.2 与 get() 方法的比较

in 运算符用于检查键的存在性，返回布尔值。而 get(key, default) 方法用于获取键对应的值，如果键不存在，可以返回一个默认值（默认为 None），避免了 KeyError。

• 场景1：只想知道键是否存在？ 使用 in。
• 场景2：想获取值，如果不存在则使用默认值？ 使用 get()。
• 场景3：想获取值，如果不存在则报错（明确要求键必须存在）？ 直接用 dict[key]。

config = {"host": "localhost"}# 使用 in
if "port" in config:port = config["port"]
else:port = 8000 # 默认值
print(f"端口号 (使用 in): {port}") # 端口号 (使用 in): 8000# 使用 get()
port = config.get("port", 8000) # 更简洁
print(f"端口号 (使用 get()): {port}") # 端口号 (使用 get()): 8000# host 存在
host = config.get("host", "127.0.0.1")
print(f"主机 (使用 get()): {host}") # 主机 (使用 get()): localhost

3.2 合并字典：update() 方法

update() 方法用于将一个字典的键值对更新到另一个字典中。如果遇到相同的键，原字典中的值会被新字典中的值覆盖。

3.2.1 使用另一个字典更新

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}dict1.update(dict2) # dict2 中的内容更新到 dict1
print(f"dict1 更新后: {dict1}") # dict1 更新后: {'a': 1, 'b': 3, 'c': 4}
# 注意：dict2 保持不变
print(f"dict2: {dict2}") # dict2: {'b': 3, 'c': 4}

3.2.2 使用可迭代的键值对更新

update() 方法不仅接受字典作为参数，还可以接受一个包含键值对元组的可迭代对象（如列表）。

user_profile = {'name': 'Alice'}
extra_info_list = [('age', 30), ('city', 'New York')]user_profile.update(extra_info_list)
print(f"更新后的用户配置: {user_profile}")
# 输出: 更新后的用户配置: {'name': 'Alice', 'age': 30, 'city': 'New York'}# 也可以使用关键字参数
user_profile.update(country='USA', occupation='Engineer')
print(f"再次更新后的用户配置: {user_profile}")
# 输出: 再次更新后的用户配置: {'name': 'Alice', 'age': 30, 'city': 'New York', 'country': 'USA', 'occupation': 'Engineer'}

3.2.3 处理键冲突

当使用 update() 合并字典时，如果参数字典中存在与原字典相同的键，则原字典中该键对应的值会被参数字典中的值所覆盖。

settings_default = {'theme': 'light', 'fontsize': 12, 'language': 'en'}
user_settings = {'fontsize': 14, 'language': 'zh-CN', 'show_sidebar': True}settings_default.update(user_settings)
print(f"合并后的设置: {settings_default}")
# 输出: 合并后的设置: {'theme': 'light', 'fontsize': 14, 'language': 'zh-CN', 'show_sidebar': True}
# 'fontsize' 和 'language' 被 user_settings 中的值覆盖

从 Python 3.9 开始，还可以使用 | (并集) 操作符合并字典，它会创建一个新字典：

# Python 3.9+
dict_a = {'x': 1, 'y': 2}
dict_b = {'y': 3, 'z': 4}
merged_dict = dict_a | dict_b
print(f"使用 | 合并 (Python 3.9+): {merged_dict}") # 使用 | 合并 (Python 3.9+): {'x': 1, 'y': 3, 'z': 4}
# dict_a 和 dict_b 保持不变

四、字典推导式：简洁创建与转换字典

类似于列表推导式，Python 也支持字典推导式 (Dictionary Comprehension)，它提供了一种简洁优雅的方式来创建字典。

4.1 什么是字典推导式？

字典推导式是一种基于现有可迭代对象（如列表、元组、集合，甚至另一个字典）来创建新字典的紧凑语法。它的基本结构是 {key_expr: value_expr for item in iterable if condition}。

4.2 基本语法与示例

4.2.1 从列表或元组创建字典

假设我们有一个名字列表，想创建一个字典，其中名字作为键，名字的长度作为值。

names = ["Alice", "Bob", "Charlie"]
name_lengths = {name: len(name) for name in names}
print(f"名字长度字典: {name_lengths}")
# 输出: 名字长度字典: {'Alice': 5, 'Bob': 3, 'Charlie': 7}

或者，从一个包含键值对元组的列表创建字典：

pairs = [("fruit", "apple"), ("color", "red"), ("count", 5)]
my_dict_from_pairs = {key: value for key, value in pairs}
print(f"从元组列表创建的字典: {my_dict_from_pairs}")
# 输出: 从元组列表创建的字典: {'fruit': 'apple', 'color': 'red', 'count': 5}

4.2.2 基于现有字典创建新字典 (带条件)

从一个现有字典中筛选元素或转换键值来创建新字典。

scores = {"Math": 95, "English": 88, "Science": 92, "History": 75}# 创建一个只包含及格科目 (>=90) 的字典
passing_scores = {subject: score for subject, score in scores.items() if score >= 90}
print(f"及格科目: {passing_scores}")
# 输出: 及格科目: {'Math': 95, 'Science': 92}# 创建一个将所有科目名称转为小写的新字典
scores_lower = {subject.lower(): score for subject, score in scores.items()}
print(f"科目小写字典: {scores_lower}")
# 输出: 科目小写字典: {'math': 95, 'english': 88, 'science': 92, 'history': 75}

4.2.3 键值互换

如果原字典的值是可哈希的（例如字符串、数字、元组），可以轻松地实现键值互换。

original_dict = {"a": 1, "b": 2, "c": 3}
# 确保值是唯一的，否则互换后会有键被覆盖
swapped_dict = {value: key for key, value in original_dict.items()}
print(f"键值互换后的字典: {swapped_dict}")
# 输出: 键值互换后的字典: {1: 'a', 2: 'b', 3: 'c'}# 如果值不唯一，后出现的会覆盖前面的
non_unique_values = {"a": 1, "b": 2, "c": 1}
swapped_non_unique = {value: key for key, value in non_unique_values.items()}
print(f"值不唯一时键值互换: {swapped_non_unique}")
# 输出: 值不唯一时键值互换: {1: 'c', 2: 'b'} (键 'a' 被 'c' 覆盖，因为它们的值都是1)

4.3 字典推导式的优势

• 简洁性：相比使用 for 循环和手动添加键值对，字典推导式更为紧凑。
• 可读性：一旦熟悉了语法，字典推导式能更清晰地表达创建字典的意图。
• 效率：通常情况下，推导式的执行效率略高于等效的 for 循环（尽管对于初学者而言，可读性优先）。

五、嵌套字典：构建复杂数据结构

当我们需要表示更复杂的数据结构时，例如一个学生信息系统，每个学生有多个属性（姓名、年龄、成绩等），这时就可以使用嵌套字典。即字典的值本身也是一个字典。

5.1 什么是嵌套字典？

嵌套字典是指一个字典的某些值是另一个字典。这允许我们创建层次化的数据结构。

5.2 创建嵌套字典

可以直接定义，也可以逐步构建。

# 直接定义
students_data = {"student_001": {"name": "Alice","age": 20,"courses": {"math": 95, "english": 88}},"student_002": {"name": "Bob","age": 22,"courses": {"math": 78, "history": 92}}
}
print(f"嵌套字典: {students_data}")
# 输出:
# 嵌套字典: {'student_001': {'name': 'Alice', 'age': 20, 'courses': {'math': 95, 'english': 88}}, 'student_002': {'name': 'Bob', 'age': 22, 'courses': {'math': 78, 'history': 92}}}

5.3 访问嵌套字典的元素

访问嵌套字典的元素需要逐层使用键。

5.3.1 逐层访问

# 获取 Alice 的姓名
alice_name = students_data["student_001"]["name"]
print(f"Alice 的姓名: {alice_name}") # Alice 的姓名: Alice# 获取 Bob 的数学成绩
bob_math_score = students_data["student_002"]["courses"]["math"]
print(f"Bob 的数学成绩: {bob_math_score}") # Bob 的数学成绩: 78

5.3.2 使用 get() 方法安全访问

为了避免因键不存在而引发 KeyError，尤其是在处理可能不完整的嵌套数据时，推荐使用 get() 方法。

# 尝试获取 Alice 的物理成绩 (不存在)
alice_physics_score = students_data.get("student_001", {}).get("courses", {}).get("physics", "N/A")
print(f"Alice 的物理成绩: {alice_physics_score}") # Alice 的物理成绩: N/A# 解释:
# students_data.get("student_001", {}) : 如果 "student_001" 存在，返回其值 (一个字典)；否则返回空字典 {}
# .get("courses", {})                  : 在上一步返回的字典中查找 "courses"；否则返回空字典 {}
# .get("physics", "N/A")               : 在上一步返回的字典中查找 "physics"；否则返回 "N/A"

这种链式 get() 调用是一种安全访问深层嵌套值的常用模式。

5.4 修改嵌套字典的元素

修改嵌套字典的元素也需要先定位到该元素。

# 修改 Alice 的年龄
students_data["student_001"]["age"] = 21
print(f"修改后 Alice 的年龄: {students_data['student_001']['age']}") # 修改后 Alice 的年龄: 21# 给 Bob 添加一门新课程和成绩
students_data["student_002"]["courses"]["science"] = 85
print(f"Bob 修改后的课程信息: {students_data['student_002']['courses']}")
# Bob 修改后的课程信息: {'math': 78, 'history': 92, 'science': 85}

5.5 遍历嵌套字典

遍历嵌套字典通常需要使用嵌套循环。

print("\n遍历所有学生信息:")
for student_id, info in students_data.items():print(f"学生ID: {student_id}")for key, value in info.items():if isinstance(value, dict): # 如果值本身也是字典 (如 courses)print(f"  {key}:")for sub_key, sub_value in value.items():print(f"    {sub_key}: {sub_value}")else:print(f"  {key}: {value}")print("-" * 20) # 分隔符# 输出:
# 遍历所有学生信息:
# 学生ID: student_001
#   name: Alice
#   age: 21
#   courses:
#     math: 95
#     english: 88
# --------------------
# 学生ID: student_002
#   name: Bob
#   age: 22
#   courses:
#     math: 78
#     history: 92
#     science: 85
# --------------------

对于任意深度的嵌套字典，可能需要递归函数来进行遍历。

六、总结

本篇文章我们深入学习了 Python 字典的更多高级和常用操作，这些是高效使用字典的关键：

1. 字典视图：keys()、values() 和 items() 方法提供了字典键、值和键值对的动态视图，它们是可迭代的，并能实时反映字典的变化。
2. 高效遍历：掌握了如何分别遍历字典的键、值以及键值对，特别是使用 items() 配合解包来同时访问键和值是最常用的方式。同时注意到了遍历时修改字典的潜在问题及应对策略。
3. 常用方法：学习了使用 in 运算符检查键是否存在，以及 update() 方法合并字典的多种方式，包括处理键冲突和 Python 3.9+ 的 | 操作符。
4. 字典推导式：掌握了使用字典推导式从可迭代对象简洁、高效地创建和转换字典，包括添加条件和键值互换等操作。
5. 嵌套字典：理解了如何创建、访问、修改和遍历嵌套字典，以表示更复杂和层次化的数据结构，并学会了使用 get() 方法进行安全访问。

通过这两篇文章的学习，你现在应该对 Python 字典的创建、基本操作、常用方法、遍历技巧以及高级应用（如推导式和嵌套）有了全面而深入的理解。字典是 Python 中用途最广泛的数据结构之一，熟练掌握它将极大提升你的编程效率和代码质量。在后续的学习和实践中，你会越来越体会到字典的强大与便捷。

---