Python: ¿la mejor forma de intercambiar claves con valores en un diccionario?

Question

Recibo un diccionario como entrada, y me gustaría devolver un diccionario cuyas claves serán los valores de entrada y cuyo valor serán las teclas de entrada correspondientes. Los valores son únicos.

Por ejemplo, decir que mi entrada es:

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

Me gustaría que mi salida sea:

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

Para aclarar Me gustaría que mi resultado ser el equivalente de los siguientes:

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

¿Alguna forma precisa de Python para lograr esto?

Gracias

Answer 1

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

Answer 2

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

Answer 3

Usted podría intentar:

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

Cuidado que un diccionario no puede 'inversa' si

1. Más de uno comparte clave las mismo valor. Por ejemplo {'one':1,'two':1}. El nuevo diccionario solo puede tener un elemento con la clave 1.
2. Uno o más de los valores no se puede ajustar. Por ejemplo {'one':[1]}. [1] es un valor válido pero no una clave válida.

Consulte this thread en la lista de correo de python para una discusión sobre el tema.

Answer 4

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

Answer 5

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

o incluso mejor, pero sólo funciona en Python 3:

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

Answer 6

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

Answer 7

Desde Python 2.7 en adelante, incluyendo 3.0 o superior, hay una versión posiblemente más corto, más fácil de leer:

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

Answer 8

Sugerencias para una mejora de Javier answe R:

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

En lugar de d.keys() puede escribir simplemente d, porque si vas a través de diccionario con un iterador, devolverá las llaves del diccionario correspondiente.

Ej.para este comportamiento:

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

Answer 9

Puede hacer uso de dict comprehensions:

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

Editado: Para Python 3, utilice a.items() en lugar de a.iteritems(). Las discusiones sobre las diferencias entre ellos se pueden encontrar en iteritems in Python en SO.

Answer 10

Usando bucle: -

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 

Answer 11

Si está utilizando python3, es ligeramente diferente:

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

Answer 12

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

.items() devuelve una lista de tuplas de (key, value). map() pasa por los elementos de la lista y aplica lambda x:[::-1] a cada uno de sus elementos (tupla) para invertirlo, de modo que cada tupla se convierte en (value, key) en la nueva lista escupida fuera del mapa. Finalmente, dict() hace un dict de la nueva lista.

Answer 13

Otra forma de ampliar la respuesta de Ilya Prokin es utilizar realmente la función reversed.

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

En esencia, su diccionario se repite a través de (usando .items()), donde cada elemento es un par clave/valor, y esos elementos se intercambian con la función reversed. Cuando esto se pasa al constructor dict, los convierte en pares de valor/clave, que es lo que desea.

Answer 14

Adición de una solución en el lugar:

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

En python3, es fundamental que utilice list(d.keys()) PORQUE dict.keys devuelve una vista de las llaves. Si está usando Python2, d.keys() es suficiente.

Answer 15

La respuesta principal actual asume que los valores son únicos, lo que no siempre es el caso. ¿Qué pasa si los valores no son únicos? ¡Perderás información! Por ejemplo:

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

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

La información sobre 'c' se ignoró por completo. Idealmente debería haber sido algo así como {2: ['b','c'], 3: ['a']}. Esto es lo que hace la implementación inferior.

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