Python如何遍历字典_Python字典遍历的常用方法汇总(遍历,字典,汇总,常用,方法.......)

feifei123 发布于 2025-08-26 阅读（2）
遍历字典的核心是通过keys()、values()和items()方法分别访问键、值或键值对。直接for循环默认遍历键，等价于使用keys()；若需访问值，应使用values()；而同时获取键和值时，items()结合元组解包是最常用且高效的方式。选择哪种方式取决于具体需求：仅处理键时用keys()，仅处理值时用values()，需键值对时用items()，其在可读性和性能上更优。遍历时修改字典会引发RuntimeError，安全做法是遍历副本或分离决策与执行。对于嵌套字典，可通过递归实现深度遍历；条件筛选则推荐使用字典推导式，简洁高效。

python如何遍历字典_python字典遍历的常用方法汇总

Python遍历字典，核心就是围绕它的键（key）、值（value）或者键值对（key-value pair）进行操作。最常用的方法通常是利用字典自带的

keys()
、
values()
和
items()
这三个视图对象，它们能让我们高效且清晰地访问字典的各个组成部分。当然，直接在字典对象上进行迭代，默认情况下也是遍历它的键。

解决方案

在Python中，遍历字典有几种非常直接且常用的方式，理解它们的区别和适用场景，能帮助我们写出更清晰、更高效的代码。

1. 遍历字典的键（Keys） 这是最基本、也是当你直接对字典对象进行

for
循环时默认的行为。如果你只需要访问字典的键，这是最简洁的方式。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

print("遍历键（默认行为）：")
for key in my_dict:
    print(key)

print("\n遍历键（使用.keys()）：")
for key in my_dict.keys():
    print(key)

这两种方式在效果上是等价的，

my_dict.keys()
返回一个字典键的视图对象，它提供了字典键的动态视图。

2. 遍历字典的值（Values） 如果你只关心字典中存储的数据，而不需要知道它们对应的键，那么

values()
方法是你的首选。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

print("遍历值：")
for value in my_dict.values():
    print(value)

my_dict.values()
返回一个字典值的视图对象。

3. 遍历字典的键值对（Items） 这是最常用、也最强大的遍历方式，因为它允许你同时访问键和对应的值。Python的元组解包（tuple unpacking）特性让这种方式异常优雅。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

print("遍历键值对：")
for key, value in my_dict.items():
    print(f"{key}: {value}")

my_dict.items()
返回一个字典键值对的视图对象，每个元素都是一个
(key, value)
元组。

何时选择
keys()
、
values()
还是
items()
？性能与可读性的考量

选择哪种遍历方式，往往取决于你具体的需求。这不仅仅是语法上的偏好，更关乎代码的可读性和潜在的性能考量。

从我个人的经验来看，

items()
方法是日常开发中最常用的。因为它一次性提供了键和值，省去了通过键再去查找值的步骤，这在逻辑上更直接，代码也更清晰。如果你需要同时处理键和值，比如打印一个格式化的报告，或者根据键值对进行某种转换，
for key, value in my_dict.items():
几乎是标准答案。它避免了在循环内部使用
my_dict[key]
进行二次查找，虽然对于小字典来说性能差异微乎其微，但在处理大规模数据时，这种直接访问的效率优势就会显现出来。

keys()
方法，无论是显式调用
my_dict.keys()
还是隐式地直接
for key in my_dict:
，主要用于你只需要对字典的键进行操作的场景。比如，你想检查某个键是否存在，或者收集所有键到一个列表中。它的优势在于简洁，如果你不需要值，就没有必要把值也取出来。

而

values()
方法则是在你只关心字典中存储的数据本身，而键对你来说是次要信息时派上用场。例如，你可能想计算所有数值型值的总和，或者将所有值进行某种聚合操作。

关于性能，现代Python解释器对这些操作都进行了高度优化。通常，如果你需要键和值，

items()
会是最高效的。如果你只需要键或值，那么对应的
keys()
或
values()
方法也是高效的。过分纠结于它们之间的微小性能差异，通常是不必要的，除非你是在处理亿级数据且性能瓶颈确实出现在这里。更多时候，选择最能表达你意图、最易于阅读的方式才是王道。

遍历字典时修改字典会怎样？Python的应对策略

这是一个非常常见的陷阱，尤其是在初学者阶段。当你在遍历一个字典的同时尝试修改它（比如添加、删除或改变键的值），Python通常会抛出一个

RuntimeError: dictionary changed size during iteration
。这并不是Python的“脾气不好”，而是为了防止迭代过程中出现不确定性和难以追踪的bug。想象一下，如果你在一个正在被迭代的集合中增删元素，迭代器就可能“迷失”方向，导致跳过元素或访问到不应访问的内存。

比如，尝试这样做：

my_dict = {'a': 1, 'b': 2, 'c': 3}
# 这会报错
# for key in my_dict:
#     if key == 'b':
#         del my_dict[key]
#     else:
#         my_dict[key] = my_dict[key] * 2

要安全地在遍历过程中“修改”字典，你需要采取一些策略：

1. 遍历字典的副本 最简单直接的方法是遍历字典的键或项的副本。这样，你修改的是原始字典，但迭代器看到的仍然是修改前的状态。

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(f"原始字典: {my_dict}")

# 遍历键的副本进行删除
keys_to_delete = [key for key in my_dict if key == 'b' or key == 'd']
for key in keys_to_delete:
    del my_dict[key]
print(f"删除键后的字典: {my_dict}") # {'a': 1, 'c': 3}

# 遍历项的副本进行修改
my_dict_copy = list(my_dict.items()) # 也可以用 my_dict.copy()
for key, value in my_dict_copy:
    my_dict[key] = value * 2
print(f"修改值后的字典: {my_dict}") # {'a': 2, 'c': 6}

注意，

my_dict.copy()
会创建一个浅拷贝，对于键值都是不可变类型的情况，这通常足够了。如果值是可变对象（如列表或另一个字典），修改这些可变对象会影响原始字典。

2. 构建一个待处理的列表/字典 如果你需要根据遍历结果来决定添加或删除哪些项，更好的方式是先收集这些操作，然后在遍历结束后一次性执行。

original_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
items_to_add = {}
keys_to_remove = []

for key, value in original_dict.items():
    if value % 2 == 0: # 如果值是偶数，就删除这个键
        keys_to_remove.append(key)
    else: # 否则，添加一个新的键值对
        items_to_add[key + '_new'] = value * 10

# 执行删除操作
for key in keys_to_remove:
    del original_dict[key]

# 执行添加操作
original_dict.update(items_to_add)

print(f"最终字典: {original_dict}") # {'apple': 1, 'apple_new': 10, 'cherry': 3, 'cherry_new': 30}

这种方法将“决策”与“执行”分离，逻辑更清晰，也避免了运行时错误。

深度遍历与特定条件筛选：更复杂的字典迭代场景

字典的遍历不仅仅是简单的循环，在实际项目中，我们经常会遇到更复杂的场景，比如处理嵌套字典、或者根据特定条件筛选数据。

1. 深度遍历嵌套字典 当字典的值本身又是字典时，我们就需要进行深度遍历。这通常会用到递归或者栈（stack）来实现。

nested_dict = {
    'level1_key1': 'value1',
    'level1_key2': {
        'level2_key1': 'value2',
        'level2_key2': {
            'level3_key1': 'value3',
            'level3_key2': 'value4'
        }
    },
    'level1_key3': 'value5'
}

def deep_traverse_dict(d):
    for key, value in d.items():
        print(f"Key: {key}, Value: {value}")
        if isinstance(value, dict):
            deep_traverse_dict(value)

print("深度遍历嵌套字典：")
deep_traverse_dict(nested_dict)

这个递归函数会一层层地深入字典结构，直到所有非字典值都被访问到。对于非常深的嵌套，递归可能会遇到栈溢出，这时可以考虑使用基于栈的迭代方式。

2. 特定条件筛选与字典推导式 我们经常需要根据某些条件来筛选字典中的键值对，或者基于现有字典生成一个新的字典。字典推导式（Dictionary Comprehension）是Python提供的一种非常简洁高效的语法。

假设我们有一个员工字典，想筛选出年龄大于30的员工：

employees = {
    'Alice': {'age': 25, 'dept': 'HR'},
    'Bob': {'age': 35, 'dept': 'IT'},
    'Charlie': {'age': 30, 'dept': 'HR'},
    'David': {'age': 40, 'dept': 'IT'}
}

# 使用字典推导式筛选年龄大于30的员工
older_employees = {
    name: details for name, details in employees.items() if details['age'] > 30
}
print("\n年龄大于30的员工：")
print(older_employees)
# 输出: {'Bob': {'age': 35, 'dept': 'IT'}, 'David': {'age': 40, 'dept': 'IT'}}

# 也可以在遍历时进行筛选，但不生成新字典
print("\n遍历并打印IT部门的员工：")
for name, details in employees.items():
    if details['dept'] == 'IT':
        print(f"{name}: {details['age']}岁")

字典推导式不仅代码量少，而且通常比传统的

for
循环加
if
条件更具可读性，特别适合创建新的字典。它将遍历、筛选和创建新字典的逻辑紧密结合在一起，体现了Python的简洁和表达力。

以上就是Python如何遍历字典_Python字典遍历的常用方法汇总的详细内容，更多请关注资源网其它相关文章！

标签:  python ai 区别 键值对 Python if for 递归 循环 栈 copy 对象 bug 

相关阅读

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最近发表

热评文章

标签列表

网站分类