Comment échanger des clés avec des valeurs dans un dictionnaire?

Je reçois un dictionnaire en entrée, et je voudrais renvoyer un dictionnaire dont les clés seront les valeurs de l'entrée et dont la valeur sera les clés d'entrée correspondantes. Les valeurs sont uniques.

Par exemple, disons que mon entrée est:

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

J'aimerais que ma sortie soit:

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

Pour clarifier, je voudrais que mon résultat soit l'équivalent de ce qui suit:

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

Un moyen pythonique pour y parvenir?

Python 2:

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

Python 3 (merci à @erik):

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

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

À partir de Python 2.7, y compris 3.0+, il existe une version sans doute plus courte et plus lisible:

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

Vous pouvez utiliser les compréhensions de dict :

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

Modifié: pour Python 3, utilisez à la a.items()place de a.iteritems(). Des discussions sur les différences entre eux peuvent être trouvées dans les iteritems en Python sur SO.

Tu pourrais essayer:

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

Attention, vous ne pouvez pas «inverser» un dictionnaire si

1. Plusieurs clés partagent la même valeur. Par exemple {'one':1,'two':1}. Le nouveau dictionnaire ne peut avoir qu'un seul élément avec clé 1.
2. Une ou plusieurs des valeurs ne sont pas contrôlables. Par exemple {'one':[1]}. [1]est une valeur valide mais pas une clé valide.

Voir ce fil sur la liste de diffusion python pour une discussion sur le sujet.

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

La réponse principale actuelle suppose que les valeurs sont uniques, ce qui n'est pas toujours le cas. Et si les valeurs ne sont pas uniques? Vous perdrez des informations! Par exemple:

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

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

Les informations sur ont 'c'été complètement ignorées. Idéalement, cela devrait être quelque chose comme {2: ['b','c'], 3: ['a']}. C'est ce que fait l'implémentation du bas.

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 encore mieux, mais ne fonctionne qu'en Python 3:

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

Une autre façon de développer la réponse d' Ilya Prokin est d'utiliser réellement la reversedfonction.

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

En substance, votre dictionnaire est itéré par (en utilisant .items()) où chaque élément est une paire clé / valeur, et ces éléments sont échangés avec la reversedfonction. Lorsque cela est passé au dictconstructeur, il les transforme en paires valeur / clé, ce que vous voulez.

Suggestion d'amélioration pour la réponse de Javier:

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

Au lieu de d.keys()vous pouvez écrire simplement d, car si vous parcourez le dictionnaire avec un itérateur, il renverra les clés du dictionnaire pertinent.

Ex. pour ce comportement:

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

Peut être fait facilement avec la compréhension du dictionnaire:

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

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

.items()renvoie une liste de tuples de (key, value). map()parcourt les éléments de la liste et applique lambda x:[::-1]à chacun son élément (tuple) pour l'inverser, de sorte que chaque tuple devient (value, key)dans la nouvelle liste crachée hors de la carte. Enfin, dict()crée un dict à partir de la nouvelle liste.

Utilisation de la boucle : -

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 vous utilisez Python3, c'est légèrement différent:

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

Ajout d'une solution sur place:

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

Dans Python3, il est essentiel que vous l'utilisiez list(d.keys())car dict.keysrenvoie une vue des clés. Si vous utilisez Python2, cela d.keys()suffit.

La réponse de Hanan est la bonne car elle couvre un cas plus général (les autres réponses sont un peu trompeuses pour quelqu'un qui n'est pas au courant de la situation en double). Une amélioration de la réponse de Hanan est l'utilisation de 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]}