Comment trier un dictionnaire par clé?

Quelle serait une belle façon d'aller de {2:3, 1:89, 4:5, 3:0}à {1:89, 2:3, 3:0, 4:5}?
J'ai vérifié certains articles mais ils utilisent tous l'opérateur "trié" qui retourne les tuples.

Les dictionnaires Python standard ne sont pas classés. Même si vous triiez les paires (clé, valeur), vous ne seriez pas en mesure de les stocker de dictmanière à préserver l'ordre.

La façon la 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 que le chemin odsoit 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 le .items()au lieu de .iteritems():

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

Les dictionnaires eux-mêmes n'ont pas d'articles commandés en tant que tels, si vous souhaitez les imprimer, etc. dans un certain ordre, voici quelques exemples:

En Python 2.4 et supérieur:

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 inférieur à 2.4 :)

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

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

De la collectionsdocumentation de la bibliothèque de Python :

>>> 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)])

Pour CPython / PyPy 3.6 et tout Python 3.7 ou supérieur, cela se fait facilement avec:

>>> d = {2:3, 1:89, 4:5, 3:0}
>>> dict(sorted(d.items()))
{1: 89, 2: 3, 3: 0, 4: 5}

Il existe un certain nombre de modules Python qui fournissent des implémentations de dictionnaire qui maintiennent automatiquement les clés dans l'ordre trié. Considérez le module sortedcontainers qui est des implémentations en Python pur et rapide en C. Il existe également une 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 effectuant une itération.

>>> 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 les recherches et les suppressions d'emplacement indexées, 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])

Simplement:

d = {2:3, 1:89, 4:5, 3:0}
sd = sorted(d.items())

for k,v in sd:
    print k, v

Production:

1 89
2 3
3 0
4 5

Comme d'autres l'ont mentionné, les dictionnaires sont intrinsèquement non ordonnés. Cependant, si le problème affiche simplement les dictionnaires de façon ordonnée, vous pouvez remplacer la __str__méthode dans une sous-classe de dictionnaire et utiliser cette classe de dictionnaire plutôt que la fonction intégrée dict. Par exemple.

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}

Remarque, cela ne change rien à la façon dont les clés sont stockées, à l'ordre dans lequel elles reviendront lorsque vous les itérerez, etc., à la façon dont elles seront affichées avec printou sur la console python.

Trouvé d'une autre manière:

import json
print json.dumps(d, sort_keys = True)

upd:
1. cela trie également les objets imbriqués (merci @DanielF).
2. Les dictionnaires python ne sont pas ordonnés, c'est pourquoi ils ne peuvent être imprimés ou assignés qu'à str.

En Python 3.

>>> D1 = {2:3, 1:89, 4:5, 3:0}
>>> for key in sorted(D1):
    print (key, D1[key])

donne

1 89
2 3
3 0
4 5

Le dictionnaire Python n'était pas ordonné avant Python 3.6. Dans l'implémentation CPython de Python 3.6, le dictionnaire conserve l'ordre d'insertion. À partir de Python 3.7, cela deviendra une fonctionnalité de langage.

Dans le journal des modifications de Python 3.6 ( https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict ):

L'aspect préservant l'ordre de cette nouvelle implémentation est considéré comme un détail d'implémentation et ne doit pas être invoqué (cela peut changer à l'avenir, mais il est souhaitable d'avoir cette nouvelle implémentation dict dans la langue pour quelques versions avant de changer la spécification de langue pour rendre obligatoire la sémantique préservant l'ordre pour toutes les implémentations Python actuelles et futures; cela permet également de préserver la compatibilité descendante avec les anciennes versions du langage où l'ordre d'itération aléatoire est toujours en vigueur, par exemple Python 3.5).

Dans le document de Python 3.7 ( https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries ):

L'exécution de list (d) sur un dictionnaire renvoie une liste de toutes les clés utilisées dans le dictionnaire, dans l'ordre d'insertion (si vous voulez le trier, utilisez simplement sorted (d) à la place).

Contrairement aux versions précédentes, vous pouvez trier un dict après Python 3.6 / 3.7. Si vous souhaitez trier un dict imbriqué comprenant le sous-dict à l'intérieur, vous pouvez faire:

test_dict = {'a': 1, 'c': 3, 'b': {'b2': 2, 'b1': 1}}

def dict_reorder(item):
    return {k: sort_dict(v) if isinstance(v, dict) else v for k, v in sorted(item.items())}

reordered_dict = dict_reorder(test_dict)

https://gist.github.com/ligyxy/f60f0374defc383aa098d44cfbd318eb

Ici, j'ai trouvé une solution la plus simple pour trier le dict python par clé en utilisant pprint. par exemple.

>>> x = {'a': 10, 'cd': 20, 'b': 30, 'az': 99} 
>>> print x
{'a': 10, 'b': 30, 'az': 99, 'cd': 20}

mais en utilisant pprint, il renverra dict dicté

>>> import pprint 
>>> pprint.pprint(x)
{'a': 10, 'az': 99, 'b': 30, 'cd': 20}

Il existe un moyen simple de trier un dictionnaire.

Selon votre question,

La solution est:

c={2:3, 1:89, 4:5, 3:0}
y=sorted(c.items())
print y

(Où c est le nom de votre dictionnaire.)

Ce programme donne la sortie suivante:

[(1, 89), (2, 3), (3, 0), (4, 5)]

comme tu voulais.

Un autre exemple est:

d={"John":36,"Lucy":24,"Albert":32,"Peter":18,"Bill":41}
x=sorted(d.keys())
print x

Donne la sortie:['Albert', 'Bill', 'John', 'Lucy', 'Peter']

y=sorted(d.values())
print y

Donne la sortie:[18, 24, 32, 36, 41]

z=sorted(d.items())
print z

Donne la sortie:

[('Albert', 32), ('Bill', 41), ('John', 36), ('Lucy', 24), ('Peter', 18)]

Par conséquent, en le changeant en clés, valeurs et éléments, vous pouvez imprimer comme vous le vouliez.

Générera exactement ce que vous voulez:

 D1 = {2:3, 1:89, 4:5, 3:0}

 sort_dic = {}

 for i in sorted(D1):
     sort_dic.update({i:D1[i]})
 print sort_dic


{1: 89, 2: 3, 3: 0, 4: 5}

Mais ce n'est pas la bonne façon de procéder, car cela pourrait montrer un comportement distinct avec différents dictionnaires, ce que j'ai appris récemment. Par conséquent, la voie parfaite a été suggérée par Tim dans la réponse de ma requête que je partage ici.

from collections import OrderedDict
sorted_dict = OrderedDict(sorted(D1.items(), key=lambda t: t[0]))

Je pense que la chose la plus simple est de trier le dict par clé et d'enregistrer la paire clé: valeur dans un nouveau dict.

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be neccessary
        dict2[key] = dict1[key]

Pour plus de clarté:

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted     values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be  neccessary
        value = dict1[key]
        dict2[key] = value

Vous pouvez créer un nouveau dictionnaire en triant le dictionnaire actuel par clé selon votre question.

Ceci est votre dictionnaire

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

Créez un nouveau dictionnaire d1 en triant ce d à l'aide de la fonction lambda

d1 = dict(sorted(d.items(), key = lambda x:x[0]))

d1 doit être {1: 89, 2: 3, 3: 0, 4: 5}, trié en fonction des clés de d.

Les dictés Python ne sont pas ordonnés. Habituellement, ce n'est pas un problème car le cas d'utilisation le plus courant consiste à effectuer une recherche.

La façon la plus simple de faire ce que vous voulez serait de créer une collections.OrderedDictinsertion des éléments dans l'ordre trié.

ordered_dict = collections.OrderedDict([(k, d[k]) for k in sorted(d.keys())])

Si vous avez besoin d'itérer, comme d'autres l'ont suggéré ci-dessus, le moyen le plus simple serait d'itérer sur des clés triées. Exemples-

Imprimer les valeurs triées par clés:

# create the dict
d = {k1:v1, k2:v2,...}
# iterate by keys in sorted order
for k in sorted(d.keys()):
    value = d[k]
    # do something with k, value like print
    print k, value

Obtenez la liste des valeurs triées par clés:

values = [d[k] for k in sorted(d.keys())]

Je propose un tri de dict sur une seule ligne.

>> a = {2:3, 1:89, 4:5, 3:0}
>> c = {i:a[i] for i in sorted(a.keys())}
>> print(c)
{1: 89, 2: 3, 3: 0, 4: 5}
[Finished in 0.4s]

J'espère que cela vous sera utile.

Cette fonction triera récursivement tout dictionnaire par sa clé. Autrement dit, si une valeur du dictionnaire est également un dictionnaire, elle sera également triée par sa clé. Si vous utilisez CPython 3.6 ou supérieur, une simple modification pour utiliser un dictplutôt qu'un OrderedDictpeut être effectuée.

from collections import OrderedDict

def sort_dict(d):
    items = [[k, v] for k, v in sorted(d.items(), key=lambda x: x[0])]
    for item in items:
        if isinstance(item[1], dict):
            item[1] = sort_dict(item[1])
    return OrderedDict(items)
    #return dict(items)

Les gars, vous compliquez les choses ... c'est vraiment simple

from pprint import pprint
Dict={'B':1,'A':2,'C':3}
pprint(Dict)

La sortie est:

{'A':2,'B':1,'C':3}

La solution la plus simple consiste à obtenir une liste des clés de dict dans l'ordre trié, puis à répéter sur dict. Par exemple

a1 = {'a':1, 'b':13, 'd':4, 'c':2, 'e':30}
a1_sorted_keys = sorted(a1, key=a1.get, reverse=True)
for r in a1_sorted_keys:
    print r, a1[r]

Voici la sortie (ordre décroissant)

e 30
b 13
d 4
c 2
a 1

Un moyen simple de le faire:

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

s = {k : d[k] for k in sorted(d)}

s

Out[1]: {1: 89, 2: 3, 3: 0, 4: 5} 

Une comparaison temporelle des deux méthodes en 2.7 montre qu'elles sont pratiquement identiques:

>>> setup_string = "a = sorted(dict({2:3, 1:89, 4:5, 3:0}).items())"
>>> timeit.timeit(stmt="[(k, val) for k, val in a]", setup=setup_string, number=10000)
0.003599141953657181

>>> setup_string = "from collections import OrderedDict\n"
>>> setup_string += "a = OrderedDict({1:89, 2:3, 3:0, 4:5})\n"
>>> setup_string += "b = a.items()"
>>> timeit.timeit(stmt="[(k, val) for k, val in b]", setup=setup_string, number=10000)
0.003581275490432745 

from operator import itemgetter
# if you would like to play with multiple dictionaries then here you go:
# Three dictionaries that are composed of first name and last name.
user = [
    {'fname': 'Mo', 'lname': 'Mahjoub'},
    {'fname': 'Abdo', 'lname': 'Al-hebashi'},
    {'fname': 'Ali', 'lname': 'Muhammad'}
]
#  This loop will sort by the first and the last names.
# notice that in a dictionary order doesn't matter. So it could put the first name first or the last name first. 
for k in sorted (user, key=itemgetter ('fname', 'lname')):
    print (k)

# This one will sort by the first name only.
for x in sorted (user, key=itemgetter ('fname')):
    print (x)

dictionary = {1:[2],2:[],5:[4,5],4:[5],3:[1]}

temp=sorted(dictionary)
sorted_dict = dict([(k,dictionary[k]) for i,k in enumerate(temp)])

sorted_dict:
         {1: [2], 2: [], 3: [1], 4: [5], 5: [4, 5]}

Ou utilisez pandas,

Démo:

>>> d={'B':1,'A':2,'C':3}
>>> df=pd.DataFrame(d,index=[0]).sort_index(axis=1)
   A  B  C
0  2  1  3
>>> df.to_dict('int')[0]
{'A': 2, 'B': 1, 'C': 3}
>>> 

Voir:

Documents de ce

Documentation de pandas entiers

Ma suggestion est la suivante car elle vous permet de trier un dict ou de garder un dict trié pendant que vous ajoutez des éléments et devrez peut-être ajouter des éléments à l'avenir:

Construisez un à dictpartir de zéro au fur et à mesure. Ayez une deuxième structure de données, une liste, avec votre liste de clés. Le paquetage bisect a une fonction d'insort qui permet d'insérer dans une liste triée, ou de trier votre liste après avoir complètement rempli votre dict. Maintenant, lorsque vous parcourez votre dict, vous parcourez plutôt la liste pour accéder à chaque clé de manière ordonnée sans vous soucier de la représentation de la structure du dict (qui n'a pas été conçue pour le tri).

Pour la façon dont la question est formulée, la plupart des réponses ici y répondent correctement.

Cependant, compte tenu de la façon dont les choses devraient être vraiment faites, en tenant compte de décennies et de décennies d'informatique, je suis totalement surpris qu'il n'y ait en fait qu'une seule réponse ici (de l' utilisateur GrantJ ) suggérant l'utilisation de conteneurs associatifs triés (conteneurs triés) qui trie les éléments en fonction de la clé à leur point d'insertion.

Cela évitera énorme impact sur les performances pour chaque appel de sort(...)(au minimum O(N*log(N)), où Nest en nombre d'éléments (logiquement, cela vaut pour toutes les solutions ici qui suggèrent d'utiliser le sort(...)). Prenez à compte que pour toutes ces solutions, l' sort(...)devront être appelé à chaque fois que la colletion doit être consultée comme triée APRÈS avoir été modifiée en ajoutant / supprimant des éléments ...

l = dict.keys()
l2 = l
l2.append(0)
l3 = []
for repeater in range(0, len(l)):
    smallnum = float("inf")
    for listitem in l2:
        if listitem < smallnum:
            smallnum = listitem
    l2.remove(smallnum)
    l3.append(smallnum)
l3.remove(0)
l = l3

for listitem in l:
    print(listitem)