Como faço para trocar chaves com valores em um dicionário?

Recebo um dicionário como entrada e gostaria de retornar um dicionário cujas chaves serão os valores de entrada e cujo valor serão as chaves de entrada correspondentes. Os valores são únicos.

Por exemplo, digamos que minha entrada seja:

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

Eu gostaria que minha saída fosse:

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

Para esclarecer, gostaria que meu resultado fosse o equivalente ao seguinte:

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

Alguma maneira Pythônica legal de conseguir isso?

Python 2:

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

Python 3 (graças a @erik):

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

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

A partir do Python 2.7, incluindo 3.0+, há uma versão indiscutivelmente mais curta e legível:

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

Você pode fazer uso de compreensões de dicionário :

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

Editado: Para Python 3, use em a.items()vez de a.iteritems(). As discussões sobre as diferenças entre eles podem ser encontradas em iteritens em Python no SO.

Você poderia tentar:

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

Esteja ciente de que você não pode 'inverter' um dicionário se

1. Mais de uma chave compartilha o mesmo valor. Por exemplo {'one':1,'two':1}. O novo dicionário só pode ter um item com chave 1.
2. Um ou mais dos valores são inalteráveis. Por exemplo {'one':[1]}. [1]é um valor válido, mas não uma chave válida.

Veja este tópico na lista de discussão do python para uma discussão sobre o assunto.

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

A resposta principal atual assume que os valores são únicos, o que nem sempre é o caso. E se os valores não forem únicos? Você perderá informações! Por exemplo:

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

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

A informação sobre 'c'foi completamente ignorada. Idealmente, deveria ser algo assim {2: ['b','c'], 3: ['a']}. Isso é o que a implementação inferior faz.

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)

ou ainda melhor, mas só funciona no Python 3:

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

Outra maneira de expandir a resposta de Ilya Prokin é realmente usar a reversedfunção.

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

Em essência, seu dicionário é iterado (usando .items()) onde cada item é um par chave / valor e esses itens são trocados com a reversedfunção. Quando isso é passado para o dictconstrutor, ele os transforma em pares de valor / chave que é o que você deseja.

Sugestão de melhoria para a resposta de Javier:

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

Em vez de d.keys()escrever apenas d, porque se você percorrer o dicionário com um iterador, ele retornará as chaves do dicionário relevante.

Ex. para este comportamento:

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

Pode ser feito facilmente com a compreensão do dicionário:

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

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

.items()retorna uma lista de tuplas de (key, value). map()passa por elementos da lista e aplica lambda x:[::-1]a cada um de seus elementos (tupla) para revertê-la, de modo que cada tupla se torna (value, key)na nova lista cuspida fora do mapa. Por fim, dict()faz um ditado da nova lista.

Usando 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 você estiver usando Python3, é um pouco diferente:

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

Adicionando uma solução no local:

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

No Python3, é fundamental que você use list(d.keys())porque dict.keysretorna uma visão das chaves. Se você estiver usando Python2, d.keys()é o suficiente.

A resposta de Hanan é a correta, pois cobre um caso mais geral (as outras respostas são meio enganosas para alguém que não tem conhecimento da situação duplicada). Uma melhoria na resposta de Hanan é 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]}