Comment trier un dictionnaire par clé ?

Question

Quel serait le meilleur moyen de passer de {2:3, 1:89, 4:5, 3:0} a {1:89, 2:3, 3:0, 4:5} ?
J'ai vérifié quelques posts mais ils utilisent tous l'opérateur "sorted" qui renvoie des tuples.

Answer 1

Les dictionnaires Python standard ne sont pas ordonnés (jusqu'à Python 3.7). Même si vous triiez les paires (clé,valeur), vous ne pourriez pas les stocker dans un fichier de type dict de manière à préserver l'ordre.

Le moyen le plus simple est d'utiliser OrderedDict qui se souvient de l'ordre dans lequel les éléments ont été insérés :

In [1]: import collections

In [2]: d = {2:3, 1:89, 4:5, 3:0}

In [3]: od = collections.OrderedDict(sorted(d.items()))

In [4]: od
Out[4]: OrderedDict([(1, 89), (2, 3), (3, 0), (4, 5)])

Peu importe la façon dont od est imprimé ; cela fonctionnera comme prévu :

In [11]: od[1]
Out[11]: 89

In [12]: od[3]
Out[12]: 0

In [13]: for k, v in od.iteritems(): print k, v
   ....: 
1 89
2 3
3 0
4 5

Python 3

Pour les utilisateurs de Python 3, il faut utiliser la fonction .items() au lieu de .iteritems() :

In [13]: for k, v in od.items(): print(k, v)
   ....: 
1 89
2 3
3 0
4 5

Answer 2

Les dictionnaires eux-mêmes ne comportent pas d'éléments ordonnés en tant que tels, mais si vous souhaitez les imprimer dans un certain ordre, voici quelques exemples :

Dans Python 2.4 et plus :

mydict = {'carl':40,
          'alan':2,
          'bob':1,
          'danny':3}

for key in sorted(mydict):
    print "%s: %s" % (key, mydict[key])

donne :

alan: 2
bob: 1
carl: 40
danny: 3

(Python en dessous de 2.4 :)

keylist = mydict.keys()
keylist.sort()
for key in keylist:
    print "%s: %s" % (key, mydict[key])

Fuente: http://www.saltycrane.com/blog/2007/09/how-to-sort-python-dictionary-by-keys/

Answer 3

Desde Python collections documentation de la bibliothèque :

>>> from collections import OrderedDict

>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

>>> # dictionary sorted by key -- OrderedDict(sorted(d.items()) also works
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

>>> # dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

Answer 4

Il existe un certain nombre de modules Python qui fournissent des implémentations de dictionnaires qui maintiennent automatiquement les clés dans un ordre trié. Considérez le module conteneurs triés qui est un module purement Python et des implémentations rapides comme C. Il existe également un module comparaison des performances avec d'autres options populaires comparées les unes aux autres.

L'utilisation d'un dict ordonné est une solution inadéquate si vous devez constamment ajouter et supprimer des paires clé/valeur tout en itérant.

>>> from sortedcontainers import SortedDict
>>> d = {2:3, 1:89, 4:5, 3:0}
>>> s = SortedDict(d)
>>> s.items()
[(1, 89), (2, 3), (3, 0), (4, 5)]

Le type SortedDict prend également en charge la recherche et la suppression d'emplacements indexés, ce qui n'est pas possible avec le type dict intégré.

>>> s.iloc[-1]
4
>>> del s.iloc[2]
>>> s.keys()
SortedSet([1, 2, 4])

Answer 5

Comme d'autres l'ont mentionné, les dictionnaires sont par nature non ordonnés. Cependant, si le problème est simplement en affichant de manière ordonnée, vous pouvez remplacer l'option __str__ dans une sous-classe de dictionnaire, et utiliser cette classe de dictionnaire plutôt que la classe de dictionnaire intégrée. dict . Eg.

class SortedDisplayDict(dict):
   def __str__(self):
       return "{" + ", ".join("%r: %r" % (key, self[key]) for key in sorted(self)) + "}"

>>> d = SortedDisplayDict({2:3, 1:89, 4:5, 3:0})
>>> d
{1: 89, 2: 3, 3: 0, 4: 5}

Notez que cela ne change rien à la manière dont les clés sont stockées, à l'ordre dans lequel elles reviennent lorsque vous les itérez, etc. print ou à la console python.