Python字典遍历items与keys区别及性能优化

脚本专家

Python 项目里经常看到这样的字典遍历：先用 keys() 拿键，再通过 d[key] 取值。代码能跑，结果也对，但在数据量大或高频调用时，会多出一次次哈希查找。下面围绕 keys()、values()、items() 三个方法，说明它们的实现差异、性能差别和常见坑，重点看什么时候该用 items()。

从一个能跑但不够好的写法说起

小周写数据导出功能时，要把字典配置逐条写成一行：

2. config = {'host': 'localhost', 'port': 8080, 'debug': True}
3. for key in config.keys():
4.     line = f'{key}={config[key]}'
5.     print(line)

复制代码

输出结果正确：host=localhost、port=8080、debug=True。同事 review 时建议改成 items()，小周一开始觉得差别不大。后来处理几万条配置时，发现导出速度明显偏慢，改成 items() 后速度提升了一大截。问题不在结果，而在每次循环多做了一次字典取值。

keys()、values()、items() 的基本用法

Python 字典提供三个遍历方法：keys()、values()、items()。

2. config = {'host': 'localhost', 'port': 8080, 'debug': True}
3. for key in config.keys():
4.     print(key)
5. for value in config.values():
6.     print(value)
7. for key, value in config.items():
8.     print(key, value)

复制代码

keys() 只给键，values() 只给值，items() 给键值对，每个元素是一个 (key, value) 元组。可以用通讯录来理解：keys() 只念姓名，values() 只念电话，items() 把姓名和电话整页念出来。只需要姓名时用 keys()，只需要电话时用 values()，同时需要姓名和电话时就应该用 items()，而不是先念姓名再回头翻电话。

小周原来的写法就是“先念姓名，再回头翻电话”：用 key 拿到键，再用 config[key] 查值。结果没错，但多做了一次查找。

items() 的本质与解包

items() 返回的是一个视图对象，每个元素是 (key, value) 元组。在 for 循环里可以直接解包：

2. for key, value in config.items():
3.     print(key, value)

复制代码

这等价于：

2. for item in config.items():
3.     key, value = item
4.     print(key, value)

复制代码

Python 会自动把元组拆开，分别赋给 key 和 value。而用 keys() 再取值时：

2. for key in config.keys():
3.     value = config[key]
4.     print(key, value)

复制代码

每次循环都要执行一次 d[key] 的哈希查找。单次查找很快，但循环几万次、几十万次时，累计开销不可忽略。

性能差异有多大？

用一个包含十万条数据的字典做 timeit 实测：

2. import timeit
3. d = {f'key_{i}': i for i in range(100000)}
5. def method1():
6.     total = 0
7.     for key in d.keys():
8.         total += d[key]
9.     return total
11. def method2():
12.     total = 0
13.     for key, value in d.items():
14.         total += value
15.     return total
17. t1 = timeit.timeit(method1, number=10)
18. t2 = timeit.timeit(method2, number=10)
19. print(f'keys() + 取值: {t1:.4f} 秒')
20. print(f'items(): {t2:.4f} 秒')

复制代码

原文实测中，keys() 方式大约 0.35 秒，items() 方式大约 0.25 秒，差距约 30%。原因是 keys() 方式每次循环都额外做了一次 d[key] 哈希查找，而 items() 在遍历时直接同时取出键和值，不需要再查。数据量越大差距越明显：十万条差 0.1 秒，一千万条就可能差约 10 秒。高频调用的函数里，这个差距会被进一步放大。

坑一：items() 返回的不是列表

很多人以为 items() 返回列表，可以按索引访问：

2. config = {'a': 1, 'b': 2}
3. items = config.items()
4. print(items[0])

复制代码

这会报 TypeError: 'dict_items' object is not subscriptable。items() 返回的是视图对象，不是列表。它支持迭代、支持 in 判断、支持 len()，但不支持索引和切片。

2. items = config.items()
3. print(len(items))
4. print(('a', 1) in items)
5. print('a' in items)

复制代码

注意，in 判断的是 (key, value) 元组，不是单独的键。因此 ('a', 1) in items 为 True，而 'a' in items 为 False。如果确实需要索引访问，可以显式转换：list(config.items())。但这会创建一个新列表，占用额外内存，除非必要，否则没必要转换。

坑二：视图对象是动态的

keys()、values()、items() 返回的都是视图对象。视图不复制数据，反映的是字典实时状态。

2. config = {'a': 1, 'b': 2}
3. keys = config.keys()
4. print(list(keys))
5. config['c'] = 3
6. print(list(keys))

复制代码

输出先是 ['a', 'b']，后来变成 ['a', 'b', 'c']。keys 变量没有重新赋值，但它“看到”了字典的新增内容。字典清空后，之前拿到的视图也会变空：

2. config = {'a': 1, 'b': 2}
3. keys = config.keys()
4. config.clear()
5. print(list(keys))

复制代码

输出为 []。

坑三：遍历时修改字典

这是遍历场景里的经典错误：

2. config = {'a': 1, 'b': 2, 'c': 3}
3. for key in config.keys():
4.     if config[key] == 2:
5.         del config[key]

复制代码

运行会报 RuntimeError: dictionary changed size during iteration。Python 不允许在遍历字典时改变它的大小。因为字典迭代依赖内部哈希表结构，插入或删除元素可能导致结构变化，使迭代器失效。

如果确实需要在遍历时删除元素，有两种方式。方式一，遍历副本：

2. for key in list(config.keys()):
3.     if config[key] == 2:
4.         del config[key]

复制代码

list(config.keys()) 创建了一个键列表，遍历的是列表，而不是字典本身，删除字典元素不会影响列表遍历。方式二，用字典推导式生成新字典：

2. config = {k: v for k, v in config.items() if v != 2}

复制代码

不修改原字典，而是创建过滤后的新字典，这种方式更 Pythonic，也更安全。

坑四：values() 拿不到键

values() 只给值，不给键。如果根据值做判断后还要操作对应键，values() 就不够用：

2. config = {'a': 1, 'b': 2, 'c': 3}
3. for value in config.values():
4.     if value == 2:
5.         pass

复制代码

想删除对应键，但不知道键是什么。这时应该用 items()：

2. for key, value in config.items():
3.     if value == 2:
4.         del config[key]

复制代码

但仍然不能在遍历时直接删。更稳妥的做法是先收集要删的键，再统一删除：

2. to_delete = [k for k, v in config.items() if v == 2]
3. for key in to_delete:
4.     del config[key]

复制代码

坑五：忘了括号

这是一个很隐蔽的错误：

2. config = {'a': 1, 'b': 2}
3. for key in config.items:
4.     print(key)

复制代码

config.items 是方法本身，不带括号就不会调用它。for 循环试图迭代方法对象，通常会报 TypeError，具体表现可能随 Python 版本和写法不同。正确写法是 config.items()，带括号。类似的还有 config.keys、config.values，都是忘了加括号。

items() 的解包细节

items() 返回的每个元素是元组，在 for 里可以直接解包。但如果字典的值本身也是元组或列表，解包时要小心：

2. data = {'a': (1, 2), 'b': (3, 4)}
3. for key, value in data.items():
4.     print(key, value)

复制代码

这里 key 是 'a'，value 是 (1, 2)。如果写成 for key, x, y in data.items()，会报错，因为 data.items() 的每个元素只有两个值：键和值。值内部的元组不会被自动展开。如果确实想同时拿到键和值内部元素，需要额外解包：

2. for key, (x, y) in data.items():
3.     print(key, x, y)

复制代码

这样 Python 会把元组 (1, 2) 拆开，分别赋给 x 和 y。

遍历顺序：Python 3.7 之后的保证

Python 3.6 之前，字典是无序的，遍历顺序不确定。从 Python 3.7 开始，字典正式保证插入顺序：

2. config = {'b': 2, 'a': 1, 'c': 3}
3. for key in config.keys():
4.     print(key)

复制代码

输出永远是 b、a、c。这个特性在 Python 3.7+ 中稳定可靠。但要注意，set 仍然是无序的，frozenset 也是。只有 dict 保证了插入顺序。如果需要按特定顺序遍历，比如按键排序，可以用 sorted()：

2. for key in sorted(config.keys()):
3.     print(key, config[key])
4. for key, value in sorted(config.items()):
5.     print(key, value)

复制代码

sorted(config.items()) 会按键排序，因为元组比较时先比较第一个元素，也就是键。

那 keys() 还有用吗？

keys() 在以下场景仍然有用。第一，只需要键，不需要值。比如把键收集到列表里：

2. keys = list(config.keys())
3. if 'host' in config.keys():
4.     print('有 host 配置')

复制代码

第二，做集合运算。keys() 返回的视图对象支持集合操作：

2. d1 = {'a': 1, 'b': 2}
3. d2 = {'b': 3, 'c': 4}
4. print(d1.keys() & d2.keys())
5. print(d1.keys() | d2.keys())
6. print(d1.keys() - d2.keys())

复制代码

输出分别是 {'b'}、{'a', 'b', 'c'}、{'a'}，也就是交集、并集、差集。这是 items() 做不到的，视图对象的集合运算能力是 keys() 的独特优势。第三，检查键是否存在。if key in config.keys() 比 if key in config 更明确，但后者更简洁，性能也更好，所以实际中直接用 in config 就够了。

回到小周的代码

原写法：

2. for key in config.keys():
3.     line = f'{key}={config[key]}'
4.     print(line)

复制代码

改成：

2. for key, value in config.items():
3.     line = f'{key}={value}'
4.     print(line)

复制代码

两行代码看起来差不多，但 items() 版本少了一次字典查找，速度更快，代码也更清晰。项目里还有类似写法：

2. for key in d.keys():
3.     if d[key] > 0:
4.         pass

复制代码

改成：

2. for key, value in d.items():
3.     if value > 0:
4.         pass

复制代码

以及一处遍历时删元素的 bug：

2. for key in d.keys():
3.     if d[key] == 0:
4.         del d[key]

复制代码

改成：

2. d = {k: v for k, v in d.items() if v != 0}

复制代码

团队文档可以记成一句话：遍历字典要键值对，用 items()，别用 keys() 再取值；只要键，用 keys()；只要值，用 values()；遍历时别改字典，要改就先复制或者用推导式。

总结

keys()、values()、items() 是字典遍历的三把工具，各司其职。keys() 只给键，适合只需要键的场景，支持集合运算；values() 只给值，适合只需要值的场景；items() 给键值对，适合同时需要键和值的场景，性能比 keys() 加取值更好。它们的返回值都是视图对象，不是列表。视图是动态的，反映字典实时状态，不支持索引，但支持迭代和 in 判断。遍历时不要修改字典的大小。如果需要删除元素，遍历副本或者用字典推导式生成新字典。记住通讯录的比喻：keys() 念姓名，values() 念电话，items() 把整页念给你。想清楚要什么，再选对应工具。小周的坑不在于不会用 items()，而在于他从没想过 keys() 加取值有什么问题。代码能跑，结果也对，但性能差了一截。这种“能跑但不够好”的代码，往往最容易被忽略，也最值得回头审视。