关于词典：Python的映射逆向/反转


Python reverse / invert a mapping

词典给了像这样： P / < >

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

知识地图的这一转化可以得到： P / < >

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

编辑注：map改变到my_map到避免conflicts与在建的功能，map。一些评论可能affected下面的。 P / < >

相关讨论

为Python 2.7。x

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

3 +的Python：

1
inv_map = {v: k for k, v in my_map.items()}
相关讨论

如果它是在独特的值是：

1
dict((v, k) for k, v in my_map.iteritems())
相关讨论

如果值不是唯一的：在my_map

1
2
3
4
inv_map = {}
for k, v in my_map.iteritems():
    inv_map[v] = inv_map.get(v, [])
    inv_map[v].append(k)
相关讨论

1
2
def inverse_mapping(f):
    return f.__class__(map(reversed, f.items()))
相关讨论

试试这个：

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

(注意在Python字典文件的明确担保，.keys()视图和.values()有自己的元素，在相同的命令，它允许上述工作的方法。)

也：

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

或使用的Python 3.0的理解

1
inv_map = {my_map[k] : k for k in my_map}
相关讨论

另一个，更多的功能，单：

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

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

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

在本expands答案Python /反转A反向映射，在申请时的值不唯一。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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测试。这里是一个如何使用用例"打印我的观察。

如果你宁愿使用setlist大于一，这本研究有应用和理解，而不是setdefault(v, []).append(k)setdefault(v, set()).add(k)，使用。

相关讨论

加上我2分的Python之道：

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

例子：

1
2
3
4
5
6
7
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}
相关讨论

如果值不是唯一的，你是一个小的核心：

1
2
3
4
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高效反向映射，因为它非A / items()回路过多的时代。

相关讨论

我们可以使用一个反向重复defaultdict键词：

1
2
3
4
5
6
7
8
9
10
11
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']}

湖在这里：

This technique is simpler and faster than an equivalent technique using dict.setdefault().

除了其他功能，建议以上，波长：如果你喜欢

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

或者，你可以这样做太。

1
invert = lambda mydict: dict( zip(mydict.values(), mydict.keys()) )
相关讨论

这非唯一值的处理和retains多看独特的案例。

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

为Python 3.x，itervalues与替换值。I can’t采取信贷这…它是由杰克建议的图标。

相关讨论

使用zip

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

例如，您有以下字典：

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

你想把它变成这样一种倒转的形式：

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

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

1
2
3
4
5
# 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)

第二个解决方案。使用字典理解方法进行倒置：

1
2
3
# Use this code to invert dictionaries that have unique values

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

第三种解决方案。使用反转方法：

1
2
3
# 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]}

我认为最好的方式这样做是一类的定义。这是在实施的"对称字典"：a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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 AS值多为你想，和你永远保持逆字典有效-这不是真的，如果你只是一次反向整个字典。

相关讨论

我会在python 2中这样做。

1
inv_map = {my_map[x] : x for x in my_map}
1
2
3
4
5
6
7
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']

1
2
3
4
5
6
7
8
9
10
11
12
13
  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

此代码如下所示：

1
2
3
4
5
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']}
相关讨论

本研究尝试Python 2.7／3

1
2
3
4
inv_map={};
for i in my_map:
    inv_map[my_map[i]]=i    
print inv_map

需要完全不同的东西，只是一位改写从食谱食谱。它由setdefault保持futhermore优化法，而不是把它的每一次通过实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
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)

在设计和运行mapping.items()CPython 2.x和3.x，mapping.iteritems()replace

在我的机器运行速度比A位，其他的例子在这里

函数是对称型的值到列表元组列表；当是为表演反向(反向_ _字典字典(词典)

1
2
3
4
5
6
7
8
9
10
11
12
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

我们需要一个独特的关键词典在词典不同的价值观，我们要用一个附加的值列表排序的键包括在新的特异性。

1
2
3
4
5
6
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

如果值不可能是一个哈希值(一个尺寸)

1
2
3
4
5
6
7
8
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)

如果你和一个递归需要挖快就只是单向的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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)
相关讨论

逆字典：

1
2
dict_ = {"k0":"v0","k1":"v1","k2":"v1
<hr><P>根据我对这个问题的评论。我认为对python2和python 3都有效的最简单和一行程序是</P>[cc lang="python"]dict(zip(inv_map.values(), inv_map.keys()))

基本功能的解决方案的非双射映射(值不唯一)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
        )
    }

在理论上本应更快比添加到集合(或发生一个列表)由一样在必要的解决方案。

一定要sortable阙值，排序由GroupBy是必需的。

相关讨论

我写的一本具有帮助周’’和’法(I).get更改名称词典"图""图""因为MAP1-LC3’是一个函数。

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

研究各种字典，不管如果他们don’t有独特的价值作为密钥的使用，你可以创建一个清单中的每个键的值

1
inv_map = {v: inv_map.get(v, []) + [k] for k,v in my_map.items()}
相关讨论

This is not the best solution, but it works. Let's say the dictionary we want to reverse is:

dictionary = {'a': 1, 'b': 2, 'c': 3}, then:

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

反向字典的输出应为1:'A'，2:'B'，3:'C'

如果这个项目是不是唯一的尝试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
     dict={}
     dict1={}
     num=int(raw_input(" how many numbers in dict?-->"))
     for i in range (0,num):
         key=raw_input(" enter key -->")
         value=raw_input("enter value -->")
         dict[key]=value
     keys=dict.keys()
     values=dict.values()
     for b in range (0,num):
         keys[b],values[b]=values[b],keys[b]
         dict1[keys[b]]=values[b]
     print keys
     print values
     print dict1
相关讨论