Wie tausche ich Schlüssel mit Werten in einem Wörterbuch aus?

Ich erhalte ein Wörterbuch als Eingabe und möchte ein Wörterbuch zurückgeben, dessen Schlüssel die Werte der Eingabe und dessen Wert die entsprechenden Eingabeschlüssel sind. Werte sind einzigartig.

Angenommen, meine Eingabe lautet:

a = dict()
a['one']=1
a['two']=2

Ich möchte, dass meine Ausgabe ist:

{1: 'one', 2: 'two'}

Zur Verdeutlichung möchte ich, dass mein Ergebnis dem folgenden entspricht:

res = dict()
res[1] = 'one'
res[2] = 'two'

Gibt es einen ordentlichen pythonischen Weg, um dies zu erreichen?

Python 2:

res = dict((v,k) for k,v in a.iteritems())

Python 3 (danke an @erik):

res = dict((v,k) for k,v in a.items())

new_dict = dict(zip(my_dict.values(), my_dict.keys()))

Ab Python 2.7, einschließlich 3.0+, gibt es eine wohl kürzere, besser lesbare Version:

>>> my_dict = {'x':1, 'y':2, 'z':3}
>>> {v: k for k, v in my_dict.items()}
{1: 'x', 2: 'y', 3: 'z'}

In [1]: my_dict = {'x':1, 'y':2, 'z':3}

In [2]: dict((value, key) for key, value in my_dict.iteritems())
Out[2]: {1: 'x', 2: 'y', 3: 'z'}

Sie können das Diktatverständnis nutzen :

res = {v: k for k, v in a.iteritems()}

Bearbeitet: Verwenden Sie für Python 3 a.items()anstelle von a.iteritems(). Diskussionen über die Unterschiede zwischen ihnen finden Sie in Iteritems in Python on SO.

Du könntest es versuchen:

d={'one':1,'two':2}
d2=dict((value,key) for key,value in d.iteritems())
d2
  {'two': 2, 'one': 1}

Beachten Sie, dass Sie ein Wörterbuch nicht "umkehren" können, wenn

1. Mehr als ein Schlüssel hat denselben Wert. Zum Beispiel {'one':1,'two':1}. Das neue Wörterbuch kann nur ein Element mit Schlüssel enthalten 1.
2. Einer oder mehrere der Werte sind nicht verwertbar. Zum Beispiel {'one':[1]}. [1]ist ein gültiger Wert, aber kein gültiger Schlüssel.

In diesem Thread auf der Python-Mailingliste finden Sie eine Diskussion zu diesem Thema.

Die aktuell führende Antwort geht davon aus, dass die Werte eindeutig sind, was nicht immer der Fall ist. Was ist, wenn Werte nicht eindeutig sind? Sie verlieren Informationen! Beispielsweise:

d = {'a':3, 'b': 2, 'c': 2} 
{v:k for k,v in d.iteritems()} 

kehrt zurück {2: 'b', 3: 'a'}.

Die Informationen über 'c'wurden vollständig ignoriert. Idealerweise sollte es so etwas sein {2: ['b','c'], 3: ['a']}. Dies ist, was die unterste Implementierung tut.

Python 2.x.

def reverse_non_unique_mapping(d):
    dinv = {}
    for k, v in d.iteritems():
        if v in dinv:
            dinv[v].append(k)
        else:
            dinv[v] = [k]
    return dinv

Python 3.x.

def reverse_non_unique_mapping(d):
    dinv = {}
    for k, v in d.items():
        if v in dinv:
            dinv[v].append(k)
        else:
            dinv[v] = [k]
    return dinv

res = dict(zip(a.values(), a.keys()))

new_dict = dict( (my_dict[k], k) for k in my_dict)

oder noch besser, funktioniert aber nur in Python 3:

new_dict = { my_dict[k]: k for k in my_dict}

Eine andere Möglichkeit, die Antwort von Ilya Prokin zu erweitern, besteht darin, die reversedFunktion tatsächlich zu verwenden .

dict(map(reversed, my_dict.items()))

Im Wesentlichen wird Ihr Wörterbuch durchlaufen (wobei .items()), wobei jedes Element ein Schlüssel / Wert-Paar ist, und diese Elemente werden mit der reversedFunktion ausgetauscht . Wenn dies an den dictKonstruktor übergeben wird, werden sie in Wert / Schlüssel-Paare umgewandelt, was Sie möchten.

Verbesserungsvorschlag für Javier Antwort:

dict(zip(d.values(),d))

Anstatt d.keys() können Sie nur schreiben d, denn wenn Sie das Wörterbuch mit einem Iterator durchgehen, werden die Schlüssel des entsprechenden Wörterbuchs zurückgegeben.

Ex. für dieses Verhalten:

d = {'a':1,'b':2}
for k in d:
 k
'a'
'b'

Kann leicht mit Wörterbuchverständnis gemacht werden:

{d[i]:i for i in d}

dict(map(lambda x: x[::-1], YourDict.items()))

.items()gibt eine Liste von Tupeln von zurück (key, value). map()Durchläuft Elemente der Liste und wendet sie lambda x:[::-1]auf jedes Element (Tupel) an, um sie umzukehren, sodass jedes Tupel (value, key)in die neue Liste aufgenommen wird, die aus der Karte herausgespuckt wurde. Schließlich dict()macht ein Diktat aus der neuen Liste.

Verwenden der Schleife : -

newdict = {} #Will contain reversed key:value pairs.

for key, value in zip(my_dict.keys(), my_dict.values()):
    # Operations on key/value can also be performed.
    newdict[value] = key

Wenn Sie Python3 verwenden, ist es etwas anders:

res = dict((v,k) for k,v in a.items())

Hinzufügen einer In-Place-Lösung:

>>> d = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>> for k in list(d.keys()):
...     d[d.pop(k)] = k
... 
>>> d
{'two': 2, 'one': 1, 'four': 4, 'three': 3}

In Python3 ist es wichtig, dass Sie verwenden, list(d.keys())da dict.keyseine Ansicht der Schlüssel zurückgegeben wird. Wenn Sie Python2 verwenden, d.keys()ist dies ausreichend.

Hanans Antwort ist die richtige, da sie einen allgemeineren Fall abdeckt (die anderen Antworten sind für jemanden, der sich der doppelten Situation nicht bewusst ist, irreführend). Eine Verbesserung von Hanans Antwort ist die Verwendung von setdefault:

mydict = {1:a, 2:a, 3:b}   
result = {}
for i in mydict:  
   result.setdefault(mydict[i],[]).append(i)
print(result)
>>> result = {a:[1,2], b:[3]}