¿Cómo puedo ordenar un diccionario por clave?

¿Cuál sería una buena manera de pasar de {2:3, 1:89, 4:5, 3:0} a {1:89, 2:3, 3:0, 4:5} ?
Revisé algunas publicaciones pero todas usan el operador “ordenado” que devuelve las tuplas.

Los diccionarios estándar de Python no están ordenados. Incluso si clasificara los pares (clave, valor), no podría almacenarlos en un dict de una manera que preservaría el orden.

La forma más fácil es usar OrderedDict , que recuerda el orden en que se insertaron los elementos:

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

No importa cómo se imprima el od ; funcionará como se esperaba

 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

Para los usuarios de Python 3, uno necesita usar .items() lugar de .iteritems() :

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

Los diccionarios en sí no tienen elementos ordenados como tales, si desea imprimirlos, etc. para algún orden, aquí hay algunos ejemplos:

En Python 2.4 y superior:

 mydict = {'carl':40, 'alan':2, 'bob':1, 'danny':3} for key in sorted(mydict): print "%s: %s" % (key, mydict[key]) 

da:

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

(Python por debajo 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/

De la documentación de la biblioteca de collections 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)]) 

Para python3.6 +, esto se hace fácilmente con:

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

Hay una serie de módulos de Python que proporcionan implementaciones de diccionarios que mantienen automáticamente las claves en orden. Considere el módulo de contenedores ordenados que es puro-Python e implementaciones rápidas como C. También hay una comparación de rendimiento con otras opciones populares comparadas entre sí.

El uso de un dictado ordenado es una solución inadecuada si necesita agregar y eliminar constantemente pares de clave / valor mientras también itera.

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

El tipo SortedDict también admite búsquedas de ubicación indexadas y eliminación, lo que no es posible con el tipo de dictado incorporado.

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

Simplemente:

 d = {2:3, 1:89, 4:5, 3:0} sd = sorted(d.items()) for k,v in sd: print k, v 

Salida:

 1 89 2 3 3 0 4 5 

Como han mencionado otros, los diccionarios están intrínsecamente desordenados. Sin embargo, si el problema es simplemente mostrar los diccionarios de una manera ordenada, puede anular el método __str__ en una subclase de diccionario, y usar esta clase de diccionario en lugar del dictado incorporado. P.ej.

 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} 

Tenga en cuenta que esto no cambia nada acerca de cómo se almacenan las claves, el orden en el que regresarán cuando las repita, etc., cómo se muestran con print o en la consola de python.

En Python 3.

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

da

 1 89 2 3 3 0 4 5 

Encontré otra manera:

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

actualizacion:
1. Esto también ordena los objetos nesteds (gracias @DanielF).
2. Los diccionarios de Python no están ordenados, por lo tanto, esto es sutable para imprimir o asignar solo a str.

Aquí encontré la solución más sencilla para ordenar el pprint Python por clave usando pprint . p.ej.

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

Pero mientras usa pprint, regresará ordenado dict

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

El diccionario de Python no estaba ordenado antes de Python 3.6. En la implementación CPython de Python 3.6, el diccionario mantiene el orden de inserción. Desde Python 3.7, esto se convertirá en una característica del idioma.

En el registro de cambios de Python 3.6 ( https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict ):

El aspecto de conservación de orden de esta nueva implementación se considera un detalle de la implementación y no se debe confiar en él (esto puede cambiar en el futuro, pero se desea tener esta nueva implementación de dictado en el idioma para algunas versiones antes de cambiar la especificación del idioma). para ordenar la semántica de conservación de órdenes para todas las implementaciones actuales y futuras de Python, esto también ayuda a preservar la compatibilidad con versiones anteriores del lenguaje en el que el orden de iteración aleatorio sigue vigente, por ejemplo, Python 3.5).

En el documento de Python 3.7 ( https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries ):

La ejecución de la lista (d) en un diccionario devuelve una lista de todas las claves utilizadas en el diccionario, en el orden de inserción (si desea que esté ordenada, solo use ordenada (d)).

Entonces, a diferencia de las versiones anteriores, puede ordenar un dict después de Python 3.6 / 3.7. Si desea ordenar un dict nested, incluido el subdecid dentro, puede hacer:

 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

Hay una manera fácil de ordenar un diccionario.

Según su pregunta,

La solucion es :

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

(Donde c, es el nombre de su diccionario.)

Este progtwig da la siguiente salida:

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

como tu querias

Otro ejemplo es:

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

Da la salida: ['Albert', 'Bill', 'John', 'Lucy', 'Peter']

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

Da la salida: [18, 24, 32, 36, 41]

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

Da la salida:

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

Por lo tanto, al cambiarlo a claves, valores y elementos, puede imprimir como lo que deseaba. ¡Espero que esto ayude!

Generará exactamente lo que quieres:

  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} 

Pero esta no es la forma de escribir para hacer esto, porque podría mostrar un comportamiento distinto con diferentes diccionarios, que he aprendido recientemente. Por lo tanto, Tim sugirió la manera perfecta en la respuesta de mi consulta que estoy compartiendo aquí.

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

Los dictados de Python no están ordenados. Por lo general, esto no es un problema ya que el caso de uso más común es hacer una búsqueda.

La forma más sencilla de hacer lo que desea es crear una collections.OrderedDict ordenando insertar los elementos en orden ordenado.

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

Si necesita iterar, como han sugerido otros anteriores, la forma más sencilla sería iterar sobre las claves ordenadas. Ejemplos-

Imprimir valores ordenados por claves:

 # 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 

Obtener lista de valores ordenados por claves:

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

Creo que lo más fácil es ordenar el dictado por clave y guardar el par ordenado clave: valor en un nuevo dictado.

 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] 

Para hacerlo más claro:

 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 

Puede crear un nuevo diccionario clasificando el diccionario actual por clave según su pregunta.

Este es tu diccionario

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

Crea un nuevo diccionario d1 ordenando este d usando la función lambda

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

d1 debe ser {1: 89, 2: 3, 3: 0, 4: 5}, ordenados según las claves en d.

Chicos, ustedes están complicando las cosas … es muy simple

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

La salida es:

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

La solución más sencilla es que usted debe obtener una lista de las claves de dictado, ordenadas y luego iteradas sobre dict. Por ejemplo

 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] 

A continuación se mostrará la salida (orden pendiente).

 e 30 b 13 d 4 c 2 a 1 

Se me ocurre una sola línea dict dictado.

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

Esperamos que esto sea útil.

Una comparación de tiempo de los dos métodos en 2.7 muestra que son prácticamente idénticos:

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

O utilizar pandas ,

Manifestación:

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

Ver:

Docs de esto

Documentación de pandas enteros.

 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) 

Si tienes un dict, por ejemplo:

 not_ordered_dict = {5 : "5555", 9 : "9999", 1 : "1111"} ordered_dict = {} for key in sorted(not_ordered_dict): ordered_dict[key] = not_ordered_dict[key]