我发现这个版本比10000个键的字典的公认版本快10%以上。

d = {i: str(i) for i in range(10000)}

new_d = dict(zip(d.values(), d.keys()))

这扩展了Robert的回答，适用于字典中的值不是唯一的情况。

class ReversibleDict(dict):
    # Ref: https://stackoverflow.com/a/13057382/
    def reversed(self):
        """
        Return a reversed dict, with common values in the original dict
        grouped into a list in the returned dict.

        Example:
        >>> d = ReversibleDict({'a': 3, 'c': 2, 'b': 2, 'e': 3, 'd': 1, 'f': 2})
        >>> d.reversed()
        {1: ['d'], 2: ['c', 'b', 'f'], 3: ['a', 'e']}
        """
        
        revdict = {}
        for k, v in self.items():
            revdict.setdefault(v, []).append(k)
        return revdict

该实现的局限性在于您不能使用反转两次并获得原始数据。它本身不是对称的。它是用Python 2.6测试的。这是一个用例，我是如何使用打印结果字典。

如果你更喜欢使用集合而不是列表，并且可能存在无序的应用程序，这是有意义的，而不是setdefault(v， []).append(k)，使用setdefault(v, set()).add(k)。

假设字典中的值是唯一的:

Python 3:

dict((v, k) for k, v in my_map.items())

Python 2:

dict((v, k) for k, v in my_map.iteritems())

除了上面建议的其他函数，如果你喜欢lambdas:

invert = lambda mydict: {v:k for k, v in mydict.items()}

或者，你也可以这样做:

invert = lambda mydict: dict( zip(mydict.values(), mydict.keys()) )

函数对于list类型的值是对称的;执行reverse_dict(reverse_dict(dictionary))时，元组被转换为列表

def reverse_dict(dictionary):
    reverse_dict = {}
    for key, value in dictionary.iteritems():
        if not isinstance(value, (list, tuple)):
            value = [value]
        for val in value:
            reverse_dict[val] = reverse_dict.get(val, [])
            reverse_dict[val].append(key)
    for key, value in reverse_dict.iteritems():
        if len(value) == 1:
            reverse_dict[key] = value[0]
    return reverse_dict

有很多答案，但没有找到任何干净的东西，以防我们谈论的是一个具有非唯一值的字典。

解决办法是:

from collections import defaultdict

inv_map = defaultdict(list) 
for k, v in my_map.items(): 
    inv_map[v].append(k)

例子:

如果初始dict my_map ={“c”:1、“d”:5,' ':5 b: 10}

然后，运行上面的代码将得到:

{5: ['a', 'd'], 1: ['c'], 10: ['b']}