Jak wymienić klucze z wartościami w słowniku?

Otrzymuję słownik jako dane wejściowe i chciałbym zwrócić słownik, którego klucze będą wartościami danych wejściowych i którego wartością będą odpowiadające im klucze wejściowe. Wartości są wyjątkowe.

Na przykład, powiedzmy, że moje dane wejściowe to:

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

Chciałbym, aby mój wynik był:

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

Aby wyjaśnić, chciałbym, aby mój wynik był odpowiednikiem następującego:

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

Czy jest jakiś fajny sposób na osiągnięcie tego w Pythonie?

Python 2:

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

Python 3 (dzięki @erik):

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

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

Począwszy od Pythona 2.7, w tym 3.0+, istnieje prawdopodobnie krótsza, bardziej czytelna wersja:

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

Możesz skorzystać z dyktowania ze zrozumieniem :

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

Edytowano: w przypadku języka Python 3 użyj a.items()zamiasta.iteritems() . Dyskusje na temat różnic między nimi można znaleźć w iteritems w Pythonie na SO.

Możesz spróbować:

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

Pamiętaj, że nie możesz „odwrócić” słownika, jeśli

1. Więcej niż jeden klucz ma tę samą wartość. Na przykład {'one':1,'two':1}. Nowy słownik może mieć tylko jedną pozycję z kluczem1 .
2. Co najmniej jednej wartości nie można zhasować. Na przykład {'one':[1]}. [1]jest prawidłową wartością, ale nie jest prawidłowym kluczem.

Zobacz ten wątek na liście mailingowej Pythona, aby zapoznać się z dyskusją na ten temat.

Obecna wiodąca odpowiedź zakłada, że ​​wartości są niepowtarzalne, co nie zawsze ma miejsce. A jeśli wartości nie są wyjątkowe? Stracisz informacje! Na przykład:

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

zwraca {2: 'b', 3: 'a'}.

Informacja o 'c'została całkowicie zignorowana. Idealnie powinno być coś takiego {2: ['b','c'], 3: ['a']}. To właśnie robi implementacja na dole.

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)

lub nawet lepiej, ale działa tylko w Pythonie 3:

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

Innym sposobem rozwinięcia odpowiedzi Ilyi Prokin jest faktyczne użycie reversedfunkcji.

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

W istocie, twój słownik jest iterowany (przy użyciu .items()), gdzie każdy element jest parą klucz / wartość, a te elementy są zamieniane z reversedfunkcją. Kiedy jest to przekazywane do dictkonstruktora, zamienia je w pary wartość / klucz, co jest tym, czego chcesz.

Propozycja ulepszenia odpowiedzi Javiera:

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

Zamiast d.keys()ciebie możesz po prostu pisaćd , ponieważ jeśli przejdziesz przez słownik z iteratorem, zwróci on klucze odpowiedniego słownika.

Dawny. dla tego zachowania:

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

Można to łatwo zrobić ze zrozumieniem słownikowym:

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

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

.items()zwraca listę krotek (key, value). map()przechodzi przez elementy listy i stosuje się lambda x:[::-1]do każdego jego elementu (krotki), aby ją odwrócić, więc każda krotka trafia (value, key)na nową listę wyplutowaną z mapy. Na koniec dict()tworzy dyktando z nowej listy.

Korzystanie z pętli : -

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

Jeśli używasz Python3, jest nieco inaczej:

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

Dodawanie rozwiązania lokalnego:

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

W Python3 krytyczne znaczenie ma użycie, list(d.keys())ponieważ dict.keyszwraca widok kluczy. Jeśli używasz Python2, d.keys()wystarczy.

Odpowiedź Hanana jest prawidłowa, ponieważ obejmuje bardziej ogólny przypadek (inne odpowiedzi są trochę mylące dla kogoś, kto nie jest świadomy powielonej sytuacji). Ulepszeniem odpowiedzi Hanana jest użycie 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]}