Come faccio a ordinare un elenco di dizionari da un valore del dizionario?

Question

Ho una lista di dizionari e i desideri di ogni elemento, ordinati per specifici valori di proprietà.

Prendere in considerazione la matrice di seguito,

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

Quando ordinate da name, deve diventare

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

Answer 1

Può sembrare più pulito utilizzando un tasto invece di un cmp:

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

o come J. F. Sebastian e altri hanno proposto,

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

Per completezza (come sottolineato nei commenti da fitzgeraldsteele), aggiungere reverse=True ordinamento decrescente

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

Answer 2

import operator

Per ordinare l'elenco dei dizionari da key= "name":

list_of_dicts.sort(key=operator.itemgetter('name'))

Per ordinare l'elenco dei dizionari da key='età':

list_of_dicts.sort(key=operator.itemgetter('age'))

Answer 3

Se si desidera ordinare l'elenco di chiavi multiple è possibile effettuare le seguenti operazioni:

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

È piuttosto hackish, dal momento che si basa sulla conversione dei valori in un'unica rappresentazione in forma di stringa per il confronto, ma funziona come previsto per i numeri compresi quelli negativi (anche se è necessario formattare la stringa in modo appropriato con zero imbottiture se si utilizza numeri)

Answer 4

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

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

my_list sarà ora quello che vuoi.

(3 anni dopo) a Cura di aggiungere:

Il nuovo key l'argomento è più efficiente e pulito.Una risposta migliore ora assomiglia a questo:

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

...la lambda è, IMO, più facile da capire rispetto operator.itemgetter, ma YMMV.

Answer 5

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

la "chiave" è utilizzato per ordinare da un valore arbitrario e 'itemgetter' imposta il valore di ogni elemento attributo 'name'.

Answer 6

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

Answer 7

Immagino tu abbia significato:

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

Questo sarebbe essere ordinati come questo:

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

Answer 8

Utilizzando Schwartzian trasformare in Perl,

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

fare

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

dà

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

Di più su Perl Schwartzian trasformare

In informatica, il Schwartzian trasformare una programmazione di Perl idioma utilizzato per migliorare l'efficienza di ordinamento di un elenco di elementi.Questo linguaggio è appropriato per il confronto di ordinamento basati su quando l'ordine è in realtà in base all'ordine di una certa proprietà (la chiave), del elementi, dove computing che la proprietà è un operazione che per la cpu deve essere eseguito un numero minimo di volte.Il Schwartzian Trasformazione è notevole in quanto non utilizza il nome di array temporanei.

Answer 9

Si potrebbe utilizzare un custom funzione di confronto, o si potrebbe passare a una funzione che calcola un ordinamento personalizzato chiave.Che di solito è più efficiente come la chiave viene calcolata solo una volta per ogni elemento, mentre la funzione di comparazione sarebbe chiamato molte volte di più.

Si potrebbe fare in questo modo:

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

Ma la libreria standard contiene una routine generica per ottenere elementi di oggetti arbitrari: itemgetter.Così invece, provare questo:

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

Answer 10

È necessario implementare la propria funzione di confronto che metterà a confronto i dizionari da valori di nome di chiavi.Vedere L'ordinamento Mini-COME da PythonInfo Wiki

Answer 11

Qui è l'alternativa soluzione generale - ordina gli elementi di dict da chiavi e valori.Il vantaggio di esso - non c'è bisogno di specificare le chiavi, e sarebbe ancora funzionare se alcuni tasti mancanti in alcuni dizionari.

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)

Answer 12

a volte abbiamo bisogno di utilizzare lower() per esempio

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

Answer 13

Ho provato qualcosa di simile a questo:

my_list.sort(key=lambda x: x['name'])

Ha funzionato per i numeri interi, come pure.

Answer 14

Utilizza la panda pacchetto è un altro metodo, anche se è di runtime su larga scala è molto più lenta rispetto a metodi più tradizionali proposte da altri:

import pandas as pd

listOfDicts = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
df = pd.DataFrame(listOfDicts)
df = df.sort_values('name')
sorted_listOfDicts = df.T.to_dict().values()

Qui ci sono alcuni valori di riferimento per un piccolo elenco e una grande (100k+) elenco dei dicts:

setup_large = "listOfDicts = [];\
[listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10})) for _ in range(50000)];\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

setup_small = "listOfDicts = [];\
listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}));\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

method1 = "newlist = sorted(listOfDicts, key=lambda k: k['name'])"
method2 = "newlist = sorted(listOfDicts, key=itemgetter('name')) "
method3 = "df = df.sort_values('name');\
sorted_listOfDicts = df.T.to_dict().values()"

import timeit
t = timeit.Timer(method1, setup_small)
print('Small Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_small)
print('Small Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_small)
print('Small Method Pandas: ' + str(t.timeit(100)))

t = timeit.Timer(method1, setup_large)
print('Large Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_large)
print('Large Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_large)
print('Large Method Pandas: ' + str(t.timeit(1)))

#Small Method LC: 0.000163078308105
#Small Method LC2: 0.000134944915771
#Small Method Pandas: 0.0712950229645
#Large Method LC: 0.0321750640869
#Large Method LC2: 0.0206089019775
#Large Method Pandas: 5.81405615807

Answer 15

Diciamo che h v un Dizionario D con elementi di seguito.Per ordinare basta usare argomento chiave nella ordinati per passare funzione personalizzata, come di seguito

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

Answer 16

Qui è la mia risposta a una domanda sull'ordinamento in base a più colonne.Funziona anche per il degenerare caso in cui il numero di colonne è uno solo.

Answer 17

Se non è necessario l'originale list di dictionaries, si potrebbe modificare con sort() il metodo di utilizzo di una chiave personalizzata in funzione.

Tasto funzione:

def get_name(d):
    """ Return the value of a key in a dictionary. """

    return d["name"]

Il list da ordinare:

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

Ordinamento-luogo:

data_one.sort(key=get_name)

Se avete bisogno di originale list, chiamare il sorted() funzione passando il list e la funzione del tasto, quindi assegnare il restituiti ordinati list per una nuova variabile:

data_two = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]
new_data = sorted(data_two, key=get_name)

Stampa data_one e new_data.

>>> print(data_one)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]
>>> print(new_data)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]

Answer 18

È possibile utilizzare itemgetter se si desidera prendere in considerazione le prestazioni. itemgetter in genere viene eseguito po ' più veloce lambda.

from operator import itemgetter
result = sorted(data, key=itemgetter('age'))  # this will sort list by property order 'age'.

Answer 19

È possibile utilizzare il codice riportato di seguito

sorted_dct = sorted(dct_name.items(), key = lambda x : x[1])