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

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

例如，假设我的输入是:

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

我希望我的输出是:

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

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

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

有没有简洁的 Python 方法来实现这一点？

139138 次浏览
小开

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

小开
最佳答案

巨蟒2:

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

Python 3(感谢@erik) :

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

你可以试试:

巨蟒3

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

巨蟒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 邮件列表中的 这根线。

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

巨蟒3

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

巨蟒2

In [2]: dict((value, key) for key, value in my_dict.iteritems())
Out[2]: {1: 'x', 2: 'y', 3: 'z'}
小开 
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}
小开 
new_dict = dict(zip(my_dict.values(), my_dict.keys()))
小开

从 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'}
小开

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

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

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

例如:

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

你可利用 词典理解:

巨蟒3

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

巨蟒2

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

编辑: 对于 Python3，使用 a.items()而不是 a.iteritems()。讨论它们之间的差异可以在关于 SO 的 Python 中的 iteritem中找到。

小开

使用 循环:-

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
小开

如果你正在使用 Python 3，它会有些不同:

res = dict((v,k) for k,v in a.items())
小开 
dict(map(lambda x: x[::-1], YourDict.items()))

.items()返回 (key, value)的元组列表。map()遍历列表中的元素，并将 lambda x:[::-1]应用于每个元素(tuple)以反转它，因此每个 tuple 在从 map 中分离出来的新列表中变成 (value, key)。最后，dict()从新列表中做出一个判断。

小开

展开 伊利亚 · 普罗金的回应的另一种方法是实际使用 reversed函数。

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

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

小开

添加就地解决方案:

>>> 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}

在 Python 3中，使用 list(d.keys())非常关键，因为 dict.keys返回键的 风景。如果您正在使用 Python 2，那么 d.keys()就足够了。

小开

当前的主要答案假设值是唯一的，但并非总是如此。如果值不是唯一的呢？你会泄露消息的！ For example:

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
小开

通过字典理解可以很容易地做到:

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

Hanan 的答案是正确的，因为它涵盖了更一般的情况(其他的答案对于没有意识到重复情况的人来说有点误导)。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]}
小开

我觉得这个版本最全面:

A = {1: ‘ one’，2: ‘ two’}

Swaps _ a = { value: key for key，value in a.item ()}

打印(交换 _ a)

产出: {‘ one’: 1，‘ two’: 2}

小开

一个不像其他答案那样可读的替代答案(在我看来) :

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

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


提交答案