反转/反转字典映射

Question

给定一本这样的字典：

my_map = {'a': 1, 'b': 2}

如何反转该映射以获得：

inv_map = {1: 'a', 2: 'b'}

Answer 1

字典值是集合的情况。 像：

some_dict = {"1":{"a","b","c"},
        "2":{"d","e","f"},
        "3":{"g","h","i"}}

逆像：

some_dict = {vi: k  for k, v in some_dict.items() for vi in v}

输出是这样的：

{'c': '1',
 'b': '1',
 'a': '1',
 'f': '2',
 'd': '2',
 'e': '2',
 'g': '3',
 'h': '3',
 'i': '3'}

Answer 2

有很多答案，但没有找到任何明确的答案，以防我们谈论具有非唯一值的字典。

解决方案是：

from collections import defaultdict

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

示例：

如果初始字典 my_map = {'c': 1, 'd': 5, 'a': 5, 'b': 10}

那么，运行上面的代码会给：

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

Answer 3

列表和字典理解的结合。 可以处理重复的键

{v:[i for i in d.keys() if d[i] == v ] for k,v in d.items()}

Answer 4

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

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

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

Answer 5

除了上面建议的其他函数之外，如果您喜欢 lambda：

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

或者，您也可以这样做：

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

Answer 6

我认为最好的方法是定义一个类。 这是“对称字典”的实现：

class SymDict:
    def __init__(self):
        self.aToB = {}
        self.bToA = {}

    def assocAB(self, a, b):
        # Stores and returns a tuple (a,b) of overwritten bindings
        currB = None
        if a in self.aToB: currB = self.bToA[a]
        currA = None
        if b in self.bToA: currA = self.aToB[b]

        self.aToB[a] = b
        self.bToA[b] = a
        return (currA, currB)

    def lookupA(self, a):
        if a in self.aToB:
            return self.aToB[a]
        return None

    def lookupB(self, b):
        if b in self.bToA:
            return self.bToA[b]
        return None

如果需要，删除和迭代方法很容易实现。

这种实现比反转整个字典（这似乎是本页上最流行的解决方案）更有效。 更不用说，您可以根据需要在 SymDict 中添加或删除值，并且您的逆向字典将始终保持有效 - 如果您只是将整个字典逆向一次，则情况并非如此。

Answer 7

如果值不唯一，并且您有点顽固：

inv_map = dict(
    (v, [k for (k, xx) in filter(lambda (key, value): value == v, my_map.items())]) 
    for v in set(my_map.values())
)

特别是对于大型字典，请注意此解决方案的效率远低于答案 Python 反转/反转映射，因为它多次循环 items()。

Answer 8

这可以处理非唯一值并保留唯一情况的大部分外观。

inv_map = {v:[k for k in my_map if my_map[k] == v] for v in my_map.itervalues()}

对于 Python 3.x，将 itervalues 替换为 values。

Answer 9

我知道这个问题已经有很多好的答案，但我想分享这个非常简洁的解决方案，它还可以处理重复值：

def dict_reverser(d):
    seen = set()
    return {v: k for k, v in d.items() if v not in seen or seen.add(v)}

这依赖于 set.add 始终返回 Python 中没有。

Answer 10

这是另一种方法。

my_map = {'a': 1, 'b': 2}

inv_map= {}
for key in my_map.keys() :
    val = my_map[key]
    inv_map[val] = key

Answer 11

dict([(value, key) for key, value in d.items()])

Answer 12

函数对于列表类型的值是对称的； 执行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

Answer 13

由于与值不同，字典在字典中需要一个唯一的键，因此我们必须将反转的值附加到一个排序列表中，以包含在新的特定键中。

def r_maping(dictionary):
    List_z=[]
    Map= {}
    for z, x in dictionary.iteritems(): #iterate through the keys and values
        Map.setdefault(x,List_z).append(z) #Setdefault is the same as dict[key]=default."The method returns the key value available in the dictionary and if given key is not available then it will return provided default value. Afterward, we will append into the default list our new values for the specific key.
    return Map

Answer 14

非双射映射的快速函数解决方案（值不唯一）：

from itertools import imap, groupby

def fst(s):
    return s[0]

def snd(s):
    return s[1]

def inverseDict(d):
    """
    input d: a -> b
    output : b -> set(a)
    """
    return {
        v : set(imap(fst, kv_iter))
        for (v, kv_iter) in groupby(
            sorted(d.iteritems(),
                   key=snd),
            key=snd
        )
    }

理论上，这应该比像 势在必行的解决方案。

不幸的是，这些值必须是可排序的，groupby 需要排序。

Answer 15

在 python 2.7/3.x 上尝试这个

inv_map={};
for i in my_map:
    inv_map[my_map[i]]=i    
print inv_map

Answer 16

def invertDictionary(d):
    myDict = {}
  for i in d:
     value = d.get(i)
     myDict.setdefault(value,[]).append(i)   
 return myDict
 print invertDictionary({'a':1, 'b':2, 'c':3 , 'd' : 1})

这将提供如下输出：{1: ['a', 'd'], 2: ['b'], 3: ['c']}

Answer 17

当前 python 3.x 版本的 lambda 解决方案：

d1 = dict(alice='apples', bob='bananas')
d2 = dict(map(lambda key: (d1[key], key), d1.keys()))
print(d2)

结果：

{'apples': 'alice', 'bananas': 'bob'}

此解决方案不检查重复项。

一些备注：

• lambda 构造可以从外部作用域访问 d1，所以我们只需要
  传入当前密钥。 它返回一个元组。
• dict() 构造函数接受元组列表。 它
  也接受映射的结果，因此我们可以跳过转换为
  列表。
• 此解决方案没有显式的 for 循环。 它还避免了对于那些数学不好的人使用列表理解;-)

Answer 18

从 如果 my_map 中的值不唯一：开始，我遇到了一个问题，不仅值不是唯一的，但此外，它们是一个列表，列表中的每个项目又由三个元素组成的列表：字符串值、数字和另一个数字。

示例：

mymap['key1'] 为您提供：

[('xyz', 1, 2),
 ('abc', 5, 4)]

我只想用键切换字符串值，将两个数字元素保持在同一位置。 您只需要另一个嵌套的 for 循环即可：

inv_map = {}
for k, v in my_map.items():
    for x in v:
        # with x[1:3] same as x[1], x[2]:
        inv_map[x[0]] = inv_map.get(x[0], []) + [k, x[1:3]]

示例：

inv_map['abc'] 现在为您提供：

[('key1', 1, 2),
 ('key1', 5, 4)]

Answer 19

即使原始字典中有非唯一值，这也有效。

def dict_invert(d):
    '''
    d: dict
    Returns an inverted dictionary 
    '''
    # Your code here
    inv_d = {}
    for k, v in d.items():
        if v not in inv_d.keys():
            inv_d[v] = [k]
        else:
            inv_d[v].append(k)
        inv_d[v].sort()
        print(f"{inv_d[v]} are the values")
        
    return inv_d

Answer 20

根据用例，可能有一种使用枚举的方法：

import enum

class Reverse(enum.Enum):
    a = 1
    b = 2

您可以双向访问值：

Reverse.a       --> prints Reverse.a
Reverse(1)      --> prints Reverse.a

Reverse.a.value --> prints 1
Reverse.a.name  --> prints 'a'

如果开发人员不知道“a”，而是包含在变量中 my_var = 'a'，相当于 my_dict[my_var] 是：

getattr(Reverse, my_var) --> prints Reverse.a

Answer 21

我会在 python 2 中这样做。

inv_map = {my_map[x] : x for x in my_map}

Answer 22

Python 3+：

inv_map = {v: k for k, v in my_map.items()}

Python 2：

inv_map = {v: k for k, v in my_map.iteritems()}

Answer 23

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

Python 3：

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

Python 2：

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

Answer 24

如果 my_map 中的值不唯一：

Python 3：

inv_map = {}
for k, v in my_map.items():
    inv_map[v] = inv_map.get(v, []) + [k]

Python 2：

inv_map = {}
for k, v in my_map.iteritems():
    inv_map[v] = inv_map.get(v, []) + [k]

Answer 25

要在保留映射类型的同时执行此操作（假设它是 dict 或 dict 子类）：

def inverse_mapping(f):
    return f.__class__(map(reversed, f.items()))

Answer 26

试试这个：（

inv_map = dict(zip(my_map.values(), my_map.keys()))

注意字典视图上的Python文档明确保证 .keys() 和 .values() 的元素顺序相同，这使得上述方法能够工作。）

或者：

inv_map = dict((my_map[k], k) for k in my_map)

或者使用 python 3.0字典理解

inv_map = {my_map[k] : k for k in my_map}

Answer 27

另一种更实用的方式：

my_map = { 'a': 1, 'b':2 }
dict(map(reversed, my_map.items()))

Answer 28

我们还可以使用 defaultdict 反转具有重复键的字典：

from collections import Counter, defaultdict

def invert_dict(d):
    d_inv = defaultdict(list)
    for k, v in d.items():
        d_inv[v].append(k)
    return d_inv

text = 'aaa bbb ccc ddd aaa bbb ccc aaa' 
c = Counter(text.split()) # Counter({'aaa': 3, 'bbb': 2, 'ccc': 2, 'ddd': 1})
dict(invert_dict(c)) # {1: ['ddd'], 2: ['bbb', 'ccc'], 3: ['aaa']}  

请参阅 此处：

此技术比使用 dict.setdefault() 的等效技术更简单、更快。

Answer 29

这扩展了 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

该实现受到限制，因为您不能使用 reversed 两次并恢复原始状态。 它本身并不对称。 它是使用 Python 2.6 进行测试的。 这里是我如何打印结果字典的用例。

如果您更愿意使用 set 而不是 list，并且可能存在对此有意义的无序应用程序，而不是 setdefault(v, []) .append(k)，使用setdefault(v, set()).add(k)。

Answer 30

例如，您有以下字典：

my_dict = {'a': 'fire', 'b': 'ice', 'c': 'fire', 'd': 'water'}

并且您希望以倒置的形式获得它：

inverted_dict = {'fire': ['a', 'c'], 'ice': ['b'], 'water': ['d']}

第一个解决方案。 要反转字典中的键值对，请使用for循环方法：

# Use this code to invert dictionaries that have non-unique values

inverted_dict = dict()
for key, value in my_dict.items():
    inverted_dict.setdefault(value, list()).append(key)

第二种解决方案。 使用字典理解方法进行反演：

# Use this code to invert dictionaries that have unique values

inverted_dict = {value: key for key, value in my_dict.items()}

第三种解决方案。 使用恢复反转方法（依赖于第二种解决方案）：

# Use this code to invert dictionaries that have lists of values

my_dict = {value: key for key in inverted_dict for value in my_map[key]}