如何交换字典中的键和值？

Question

我收到一个字典作为输入，并希望返回一个字典，其键将是输入的值，其值将是相应的输入键。 价值观是独一无二的。

例如，假设我的输入是：

a = dict()
a['one']=1
a['two']=2

我希望我的输出是：

{1: 'one', 2: 'two'}

为了澄清，我希望我的结果相当于以下内容：

res = dict()
res[1] = 'one'
res[2] = 'two'

有什么简洁的 Pythonic 方法可以实现这一点吗？

Answer 1

Python 2：

res = dict((v,k) for k,v in a.iteritems())

Python 3（感谢@erik）：

res = dict((v,k) for k,v in a.items())

Answer 2

new_dict = dict(zip(my_dict.values(), my_dict.keys()))

Answer 3

从 Python 2.7 开始，包括 3.0+，有一个可以说更短、更易读的版本：

>>> my_dict = {'x':1, 'y':2, 'z':3}
>>> {v: k for k, v in my_dict.items()}
{1: 'x', 2: 'y', 3: 'z'}

Answer 4

您可以使用 字典理解：

Python 3

res = {v: k for k, v in a.items()}

Python 2

res = {v: k for k, v in a.iteritems()}

编辑：对于 Python 3、使用a.items()代替a.iteritems()。 关于它们之间差异的讨论可以在 iteritems in Python on SO 中找到。

Answer 5

In [1]: my_dict = {'x':1, 'y':2, 'z':3}

Python 3

In [2]: dict((value, key) for key, value in my_dict.items())
Out[2]: {1: 'x', 2: 'y', 3: 'z'}

Python 2

In [2]: dict((value, key) for key, value in my_dict.iteritems())
Out[2]: {1: 'x', 2: 'y', 3: 'z'}

Answer 6

当前的主要答案假设值是唯一的，但情况并非总是如此。 如果值不唯一怎么办？ 你会丢失信息！
例如：

d = {'a':3, 'b': 2, 'c': 2} 
{v:k for k,v in d.iteritems()} 

返回{2: 'b', 3: 'a'}。

关于'c'的信息被完全忽略。
理想情况下，它应该类似于 {2: ['b','c'], 3: ['a']}。 这就是底层实现的作用。

Python 2.x

def reverse_non_unique_mapping(d):
    dinv = {}
    for k, v in d.iteritems():
        if v in dinv:
            dinv[v].append(k)
        else:
            dinv[v] = [k]
    return dinv

Python 3.x

def reverse_non_unique_mapping(d):
    dinv = {}
    for k, v in d.items():
        if v in dinv:
            dinv[v].append(k)
        else:
            dinv[v] = [k]
    return dinv

Answer 7

res = dict(zip(a.values(), a.keys()))

Answer 8

您可以尝试：

Python 3

d={'one':1,'two':2}
d2=dict((value,key) for key,value in d.items())
d2
  {'two': 2, 'one': 1}

Python 2

d={'one':1,'two':2}
d2=dict((value,key) for key,value in d.iteritems())
d2
  {'two': 2, 'one': 1}

则无法“反转”字典

1. 请注意，如果多个键共享相同的值， 。 例如{'one':1,'two':1}。 新字典只能包含一项带有键 1 的项目。
2. 其中一个或多个值是不可散列的。 例如{'one':[1]}。 [1] 是有效值，但不是有效键。

请参阅 python 邮件列表上的此线程关于该主题的讨论。

Answer 9

扩展 Ilya Prokin 的响应的另一种方法是实际使用 reversed 函数。

dict(map(reversed, my_dict.items()))

本质上，您的字典是通过（使用 .items()）进行迭代的，其中每个项目都是一个键/值对，并且这些项目与 reversed 函数进行交换。 当它传递给 dict 构造函数时，它会将它们转换为您想要的值/键对。

Answer 10

new_dict = dict( (my_dict[k], k) for k in my_dict)

甚至更好，但仅适用于 Python 3：

new_dict = { my_dict[k]: k for k in my_dict}

Answer 11

对哈维尔答案的改进建议：

dict(zip(d.values(),d))

您可以只编写 d 而不是 d.keys() ，因为如果您使用迭代器遍历字典，它将返回键的相关词典。

前任。 对于这种行为：

d = {'a':1,'b':2}
for k in d:
 k
'a'
'b'

Answer 12

可以通过字典理解轻松完成：

{d[i]:i for i in d}

Answer 13

dict(map(lambda x: x[::-1], YourDict.items()))

.items() 返回(key, value) 元组列表。 map() 遍历列表的元素，并将 lambda x:[::-1] 应用于每个元素（元组）以反转它，因此每个元组都变为 <从地图中吐出的新列表中的 code>(value, key) 。 最后，dict() 从新列表中创建一个字典。

Answer 14

哈南的答案是正确的，因为它涵盖了更一般的情况（其他答案对于不知道重复情况的人来说有点误导）。 Hanan 的答案的改进是使用 setdefault：

mydict = {1:a, 2:a, 3:b}   
result = {}
for i in mydict:  
   result.setdefault(mydict[i],[]).append(i)
print(result)
>>> result = {a:[1,2], b:[3]}

Answer 15

使用循环：-

newdict = {} #Will contain reversed key:value pairs.

for key, value in zip(my_dict.keys(), my_dict.values()):
    # Operations on key/value can also be performed.
    newdict[value] = key

Answer 16

如果您使用的是 Python3，则略有不同：

res = dict((v,k) for k,v in a.items())

Answer 17

添加就地解决方案：

>>> d = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>> for k in list(d.keys()):
...     d[d.pop(k)] = k
... 
>>> d
{'two': 2, 'one': 1, 'four': 4, 'three': 3}

在 Python3 中，使用 list(d.keys()) 至关重要，因为 dict.keys 返回一个视图 键。 如果您使用的是 Python2，d.keys() 就足够了。

Answer 18

我发现这个版本是最全面的版本：

a = {1: 'one', 2: 'two'}

swapped_a = {value : key for key, value in a.items()}

print(swapped_a)

输出：
{'一'：1，'二'：2}

Answer 19

在我看来，另一种方法的可读性不如其他一些答案：

new_dict = dict(zip(*list(zip(*old_dict.items()))[::-1]))

其中 list(zip(*old_dict.items()))[::-1] 给出 2 个元组的列表，即 old_dict 的值和键， 分别。