Come si scambiano le chiavi con i valori in un dizionario?

Ricevo un dizionario come input e desidero restituire un dizionario le cui chiavi saranno i valori dell'input e il cui valore saranno le chiavi di input corrispondenti. I valori sono unici.

Ad esempio, supponiamo che il mio input sia:

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

Vorrei che il mio output fosse:

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

Per chiarire, vorrei che il mio risultato fosse l'equivalente del seguente:

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

Qualche modo preciso e pitonico per ottenere questo risultato?

Python 2:

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

Python 3 (grazie a @erik):

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

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

Da Python 2.7 in poi, incluso 3.0+, c'è una versione probabilmente più breve e più leggibile:

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

Puoi utilizzare le comprensioni dict :

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

Modificato: per Python 3, usa a.items()invece di a.iteritems(). Discussioni sulle differenze tra loro possono essere trovate negli iteritem in Python su SO.

Potresti provare:

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

Fai attenzione che non puoi "invertire" un dizionario se

1. Più di una chiave condivide lo stesso valore. Ad esempio {'one':1,'two':1}. Il nuovo dizionario può avere solo un elemento con chiave1 .
2. Uno o più valori non sono modificabili. Ad esempio {'one':[1]}. [1]è un valore valido ma non una chiave valida.

Vedi questo thread sulla mailing list di Python per una discussione sull'argomento.

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

L'attuale risposta principale presume che i valori siano unici, il che non è sempre il caso. E se i valori non sono univoci? Perderai informazioni! Per esempio:

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

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

Le informazioni su sono 'c'state completamente ignorate. Idealmente dovrebbe essere qualcosa di simile{2: ['b','c'], 3: ['a']} . Questo è ciò che fa l'implementazione in basso.

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

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

o anche meglio, ma funziona solo in Python 3:

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

Un altro modo per espandere la risposta di Ilya Prokin è utilizzare effettivamente la reversedfunzione.

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

In sostanza, il tuo dizionario viene iterato attraverso (usando .items()) dove ogni elemento è una coppia chiave / valore e quegli elementi vengono scambiati con la reversedfunzione. Quando questo viene passato al dictcostruttore, li trasforma in coppie valore / chiave che è quello che vuoi.

Suggerimento per un miglioramento per la risposta di Javier:

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

Invece di d.keys()te puoi scrivere solod , perché se scorri il dizionario con un iteratore, restituirà le chiavi del dizionario pertinente.

Ex. per questo comportamento:

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

Può essere fatto facilmente con la comprensione del dizionario:

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

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

.items()restituisce un elenco di tuple di (key, value). map()passa attraverso gli elementi della lista e applica lambda x:[::-1]a ogni suo elemento (tupla) per invertirla, così ogni tupla diventa (value, key)nella nuova lista sputata dalla mappa. Infine, dict()fa un dict dalla nuova lista.

Utilizzando loop : -

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

Se stai usando Python3, è leggermente diverso:

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

Aggiunta di una soluzione sul posto:

>>> 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, è fondamentale che tu lo usi list(d.keys())perché dict.keysrestituisce una vista delle chiavi. Se stai usando Python2, d.keys()è sufficiente.

La risposta di Hanan è quella corretta in quanto copre un caso più generale (le altre risposte sono un po 'fuorvianti per qualcuno inconsapevole della situazione duplicata). Un miglioramento alla risposta di Hanan sta usando 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]}