Python 反转/反转映射

Question

给定一个像这样的字典：

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

如何反转这张图得到：

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

Answer 1

有关的Python 2.7.x

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

有关的Python 3 +：

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

Answer 2

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

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

Answer 3

如果在my_map的值不是唯一的：

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

Answer 4

要做到这一点，同时保留映射的类型（假设它是一个dict或dict子类）：

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

Answer 5

尝试这种情况：

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 6

另一个更功能，方式：

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

Answer 7

这扩展了答案 https://stackoverflow.com/questions/ 483666 /蟒-反向逆一个映射/ 485368＃485368 时，施加到当在字典中的值不是唯一的。

class ReversibleDict(dict):

    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.iteritems():
            revdict.setdefault(v, []).append(k)
        return revdict

在实现有限的，因为你不能使用reversed两次，得到原来的回来。它是不是对称的这样。它与Python 2.6测试。 这里是的，我了如何使用来打印所得到的字典的使用情况。

如果你想用一个set比list，并有应用程序，而不是setdefault(v, []).append(k)对于这这是有道理的，使用setdefault(v, set()).add(k)。

Answer 8

我们还可以逆转与重复的键的字典使用defaultdict：

from collections import Counter, defaultdict

def invert_dict(d):
    d_inv = defaultdict(list)
    for k, v in c.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 9

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

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

Answer 10

添加我2的Python的方式美分：

inv_map = dict(map(reversed, my_map.items()))

示例：

In [7]: my_map
Out[7]: {1: 'one', 2: 'two', 3: 'three'}

In [8]: inv_map = dict(map(reversed, my_map.items()))

In [9]: inv_map
Out[9]: {'one': 1, 'three': 3, 'two': 2}

Answer 11

如果这些值不是唯一的，并且您有点顽固：

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 12

在除了其它功能上面建议，如果你喜欢lambda表达式：

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

或者，你可以做这种方式太：

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

Answer 13

我想做到这一点，最好的方法是定义一个类。这里是一个“对称字典”的实现：

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 14

使用拉链

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

Answer 15

此处理非唯一值，并且保留了许多独特的壳体的外观的。

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

有关的Python 3.x中，取代的 itervalues 与值。 我不能居功这...这是由杰克图标提示。

Answer 16

尝试此蟒2.7 / 3.x的

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

Answer 17

例如，你有以下词典：

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 = dictio()
for key, value in 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 dict.items()}

<强>第三解决方案即可。使用如果还原反转的方法：

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

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

Answer 18

功能是对称的类型列表中的值;执行反向字典当元组被转换为列表（反向字典（词典））

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 19

由于字典需要不同值的字典中的一个唯一的密钥，我们要反向值追加到排序列表将包含新的特定按键内。

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 20

我会做这种方式在Python 2。

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

Answer 21

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 22

  def reverse_dictionary(input_dict):
      out = {}
      for v in input_dict.values():  
          for value in v:
              if value not in out:
                  out[value.lower()] = []

      for i in input_dict:
          for j in out:
              if j in map (lambda x : x.lower(),input_dict[i]):
                  out[j].append(i.lower())
                  out[j].sort()
      return out

此代码这样做：

r = reverse_dictionary({'Accurate': ['exact', 'precise'], 'exact': ['precise'], 'astute': ['Smart', 'clever'], 'smart': ['clever', 'bright', 'talented']})

print(r)

{'precise': ['accurate', 'exact'], 'clever': ['astute', 'smart'], 'talented': ['smart'], 'bright': ['smart'], 'exact': ['accurate'], 'smart': ['astute']}

Answer 23

（不是唯一的值）的非双射映射的快速功能性溶液：

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

在理论上，这应该比在势在必行溶液添加到该组（或附加到列表）一个个像<更快/ A>

不幸的是，值必须是可排序的，由GROUPBY所需的排序。

Answer 24

不完全不同的东西，只是有点重写配方从食谱。它futhermore通过保留setdefault方法，而不是每次都得到它通过实例优化：

def inverse(mapping):
    '''
    A function to inverse mapping, collecting keys with simillar values
    in list. Careful to retain original type and to be fast.
    >> d = dict(a=1, b=2, c=1, d=3, e=2, f=1, g=5, h=2)
    >> inverse(d)
    {1: ['f', 'c', 'a'], 2: ['h', 'b', 'e'], 3: ['d'], 5: ['g']}
    '''
    res = {}
    setdef = res.setdefault
    for key, value in mapping.items():
        setdef(value, []).append(key)
    return res if mapping.__class__==dict else mapping.__class__(res)

设计下的CPython 3.X被运行时，用于2.x的替换mapping.items() mapping.iteritems()

在我的机器运行快一点，比其它实施例在这里

Answer 25

如果值不是唯一的，并且可以是散列（一维）：

for k, v in myDict.items():
    if len(v) > 1:
        for item in v:
            invDict[item] = invDict.get(item, [])
            invDict[item].append(k)
    else:
        invDict[v] = invDict.get(v, [])
        invDict[v].append(k)

和使用，如果你需要深入挖掘则只是一维中的递归：

def digList(lst):
    temp = []
    for item in lst:
        if type(item) is list:
            temp.append(digList(item))
        else:
            temp.append(item)
    return set(temp)

for k, v in myDict.items():
    if type(v) is list:
        items = digList(v)
        for item in items:
            invDict[item] = invDict.get(item, [])
            invDict[item].append(k)
    else:
        invDict[v] = invDict.get(v, [])
        invDict[v].append(k)

Answer 26

逆你的字典：

dict_ = {"k0":"v0", "k1":"v1", "k2":"v1"}
inversed_dict_ = {val: key for key, val in dict_.items()}

print(inversed_dict_["v1"])

Answer 27

我写这与“为”循环的帮助和方法“获得（）”和我改变了词典‘MAP1’的名称‘地图’，因为‘映射’是一个功能。

def dict_invert(map1):
    inv_map = {} # new dictionary
    for key in map1.keys():
        inv_map[map1.get(key)] = key
    return inv_map

Answer 28

有关各种字典，不管他们没有作为键使用唯一值，你可以为每个值创建密钥列表

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

Answer 29

这不是最好的解决方案，但它的工作原理。比方说，我们要扭转字典是：

字典= { 'A'：1， 'B'：2， 'C'：3}，那么：

dictionary = {'a': 1, 'b': 2, 'c': 3}
reverse_dictionary = {}
for index, val in enumerate(list(dictionary.values())):
    reverse_dictionary[val] = list(dictionary.keys())[index]

reverse_dictionary的输出，应该是{1： 'A'，2： 'B'，3： 'C'}