Come ordinare un elenco di dizionari in base al valore del dizionario?


1899

Ho un elenco di dizionari e desidero che ogni articolo sia ordinato in base a valori di proprietà specifici.

Prendi in considerazione l'array di seguito,

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

Se ordinato da name, dovrebbe diventare

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

Leggere la risposta e cercare su operator.itemgetter . Posso ordinare su più valori nello stesso processo (ad esempio abbiamo [{'name':'Bart', 'age':10, 'note':3},{'name':'Homer','age':10,'note':2},{'name':'Vasile','age':20,'note':3}] E usare: from operator import itemgetter newlist = sorted(old_list, key=itemgetter(-'note','name') EDIT: testato e funziona, ma non so come prendere nota DESC e nome ASC.
Claudiu

Risposte:


2471

Può sembrare più pulito usando una chiave invece di un cmp:

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

o come suggerito da JFSebastian e altri,

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

Per completezza (come sottolineato nei commenti di fitzgeraldsteele), aggiungi reverse=Trueall'ordinamento decrescente

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

34
L'uso della chiave non è solo più pulito, ma anche più efficace.
jfs,

5
Il modo più veloce sarebbe quello di aggiungere un'istruzione newlist.reverse (). Altrimenti puoi definire un confronto come cmp = lambda x, y: - cmp (x ['name'], y ['name']).
Mario F,

3
se il valore dell'ordinamento è un numero potresti dire: lambda k: (k ['age'] * -1) per ottenere un ordinamento inverso
Philluminati,

2
Questo vale anche per un elenco di tuple, se si utilizza itemgetter(i)dove si itrova l'indice dell'elemento tupla su cui ordinare.
Radicand,

42
itemgetteraccetta più di un argomento: itemgetter(1,2,3)è una funzione che restituisce una tupla simile obj[1], obj[2], obj[3], quindi puoi usarla per fare ordinamenti complessi.
Bakuriu,

167
import operator

Per ordinare l'elenco dei dizionari in base a key = 'name':

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

Per ordinare l'elenco dei dizionari in base a key = 'age':

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

9
Ad ogni modo unire nome ed età? (come in SQL ORDER BY name, age?)
monojohnny,

28
@monojohnny: sì, basta avere la chiave di restituire una tupla, key=lambda k: (k['name'], k['age']). (o key=itemgetter('name', 'age')). le tuple cmpconfronteranno ogni elemento a turno. è dannatamente brillante.
Claudiu,

1
Nella documentazione ( docs.python.org/2/tutorial/datastructures.html ) l' keyargomento facoltativo per list.sort()non è descritto. Qualche idea su dove trovarlo?
TTT

2
@TTT: consultare la documentazione della libreria per liste amici.
Kevin,

65
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) Modificato per aggiungere:

Il nuovo keyargomento è più efficiente e ordinato. Una risposta migliore ora sembra:

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

... il lambda è, IMO, più facile da capire di operator.itemgetter, ma YMMV.


51

Se si desidera ordinare l'elenco per più chiavi, è 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, poiché si basa sulla conversione dei valori in una rappresentazione a stringa singola per il confronto, ma funziona come previsto per i numeri inclusi quelli negativi (anche se sarà necessario formattare la stringa in modo appropriato con zero padding se si utilizzano i numeri)


2
ordinati usando timsort che è stabile, puoi chiamare ordinato più volte per avere un ordinamento su più criteri
njzk2

Il commento di njzk2 non mi è stato immediatamente chiaro, quindi ho trovato quanto segue. Puoi semplicemente ordinare due volte come suggerisce njzk2 o passare più argomenti a operator.itemgetter nella risposta in alto. Link: stackoverflow.com/questions/5212870/...
Permafacture

15
Non è necessario convertire in stringa. Restituisci una tupla come chiave.
Winston Ewert,

Ordinamento più volte è la soluzione più semplice generica senza hack: stackoverflow.com/a/29849371/1805397
Wouter bolsterlee

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

'key' viene utilizzato per ordinare in base a un valore arbitrario e 'itemgetter' imposta tale valore sull'attributo 'name' di ciascun elemento.


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

21

Immagino tu abbia significato:

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

Questo sarebbe ordinato in questo modo:

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

19

È possibile utilizzare una funzione di confronto personalizzata oppure è possibile passare una funzione che calcola una chiave di ordinamento personalizzata. Questo di solito è più efficiente in quanto la chiave viene calcolata una sola volta per articolo, mentre la funzione di confronto viene chiamata più volte.

Puoi farlo 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. Quindi prova questo invece:

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

19

Utilizzando la trasformazione Schwartziana di 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]

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

Maggiori informazioni sulla trasformazione di Perl Schwartzian

Nell'informatica, la trasformazione di Schwartz è un linguaggio di programmazione Perl utilizzato per migliorare l'efficienza dello smistamento di un elenco di elementi. Questo idioma è appropriato per l'ordinamento basato sul confronto quando l'ordinamento si basa effettivamente sull'ordinamento di una determinata proprietà (la chiave) degli elementi, in cui il calcolo di quella proprietà è un'operazione intensiva che deve essere eseguita un numero minimo di volte. La trasformata di Schwartz è notevole in quanto non utilizza matrici temporanee denominate.


9
Python ha sostenuto il key=per .sortdal 2.4, che è 2004, lo fa la Trasformata di Schwartz all'interno del codice di smistamento, in C; quindi questo metodo è utile solo su Pythons 2.0-2.3. tutti di età superiore ai 12 anni.
Antti Haapala,


12

qualche volta dobbiamo usare 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}]

11

Ecco la soluzione generale alternativa: ordina gli elementi di dict in base a chiavi e valori. Il vantaggio è che non è necessario specificare le chiavi e funzionerebbe comunque se in alcuni dizionari mancassero alcune chiavi.

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)

10

L'uso del pacchetto Panda è un altro metodo, sebbene il suo runtime su larga scala sia molto più lento rispetto ai metodi più tradizionali proposti 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()

Ecco alcuni valori di riferimento per un piccolo elenco e un grande (100k +) elenco di dadi:

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

3
Ho eseguito il tuo codice e ho trovato un errore nel timeit.Timer sostiene i panda di metodo grande: specifichi "setup_small" dove dovrebbe essere "setup_large". La modifica di tale argomento ha causato l'esecuzione del programma senza fine e l'ho interrotto dopo più di 5 minuti. Quando l'ho eseguito con "timeit (1)", i Panda di Metodo Grande hanno terminato in 7,3 secondi, molto peggio di LC o LC2.
clp2

Hai perfettamente ragione, è stata una vera svista da parte mia. Non lo consiglio più per casi grandi! Ho modificato la risposta per consentirle semplicemente come possibilità, il caso d'uso è ancora in discussione.
abby sobh,

6

Se non è necessario l'originale listdi dictionaries, è possibile modificarlo sul posto con il sort()metodo utilizzando una funzione chiave personalizzata.

Funzione chiave:

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

    return d["name"]

Il listda ordinare:

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

Ordinamento sul posto:

data_one.sort(key=get_name)

Se hai bisogno dell'originale list, chiama la sorted()funzione passandole liste la funzione chiave, quindi assegna l'ordinato restituito lista una nuova variabile:

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

Stampa data_onee new_data.

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

6

Diciamo che ho un dizionario Dcon gli elementi di seguito. Per ordinare basta usare l'argomento chiave in ordinato per passare la 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

Controllare questo fuori.


3

Sono stato un grande fan del filtro con lambda, tuttavia non è l'opzione migliore se si considera la complessità del tempo

Prima opzione

sorted_list = sorted(list_to_sort, key= lambda x: x['name'])
# returns list of values

Seconda opzione

list_to_sort.sort(key=operator.itemgetter('name'))
#edits the list, does not return a new list

Confronto veloce dei tempi di esecuzione

# First option
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" "sorted_l = sorted(list_to_sort, key=lambda e: e['name'])"

1000000 loop, meglio di 3: 0,736 usec per loop

# Second option 
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" -s "import operator" "list_to_sort.sort(key=operator.itemgetter('name'))"

1000000 loop, meglio di 3: 0,438 usec per loop


2

Se le prestazioni sono un problema, userei operator.itemgetterinvece lambdache le funzioni integrate eseguono più velocemente delle funzioni artigianali. La itemgetterfunzione sembra eseguire circa il 20% più veloce rispetto lambdaalla mia prova.

Da https://wiki.python.org/moin/PythonSpeed :

Allo stesso modo, le funzioni integrate sono più veloci degli equivalenti creati a mano. Ad esempio, map (operator.add, v1, v2) è più veloce di map (lambda x, y: x + y, v1, v2).

Ecco un confronto tra l'ordinamento velocità utilizzando lambdavs itemgetter.

import random
import operator

# create a list of 100 dicts with random 8-letter names and random ages from 0 to 100.
l = [{'name': ''.join(random.choices(string.ascii_lowercase, k=8)), 'age': random.randint(0, 100)} for i in range(100)]

# Test the performance with a lambda function sorting on name
%timeit sorted(l, key=lambda x: x['name'])
13 µs ± 388 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

# Test the performance with itemgetter sorting on name
%timeit sorted(l, key=operator.itemgetter('name'))
10.7 µs ± 38.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

# Check that each technique produces same sort order
sorted(l, key=lambda x: x['name']) == sorted(l, key=operator.itemgetter('name'))
True

Entrambe le tecniche ordinano l'elenco nello stesso ordine (verificato dall'esecuzione dell'istruzione finale nel blocco di codice) ma uno è un po 'più veloce.


-1

È possibile utilizzare il seguente codice

sorted_dct = sorted(dct_name.items(), key = lambda x : x[1])
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.