Python逆転/反転のマッピング

Question

された辞書のように:

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

できるように、き反転をこのマップを取得す:

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

Answer 1

Pythonの2.7.35の場合

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または<=>サブクラスであると仮定します）：

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のdictの内包表記を使用して

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セントを追加

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

特に大きなdictのため、この解決策は、はるかに効率的な答え<のhref = "https://stackoverflow.com/questions/483666/python-reverse-inverse-a-mapping/485368#485368よりであることに注意してください「> Pythonは、それが複数回items()をループするのでマッピングを反転/逆転

Answer 12

他の機能に加えて、あなたはラムダのような場合、上記の提案

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

のpython 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']}

第一ソリューション.反転 key-value ペアのお辞書を利用 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

辞書は値とは異なり、辞書内の1つの一意のキーを必要とするので、

、我々は新しい固有のキー内に含まれるようにソートのリストに反転した値を追加する必要があります。

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

理論的には、これは<不可欠溶液中でのように一つ一つをセットに追加（またはリストに追加する）よりも高速でなければなりません/>。

残念ながら値をソート可能にする必要があり、ソートはGROUPBYによって要求されます。

Answer 24

未完全に異なる何か、クックブックから少しだけ書き換えレシピ。これは、インスタンスを通してそれを得る代わりに、毎回の方法をsetdefault保持することにより最適化されたfuthermore、ですます：

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)

2.xのためにmapping.items()置き換え、CPythonの3.xの下で実行されるように設計され、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

私は「の」サイクルの助けを借りてこれを書いたと方法「に.get（）を」と 『マップが』関数であるので、私は 『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

これが最善の解決策ではないですが、それは動作します。

：我々は逆にしたい辞書があるとしましょう

辞書= { ''：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'}