python - una - ¿Cómo puedo ordenar un diccionario por clave?

ordenar una lista en python sin sort

Question

¿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.

Answer 1

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}

Answer 2

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}

Answer 3

Como otros han mencionado, los diccionarios están intrínsecamente desordenados. Sin embargo, si el problema se limita a mostrar los diccionarios de forma 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.

Answer 4

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

Answer 5

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

Answer 6

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.

Si desea ordenar un dict anidado, 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

Answer 7

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

Answer 8

Encontré otra manera:

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

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

Answer 9

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

Answer 10

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 programa 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 en claves, valores y elementos, puede imprimir como lo que deseaba. ¡Espero que esto ayude!

Answer 11

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 sortedcontainers que es implementaciones de Python puro y rápido 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])

Answer 12

La forma más concisa que no se menciona en ninguna de las otras respuestas es probablemente esta:

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

Answer 13

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

Answer 14

Los diccionarios en sí no tienen elementos ordenados como tales, si desea imprimirlos, etc., por favor, 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/

Answer 15

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

Answer 16

Los dictados de Python no están ordenados. Generalmente, 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 . Se ordena ordenar insertando los elementos en orden.

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

Answer 17

O utilizar pandas ,

Manifestación:

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

Ver:

Docs de esto

Documentación de pandas enteros.

Answer 18

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.

Answer 19

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]

Answer 20

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

Answer 21

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

Answer 22

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

Answer 23

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)

Answer 24

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)