Como classifico uma lista de dicionários por um valor do dicionário?

Question

Eu tenho uma lista de dicionários e quero que cada item seja classificado por valores de propriedade específicos.

Leve em consideração a matriz abaixo,

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

Quando classificado por name, Deve se tornar

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

Answer 1

Pode parecer mais limpo usando uma chave em vez de um cmp:

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

ou como J.F.Sebastian e outros sugeriram,

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

Para completar (conforme apontado nos comentários de fitzgeraldsteele), adicione reverse=True classificar em ordem decrescente

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

Answer 2

import operator

Para classificar a lista de dicionários por key='name':

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

Para classificar a lista de dicionários por key='age':

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

Answer 3

Se quiser classificar a lista por várias chaves, você pode fazer o seguinte:

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

É bastante hackeado, pois depende da conversão dos valores em uma única representação de string para comparação, mas funciona conforme o esperado para números, incluindo os negativos (embora você precise formatar sua string apropriadamente com preenchimento de zero se estiver usando números)

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 agora será o que você deseja.

(3 anos depois) Editado para adicionar:

O novo key o argumento é mais eficiente e mais claro.Uma resposta melhor agora parece:

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

... o lambda é, IMO, mais fácil de entender do que operator.itemgetter, mas YMMV.

Answer 5

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

'key' é usado para classificar por um valor arbitrário e 'itemgetter' define esse valor para o atributo 'name' de cada item.

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

Acho que você quis dizer:

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

Isso seria classificado assim:

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

Answer 8

Usando a transformação Schwartziana do Perl,

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

fazer

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

Mais sobre Transformada Perl Schwartziana

Na ciência da computação, o Schwartzian Transform é um idioma de programação PERL usado para melhorar a eficiência de classificar uma lista de itens.Esse idioma é apropriado para classificação baseada em comparação quando a ordem é realmente baseada na ordem de uma determinada propriedade (a chave) dos elementos, onde calcular essa propriedade é uma operação intensiva que deve ser executada um número mínimo de vezes.A transformação Schwartzian é notável, pois não usa matrizes temporárias nomeadas.

Answer 9

Você pode usar uma função de comparação personalizada ou passar uma função que calcule uma chave de classificação personalizada.Isso geralmente é mais eficiente, pois a chave é calculada apenas uma vez por item, enquanto a função de comparação seria chamada muito mais vezes.

Você poderia fazer desta maneira:

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

Mas a biblioteca padrão contém uma rotina genérica para obter itens de objetos arbitrários: itemgetter.Então tente isto:

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

Answer 10

Você deve implementar sua própria função de comparação que comparará os dicionários por valores de chaves de nome.Ver Classificando Mini-COMO FAZER do PythonInfo Wiki

Answer 11

Aqui está a solução geral alternativa - ela classifica os elementos do dict por chaves e valores.A vantagem disso é que não há necessidade de especificar chaves e ainda funcionaria se algumas chaves estivessem faltando em alguns dicionários.

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

algum dia precisamos usar lower() por exemplo

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

Eu tentei algo assim:

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

Funcionou para números inteiros também.

Answer 14

Usar o pacote pandas é outro método, embora seu tempo de execução em larga escala seja muito mais lento do que os métodos mais tradicionais propostos por outros:

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

Aqui estão alguns valores de referência para uma lista pequena e uma lista grande (100k+) de dictos:

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

Digamos que tenho um Dicionário D com os elementos abaixo.Para classificar, basta usar o argumento chave na classificação para passar a função personalizada como abaixo

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

Aqui está minha resposta a uma pergunta relacionada sobre classificação por múltiplas colunas.Também funciona para o caso degenerado em que o número de colunas é apenas um.

Answer 17

Se você não precisa do original list de dictionaries, você pode modificá-lo no local com sort() método usando uma função de tecla personalizada.

Função chave:

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

    return d["name"]

O list para ser classificado:

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

Classificando no local:

data_one.sort(key=get_name)

Se você precisar do original list, Ligar para sorted() função passando o list e a função chave e, em seguida, atribua a classificação retornada list para uma nova variável:

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

Impressão 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

Você pode usar coletor de itens , se você quiser considerar o desempenho. coletor de itens normalmente funciona um pouco mais rápido do que lambda.

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

Answer 19

Você pode usar o seguinte código

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