幕雪

python遍历dict：全面解析字典遍历的各种姿势与实践

Python字典（dict）是一种非常强大且灵活的数据结构，用于存储键值对集合。在日常编程任务中，我们经常需要访问字典中的每一个元素，这便涉及到字典的“遍历”。理解和掌握字典遍历的各种方法，对于高效地处理数据、编写清晰可读的代码至关重要。

1. 字典遍历“是什么”？

简单来说，字典遍历是指按序或按特定方式逐一访问字典中的键（key）、值（value），或者同时访问键值对（key-value pair）的过程。在Python中，字典在Python 3.7+版本中保留了插入顺序，这意味着当你遍历一个字典时，元素的访问顺序将与它们被添加到字典时的顺序一致。在此之前，字典被认为是无序的。

无论你是想检查每个键是否存在特定条件，计算所有值的总和，还是根据键值对生成新的数据结构，遍历都是实现这些目标的基础操作。

2. 为什么需要遍历字典？

遍历字典的需求无处不在，它几乎是处理字典型数据的核心操作。以下是一些常见且具体的应用场景：

  • 数据分析与统计： 假设你有一个字典存储了不同商品的销售额，你需要计算总销售额，或者找出销售额最高的商品。
  • 配置读取与解析： 配置文件通常以键值对的形式存在（如JSON、YAML），读取后加载到字典中，你需要遍历字典来获取各个配置项的值。
  • 数据筛选与转换： 你可能需要根据某个条件筛选出字典中符合要求的键值对，或者对所有值进行某种形式的转换（例如，将字符串日期转换为datetime对象）。
  • 报告生成： 从数据库或API获取数据后，通常会组织成字典列表或嵌套字典，你需要遍历它们来格式化输出，生成报表或视图。
  • 构建新的数据结构： 基于现有字典的内容，通过遍历来构建一个新的字典、列表或集合，以满足不同的业务逻辑。
  • 验证与检查： 遍历字典以确保所有必需的键都存在，或者检查值的类型和有效性。

3. 字典遍历“如何”操作？

Python提供了多种直观且高效的方法来遍历字典。核心在于利用字典的视图对象（keys、values、items）或直接对字典本身进行迭代。

3.1 遍历键 (Keys)

这是最常见的遍历方式之一，默认情况下，直接在for循环中使用字典对象就会遍历其所有的键。

方法一：直接遍历字典（默认遍历键）


my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
    "occupation": "Engineer"
}

print("--- 遍历字典的键（默认方式） ---")
for key in my_dict:
    print(f"键: {key}")

输出：


--- 遍历字典的键（默认方式） ---
键: name
键: age
键: city
键: occupation

方法二：使用 .keys() 方法

.keys() 方法会返回一个字典所有的键的视图对象。这是一个更明确的写法，尤其是在阅读代码时能清楚地表达意图。


my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
    "occupation": "Engineer"
}

print("--- 遍历字典的键（使用 .keys()） ---")
for key in my_dict.keys():
    print(f"键: {key}")

3.2 遍历值 (Values)

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


my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
    "occupation": "Engineer"
}

print("--- 遍历字典的值（使用 .values()） ---")
for value in my_dict.values():
    print(f"值: {value}")

输出：


--- 遍历字典的值（使用 .values()） ---
值: Alice
值: 30
值: New York
值: Engineer

3.3 遍历键值对 (Items)

这是最常用且推荐的遍历方式，因为它一次性提供了键和值，通常能避免二次查找，代码也更简洁。使用 .items() 方法可以获取字典中所有的键值对，每个键值对以一个元组的形式返回。


my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
    "occupation": "Engineer"
}

print("--- 遍历字典的键值对（使用 .items()） ---")
for key, value in my_dict.items():
    print(f"键: {key}, 值: {value}")

输出：


--- 遍历字典的键值对（使用 .items()） ---
键: name, 值: Alice
键: age, 值: 30
键: city, 值: New York
键: occupation, 值: Engineer

3.4 使用列表推导式或字典推导式

当需要从现有字典中生成新的列表或字典时，推导式是极其强大和Pythonic的工具。

生成键的列表


my_dict = {"a": 1, "b": 2, "c": 3}
keys_list = [key for key in my_dict] # 等同于 list(my_dict.keys())
print(f"键的列表: {keys_list}")

生成值的列表


my_dict = {"a": 1, "b": 2, "c": 3}
values_list = [value for value in my_dict.values()] # 等同于 list(my_dict.values())
print(f"值的列表: {values_list}")

生成符合条件的键值对的新字典（字典推导式）


my_dict = {"apple": 10, "banana": 25, "cherry": 5, "date": 15}
filtered_dict = {key: value for key, value in my_dict.items() if value > 10}
print(f"过滤后的字典: {filtered_dict}")

输出：


过滤后的字典: {'banana': 25, 'date': 15}

3.5 带有索引的遍历 (结合 enumerate)

虽然字典本身没有顺序索引，但如果你需要为遍历的键、值或键值对提供一个计数器或索引，可以结合enumerate函数和items()方法。这实际上是对items()返回的视图对象进行带索引的遍历。


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

print("--- 带索引的遍历字典 ---")
for index, (key, value) in enumerate(my_dict.items()):
    print(f"索引: {index}, 键: {key}, 值: {value}")

输出：


--- 带索引的遍历字典 ---
索引: 0, 键: name, 值: Alice
索引: 1, 键: age, 值: 30
索引: 2, 键: city, 值: New York

4. 字典遍历“哪里”能派上用场？

字典遍历的应用场景非常广泛，它几乎可以出现在任何需要处理结构化数据的地方。以下是一些具体的代码结构和上下文示例：

  • 函数内部的数据处理

    在编写处理特定数据格式的函数时，字典遍历是核心操作。

    
def summarize_sales(sales_data):
    """
    计算并打印销售数据的总额及各区域销售情况。
    sales_data 示例: {"East": 12000, "West": 15000, "North": 9000}
    """
    total_sales = 0
    print("各区域销售额:")
    for region, amount in sales_data.items():
        print(f"- {region}: ${amount:,}")
        total_sales += amount
    print(f"\n总销售额: ${total_sales:,}")

report_data = {"East": 12000, "West": 15000, "North": 9000, "South": 10500}
summarize_sales(report_data)

  • 类方法中处理对象属性

    如果一个类的实例包含一个字典作为其属性，类方法经常需要遍历这个字典来执行操作。

    
class UserProfile:
    def __init__(self, user_id, profile_data):
        self.user_id = user_id
        self.profile_data = profile_data # profile_data 是一个字典

    def display_profile(self):
        print(f"用户ID: {self.user_id}")
        print("--- 个人资料 ---")
        for key, value in self.profile_data.items():
            print(f"{key.replace('_', ' ').title()}: {value}")

user1_profile = {
    "first_name": "John",
    "last_name": "Doe",
    "email": "[email protected]",
    "country": "USA"
}
user1 = UserProfile(101, user1_profile)
user1.display_profile()

  • 脚本文件中的数据清洗与处理

    在处理文件（如CSV、JSON）中的数据时，加载到字典后进行清洗、转换是常见步骤。

    
import json

# 假设这是一个从文件读取的JSON数据
raw_data_str = '''
{
    "item_001": {"price": 10.5, "quantity": 5, "available": true},
    "item_002": {"price": 20.0, "quantity": 0, "available": false},
    "item_003": {"price": 5.0, "quantity": 10, "available": true}
}
'''
inventory = json.loads(raw_data_str)

print("--- 检查库存状态 ---")
for item_id, details in inventory.items():
    if details["available"] and details["quantity"] > 0:
        print(f"商品 {item_id} (价格: ${details['price']}) 库存充足。")
    else:
        print(f"商品 {item_id} (价格: ${details['price']}) 库存不足或不可用。")

  • Web框架中处理请求参数或响应数据

    例如，在Flask或Django中，HTTP请求的表单数据或JSON体经常被解析为字典，你可能需要遍历这些字典来验证输入或构建响应。

    
# 模拟一个来自Web请求的JSON数据
request_json = {
    "product_id": "P123",
    "quantity": 2,
    "user_id": "U456",
    "delivery_address": "123 Main St"
}

required_fields = ["product_id", "quantity", "user_id"]
missing_fields = []

for field in required_fields:
    if field not in request_json:
        missing_fields.append(field)

if missing_fields:
    print(f"错误：缺少必需字段: {', '.join(missing_fields)}")
else:
    print("所有必需字段均已提供，处理请求...")

5. 字典遍历“多少”考虑？

在选择遍历方法时，除了“如何做”之外，还需要考虑效率、内存使用以及在特定情况下的行为。这包括对性能的考量、对字典视图对象的理解，以及最关键的：遍历时修改字典的后果。

5.1 性能与效率

  • .items()通常是最效率的： 当你既需要键又需要值时，使用for key, value in my_dict.items():是最高效的方式。它避免了在循环内部使用my_dict[key]进行二次查找，这在处理大型字典时尤为明显。
  • 视图对象（.keys(), .values(), .items()）的内存效率： 这些方法在Python 3中返回的是“视图对象”，而不是完整的列表。这意味着它们不复制字典的所有内容，而是提供一个动态的视图，当字典变化时，视图也会随之更新。这对于处理大型字典来说，极大地节省了内存。只有当你明确需要一个列表时，才使用list(my_dict.keys())等构造函数。

5.2 遍历时修改字典的注意事项

这是一个非常重要的陷阱，不理解它会导致运行时错误：

切勿在遍历字典时直接修改它（添加或删除键值对）！

Python的字典设计不允许在迭代过程中改变其大小，否则会抛出RuntimeError: dictionary changed size during iteration。

以下代码会报错：


my_dict = {"a": 1, "b": 2, "c": 3}
# 错误示例：尝试在遍历时修改字典
try:
    for key in my_dict:
        if key == "b":
            del my_dict[key] # 这会引发 RuntimeError
        else:
            my_dict["d"] = 4 # 这也会引发 RuntimeError
except RuntimeError as e:
    print(f"发生错误: {e}")

输出：


发生错误: dictionary changed size during iteration

解决方案：

  1. 遍历字典的副本： 如果你需要在遍历时删除或添加元素，请遍历字典的键或项的副本。

    
# 方案一：遍历键的副本
my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
keys_to_delete = []
for key in list(my_dict.keys()): # 遍历键的列表副本
    if key == "b" or key == "d":
        keys_to_delete.append(key)
for key in keys_to_delete:
    del my_dict[key]
print(f"删除后的字典 (遍历键副本): {my_dict}")

# 方案二：使用字典推导式创建新字典 (推荐用于过滤/转换)
my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
new_dict = {key: value for key, value in my_dict.items() if key not in ["b", "d"]}
print(f"删除后的字典 (使用字典推导式): {new_dict}")

# 方案三：如果只是添加，可以先收集要添加的键值对，再统一添加
my_dict = {"a": 1, "b": 2, "c": 3}
items_to_add = {}
for key, value in my_dict.items():
    if value == 2:
        items_to_add["new_key"] = value * 10
my_dict.update(items_to_add)
print(f"添加后的字典: {my_dict}")
  2. 收集待修改的键/值： 在遍历过程中只记录需要修改（添加、删除）的键或项，然后在新循环结束后一次性执行修改操作。
  3. 使用字典推导式： 如果你的目标是基于现有字典的内容创建并返回一个新的字典（例如，筛选、转换值），字典推导式是最佳选择。它本身就避免了在原地修改的问题。

5.3 嵌套字典的遍历

对于包含嵌套字典的数据结构，你可能需要递归地遍历。这在处理JSON或XML数据时很常见。


data = {
    "user_1": {
        "name": "Alice",
        "details": {"age": 30, "city": "New York"}
    },
    "user_2": {
        "name": "Bob",
        "details": {"age": 25, "city": "London", "occupation": "Designer"}
    }
}

def deep_traverse_dict(obj, indent=0):
    for key, value in obj.items():
        print("  " * indent + f"- {key}: ", end="")
        if isinstance(value, dict):
            print("{")
            deep_traverse_dict(value, indent + 1)
            print("  " * indent + "}")
        else:
            print(value)

print("--- 递归遍历嵌套字典 ---")
deep_traverse_dict(data)

输出：


--- 递归遍历嵌套字典 ---
- user_1: {
  - name: Alice
  - details: {
    - age: 30
    - city: New York
  }
}
- user_2: {
  - name: Bob
  - details: {
    - age: 25
    - city: London
    - occupation: Designer
  }
}

6. 字典遍历“怎么”解决特定问题？

除了基本遍历，还有许多高级技巧和考虑事项可以帮助你更优雅、高效地解决问题。

6.1 按特定顺序遍历

尽管Python 3.7+的字典保持插入顺序，但有时你可能需要按键或值进行字母顺序、数字大小等排序后的遍历。

  • 按键排序遍历

    使用sorted()函数对.keys()的返回结果进行排序。

    
my_dict = {"banana": 3, "apple": 1, "cherry": 2}
print("--- 按键字母顺序遍历 ---")
for key in sorted(my_dict.keys()):
    print(f"键: {key}, 值: {my_dict[key]}")

    输出：

    
--- 按键字母顺序遍历 ---
键: apple, 值: 1
键: banana, 值: 3
键: cherry, 值: 2

  • 按值排序遍历

    使用sorted()函数对.items()的返回结果进行排序，并提供一个key参数来指定排序依据。

    
my_dict = {"banana": 3, "apple": 1, "cherry": 2}
print("--- 按值升序遍历 ---")
for key, value in sorted(my_dict.items(), key=lambda item: item[1]):
    print(f"键: {key}, 值: {value}")

print("--- 按值降序遍历 ---")
for key, value in sorted(my_dict.items(), key=lambda item: item[1], reverse=True):
    print(f"键: {key}, 值: {value}")

    输出：

    
--- 按值升序遍历 ---
键: apple, 值: 1
键: cherry, 值: 2
键: banana, 值: 3
--- 按值降序遍历 ---
键: banana, 值: 3
键: cherry, 值: 2
键: apple, 值: 1

6.2 条件遍历与筛选

在遍历过程中加入条件判断是常见的操作，以实现数据筛选。


products = {
    "Laptop": 1200,
    "Mouse": 25,
    "Keyboard": 75,
    "Monitor": 300
}

print("--- 价格高于100的产品 ---")
for product, price in products.items():
    if price > 100:
        print(f"{product}: ${price}")

输出：


--- 价格高于100的产品 ---
Laptop: $1200
Monitor: $300

也可以使用字典推导式一次性完成筛选和新字典的创建：


products = {
    "Laptop": 1200,
    "Mouse": 25,
    "Keyboard": 75,
    "Monitor": 300
}
expensive_products = {product: price for product, price in products.items() if price > 100}
print(f"价格高于100的产品字典: {expensive_products}")

6.3 处理缺失键 (避免 KeyError)

在遍历过程中，如果根据键去访问对应的值，可能会遇到键不存在的情况，从而引发KeyError。有几种方法可以优雅地处理这种情况：

  • 使用 .get() 方法

    dict.get(key, default_value)方法在键不存在时返回指定的default_value（默认为None），而不会引发错误。

    
user_settings = {
    "theme": "dark",
    "font_size": 14
}

# 尝试获取一个可能不存在的键
editor_mode = user_settings.get("editor_mode", "normal")
print(f"编辑器模式: {editor_mode}")

# 在遍历中使用 .get()
config_keys = ["theme", "font_size", "language", "auto_save"]
for key in config_keys:
    value = user_settings.get(key, "未设置")
    print(f"{key}: {value}")

    输出：

    
编辑器模式: normal
theme: dark
font_size: 14
language: 未设置
auto_save: 未设置

  • 使用 try-except KeyError 块

    如果业务逻辑需要对缺失键进行特别处理或记录日志，使用try-except是更明确的方式。

    
data = {"param1": "value1", "param3": "value3"}
required_params = ["param1", "param2", "param3"]

for param in required_params:
    try:
        val = data[param]
        print(f"参数 {param} 存在，值为: {val}")
    except KeyError:
        print(f"警告: 参数 {param} 不存在。")

  • 使用 collections.defaultdict (针对自动创建默认值)

    虽然这不是直接用于“遍历中”处理缺失键的方法，但在构建或更新字典时，defaultdict可以避免预先检查键是否存在。当你访问一个不存在的键时，它会自动创建一个默认值。

    
from collections import defaultdict

# 统计列表中每个元素的出现次数
word_counts = defaultdict(int) # int() 的默认值是 0
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]

for word in words:
    word_counts[word] += 1 # 如果 word 不存在，会自动初始化为 0 再加 1

print("--- 单词计数 ---")
for word, count in word_counts.items():
    print(f"{word}: {count}")

    输出：

    
--- 单词计数 ---
apple: 3
banana: 2
cherry: 1

6.4 Python 3.7+ 字典的有序性

从Python 3.7版本开始，字典被保证是插入有序的。这意味着当你遍历一个字典时，键值对的返回顺序将与它们被插入字典时的顺序一致。这使得遍历结果更具可预测性，在很多情况下无需再依赖collections.OrderedDict。


# 在Python 3.7+中，字典是插入有序的
my_ordered_dict = {}
my_ordered_dict["first"] = 1
my_ordered_dict["second"] = 2
my_ordered_dict["third"] = 3
my_ordered_dict["fourth"] = 4

print("--- Python 3.7+ 字典的插入顺序遍历 ---")
for key, value in my_ordered_dict.items():
    print(f"{key}: {value}")

输出：


--- Python 3.7+ 字典的插入顺序遍历 ---
first: 1
second: 2
third: 3
fourth: 4

总结

字典遍历是Python编程中的一项基本技能。理解并熟练运用.keys()、.values()和.items()等方法，结合列表/字典推导式，可以让你高效、清晰地处理各种字典数据。同时，务必记住不要在遍历过程中直接修改字典的大小，并学会如何优雅地处理潜在的KeyError，这将帮助你编写出健壮且高性能的Python代码。

掌握这些遍历技巧，将使你在数据处理、配置管理、API交互等众多领域游刃有余。

python遍历dict