Сортировка словарей в Python: понимание и применение

Обновлено: июль 2026.

Чтобы отсортировать словарь по значениям в Python, передайте dict.items() в функцию sorted() с ключом, который берёт значение пары:

d = {'apple': 2, 'banana': 3, 'orange': 1} result = dict(sorted(d.items(), key=lambda item: item[1])) # {'orange': 1, 'apple': 2, 'banana': 3}

Для убывания добавьте reverse=True. С Python 3.7 порядок вставки в словаре сохраняется, поэтому dict() вокруг результата фиксирует отсортированный порядок.

Коротко: способы сортировки словарей в Python

• По значениям: sorted(d.items(), key=lambda item: item[1]).
• По ключам: sorted(d.items(), key=lambda item: item[0]) или просто sorted(d.items()).
• Убывание: тот же вызов с reverse=True.
• Быстрее и чище: operator.itemgetter(1) вместо lambda.
• По нескольким критериям: itemgetter(1, 0) — сначала по значению, потом по ключу.
• Сохранить результат: обернуть в dict() (Python 3.7+).

ОНЛАЙН-ПРАКТИКУМ

ЗАПУСК нейросети DEEPSEEK R1 ЛОКАЛЬНО НА СВОЕМ КОМПЬЮТЕРЕ

ЧТО БУДЕТ НА ОБУЧЕНИИ?

• ПОКАЖЕМ, КАК РАЗВЕРНУТЬ МОДЕЛЬ нейросети DEEPSEEK R1 ПРЯМО НА СВОЁМ КОМПЬЮТЕРЕ
• Где и как применять? Потестируем модель после установки на разных задачах
• Как дообучить модель под себя?

Участвовать бесплатно

Как отсортировать словарь по значениям python

Словарь сам по себе отсортировать нельзя — можно построить новый упорядоченный словарь. Метод items() возвращает пары ключ-значение как список кортежей вида ('banana', 3). Функция sorted() строит из любого итерируемого объекта новый отсортированный список, а параметр key задаёт, по какому элементу пары сравнивать. Индекс 1 — это значение, индекс 0 — ключ.

scores = {'Игорь': 74, 'Анна': 91, 'Пётр': 68, 'Мария': 91} by_value = sorted(scores.items(), key=lambda item: item[1]) # [('Пётр', 68), ('Игорь', 74), ('Анна', 91), ('Мария', 91)]

Согласно документации Python, функция из key вызывается ровно один раз для каждого элемента — поэтому такой подход быстрый даже на больших словарях. Обратите внимание на пару ('Анна', 91) и ('Мария', 91): при равных значениях исходный порядок сохраняется. Это не случайность, а гарантия языка — сортировка в Python стабильна (документация Python).

Мини-вывод: сортировка по значениям — это sorted() над items() с key=lambda item: item[1]. Всё остальное — вариации этого приёма.

Сортировка словаря по ключам

Если нужно упорядочить по ключам, а не по значениям, сравнивайте нулевой элемент пары:

d = {'значение': 42, 'ключ': 18, 'данные': 7} by_key = dict(sorted(d.items(), key=lambda item: item[0])) # {'данные': 7, 'значение': 42, 'ключ': 18}

Для ключей key можно вообще опустить: sorted(d.items()) сортирует кортежи по первому элементу автоматически. Строки при этом сравниваются лексикографически, а не по алфавиту в человеческом смысле — заглавные буквы идут раньше строчных, потому что сравнение опирается на коды символов Unicode.

Мини-вывод: по ключам работает тот же sorted(), но с индексом 0 или вовсе без key.

Сортировка в обратном порядке

Оба варианта — по значениям и по ключам — принимают булев параметр reverse для сортировки по убыванию:

top = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True)) # {'Анна': 91, 'Мария': 91, 'Игорь': 74, 'Пётр': 68}

Важная деталь: reverse=True не ломает стабильность. При равных значениях исходный порядок ключей сохраняется, а не переворачивается. Это прямо оговорено в документации Python и избавляет от неприятных сюрпризов, когда два элемента с одинаковым весом внезапно меняются местами между запусками.

operator.itemgetter вместо lambda

Функция itemgetter из модуля operator делает то же, что lambda item: item[1], но короче и, как правило, быстрее — вызов уходит в C-код вместо интерпретации Python-функции на каждом элементе.

from operator import itemgetter by_value = dict(sorted(scores.items(), key=itemgetter(1))) by_key = dict(sorted(scores.items(), key=itemgetter(0)))

На словаре из десятков элементов разница незаметна. На сотнях тысяч пар itemgetter стабильно опережает lambda — меньше накладных расходов на каждый вызов. Для продакшн-кода это предпочтительный вариант.

Сортировка по нескольким критериям

Когда значения совпадают, нужен второй уровень сортировки — например, при равном балле упорядочить по имени. itemgetter принимает несколько индексов и сортирует по ним последовательно:

from operator import itemgetter # сначала по значению, при равенстве — по ключу result = sorted(scores.items(), key=itemgetter(1, 0)) # [('Пётр', 68), ('Игорь', 74), ('Анна', 91), ('Мария', 91)]

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

data = sorted(scores.items(), key=itemgetter(0)) # сначала по ключу (возр.) data = sorted(data, key=itemgetter(1), reverse=True) # потом по значению (убыв.)

Поскольку каждая сортировка стабильна, второй проход не разрушает порядок, заданный первым, — так собираются сложные сортировки из простых шагов.

Мини-вывод: один критерий — lambda или itemgetter; несколько — itemgetter(1, 0) или каскад проходов от младшего критерия к старшему.

Как сохранить отсортированный словарь

Результат sorted() — это список кортежей, а не словарь. Чтобы получить словарь, оберните его в dict():

sorted_dict = dict(sorted(d.items(), key=lambda item: item[1]))

Начиная с Python 3.7 словари сохраняют порядок вставки как часть спецификации языка, поэтому dict() вокруг отсортированного списка удерживает нужный порядок. В коде под версии до 3.7 для этого применяли collections.OrderedDict — сегодня он нужен редко, в основном для методов вроде move_to_end().

Сортировка вложенных словарей

Частая задача — словарь, где значение само является словарём, и сортировать надо по внутреннему полю. Обращайтесь к нужному ключу прямо в key:

users = { 'u1': {'name': 'Анна', 'age': 34}, 'u2': {'name': 'Пётр', 'age': 28}, 'u3': {'name': 'Игорь', 'age': 41}, } by_age = dict(sorted(users.items(), key=lambda item: item[1]['age'])) # порядок: u2 (28), u1 (34), u3 (41)

Тот же приём работает для списка словарей — здесь item уже сам словарь, без распаковки пары:

rows = [{'name': 'Анна', 'age': 34}, {'name': 'Пётр', 'age': 28}] rows.sort(key=lambda r: r['age'])

Если внутренний ключ есть не у всех элементов, задайте значение по умолчанию через item[1].get('age', 0), иначе сортировка упадёт с KeyError.

Сравнение подходов: что выбрать

Для повседневных задач подойдёт lambda — она нагляднее. Как только словарь вырастает до сотен тысяч элементов или сортировка попадает в горячий цикл, переходите на itemgetter.

Типичные ошибки

• Пытаться отсортировать сам словарь. sorted(d) вернёт список ключей, а не упорядоченный словарь. Работайте с d.items() и оборачивайте результат в dict().
• Забыть про .items(). Без него сортировка идёт по ключам, а значения теряются из виду.
• Перепутать индексы. item[0] — ключ, item[1] — значение. Сортировка «не по тому» почти всегда сводится к этой опечатке.
• Ждать сортировки «на месте». У словарей нет метода .sort() — он есть только у списков. d.sorted() не существует и вызовет AttributeError.
• Опираться на порядок в старом Python. До версии 3.7 порядок словаря не гарантирован — там нужен OrderedDict.
• KeyError на вложенных словарях. Если поле есть не везде, используйте .get(ключ, значение_по_умолчанию).

О производительности

Сложность любой из этих сортировок — O(n log n), потому что под капотом работает Timsort. Выбор между lambda и itemgetter влияет только на константу: itemgetter убирает накладные расходы на вызов Python-функции. Если данные уже почти упорядочены, Timsort отработает близко к линейному времени — это его сильная сторона. Ключевая функция вызывается один раз на элемент, так что тяжёлые вычисления в key стоит выносить заранее, а не пересчитывать при каждом сравнении.

Что запомнить

Сортировка словарей в Python сводится к одному приёму: sorted(d.items(), key=...). По значениям — берите item[1], по ключам — item[0], для убывания — reverse=True, для скорости — itemgetter, для нескольких критериев — itemgetter(1, 0) или каскад стабильных проходов. Оберните результат в dict(), и в Python 3.7+ порядок сохранится.