¿Cómo intercambio claves con valores en un diccionario?

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

Por ejemplo, digamos que mi entrada es:

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

Me gustaría que mi salida fuera:

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

Para aclarar, me gustaría que mi resultado fuera el equivalente a lo siguiente:

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

¿Alguna forma pitónica ordenada de lograr esto?

Python 2:

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

Python 3 (gracias a @erik):

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

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

Desde Python 2.7 en adelante, incluida la 3.0+, hay una versión posiblemente más corta y legible:

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

Puede hacer uso de dict comprensiones :

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

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

Tu podrías intentar:

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

Tenga en cuenta que no puede 'revertir' un diccionario si

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

Vea este hilo en la lista de correo de Python para una discusión sobre el tema.

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

La respuesta principal actual asume que los valores son únicos, lo que no siempre es el caso. ¿Y 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()} 

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

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

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 incluso mejor, pero solo funciona en Python 3:

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

Otra forma de ampliar la respuesta de Ilya Prokin es utilizar la reversedfunción.

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

En esencia, su diccionario se itera (usando .items()) donde cada elemento es un par clave / valor, y esos elementos se intercambian con la reversedfunción. Cuando esto se pasa al dictconstructor, los convierte en pares de valor / clave, que es lo que desea.

Sugerencia de mejora para la respuesta de Javier:

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

En lugar de d.keys()puede escribir simplemente d, porque si revisa el diccionario con un iterador, devolverá las claves del diccionario correspondiente.

Ex. para este comportamiento:

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

Se puede hacer fácilmente con la comprensión del diccionario:

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

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 su elemento (tupla) para revertirlo, por lo que cada tupla se convierte (value, key)en la nueva lista escupida fuera del mapa. Finalmente, dict()hace un dictamen de la nueva lista.

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

Si está usando Python3, es ligeramente diferente:

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

Agregar una solución in situ:

>>> 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.keysdevuelve una vista de las claves. Si está utilizando Python2, d.keys()es suficiente.

La respuesta de Hanan es la correcta ya que cubre un caso más general (las otras respuestas son un poco engañosas para alguien que desconoce la situación duplicada). Una mejora de la respuesta de Hanan es usar 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]}