Как отсортировать список словарей по значению словаря?

Как указано @Claudiu @monojohnny в разделе комментариев этого ответа,
дано:

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

для сортировки списка словарей по ключу 'age', 'name'
(как в операторе SQL ORDER BY age, name), вы можете использовать:

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

или аналогично

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

print(newlist)

[{'имя': 'Барт', 'возраст': 10},
{'имя': 'Милхаус', 'возраст': 10},
{'имя': 'Гомер', 'возраст': 39}]

Если производительность вызывает беспокойство, я бы использовал operator.itemgetter вместо lambda, поскольку встроенные функции работают быстрее, чем функции, созданные вручную. По результатам моего тестирования функция itemgetter работает примерно на 20% быстрее, чем lambda.

Из https://wiki.python.org/moin/PythonSpeed ​​:

Аналогично, встроенные функции работают быстрее, чем их аналоги, созданные вручную. Например, map (operator.add, v1, v2) быстрее, чем map (lambda x, y: x + y, v1, v2).

Вот сравнение скорости сортировки с использованием lambda и 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 the same sort order
sorted(l, key=lambda x: x['name']) == sorted(l, key=operator.itemgetter('name'))
True

Оба метода сортируют список в одном и том же порядке (проверяется выполнением последнего оператора в блоке кода), но первый работает немного быстрее.

Я был большим поклонником фильтра с лямбда. Однако это не лучший вариант, если учесть временную сложность.

Первый вариант

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

Второй вариант

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

Быстрое сравнение времени выполнения

# 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 циклов, лучшее из 3: 0,736 мкс на цикл

# 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 циклов, лучшее из 3: 0,438 мкс на цикл

Допустим, у меня есть словарь D с элементами ниже. Для сортировки просто используйте ключевой аргумент в sorted, чтобы передать настраиваемую функцию, как показано ниже:

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

Отметьте этот.

Вот альтернативное общее решение - сортирует элементы словаря по ключам и значениям.

Преимущество этого метода - не нужно указывать ключи, и он все равно будет работать, если некоторые ключи отсутствуют в некоторых словарях.

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)

Использование преобразования Шварца из Perl,

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

делать

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

Подробнее о преобразовании Перла Шварца:

В информатике преобразование Шварца - это программирование на Perl. идиома, используемая для повышения эффективности сортировки списка элементов. Этот идиома подходит для сортировки на основе сравнения, когда порядок фактически на основе упорядочивания определенного свойства (ключа) элементов, где вычисление этого свойства является интенсивной операцией, которая следует выполнять минимальное количество раз. Шварцианский Преобразование примечательно тем, что в нем не используются именованные временные массивы.

Если вы хотите отсортировать список по нескольким ключам, вы можете сделать следующее:

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

Это довольно хакерский метод, поскольку он полагается на преобразование значений в одно строковое представление для сравнения, но он работает, как ожидалось, для чисел, включая отрицательные (хотя вам нужно будет соответствующим образом отформатировать строку с нулевыми отступами, если вы используете числа).

Использование пакета Pandas - другой метод, хотя его время выполнения в больших масштабах намного медленнее, чем более традиционные методы, предложенные другими:

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

Вот некоторые контрольные значения для крошечного списка и большого (более 100 тыс.) Списков 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

Иногда нам нужно использовать lower(). Например,

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

Если вам не нужен исходный list из dictionaries, вы можете изменить его на месте с помощью метода sort() с использованием настраиваемой ключевой функции.

Функция ключа:

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

    return d["name"]

list для сортировки:

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

Сортировка на месте:

data_one.sort(key=get_name)

Если вам нужен исходный list, вызовите функцию sorted(), передав ей list и ключевую функцию, затем назначьте возвращенный отсортированный list новой переменной:

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

Печать data_one и new_data.

>>> print(data_one)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]
>>> print(new_data)
[{'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

Чтобы отсортировать список словарей по ключу = 'name':

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

Чтобы отсортировать список словарей по ключу = 'age':

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

Вы можете использовать настраиваемую функцию сравнения или передать функцию, которая вычисляет настраиваемый ключ сортировки. Обычно это более эффективно, поскольку ключ вычисляется только один раз для каждого элемента, в то время как функция сравнения будет вызываться много раз.

Вы можете сделать это так:

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

Но стандартная библиотека содержит общую процедуру для получения элементов произвольных объектов: itemgetter. Так что попробуйте вместо этого:

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

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

'ключ' используется для сортировки по произвольному значению, а 'itemgetter' устанавливает это значение для атрибута 'name' каждого элемента.

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

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

my_list теперь будет тем, что вы хотите.

Или лучше:

Начиная с Python 2.4, аргумент key более эффективен и аккуратен:

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

... лямбда, IMO, легче понять, чем operator.itemgetter, но ваш пробег может отличаться.

Думаю, вы имели в виду:

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

Это будет отсортировано следующим образом:

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

Вы должны реализовать свою собственную функцию сравнения, которая будет сравнивать словари по значениям ключей имен. См. Сортировка Mini-HOW TO из PythonInfo Wiki