valor - sorted diccionario python




¿Cómo ordeno una lista de diccionarios por un valor del diccionario? (12)

Tengo una lista de diccionarios y quiero que cada elemento se clasifique según los valores de una propiedad específica.

Tenga en cuenta la siguiente matriz,

[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

Cuando se ordena por name , debe convertirse

[{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]


Aquí está la solución general alternativa: ordena los elementos de dictado por claves y valores. La ventaja es que no es necesario especificar las claves, y aún funcionaría si faltan algunas claves en algunos de los diccionarios.

def sort_key_func(item):
    """ helper function used to sort list of dicts

    :param item: dict
    :return: sorted list of tuples (k, v)
    """
    pairs = []
    for k, v in item.items():
        pairs.append((k, v))
    return sorted(pairs)
sorted(A, key=sort_key_func)

Digamos que tengo un Diccionario D con elementos a continuación. Para ordenar solo use el argumento clave en ordenado para pasar la función personalizada como se muestra abajo

D = {'eggs': 3, 'ham': 1, 'spam': 2}

def get_count(tuple):
    return tuple[1]

sorted(D.items(), key = get_count, reverse=True)
or
sorted(D.items(), key = lambda x: x[1], reverse=True)  avoiding get_count function call

https://wiki.python.org/moin/HowTo/Sorting/#Key_Functions


Podría usar una función de comparación personalizada, o podría pasar a una función que calcula una clave de clasificación personalizada. Eso suele ser más eficiente, ya que la clave solo se calcula una vez por elemento, mientras que la función de comparación se llamará muchas veces más.

Podrías hacerlo de esta manera:

def mykey(adict): return adict['name']
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=mykey)

Pero la biblioteca estándar contiene una rutina genérica para obtener elementos de objetos arbitrarios: itemgetter . Así que prueba esto en su lugar:

from operator import itemgetter
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=itemgetter('name'))

Puede verse más limpio usando una tecla en lugar de un cmp:

newlist = sorted(list_to_be_sorted, key=lambda k: k['name']) 

o como JFSebastian y otros sugirieron,

from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name')) 

Para completar (como se señala en los comentarios de fitzgeraldsteele), agregue reverse=True para ordenar descendente

newlist = sorted(l, key=itemgetter('name'), reverse=True)

Si desea ordenar la lista por varias claves, puede hacer lo siguiente:

my_list = [{'name':'Homer', 'age':39}, {'name':'Milhouse', 'age':10}, {'name':'Bart', 'age':10} ]
sortedlist = sorted(my_list , key=lambda elem: "%02d %s" % (elem['age'], elem['name']))

Es más bien pirata, ya que se basa en convertir los valores en una representación de cadena única para comparación, pero funciona como se espera para los números que incluyen los negativos (aunque necesitará usar el formato de la cadena adecuadamente con cero rellenos si está usando números)


Supongo que has querido decir:

[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

Esto se ordenaría así:

sorted(l,cmp=lambda x,y: cmp(x['name'],y['name']))

Usando la transformación de Schwartzian de Perl,

py = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

hacer

sort_on = "name"
decorated = [(dict_[sort_on], dict_) for dict_ in py]
decorated.sort()
result = [dict_ for (key, dict_) in decorated]

da

>>> result
[{'age': 10, 'name': 'Bart'}, {'age': 39, 'name': 'Homer'}]

Más sobre Perl Schwartzian transform

En informática, la transformación de Schwartz es un lenguaje de programación Perl que se utiliza para mejorar la eficiencia de la clasificación de una lista de elementos. Este idioma es apropiado para la clasificación basada en comparación cuando el ordenamiento se basa realmente en el ordenamiento de una determinada propiedad (la clave) de los elementos, donde el cálculo de esa propiedad es una operación intensiva que debe realizarse un número mínimo de veces. La transformada de Schwartz es notable en que no utiliza arrays temporales con nombre.


alguna vez necesitamos usar lower() por ejemplo

lists = [{'name':'Homer', 'age':39},
  {'name':'Bart', 'age':10},
  {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'])
print(lists)
# [{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}, {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'].lower())
print(lists)
# [ {'name':'abby', 'age':9}, {'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]

a = [{'name':'Homer', 'age':39}, ...]

# This changes the list a
a.sort(key=lambda k : k['name'])

# This returns a new list (a is not modified)
sorted(a, key=lambda k : k['name']) 

import operator
a_list_of_dicts.sort(key=operator.itemgetter('name'))

'key' se utiliza para ordenar por un valor arbitrario y 'itemgetter' establece ese valor en el atributo 'nombre' de cada elemento.


my_list = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

my_list.sort(lambda x,y : cmp(x['name'], y['name']))

my_list ahora será lo que quieras.

(3 años después) Editado para agregar:

El nuevo argumento key es más eficiente y ordenado. Una mejor respuesta ahora se ve como:

my_list = sorted(my_list, key=lambda k: k['name'])

... la lambda es, IMO, más fácil de entender que operator.itemgetter , pero YMMV.





data-structures