python中如何将字典的键值对互换？-Python教程-PHP中文网

最直接的方式是使用字典推导式实现键值互换，但需注意值的唯一性和可哈希性：若原字典存在重复值，后出现的键会覆盖先出现的键；若值为不可哈希类型（如列表），则需转换为元组等可哈希形式或采用替代数据结构；对于重复值场景，可通过构建值到键列表的映射来保留所有信息。该方法广泛应用于反向查找、索引优化和数据转换等场景。

python中如何将字典的键值对互换？

在Python中，要将字典的键值对互换，最直接且Pythonic的方式是利用字典推导式（Dictionary Comprehension）。它允许我们以简洁的语法遍历原字典，并构建一个新字典，其中原字典的值成为新字典的键，而原字典的键则成为新字典的值。

解决方案

将字典的键值对互换，通常我们会创建一个新的字典来存储这种反向映射。这事儿说起来简单，但背后其实有些细节需要我们留心。

最常见的做法，也是我个人觉得最优雅的，就是使用字典推导式：

original_dict = {'a': 1, 'b': 2, 'c': 3}

# 使用字典推导式进行键值互换
# 注意：如果原始字典的值有重复，后出现的键会覆盖先出现的键
swapped_dict = {value: key for key, value in original_dict.items()}

print(f"原始字典: {original_dict}")
print(f"互换后的字典: {swapped_dict}")
# 输出:
# 原始字典: {'a': 1, 'b': 2, 'c': 3}
# 互换后的字典: {1: 'a', 2: 'b', 3: 'c'}

登录后复制

如果你更喜欢传统的循环方式，当然也可以：

立即学习“Python免费学习笔记（深入）”；

original_dict = {'x': 10, 'y': 20, 'z': 30}
swapped_dict_loop = {}

for key, value in original_dict.items():
    swapped_dict_loop[value] = key

print(f"通过循环互换后的字典: {swapped_dict_loop}")
# 输出:
# 通过循环互换后的字典: {10: 'x', 20: 'y', 30: 'z'}

登录后复制

这两种方法都能实现基本的键值互换。但话说回来，这背后藏着什么呢？最大的坑，也是我们必须提前想到的，就是原始字典中值的唯一性。如果你的原始字典里有重复的值，那么在互换之后，这些重复的值只能保留一个对应的键。比如

{'a': 1, 'b': 1}

登录后复制

互换后就成了

{1: 'b'}

登录后复制

，键

'a'

登录后复制

就这么悄无声息地消失了。这就像你把两个名字都叫“小明”的人，都登记到了“小明”这个名字下，结果你只记得最后登记的那个“小明”是谁了。

互换键值对时，如何处理原始字典中重复的值？

这绝对是你在实际操作中会遇到的一个核心问题。就像前面提到的，Python字典的键必须是唯一的。所以，如果你的原始字典里有多个键指向同一个值（例如

{'apple': 'fruit', 'banana': 'fruit'}

登录后复制

），当你尝试将这些值作为新字典的键时，后处理的键会覆盖掉前面处理的。结果就是，你可能会丢失一部分原始数据。

那么，怎么才能“不丢失”数据呢？这取决于你对“不丢失”的定义。如果你希望新字典的键依然是原始值，而值则是一个包含所有原始键的列表，那我们可以这样做：

original_data = {'apple': 'fruit', 'banana': 'fruit', 'carrot': 'vegetable'}
inverted_multi_value_dict = {}

for key, value in original_data.items():
    if value not in inverted_multi_value_dict:
        inverted_multi_value_dict[value] = [key]
    else:
        inverted_multi_value_dict[value].append(key)

print(f"原始数据: {original_data}")
print(f"处理重复值后的互换字典: {inverted_multi_value_dict}")
# 输出:
# 原始数据: {'apple': 'fruit', 'banana': 'fruit', 'carrot': 'vegetable'}
# 处理重复值后的互换字典: {'fruit': ['apple', 'banana'], 'vegetable': ['carrot']}

登录后复制

这种方法就很好地解决了重复值的问题。现在，

'fruit'

登录后复制

这个键对应的值是一个列表

['apple', 'banana']

登录后复制

，它包含了所有原始字典中映射到

'fruit'

登录后复制

的键。这样一来，你就没有丢失任何原始信息，只是数据的组织形式变了。当然，你也可以用

collections.defaultdict

登录后复制

让代码更简洁一点，原理是一样的。在我看来，这种处理方式在很多实际场景中都非常实用，比如你需要根据某个属性（值）来查找所有相关联的实体（键）。

当字典的值不可哈希时，互换操作该如何进行？

这是另一个比较棘手的技术挑战。Python字典的键必须是可哈希（hashable）的对象。什么是可哈希？简单来说，就是它的哈希值在生命周期内不会改变，并且可以与其他对象进行比较。像字符串、数字、元组（如果其所有元素都是可哈希的）都是可哈希的。但列表（list）、集合（set）和字典（dict）本身是不可哈希的，因为它们是可变的。

一键抠图

在线一键抠图换背景

查看详情

这意味着，如果你的原始字典的值是列表、集合或字典，你将无法直接将它们作为新字典的键。如果你尝试这样做，Python会毫不留情地抛出一个

TypeError: unhashable type: 'list'

登录后复制

错误。

unhashable_value_dict = {'item1': [1, 2], 'item2': [3, 4]}

try:
    # 这会引发 TypeError
    swapped_unhashable = {value: key for key, value in unhashable_value_dict.items()}
    print(swapped_unhashable)
except TypeError as e:
    print(f"尝试互换不可哈希值时遇到错误: {e}")
# 输出:
# 尝试互换不可哈希值时遇到错误: unhashable type: 'list'

登录后复制

面对这种情况，我们得换个思路。你不能直接把它们作为键，但你可以考虑：

转换为可哈希形式： 如果这些不可哈希的值可以被有意义地转换为可哈希的形式，比如把列表转换为元组（
```
tuple([1, 2])
```
登录后复制
变成
```
(1, 2)
```
登录后复制
），或者将字典序列化为字符串（
```
str({'a': 1})
```
登录后复制
），那么你就可以用转换后的形式作为键。但要注意，这种转换可能会带来信息丢失（例如，字符串序列化后的顺序问题）或性能开销。
```
# 将列表转换为元组
convertible_dict = {'item1': [1, 2], 'item2': [3, 4]}
swapped_converted = {tuple(value): key for key, value in convertible_dict.items()}
print(f"转换后互换的字典: {swapped_converted}")
# 输出:
# 转换后互换的字典: {(1, 2): 'item1', (3, 4): 'item2'}
```
登录后复制
重新考虑数据结构： 如果转换不可行或不合理，你可能需要重新评估你的需求。也许你根本不需要一个以这些复杂对象为键的字典。一个更合适的结构可能是一个包含元组的列表，例如
```
[(value, key), (value, key), ...]
```
登录后复制
。这样，你可以保留所有数据，只是查找方式会变成遍历列表而不是直接通过键查找。
```
alternative_structure = []
for key, value in unhashable_value_dict.items():
    alternative_structure.append((value, key))
print(f"不可哈希值情况下的替代结构: {alternative_structure}")
# 输出:
# 不可哈希值情况下的替代结构: [[1, 2], 'item1'], [[3, 4], 'item2']]
```
登录后复制
这两种方法各有适用场景，关键在于理解不可哈希的本质限制，并根据实际需求选择最合适的策略。

除了直接互换，还有哪些场景下需要考虑字典的逆向映射？

字典的逆向映射，或者说根据值来查找键的需求，在软件开发中其实非常普遍，远不止我们刚才讨论的直接互换。它常常出现在我们需要“反查”信息的场景中。

查找优化与数据索引： 想象一下，你有一个字典存储着用户ID到用户名的映射
```
{'1001': 'Alice', '1002': 'Bob'}
```
登录后复制
。当你的系统需要根据用户名快速找到对应的用户ID时，逆向映射就派上用场了。与其遍历整个字典去查找
```
'Bob'
```
登录后复制
对应的ID，不如直接有一个
```
{'Alice': '1001', 'Bob': '1002'}
```
登录后复制
这样的逆向字典，查找效率会高得多。这在数据库索引、缓存管理等场景中非常常见。
配置管理与枚举值处理： 在处理系统配置时，我们可能有一个字典
```
{'DEBUG_MODE': True, 'LOG_LEVEL': 'INFO'}
```
登录后复制
。有时我们可能需要根据某个配置值（比如
```
True
```
登录后复制
）来找出所有启用了该值的配置项。又比如，在定义枚举（Enums）时，我们常常有
```
status_code_to_name = {200: 'OK', 404: 'NOT_FOUND'}
```
登录后复制
，而有时我们需要根据
```
name
```
登录后复制
来获取
```
status_code
```
登录后复制
，这就是典型的逆向映射需求。
API响应处理与数据转换： 当你调用一个外部API，它返回的数据结构可能是一个映射，例如
```
{'city_id': '123', 'city_name': 'New York'}
```
登录后复制
。而你的内部系统可能需要根据
```
city_name
```
登录后复制
来查找对应的
```
city_id
```
登录后复制
。或者在数据转换过程中，你建立了一个从旧格式字段到新格式字段的映射，反过来也可能需要根据新字段找到旧字段。
图论与关系建模： 在处理某些图结构或复杂关系时，你可能有一个字典表示从A到B的单向连接。如果你也需要快速查询从B到A的连接，那么一个逆向映射的字典就成了非常有用的工具。