В Python для решения задач сортировки предусмотрены два основных инструмента: функция sorted() и метод .sort(). На первый взгляд, различия между ними могут показаться незначительными, но когда дело доходит до реального программирования, выбор подходящего инструмента может существенно повлиять на производительность и читаемость кода. Функция sorted() – универсальный боец, который работает с любыми итерируемыми объектами и всегда возвращает новый отсортированный список. В противоположность ей, метод .sort() – специалист узкого профиля, применимый только к спискам и модифицирующий их "на месте", не создавая копии.
| Python | 1
2
3
4
5
6
7
8
9
| # Сортировка с помощью sorted()
numbers = [5, 2, 8, 1, 3]
sorted_numbers = sorted(numbers) # [1, 2, 3, 5, 8]
print(numbers) # [5, 2, 8, 1, 3] - исходный список не изменился
# Сортировка с помощью .sort()
numbers = [5, 2, 8, 1, 3]
numbers.sort() # Метод ничего не возвращает!
print(numbers) # [1, 2, 3, 5, 8] - исходный список изменился |
|
Выбирайте sorted(), когда:- Работаете с неизменяемыми типами данных (кортежи, строки).
- Хотите сохранить исходную коллекцию неизменной.
- Нужно отсортировать данные в цепочке операций.
Выбирайте .sort(), когда:- Важна производительность и экономия памяти.
- Исходная коллекция вам больше не нужна.
- Работаете исключительно со списками.
Базовая механика
Чтобы эффективно использовать сортировку в Python нужно четко понимать, как они работают "под капотом".
Функция sorted() является встроенной функцией Python и может работать с любым итерируемым типом данных. Это значит, что она способна сортировать не только списки, но и кортежи, множества, строки и другие коллекции:
| Python | 1
2
3
4
5
6
7
8
9
10
| # Сортировка разных типов данных
числа_список = [3, 1, 4, 1, 5, 9]
числа_кортеж = (3, 1, 4, 1, 5, 9)
числа_множество = {3, 1, 4, 1, 5, 9}
текст = "Python"
print(sorted(числа_список)) # [1, 1, 3, 4, 5, 9]
print(sorted(числа_кортеж)) # [1, 1, 3, 4, 5, 9]
print(sorted(числа_множество)) # [1, 3, 4, 5, 9] (множества удаляют дубликаты)
print(sorted(текст)) # ['P', 'h', 'n', 'o', 't', 'y'] |
|
sorted() всегда возвращает новый список. Если вам нужно сохранить тип исходной коллекции, придется выполнить преобразование:
| Python | 1
2
3
| исходный_кортеж = (3, 1, 4, 1, 5, 9)
отсортированный_кортеж = tuple(sorted(исходный_кортеж))
print(отсортированный_кортеж) # (1, 1, 3, 4, 5, 9) |
|
sorted(), метод .sort() доступен только для списков. Это метод объекта, который модифицирует сам объект, не создавая копии. Когда вы вызываете .sort(), список изменяется на месте:
| Python | 1
2
3
| фрукты = ["яблоко", "банан", "груша", "апельсин"]
фрукты.sort()
print(фрукты) # ['апельсин', 'банан', 'груша', 'яблоко'] |
|
None. Это распространенная ошибка среди начинающих разработчиков:
| Python | 1
2
3
| фрукты = ["яблоко", "банан", "груша", "апельсин"]
отсортированные_фрукты = фрукты.sort() # Неправильно!
print(отсортированные_фрукты) # None |
|
Для простых типов данных вроде чисел и строк сортировка работает интуитивно понятно. Числа сортируются по возрастанию значений, а строки — по алфавиту, используя лексикографический порядок:
| Python | 1
2
3
4
5
6
7
| # Сортировка чисел
числа = [42, 23, 16, 15, 8, 4]
print(sorted(числа)) # [4, 8, 15, 16, 23, 42]
# Сортировка строк
слова = ["зебра", "аист", "жираф", "бегемот"]
print(sorted(слова)) # ['аист', 'бегемот', 'жираф', 'зебра'] |
|
| Python | 1
2
3
4
5
6
| смешанный_список = [1, "два", 3, "четыре"]
try:
print(sorted(смешанный_список))
except TypeError as e:
print(f"Ошибка: {e}")
# Выведет: Ошибка: '<' not supported between instances of 'str' and 'int' |
|
False — числу 0, поэтому такие списки можно отсортировать:
| Python | 1
2
| булево_числовой_список = [True, 0, False, 1, True]
print(sorted(булево_числовой_список)) # [False, 0, True, 1, True] |
|
| Python | 1
2
| матрица = [[3, 2], [2, 1], [1, 3], [1, 2]]
print(sorted(матрица)) # [[1, 2], [1, 3], [2, 1], [3, 2]] |
|
Для словарей ситуация немного сложнее. По умолчанию sorted(словарь) сортирует только ключи словаря:
| Python | 1
2
| студенты = {"Иван": 85, "Мария": 92, "Алексей": 78, "Елена": 95}
print(sorted(студенты)) # ['Алексей', 'Елена', 'Иван', 'Мария'] |
|
Понимание базовых механик сортировки — ключевой шаг к освоению более продвинутых техник. Теперь, зная как работают sorted() и .sort(), мы можем перейти к более детальному изучению их возвращаемых значений и сценариев использования.
Отличия между методом sort() списка и функцией sorted()
Напишите пример, который продемонстрирует отличия между методом sort() списка и функцией sorted(arr).
На основе вашего кода должно быть возможно... Сортировка по нескольким параметрам с использованием sorted
Всем привет. Пытаюсь разобраться можно ли с помощью sorted сортировать по нескольким параметрам.
Например, есть список
l =
Хочу... Обзор текстовых редакторов для python
Начал изучать Django, раньше писал код в wing ide, pycharm, но не особо доволен, для Django мне пока что только и пригодилась консоль, браузер, да... .sort() сортировка
есть некий массив (list) a, каждое значение которого - строка
массив а сформирован поэлементным добавлением по определенному алгоритму (если это...
Возвращаемые значения методов: что нужно знать
Функция sorted() всегда возвращает новый список, содержащий отсортированные элементы исходной последовательности. Это означает, что независимо от типа переданного объекта, вы получите список:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| # Возвращаемые значения sorted()
исходный_список = [3, 1, 4, 2]
исходный_кортеж = (3, 1, 4, 2)
исходное_множество = {3, 1, 4, 2}
результат1 = sorted(исходный_список) # Список -> Список
результат2 = sorted(исходный_кортеж) # Кортеж -> Список
результат3 = sorted(исходное_множество) # Множество -> Список
print(type(результат1)) # <class 'list'>
print(type(результат2)) # <class 'list'>
print(type(результат3)) # <class 'list'> |
|
| Python | 1
2
3
4
| # Фильтрация и сортировка в одной цепочке
числа = [10, -5, 8, 3, -1, 0, 4]
положительные_отсортированные = [x for x in sorted(числа) if x > 0]
print(положительные_отсортированные) # [3, 4, 8, 10] |
|
.sort() модифицирует список на месте и возвращает None. Это типичный подход для методов, которые изменяют объект вместо создания нового. Такое поведение можно встретить и в других методах списков, например в .append() или .extend().
| Python | 1
2
3
4
5
6
| # Демонстрация возвращаемого значения .sort()
числа = [3, 1, 4, 2]
результат = числа.sort()
print(числа) # [1, 2, 3, 4] - список изменен
print(результат) # None - метод ничего не возвращает |
|
None может показаться странным, но это осознанное решение дизайна языка. Такое поведение помогает различать функции, которые возвращают новые объекты, от тех, что изменяют существующие. Это также помогает избежать ненужного дублирования данных в памяти.
Однако возврат None часто становится источником ошибок. Вот распространенная ловушка, в которую попадают многие разработчики:
| Python | 1
2
3
4
5
6
7
8
9
| # Распространенная ошибка
имена = ["Мария", "Иван", "Александр", "Елена"]
отсортированные_имена = имена.sort() # Ошибка логики!
# Попытка использовать результат приведет к проблемам
try:
print(f"Первое имя: {отсортированные_имена[0]}") # Ошибка!
except:
print("отсортированные_имена - это None, нельзя получить элемент") |
|
sorted():
| Python | 1
2
3
4
| имена = ["Мария", "Иван", "Александр", "Елена"]
отсортированные_имена = sorted(имена)
print(f"Исходный список: {имена}")
print(f"Отсортированный список: {отсортированные_имена}") |
|
.sort():
| Python | 1
2
3
| имена = ["Мария", "Иван", "Александр", "Елена"]
имена.sort() # Модифицируем список на месте
print(f"Отсортированный список: {имена}") |
|
.sort() возвращает None, его нельзя использовать в цепочке методов, что иногда может быть неудобно:
| Python | 1
2
3
4
5
6
7
8
| # Не сработает как ожидается!
результат = [3, 1, 4, 2].sort().append(5) # Ошибка атрибута
# Правильный подход
числа = [3, 1, 4, 2]
числа.sort()
числа.append(5)
print(числа) # [1, 2, 3, 4, 5] |
|
sorted() отлично работает в цепочках операций:
| Python | 1
2
3
| # Работает отлично
результат = sorted([3, 1, 4, 2]) + [5]
print(результат) # [1, 2, 3, 4, 5] |
|
Сортировка строк с учетом регистра и юникод-символов
Сортировка строковых данных — задача, с которой сталкивается практически каждый разработчик. Однако за кажущейся простотой могут скрываться неожиданные нюансы, особенно когда дело касается регистра букв и символов Юникода. В Python строки сортируются лексикографически, то есть побуквенно сравниваются их символы. При этом важно помнить, что сравнение происходит на основе численных значений символов в таблице Unicode:
| Python | 1
2
3
| слова = ["яблоко", "Апельсин", "банан", "Груша"]
отсортированные = sorted(слова)
print(отсортированные) # ['Апельсин', 'Груша', 'банан', 'яблоко'] |
|
ord(), которая возвращает код символа:
| Python | 1
2
3
4
| print(ord('A')) # 65
print(ord('a')) # 97
print(ord('А')) # 1040 (кириллическая 'А')
print(ord('а')) # 1072 (кириллическая 'а') |
|
key функции sorted():
| Python | 1
2
3
| слова = ["яблоко", "Апельсин", "банан", "Груша"]
отсортированные = sorted(слова, key=str.lower)
print(отсортированные) # ['Апельсин', 'банан', 'Груша', 'яблоко'] |
|
str.lower применяется к каждому элементу перед сравнением, но при этом оригинальные значения сохраняются в результирующем списке. При работе с многоязычными текстами возникают дополнительные сложности. По умолчанию Python сортирует строки на основе кодов Unicode, что может приводить к неожиданным результатам при смешении алфавитов:
| Python | 1
2
| международные = ["café", "apple", "zürich", "елка"]
print(sorted(международные)) # ['apple', 'café', 'елка', 'zürich'] |
|
locale:
| Python | 1
2
3
4
5
6
7
8
| import locale
# Установка локали (например, русской)
locale.setlocale(locale.LC_ALL, 'ru_RU.UTF-8')
международные = ["café", "apple", "zürich", "елка"]
отсортированные = sorted(международные, key=locale.strxfrm)
print(отсортированные) # Порядок будет зависеть от выбранной локали |
|
locale может зависеть от настроек операционной системы и не всегда дает предсказуемые результаты на разных платформах.
Для более надежного и гибкого решения многие разработчики используют библиотеку PyICU или pyuca, которые реализуют алгоритм сравнения Unicode Collation Algorithm:
| Python | 1
2
3
4
5
6
7
| # Пример с pyuca (требуется установка: pip install pyuca)
import pyuca
коллатор = pyuca.Collator()
международные = ["café", "apple", "zürich", "елка"]
отсортированные = sorted(международные, key=коллатор.sort_key)
print(отсортированные) # Сортировка согласно Unicode Collation Algorithm |
|
| Python | 1
2
| версии = ["v1", "v10", "v2", "v11"]
print(sorted(версии)) # ['v1', 'v10', 'v11', 'v2'] |
|
Для естественной сортировки версий можно использовать тот же параметр key с функцией, которая разбирает числовую часть:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| def sort_версии(версия):
компоненты = []
for группа in re.findall(r'(\d+|\D+)', версия):
if группа.isdigit():
компоненты.append(int(группа))
else:
компоненты.append(группа)
return компоненты
import re
версии = ["v1", "v10", "v2", "v11"]
print(sorted(версии, key=sort_версии)) # ['v1', 'v2', 'v10', 'v11'] |
|
Параметры настройки
Сортировка в Python становится по-настоящему мощным инструментом, когда вы начинаете использовать дополнительные параметры, позволяющие тонко настраивать процесс упорядочивания данных. Рассмотрим два ключевых параметра, которые присутствуют как в sorted(), так и в .sort(): reverse и key.
Параметр reverse — самый простой из них. Он принимает логическое значение (True или False) и определяет направление сортировки. По умолчанию reverse=False, что дает сортировку по возрастанию. Если установить reverse=True, порядок сортировки изменится на противоположный:
| Python | 1
2
3
4
5
6
7
8
| числа = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(числа)) # [1, 1, 2, 3, 4, 5, 6, 9]
print(sorted(числа, reverse=True)) # [9, 6, 5, 4, 3, 2, 1, 1]
# То же самое для метода .sort()
копия = числа.copy()
копия.sort(reverse=True)
print(копия) # [9, 6, 5, 4, 3, 2, 1, 1] |
|
reverse часто используется при ранжировании, например, чтобы вывести список лучших результатов сверху:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| оценки = [
{"имя": "Алексей", "баллы": 85},
{"имя": "Мария", "баллы": 92},
{"имя": "Павел", "баллы": 78},
{"имя": "Елена", "баллы": 95}
]
# Сортировка по убыванию баллов
отсортированные = sorted(оценки, key=lambda x: x["баллы"], reverse=True)
for студент in отсортированные:
print(f"{студент['имя']}: {студент['баллы']}")
# Выведет:
# Елена: 95
# Мария: 92
# Алексей: 85
# Павел: 78 |
|
key, который открывает гораздо больше возможностей для настройки сортировки.
Параметр key принимает функцию, которая будет применяться к каждому элементу перед сравнением. Функция должна принимать один аргумент (элемент списка) и возвращать значение, по которому будет производиться сортировка. Это чрезвычайно гибкий механизм, позволяющий реализовать практически любую логику сортировки.
Рассмотрим несколько распространенных сценариев использования параметра key:
1. Сортировка по длине строк:
| Python | 1
2
| слова = ["кот", "собака", "хомяк", "лев", "жираф", "муравьед"]
print(sorted(слова, key=len)) # ['кот', 'лев', 'хомяк', 'жираф', 'собака', 'муравьед'] |
|
| Python | 1
2
| слова = ["кот", "собака", "хомяк", "лев", "жираф"]
print(sorted(слова, key=lambda s: s[-1])) # ['жираф', 'лев', 'хомяк', 'кот', 'собака'] |
|
| Python | 1
2
| пары = [(1, 'один'), (2, 'два'), (3, 'три'), (4, 'четыре')]
print(sorted(пары, key=lambda x: x[1])) # [(2, 'два'), (4, 'четыре'), (1, 'один'), (3, 'три')] |
|
| Python | 1
2
| слова = ["Яблоко", "банан", "Груша", "апельсин"]
print(sorted(слова, key=str.lower)) # ['апельсин', 'банан', 'Груша', 'Яблоко'] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| class Товар:
def __init__(self, название, цена):
self.название = название
self.цена = цена
def __repr__(self):
return f"{self.название} (₽{self.цена})"
каталог = [
Товар("Чайник", 1500),
Товар("Микроволновка", 4200),
Товар("Тостер", 1800),
Товар("Блендер", 2300)
]
по_названию = sorted(каталог, key=lambda x: x.название)
print(по_названию) # [Блендер (₽2300), Микроволновка (₽4200), Тостер (₽1800), Чайник (₽1500)]
по_цене = sorted(каталог, key=lambda x: x.цена)
print(по_цене) # [Чайник (₽1500), Тостер (₽1800), Блендер (₽2300), Микроволновка (₽4200)] |
|
key и reverse. Например, если мы хотим отсортировать список слов по длине в порядке убывания:
| Python | 1
2
3
| слова = ["питон", "программирование", "код", "алгоритм", "функция"]
print(sorted(слова, key=len, reverse=True))
# ['программирование', 'алгоритм', 'функция', 'питон', 'код'] |
|
key можно использовать и для более сложной логики сортировки. Например, если нужно отсортировать список чисел по остатку от деления на 3:
| Python | 1
2
3
4
5
6
| числа = [7, 2, 5, 1, 8, 3, 9, 4, 6]
print(sorted(числа, key=lambda x: x % 3))
# [3, 6, 9, 1, 4, 7, 2, 5, 8]
# Остаток 0: 3, 6, 9
# Остаток 1: 1, 4, 7
# Остаток 2: 2, 5, 8 |
|
key, применяется к каждому элементу списка ровно один раз перед началом сортировки. Это оптимизация производительности, особенно важная, если функция вычисления ключа является ресурсоемкой.
Часто требуется сортировать словари, что также легко реализуется с помощью параметра key. Сортировка словаря по умолчанию производится по его ключам, но можно настроить сортировку и по значениям:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| оценки_студентов = {
"Иванов": 85,
"Петров": 78,
"Сидорова": 92,
"Кузнецов": 65,
"Смирнова": 88
}
# Сортировка по ключам (фамилиям)
sorted_names = sorted(оценки_студентов)
print(sorted_names) # ['Иванов', 'Кузнецов', 'Петров', 'Сидорова', 'Смирнова']
# Сортировка по значениям (баллам)
sorted_by_grades = sorted(оценки_студентов, key=lambda x: оценки_студентов[x])
print(sorted_by_grades) # ['Кузнецов', 'Петров', 'Иванов', 'Смирнова', 'Сидорова'] |
|
| Python | 1
2
3
| отсортированный_словарь = {k: оценки_студентов[k] for k in sorted(оценки_студентов,
key=lambda x: оценки_студентов[x])}
print(отсортированный_словарь) |
|
key также пригодится при сортировке данных, где нужно обработать значения перед сравнением. Например, для сортировки списка дат в строковом формате:
| Python | 1
2
3
4
5
| даты = ["15/03/2022", "07/01/2021", "23/12/2022", "18/05/2021"]
# Разбиваем строки на день, месяц, год и сортируем по году, затем месяцу, затем дню
отсортированные_даты = sorted(даты, key=lambda x: tuple(map(int, x.split('/')[::-1])))
print(отсортированные_даты) # ['07/01/2021', '18/05/2021', '15/03/2022', '23/12/2022'] |
|
Стоит помнить, что параметры key и reverse доступны как в функции sorted(), так и в методе .sort(), что делает их универсальными инструментами для гибкой настройки сортировки в Python.
Создание анонимных функций lambda для параметра key
В предыдущих примерах мы уже использовали lambda-функции для параметра key, но давайте разберем их более подробно. Lambda-функции (или анонимные функции) — это компактные однострочные функции, которые определяются без имени и незаменимы при работе с сортировкой.
Синтаксис lambda-функции довольно прост:
| Python | 1
| lambda аргументы: выражение |
|
def, можно использовать более лаконичный синтаксис:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| # Традиционный способ с использованием def
def получить_возраст(человек):
return человек["возраст"]
люди = [
{"имя": "Алексей", "возраст": 30},
{"имя": "Елена", "возраст": 25},
{"имя": "Михаил", "возраст": 35}
]
отсортированы_по_возрасту = sorted(люди, key=получить_возраст)
# Тот же результат с lambda-функцией
отсортированы_по_возрасту = sorted(люди, key=lambda человек: человек["возраст"]) |
|
| Python | 1
2
3
| данные = [("яблоко", 3), ("банан", 2), ("вишня", 5), ("дыня", 1)]
отсортированные = sorted(данные, key=lambda x: x[1])
print(отсортированные) # [('дыня', 1), ('банан', 2), ('яблоко', 3), ('вишня', 5)] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
| студенты = [
{"имя": "Анна", "группа": "А", "средний_балл": 4.8},
{"имя": "Борис", "группа": "Б", "средний_балл": 4.5},
{"имя": "Вера", "группа": "А", "средний_балл": 4.9},
{"имя": "Глеб", "группа": "Б", "средний_балл": 4.5}
]
# Сначала сортируем по группе, затем по среднему баллу (по убыванию)
отсортированные = sorted(
студенты,
key=lambda x: (x["группа"], -x["средний_балл"])
)
print(отсортированные) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| книги = [
{"название": "Война и мир", "автор": "Толстой", "год": 1869},
{"название": "Преступление и наказание", "автор": "Достоевский", "год": 1866},
{"название": "Мастер и Маргарита", "автор": "Булгаков", "год": 1967}
]
# Сначала сортируем по году (по убыванию), затем по автору (по возрастанию)
отсортированные = sorted(
книги,
key=lambda x: (-x["год"], x["автор"])
)
print(отсортированные) |
|
| Python | 1
2
3
4
| # Сортировка чисел по расстоянию до 50
числа = [10, 40, 30, 70, 90, 55]
отсортированные = sorted(числа, key=lambda x: abs(x - 50))
print(отсортированные) # [55, 40, 30, 70, 10, 90] |
|
| Python | 1
2
3
4
5
6
7
8
| # Вместо сложной lambda...
отсортированные = sorted(слова, key=lambda x: (x.lower(), len(x)))
# ...лучше использовать обычную функцию
def ключ_сортировки(слово):
return (слово.lower(), len(слово))
отсортированные = sorted(слова, key=ключ_сортировки) |
|
1. Lambda может содержать только одно выражение
2. Нельзя использовать операторы ветвления и циклы напрямую
3. Отсутствие имени затрудняет отладку
Для обхода этих ограничений иногда используют тернарные операторы или встроенные функции:
| Python | 1
2
3
4
5
| # Использование тернарного оператора в lambda
сортировка_с_условием = sorted(
числа,
key=lambda x: x if x % 2 == 0 else x * 100
) |
|
| Python | 1
2
3
4
5
6
7
| def ключ_сортировки_с_логикой(число):
if число % 2 == 0:
return (0, число) # Четные числа идут первыми
else:
return (1, число) # Нечетные числа идут вторыми
отсортированные = sorted(числа, key=ключ_сортировки_с_логикой) |
|
Использование operator.itemgetter и operator.attrgetter для сложных объектов
Хотя lambda-функции очень удобны для сортировки, существуют более специализированные инструменты, которые могут сделать код еще компактнее и эффективнее. Речь идет о функциях itemgetter и attrgetter из модуля operator. Модуль operator предоставляет набор функций, соответствующих основным операторам Python, что делает их отличной альтернативой lambda-функциям в определенных сценариях. Когда речь идет о сортировке, особенно полезны две функции:
| Python | 1
| from operator import itemgetter, attrgetter |
|
itemgetter создает вызываемый объект, который извлекает элемент из позиции, указанной при создании. Это идеально подходит для сортировки списков кортежей или списков словарей:
| Python | 1
2
3
4
5
6
7
8
9
10
| данные = [("яблоко", 3), ("банан", 2), ("вишня", 5), ("дыня", 1)]
# С использованием lambda
sorted_lambda = sorted(данные, key=lambda x: x[1])
# С использованием itemgetter
from operator import itemgetter
sorted_itemgetter = sorted(данные, key=itemgetter(1))
print(sorted_itemgetter) # [('дыня', 1), ('банан', 2), ('яблоко', 3), ('вишня', 5)] |
|
itemgetter может быть более эффективным и читаемым, особенно для сложных сортировок. Если нам нужно отсортировать по нескольким элементам, itemgetter особенно элегантен:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| студенты = [
("Александр", "Иванов", 20),
("Мария", "Петрова", 19),
("Александр", "Смирнов", 21),
("Дарья", "Кузнецова", 20)
]
# Сортировка сначала по имени, затем по фамилии
отсортированные = sorted(студенты, key=itemgetter(0, 1))
print(отсортированные)
# [('Александр', 'Иванов', 20), ('Александр', 'Смирнов', 21),
# ('Дарья', 'Кузнецова', 20), ('Мария', 'Петрова', 19)] |
|
Для сортировки списка словарей itemgetter также очень полезен:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| товары = [
{"название": "Чайник", "цена": 1500, "рейтинг": 4.2},
{"название": "Тостер", "цена": 1800, "рейтинг": 4.5},
{"название": "Блендер", "цена": 2300, "рейтинг": 4.0},
{"название": "Миксер", "цена": 1500, "рейтинг": 4.7}
]
# Сортировка по цене, затем по рейтингу (по убыванию)
from operator import itemgetter
отсортированные = sorted(
товары,
key=lambda x: (x["цена"], -x["рейтинг"])
)
# К сожалению, itemgetter не может напрямую обрабатывать отрицательные значения,
# поэтому для смешанных направлений сортировки lambda остаётся предпочтительнее |
|
attrgetter:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class Студент:
def __init__(self, имя, фамилия, возраст):
self.имя = имя
self.фамилия = фамилия
self.возраст = возраст
def __repr__(self):
return f"{self.имя} {self.фамилия}, {self.возраст} лет"
студенты = [
Студент("Александр", "Иванов", 20),
Студент("Мария", "Петрова", 19),
Студент("Александр", "Смирнов", 21),
Студент("Дарья", "Кузнецова", 20)
]
# Сортировка по возрасту, затем по фамилии
from operator import attrgetter
отсортированные = sorted(студенты, key=attrgetter('возраст', 'фамилия'))
print(отсортированные)
# [Мария Петрова, 19 лет, Александр Иванов, 20 лет,
# Дарья Кузнецова, 20 лет, Александр Смирнов, 21 лет] |
|
attrgetter перед lambda заключается в том, что он создает оптимизированную функцию доступа, что может быть быстрее при сортировке больших наборов данных.
Можно комбинировать itemgetter и attrgetter для более сложных сценариев:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class Заказ:
def __init__(self, номер, клиент, товары):
self.номер = номер
self.клиент = клиент
self.товары = товары # список кортежей (название, количество)
def __repr__(self):
return f"Заказ #{self.номер}, клиент: {self.клиент}"
заказы = [
Заказ(1001, "Иванов", [("Чайник", 1), ("Тостер", 2)]),
Заказ(1002, "Петров", [("Блендер", 1)]),
Заказ(1003, "Иванов", [("Миксер", 1)])
]
# Сортировка по клиенту, затем по номеру заказа
отсортированные = sorted(заказы, key=attrgetter('клиент', 'номер'))
print(отсортированные) |
|
itemgetter и attrgetter может сделать ваш код более читаемым и производительным, особенно при работе со сложными структурами данных. Эти функции - еще один инструмент в вашем арсенале для эффективной сортировки в Python.
Кастомные сортировки
До сих пор мы рассматривали относительно простые примеры сортировки. Однако в реальных проектах часто возникают ситуации, требующие сложных, нестандартных подходов к упорядочиванию данных. Кастомные сортировки — это область, где Python особенно силён благодаря своей гибкости. Одна из распространённых задач — сортировка вложенных структур данных. Представьте, что у вас есть список списков, и вы хотите отсортировать его по определённым элементам вложенных списков:
| Python | 1
2
3
4
5
6
7
| матрица_данных = [
[5, "Проект A", 100],
[3, "Проект B", 200],
[1, "Проект C", 150],
[4, "Проект D", 100],
[2, "Проект E", 150]
] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| отсортированная_матрица = sorted(
матрица_данных,
key=lambda x: (-x[2], x[0])
)
for строка in отсортированная_матрица:
print(строка)
# [3, 'Проект B', 200]
# [1, 'Проект C', 150]
# [2, 'Проект E', 150]
# [5, 'Проект A', 100]
# [4, 'Проект D', 100] |
|
| Python | 1
2
3
4
5
6
7
| масти = ["пики", "червы", "бубны", "трефы", "пики", "червы"]
# Определяем кастомный порядок
порядок_мастей = {"пики": 1, "червы": 2, "бубны": 3, "трефы": 4}
отсортированные_масти = sorted(масти, key=lambda x: порядок_мастей[x])
print(отсортированные_масти) # ['пики', 'пики', 'червы', 'червы', 'бубны', 'трефы'] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
| точки = [(3, 4), (1, 2), (5, 6), (0, 1)]
# Вычисляем расстояние по теореме Пифагора
import math
def расстояние_от_начала(точка):
x, y = точка
return math.sqrt(x[B]2 + y[/B]2)
отсортированные_точки = sorted(точки, key=расстояние_от_начала)
print(отсортированные_точки) # [(0, 1), (1, 2), (3, 4), (5, 6)] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| class Интервал:
def __init__(self, начало, конец):
self.начало = начало
self.конец = конец
def длительность(self):
return self.конец - self.начало
def __repr__(self):
return f"[{self.начало} - {self.конец}]"
интервалы = [
Интервал(10, 20),
Интервал(5, 10),
Интервал(1, 15),
Интервал(3, 8)
]
# Сортировка по длительности интервала
отсортированные = sorted(интервалы, key=lambda x: x.длительность())
print(отсортированные) # [[5 - 10], [3 - 8], [10 - 20], [1 - 15]] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
| версии = ["1.0", "1.10", "1.2", "2.0", "0.9"]
# Обычная сортировка даст неверный результат
print(sorted(версии)) # ['0.9', '1.0', '1.10', '1.2', '2.0']
# Кастомная функция для корректного сравнения версий
def сравнение_версий(версия):
return [int(x) for x in версия.split('.')]
отсортированные_версии = sorted(версии, key=сравнение_версий)
print(отсортированные_версии) # ['0.9', '1.0', '1.2', '1.10', '2.0'] |
|
Стабильные и нестабильные сортировки в Python: практическое значение
При работе с алгоритмами сортировки существует важный аспект, который разработчики часто упускают из виду — стабильность сортировки. Этот фактор может оказать существенное влияние на результаты работы вашего кода, особенно при работе со сложными данными. Стабильная сортировка гарантирует, что элементы с одинаковыми ключами сохраняют свой относительный порядок после сортировки. Иными словами, если в исходном списке есть два элемента с одинаковыми значениями сортировки, и первый элемент стоит перед вторым, то после стабильной сортировки первый элемент всё равно будет предшествовать второму.
Хорошая новость: в Python как sorted(), так и .sort() используют стабильный алгоритм Timsort. Это гибридный алгоритм, сочетающий сортировку вставками и сортировку слиянием, который был специально разработан для языка Python. Простой пример, демонстрирующий стабильность сортировки в Python:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| карты = [
('7', 'пики'), ('7', 'червы'), ('туз', 'бубны'), ('король', 'трефы'),
('туз', 'пики'), ('7', 'бубны'), ('король', 'червы'), ('туз', 'червы')
]
# Сортируем только по номиналу
отсортированные_карты = sorted(карты, key=lambda x: x[0])
for карта in отсортированные_карты:
print(карта)
# ('7', 'пики')
# ('7', 'червы')
# ('7', 'бубны')
# ('король', 'трефы')
# ('король', 'червы')
# ('туз', 'бубны')
# ('туз', 'пики')
# ('туз', 'червы') |
|
Стабильность сортировки становится особенно важной, когда вы выполняете последовательные сортировки. Например, если вам нужно отсортировать таблицу сначала по одному столбцу, а затем по другому:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| сотрудники = [
('Иванов', 'инженер', 35),
('Петров', 'менеджер', 40),
('Сидоров', 'инженер', 30),
('Козлов', 'дизайнер', 25),
('Смирнов', 'дизайнер', 35)
]
# Сначала сортируем по возрасту
по_возрасту = sorted(сотрудники, key=lambda x: x[2])
# Затем по должности
по_должности_и_возрасту = sorted(по_возрасту, key=lambda x: x[1])
print("Сортировка по должности и возрасту:")
for сотрудник in по_должности_и_возрасту:
print(сотрудник) |
|
Вместо выполнения двух отдельных сортировок можно также использовать кортежи для многоуровневой сортировки:
| Python | 1
2
| # Эквивалентно предыдущему примеру, но в одной операции
отсортированные = sorted(сотрудники, key=lambda x: (x[1], x[2])) |
|
- Сортировку записей в базах данных.
- Обработку логов и временных рядов.
- Построение многоуровневых отчётов.
- Обработку транзакций в финансовых системах.
Во всех этих случаях сохранение относительного порядка равнозначных элементов может быть критически важным для корректности результатов.
Мультисортировка: упорядочивание по нескольким критериям
Часто в реальных проектах возникает необходимость сортировать данные сразу по нескольким полям или атрибутам. Например, таблицу сотрудников — сначала по отделу, затем по должности, а потом по фамилии. Такой тип сортировки называется мультисортировкой. Python предлагает способ реализации мультисортировки через возвращение кортежей в функции ключа. Когда функция key возвращает кортеж, Python сравнивает элементы кортежа последовательно, пока не обнаружит различие:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| сотрудники = [
{"фамилия": "Иванов", "отдел": "Разработка", "стаж": 5, "зарплата": 120000},
{"фамилия": "Петров", "отдел": "Маркетинг", "стаж": 3, "зарплата": 90000},
{"фамилия": "Сидоров", "отдел": "Разработка", "стаж": 8, "зарплата": 150000},
{"фамилия": "Козлова", "отдел": "Маркетинг", "стаж": 1, "зарплата": 70000},
{"фамилия": "Новиков", "отдел": "Разработка", "стаж": 5, "зарплата": 125000}
]
# Сортируем по отделу, затем по стажу (по убыванию), затем по фамилии
отсортированные = sorted(
сотрудники,
key=lambda x: (x["отдел"], -x["стаж"], x["фамилия"])
)
for сотрудник in отсортированные:
print(f"{сотрудник['фамилия']}, {сотрудник['отдел']}, стаж: {сотрудник['стаж']}")
# Петров, Маркетинг, стаж: 3
# Козлова, Маркетинг, стаж: 1
# Сидоров, Разработка, стаж: 8
# Иванов, Разработка, стаж: 5
# Новиков, Разработка, стаж: 5 |
|
-x["стаж"]) работает только для числовых полей и позволяет сортировать это поле по убыванию, в то время как остальные поля сортируются по возрастанию. Для строковых полей, которые нужно отсортировать по убыванию, можно воспользоваться обратным порядком символов с помощью среза [::-1]:
| Python | 1
2
3
4
5
| # Сортировка по отделу по убыванию, затем по фамилии по возрастанию
отсортированные = sorted(
сотрудники,
key=lambda x: (x["отдел"][::-1], x["фамилия"])
) |
|
| Python | 1
2
3
4
5
| # Сортировка сначала по отделу (убывание), затем по стажу (возрастание)
отсортированные = sorted(
сотрудники,
key=lambda x: (True, x["отдел"], x["стаж"]) if x["отдел"] == "Маркетинг" else (False, x["отдел"], x["стаж"])
) |
|
attrgetter с кортежами:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| class Сотрудник:
def __init__(self, фамилия, отдел, должность, зарплата):
self.фамилия = фамилия
self.отдел = отдел
self.должность = должность
self.зарплата = зарплата
def __repr__(self):
return f"{self.фамилия}, {self.отдел}, {self.должность}"
from operator import attrgetter
сотрудники = [
Сотрудник("Иванов", "ИТ", "Разработчик", 120000),
Сотрудник("Петров", "ИТ", "Тестировщик", 90000),
Сотрудник("Сидоров", "HR", "Менеджер", 100000),
Сотрудник("Кузнецов", "ИТ", "Разработчик", 130000)
]
# Создаем функцию для мультисортировки с attrgetter
def multi_sort_key(сотрудник):
return (сотрудник.отдел, сотрудник.должность, -сотрудник.зарплата)
отсортированные = sorted(сотрудники, key=multi_sort_key) |
|
Мультисортировка особенно полезна при создании отчетов, обработке данных и визуализации информации, когда требуется представить данные в логически структурированном виде с четкой иерархией критериев сортировки.
Производительность и оптимизация
Понимание производительности функций сортировки в Python критически важно при работе с большими наборами данных. В отличие от многих других языков программирования, Python предоставляет высокоуровневые интерфейсы для сортировки, скрывая детали реализации. Но что на самом деле происходит под капотом?
И sorted(), и .sort() используют алгоритм Timsort — гибридную сортировку, созданную специально для Python. Timsort комбинирует лучшие аспекты сортировки слиянием и вставками, обеспечивая превосходную производительность на различных типах данных.
Сравнивая скорость работы sorted() и .sort(), можно увидеть, что .sort() обычно работает немного быстрее, поскольку ему не нужно создавать новый список:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| import time
import random
# Создаем большой случайный список
большой_список = [random.randint(1, 1000) for _ in range(1000000)]
копия_списка = большой_список.copy()
# Измеряем время для sorted()
начало = time.time()
_ = sorted(большой_список)
конец = time.time()
print(f"sorted(): {конец - начало:.4f} сек")
# Измеряем время для .sort()
начало = time.time()
копия_списка.sort()
конец = time.time()
print(f".sort(): {конец - начало:.4f} сек") |
|
Когда речь идет об использовании функции key, стоит помнить, что она вызывается для каждого элемента списка ровно один раз. Python сначала применяет функцию ко всем элементам, создавая вспомогательный список кортежей `(key(item), item)`, сортирует этот список, а затем извлекает из него исходные элементы:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| # Для демонстрации: ресурсоемкая функция key
def тяжелая_функция(x):
time.sleep(0.0001) # Имитируем сложные вычисления
return len(str(x))
# Сравним два подхода
список1 = [random.randint(1, 1000) for _ in range(1000)]
список2 = список1.copy()
# Подход 1: Многократные вызовы в цикле сортировки
начало = time.time()
список1.sort(key=lambda x: тяжелая_функция(x) if x % 2 == 0 else x)
конец = time.time()
print(f"Прямой вызов: {конец - начало:.4f} сек")
# Подход 2: Предварительное вычисление ключей
начало = time.time()
ключи = {x: тяжелая_функция(x) if x % 2 == 0 else x for x in список2}
список2.sort(key=lambda x: ключи[x])
конец = time.time()
print(f"С кешированием: {конец - начало:.4f} сек") |
|
key выполняет сложные вычисления.
При оптимизации сортировки больших объемов данных стоит учесть следующие моменты:
1. Избегайте лишних сортировок — сортируйте данные только когда это действительно необходимо
2. Используйте .sort() вместо sorted(), если можно изменить исходные данные
3. Упрощайте функцию key — чем она проще, тем быстрее будет выполняться сортировка
4. Для частично отсортированных данных Timsort работает особенно эффективно
5. При работе с очень большими наборами данных рассмотрите использование специализированных библиотек, таких как NumPy или pandas
Для экстремально больших наборов, которые не помещаются в память, можно использовать внешнюю сортировку:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| def внешняя_сортировка(входной_файл, выходной_файл, размер_чанка=1000000):
# Разделяем большой файл на отсортированные чанки
чанки = []
with open(входной_файл, 'r') as f:
часть = []
for строка in f:
часть.append(int(строка.strip()))
if len(часть) >= размер_чанка:
часть.sort()
имя_чанка = f"chunk_{len(чанки)}.tmp"
with open(имя_чанка, 'w') as chunk_file:
for число in часть:
chunk_file.write(f"{число}\n")
чанки.append(имя_чанка)
часть = []
# Сортируем оставшиеся элементы
if часть:
часть.sort()
имя_чанка = f"chunk_{len(чанки)}.tmp"
with open(имя_чанка, 'w') as chunk_file:
for число in часть:
chunk_file.write(f"{число}\n")
чанки.append(имя_чанка)
# Слияние отсортированных чанков
# Здесь должен быть код для многопутевого слияния |
|
Типичные ошибки и их решения
При работе с сортировкой в Python разработчики нередко сталкиваются с рядом типичных ошибок и проблем. Знание этих подводных камней и способов их обхода помогает существенно сократить время отладки и повысить качество кода.
Неправильное использование возвращаемого значения
Пожалуй, самая распространенная ошибка связана с игнорированием разницы между возвращаемыми значениями sort() и sorted():
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| # Распространенная ошибка
список = [5, 2, 9, 1, 3]
отсортированный = список.sort() # отсортированный будет равен None!
print(отсортированный) # None
# Правильное использование
список = [5, 2, 9, 1, 3]
список.sort() # Изменяет список на месте
print(список) # [1, 2, 3, 5, 9]
# Или
список = [5, 2, 9, 1, 3]
отсортированный = sorted(список) # Создает новый список
print(отсортированный) # [1, 2, 3, 5, 9] |
|
Попытка сортировки неизменяемых типов данных
Многие разработчики пытаются использовать метод .sort() с кортежами или строками, забывая что этот метод доступен только для списков:
| Python | 1
2
3
4
5
6
7
8
| # Ошибка
кортеж = (5, 2, 9, 1, 3)
кортеж.sort() # AttributeError: 'tuple' object has no attribute 'sort'
# Правильное решение
кортеж = (5, 2, 9, 1, 3)
отсортированный = sorted(кортеж) # [1, 2, 3, 5, 9]
отсортированный_кортеж = tuple(sorted(кортеж)) # (1, 2, 3, 5, 9) |
|
Проблемы при сортировке списков с разнородными типами данных
Попытка отсортировать список, содержащий несовместимые типы данных, приводит к ошибке TypeError:
| Python | 1
2
3
4
5
6
7
| # Ошибка
смешанный_список = [5, "яблоко", 3.14, True]
try:
sorted(смешанный_список)
except TypeError as e:
print(f"Ошибка: {e}")
# Ошибка: '<' not supported between instances of 'str' and 'int' |
|
1. Разделить список на однородные части и сортировать их отдельно
2. Привести все элементы к одному типу (если возможно)
3. Использовать кастомную функцию key, которая обрабатывает разные типы:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| # Кастомная функция для сортировки разнотипных данных
def безопасный_ключ(элемент):
if isinstance(элемент, str):
return (1, элемент)
elif isinstance(элемент, (int, float)):
return (0, элемент)
elif isinstance(элемент, bool):
return (0, int(элемент))
else:
return (2, str(элемент)) # Для прочих типов
смешанный_список = [5, "яблоко", 3.14, True]
отсортированный = sorted(смешанный_список, key=безопасный_ключ)
print(отсортированный) # [True, 3.14, 5, 'яблоко'] |
|
Неправильная обработка None значений
Значения None в Python сравниваются особым образом: они считаются меньше любого другого типа, но не могут сравниваться через операторы сравнения с другими типами:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| # Проблема с None в списке
список_с_none = [5, None, 3, 10, None, 7]
# Это работает, потому что sorted() особым образом обрабатывает None
отсортированный = sorted(список_с_none) # [None, None, 3, 5, 7, 10]
# Но при использовании функции key может возникнуть проблема
try:
sorted(список_с_none, key=lambda x: x * 2)
except TypeError as e:
print(f"Ошибка: {e}")
# Ошибка: unsupported operand type(s) for *: 'NoneType' and 'int' |
|
None явно в функции key:
| Python | 1
2
3
4
5
6
7
8
9
| # Безопасная функция ключа для списка с None
def безопасный_ключ(x):
if x is None:
return float('-inf') # None будет считаться самым маленьким
return x
список_с_none = [5, None, 3, 10, None, 7]
отсортированный = sorted(список_с_none, key=безопасный_ключ)
print(отсортированный) # [None, None, 3, 5, 7, 10] |
|
None значения перед сортировкой:
| Python | 1
2
3
4
| список_с_none = [5, None, 3, 10, None, 7]
без_none = [x for x in список_с_none if x is not None]
отсортированный = sorted(без_none)
print(отсортированный) # [3, 5, 7, 10] |
|
Неэффективное использование функции key
Распространенная ошибка — использование ресурсоемкой функции key без учета того, что она вызывается для каждого элемента списка:
| Python | 1
2
3
4
| # Неэффективный подход
items = ["apple", "banana", "cherry", "date"]
# Предположим, что compute_score — ресурсоемкая функция
отсортированный = sorted(items, key=lambda x: compute_score(x)) |
|
| Python | 1
2
3
4
5
| items = ["apple", "banana", "cherry", "date"]
# Предварительно вычисляем ключи
key_values = {item: compute_score(item) for item in items}
# Используем предварительно вычисленные значения
отсортированный = sorted(items, key=lambda x: key_values[x]) |
|
Забывание о нестабильной сортировке при использовании ручных компараторов
До Python 2.2 метод .sort() использовал нестабильный алгоритм сортировки. В современном Python и .sort(), и sorted() используют стабильный алгоритм Timsort по умолчанию. Однако если вы переопределяете магические методы сравнения (__lt__, __gt__ и т.д.) в своих классах, не подразумевая транзитивность, вы можете столкнуться с проблемами:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| class НестабильныйОбъект:
def __init__(self, значение, группа):
self.значение = значение
self.группа = группа
def __lt__(self, другой):
# Нетранзитивное сравнение
if self.группа == другой.группа:
return self.значение < другой.значение
else:
# Здесь может быть нетранзитивная логика
return hash(self.группа) < hash(другой.группа)
def __repr__(self):
return f"[{self.группа}:{self.значение}]"
объекты = [
НестабильныйОбъект(3, "A"),
НестабильныйОбъект(1, "B"),
НестабильныйОбъект(2, "A"),
НестабильныйОбъект(4, "B")
]
# Может давать непредсказуемые результаты
print(sorted(объекты)) |
|
key вместо переопределения методов сравнения.
Неочевидное поведение при сортировке строк с числами
Сортировка списка строк, содержащих числа, часто приводит к неожиданным результатам:
| Python | 1
2
| версии = ["v1.0", "v2.0", "v10.0", "v1.1", "v1.10"]
print(sorted(версии)) # ['v1.0', 'v1.1', 'v1.10', 'v10.0', 'v2.0'] |
|
Для "естественной" сортировки версий лучше использовать специальную библиотеку или написать функцию разбора версий:
| Python | 1
2
3
4
5
6
7
| import re
def natural_key(строка):
return [int(c) if c.isdigit() else c.lower() for c in re.split(r'(\d+)', строка)]
версии = ["v1.0", "v2.0", "v10.0", "v1.1", "v1.10"]
print(sorted(версии, key=natural_key)) # ['v1.0', 'v1.1', 'v1.10', 'v2.0', 'v10.0'] |
|
natsort:
| Python | 1
2
3
| from natsort import natsorted
версии = ["v1.0", "v2.0", "v10.0", "v1.1", "v1.10"]
print(natsorted(версии)) # ['v1.0', 'v1.1', 'v1.10', 'v2.0', 'v10.0'] |
|
Проблемы с сортировкой объектов без установленного порядка сравнения
При попытке отсортировать список пользовательских объектов без определенных методов сравнения Python выдаст ошибку:
| Python | 1
2
3
4
5
6
7
8
9
10
11
| class Пользователь:
def __init__(self, имя, возраст):
self.имя = имя
self.возраст = возраст
пользователи = [Пользователь("Алексей", 30), Пользователь("Мария", 25)]
try:
sorted(пользователи)
except TypeError as e:
print(f"Ошибка: {e}")
# Ошибка: '<' not supported between instances of 'Пользователь' and 'Пользователь' |
|
1. Использовать функцию key:
| Python | 1
| отсортированные = sorted(пользователи, key=lambda x: x.возраст) |
|
| Python | 1
2
3
4
5
6
7
| class Пользователь:
def __init__(self, имя, возраст):
self.имя = имя
self.возраст = возраст
def __lt__(self, другой):
return self.возраст < другой.возраст |
|
Сортировка словарей и связанные с этим ошибки
Часто возникает путаница при сортировке словарей. По умолчанию sorted(dictionary) возвращает отсортированный список ключей:
| Python | 1
2
| словарь = {"c": 3, "a": 1, "b": 2}
print(sorted(словарь)) # ['a', 'b', 'c'] |
|
1. Ожидание, что результатом будет отсортированный словарь:
| Python | 1
2
| # Ошибка понимания
sorted_dict = sorted(словарь) # Это список ключей ['a', 'b', 'c'], а не словарь |
|
| Python | 1
2
| # До Python 3.7 это не гарантировало порядок
sorted_dict = {k: словарь[k] for k in sorted(словарь)} |
|
| Python | 1
2
| sorted_dict = dict(sorted(словарь.items()))
print(sorted_dict) # {'a': 1, 'b': 2, 'c': 3} |
|
| Python | 1
2
| sorted_by_value = dict(sorted(словарь.items(), key=lambda item: item[1]))
print(sorted_by_value) # {'a': 1, 'b': 2, 'c': 3} |
|
Непонимание, когда использовать обратную сортировку
Новички часто вручную реверсируют результаты сортировки, не зная о параметре reverse:
| Python | 1
2
3
4
5
6
7
| # Неэффективно и менее читаемо
числа = [5, 2, 9, 1]
отсортированные = sorted(числа)
reversed_sorted = отсортированные[::-1] # [9, 5, 2, 1]
# Правильный подход
отсортированные_по_убыванию = sorted(числа, reverse=True) # [9, 5, 2, 1] |
|
Диагностика проблем сортировки с неоднородными данными
Сортировка списков, содержащих разные типы данных, может привести к ошибкам сравнения. Python не знает, как сравнивать несопоставимые типы:
| Python | 1
2
3
4
5
6
| # Ошибка при попытке сортировки разнородных типов
смешанный_список = [1, "два", 3.5, True]
try:
sorted(смешанный_список)
except TypeError as e:
print(f"Ошибка: {e}") # Ошибка: '<' not supported between instances of 'str' and 'int' |
|
key:
| Python | 1
2
3
4
| # Преобразование всех элементов к строкам
смешанный_список = [1, "два", 3.5, True]
отсортированный = sorted(смешанный_список, key=str)
print(отсортированный) # [1, 3.5, True, 'два'] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Студент:
def __init__(self, имя, оценка):
self.имя = имя
self.оценка = оценка
студенты = [
Студент("Анна", 95),
Студент("Петр", 85),
Студент("Мария", 90)
]
try:
отсортированные = sorted(студенты)
except TypeError as e:
print(f"Ошибка: {e}") # Ошибка: '<' not supported between instances of 'Студент' and 'Студент' |
|
1. Использование параметра key:
| Python | 1
| отсортированные = sorted(студенты, key=lambda s: s.оценка) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Студент:
def __init__(self, имя, оценка):
self.имя = имя
self.оценка = оценка
def __lt__(self, other):
return self.оценка < other.оценка
def __repr__(self):
return f"{self.имя}: {self.оценка}"
студенты = [
Студент("Анна", 95),
Студент("Петр", 85),
Студент("Мария", 90)
]
отсортированные = sorted(студенты)
print(отсортированные) # [Петр: 85, Мария: 90, Анна: 95] |
|
Обработка None значений при сортировке коллекций
Особый случай представляют собой коллекции, содержащие значения None. Они требуют специальной обработки, поскольку None нельзя сравнивать с другими типами данных:
| Python | 1
2
3
4
5
6
| # Список с None значениями приведет к ошибке
список_с_none = [5, None, 3, 8, None, 1]
try:
sorted(список_с_none)
except TypeError as e:
print(f"Ошибка: {e}") # Ошибка: '<' not supported between instances of 'NoneType' and 'int' |
|
key, которая заменяет None на значение-заполнитель:
| Python | 1
2
3
4
5
6
7
8
| def сортировка_с_none(x):
if x is None:
return float('-inf') # None будет меньше всех чисел
return x
список_с_none = [5, None, 3, 8, None, 1]
отсортированный = sorted(список_с_none, key=сортировка_с_none)
print(отсортированный) # [None, None, 1, 3, 5, 8] |
|
None в конец списка:
| Python | 1
2
3
4
5
6
7
8
| def сортировка_с_none(x):
if x is None:
return float('inf') # None будет больше всех чисел
return x
список_с_none = [5, None, 3, 8, None, 1]
отсортированные = sorted(список_с_none, key=сортировка_с_none)
print(отсортированные) # [1, 3, 5, 8, None, None] |
|
None и не-None значений:
| Python | 1
2
3
| список_с_none = [5, None, 3, 8, None, 1]
отсортированные = sorted(список_с_none, key=lambda x: (x is None, x))
print(отсортированные) # [1, 3, 5, 8, None, None] |
|
x и y.
Когда вы работаете с словарями и хотите отсортировать по значениям, некоторые из которых могут быть None, вы можете применить аналогичный подход:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| данные = {
"A": 5,
"B": None,
"C": 3,
"D": 8,
"E": None,
"F": 1
}
# Сортировка ключей по их значениям, с None в конце
отсортированные_ключи = sorted(данные.keys(), key=lambda k: (данные[k] is None, данные[k]))
print(отсортированные_ключи) # ['F', 'C', 'A', 'D', 'B', 'E'] |
|
Измерение производительности сортировки на больших наборах данных
Когда дело доходит до работы с масштабными приложениями, понимание того, как различные алгоритмы сортировки ведут себя на больших объемах данных, становится критически важным. Неоптимальный выбор метода сортировки может превратить быстрое приложение в неприемлемо медленное.
Для объективной оценки производительности сортировки можно использовать модуль timeit, который позволяет измерять время выполнения небольших фрагментов кода с высокой точностью:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| import timeit
import random
def тест_производительности(размер_списка, количество_тестов=5):
# Создаем и сохраняем случайный список для повторного использования
случайный_список = [random.randint(1, 1000000) for _ in range(размер_списка)]
# Измеряем время для sorted()
время_sorted = timeit.timeit(
lambda: sorted(случайный_список.copy()),
number=количество_тестов
) / количество_тестов
# Измеряем время для .sort()
время_sort = timeit.timeit(
lambda: случайный_список.copy().sort(),
number=количество_тестов
) / количество_тестов
print(f"Размер списка: {размер_списка:,}")
print(f"Среднее время sorted(): {время_sorted:.6f} сек")
print(f"Среднее время .sort(): {время_sort:.6f} сек")
print(f"Отношение sorted()/.sort(): {время_sorted/время_sort:.2f}x\n")
# Тестирование на списках разного размера
for размер in [10000, 100000, 1000000]:
тест_производительности(размер) |
|
sorted() и .sort() становится всё заметнее по мере увеличения размера данных, причем .sort() обычно показывает преимущество за счёт отсутствия накладных расходов на создание нового списка.
При оценке производительности важно учитывать не только общее время сортировки, но и характер данных. Алгоритм Timsort, используемый в Python, особенно эффективен в ситуациях, когда исходные данные уже частично упорядочены:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| def тест_частичной_упорядоченности(размер_списка=100000):
# Создаем полностью случайный список
случайный_список = [random.randint(1, 1000000) for _ in range(размер_списка)]
# Создаем частично упорядоченный список (50% отсортировано)
частично_упорядоченный = sorted(случайный_список[:размер_списка//2]) + \
[random.randint(1, 1000000) for _ in range(размер_списка//2)]
# Измеряем время для полностью случайного списка
время_случайный = timeit.timeit(
lambda: sorted(случайный_список.copy()),
number=5
) / 5
# Измеряем время для частично упорядоченного списка
время_частичный = timeit.timeit(
lambda: sorted(частично_упорядоченный.copy()),
number=5
) / 5
print("Влияние частичной упорядоченности на производительность:")
print(f"Время для случайного списка: {время_случайный:.6f} сек")
print(f"Время для частично упорядоченного: {время_частичный:.6f} сек")
print(f"Ускорение: {время_случайный/время_частичный:.2f}x\n")
тест_частичной_упорядоченности() |
|
key на производительность сортировки можно создать тест, сравнивающий простой и сложные ключи:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| def тест_влияния_ключа(размер_списка=50000):
# Создаем список кортежей (id, name, score)
данные = [(i, f"Имя_{i}", random.randint(50, 100))
for i in range(размер_списка)]
# Простая сортировка без ключа
время_без_ключа = timeit.timeit(
lambda: sorted(данные),
number=3
) / 3
# Сортировка с простым ключом (по третьему элементу)
время_простой_ключ = timeit.timeit(
lambda: sorted(данные, key=lambda x: x[2]),
number=3
) / 3
# Сортировка со сложным ключом (множественные операции)
время_сложный_ключ = timeit.timeit(
lambda: sorted(данные, key=lambda x: (x[2] % 10, len(str(x[0])), x[1][::-1])),
number=3
) / 3
print("Влияние сложности ключа на производительность:")
print(f"Без ключа: {время_без_ключа:.6f} сек")
print(f"Простой ключ: {время_простой_ключ:.6f} сек")
print(f"Сложный ключ: {время_сложный_ключ:.6f} сек")
print(f"Отношение (сложный/без ключа): {время_сложный_ключ/время_без_ключа:.2f}x\n")
тест_влияния_ключа() |
|
Оптимизация памяти при сортировке в ограниченных ресурсах
Обработка особо крупных наборов данных требует внимания не только к скорости работы, но и к расходу памяти. Когда данные не помещаются целиком в оперативную память, приходится прибегать к внешней сортировке и другим специализированным подходам.
Простейший способ уменьшить потребление памяти — использовать .sort() вместо sorted() там, где это возможно:
| Python | 1
2
3
4
5
6
7
8
9
| # Экономия памяти при использовании .sort()
большой_список = [random.randint(1, 1000) for _ in range(10000000)]
# Этот подход создаст копию списка, потребляя вдвое больше памяти
[H2]отсортированный = sorted(большой_список)[/H2]
# Более эффективный подход с точки зрения памяти
большой_список.sort()
отсортированный = большой_список # Теперь это один и тот же объект |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| def сортировка_файла(входной_файл, выходной_файл, размер_буфера=100000):
"""Сортировка файла с числами с минимальными требованиями к памяти"""
# Чтение и сортировка частями
временные_файлы = []
with open(входной_файл, 'r') as f:
буфер = []
for строка in f:
буфер.append(int(строка.strip()))
if len(буфер) >= размер_буфера:
буфер.sort()
tmp_имя = f"tmp_{len(временные_файлы)}.txt"
with open(tmp_имя, 'w') as tmp:
for число in буфер:
tmp.write(f"{число}\n")
временные_файлы.append(tmp_имя)
буфер = []
# Обработка оставшихся элементов
if буфер:
буфер.sort()
tmp_имя = f"tmp_{len(временные_файлы)}.txt"
with open(tmp_имя, 'w') as tmp:
for число in буфер:
tmp.write(f"{число}\n")
временные_файлы.append(tmp_имя)
# Слияние временных файлов
with open(выходной_файл, 'w') as выход:
# Открываем все временные файлы
файлы = [open(имя, 'r') for имя in временные_файлы]
текущие_значения = []
# Читаем первое число из каждого файла
for f in файлы:
строка = f.readline().strip()
if строка:
текущие_значения.append((int(строка), f))
# Начинаем слияние
while текущие_значения:
# Находим минимальное значение
мин_значение, мин_файл = min(текущие_значения, key=lambda x: x[0])
выход.write(f"{мин_значение}\n")
# Читаем следующее число из того же файла
строка = мин_файл.readline().strip()
# Обновляем значение в куче или удаляем
индекс = текущие_значения.index((мин_значение, мин_файл))
if строка:
текущие_значения[индекс] = (int(строка), мин_файл)
else:
текущие_значения.pop(индекс)
# Закрываем файлы и удаляем временные
for f in файлы:
f.close()
import os
for имя in временные_файлы:
os.remove(имя) |
|
Интересной альтернативой стандартной сортировке для больших массивов однотипных данных является использование специализированных библиотек как NumPy, которые могут быть значительно эффективнее при работе с числовыми данными:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| import numpy as np
import timeit
def сравнение_с_numpy(размер=1000000):
# Создаем случайные данные
python_list = [random.random() for _ in range(размер)]
numpy_array = np.array(python_list)
# Измеряем время сортировки Python-списка
время_python = timeit.timeit(
lambda: sorted(python_list),
number=3
) / 3
# Измеряем время сортировки NumPy-массива
время_numpy = timeit.timeit(
lambda: np.sort(numpy_array),
number=3
) / 3
print(f"Сортировка {размер:,} чисел:")
print(f"Python sorted(): {время_python:.4f} сек")
print(f"NumPy sort(): {время_numpy:.4f} сек")
print(f"Ускорение с NumPy: {время_python/время_numpy:.2f}x")
сравнение_с_numpy() |
|
Профилирование для выбора оптимального метода
Когда речь идёт о критически важном коде, не полагайтесь исключительно на теоретические знания — проводите профилирование. Это позволит сделать обоснованный выбор, учитывающий особенности конкретных данных:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| import cProfile
import random
def тест_сортировки(размер=100000):
данные = [random.random() for _ in range(размер)]
# Тестирование sorted()
def использовать_sorted():
return sorted(данные)
# Тестирование .sort()
def использовать_sort():
копия = данные.copy()
копия.sort()
return копия
# Профилирование
print("Профилирование sorted():")
cProfile.run("использовать_sorted()")
print("\nПрофилирование .sort():")
cProfile.run("использовать_sort()")
# тест_сортировки() # Раскомментируйте для запуска |
|
Оптимизация сортировки в реальных проектах
При работе над реальными проектами стоит учитывать несколько практических аспектов:
1. Частичная сортировка: Если нужны только N первых или последних элементов отсортированного списка, можно использовать модуль heapq:
| Python | 1
2
3
4
5
6
7
8
9
10
| import heapq
# Получить N наименьших элементов
данные = [5, 2, 8, 1, 9, 3, 7]
n_наименьших = heapq.nsmallest(3, данные)
print(n_наименьших) # [1, 2, 3]
# Получить N наибольших элементов
n_наибольших = heapq.nlargest(2, данные)
print(n_наибольших) # [9, 8] |
|
2. Кеширование ключей сортировки: Если функция вычисления ключа ресурсоемкая, а данные не меняются, можно закешировать результаты:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from functools import lru_cache
# Ресурсоёмкая функция для вычисления ключа сортировки
@lru_cache(maxsize=None)
def сложное_вычисление(значение):
# Имитация сложных вычислений
import time
time.sleep(0.001) # На реальных данных здесь будут вычисления
return sum(int(цифра) for цифра в str(значение))
# Использование кешированной функции для сортировки
числа = [123, 456, 789, 101, 202, 303]
отсортированные = sorted(числа, key=сложное_вычисление)
print(отсортированные) # [101, 202, 303, 123, 456, 789] |
|
@lru_cache кеширует результаты функции, что особено полезно при многократной сортировке одних и тех же данных с одинаковой функцией ключа.
3. Избегайте избыточной сортировки: Иногда можно избежать повторной сортировки, запомнив порядок:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| # Предположим, у нас есть список объектов с несколькими атрибутами
class Продукт:
def __init__(self, название, цена, рейтинг):
self.название = название
self.цена = цена
self.рейтинг = рейтинг
def __repr__(self):
return f"{self.название} (₽{self.цена}, ★{self.рейтинг})"
продукты = [
Продукт("Чайник", 1200, 4.2),
Продукт("Тостер", 900, 3.8),
Продукт("Миксер", 1500, 4.5),
Продукт("Блендер", 2000, 4.0)
]
# Вместо многократной сортировки по разным критериям
from operator import attrgetter
# Запоминаем порядок индексов после каждой сортировки
порядок_по_цене = [i for i, _ in sorted(enumerate(продукты), key=lambda x: x[1].цена)]
порядок_по_рейтингу = [i for i, _ in sorted(enumerate(продукты), key=lambda x: x[1].рейтинг, reverse=True)]
print("По возрастанию цены:")
for индекс in порядок_по_цене:
print(f" {продукты[индекс]}")
print("\nПо убыванию рейтинга:")
for индекс in порядок_по_рейтингу:
print(f" {продукты[индекс]}") |
|
Работа со специфическими типами данных
Разные типы данных требуют разного подхода к сортировке:
1. Пользовательские объекты: При частой сортировке пользовательских объектов по одному критерию, реализуйте методы __lt__, __gt__ и другие:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| class ВерсияПрограммы:
def __init__(self, версия_строка):
self.версия_строка = версия_строка
# Разбиваем "1.2.3" на [1, 2, 3]
self.компоненты = [int(x) for x в версия_строка.split('.')]
def __lt__(self, other):
return self.компоненты < other.компоненты
def __repr__(self):
return self.версия_строка
версии = [
ВерсияПрограммы("1.10.0"),
ВерсияПрограммы("1.5.1"),
ВерсияПрограммы("2.0.0"),
ВерсияПрограммы("0.9.9")
]
версии.sort() # Использует определённый метод __lt__
print(версии) # [0.9.9, 1.5.1, 1.10.0, 2.0.0] |
|
key.
2. Словари и JSON-данные: При работе с вложенными структурами используйте lambda-функции с доступом к глубоким уровням вложенности:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| данные = [
{"имя": "Алиса", "профиль": {"возраст": 30, "статус": "активен"}},
{"имя": "Борис", "профиль": {"возраст": 25, "статус": "отключен"}},
{"имя": "Вера", "профиль": {"возраст": 30, "статус": "активен"}}
]
# Сортировка по вложенному полю с обработкой возможных отсутствующих значений
отсортированные = sorted(
данные,
key=lambda x: (
x.get("профиль", {}).get("статус", ""), # Сначала по статусу
x.get("профиль", {}).get("возраст", 0), # Затем по возрасту
x.get("имя", "") # Наконец по имени
)
)
for запись in отсортированные:
print(f"{запись['имя']}: {запись['профиль']}") |
|
.get() с значением по умолчанию обеспечивает устойчивость кода к ошибкам при отсутствии ключей.
Интеграция с другими инструментами
Для повышения производительности при работе с большими наборами данных рассмотрите интеграцию с библиотеками для обработки данных:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| import pandas as pd
import numpy as np
# Создаем DataFrame
df = pd.DataFrame({
'Имя': ['Алексей', 'Борис', 'Василий', 'Галина'],
'Возраст': [32, 45, 28, 39],
'Зарплата': [85000, 120000, 70000, 95000]
})
# Сортировка с использованием pandas
отсортированный_df = df.sort_values(['Возраст', 'Зарплата'], ascending=[True, False])
print(отсортированный_df)
# Для числовых данных numpy может быть эффективнее
числовые_данные = np.array([5, 2, 8, 1, 9, 3])
отсортированный_массив = np.sort(числовые_данные)
print(отсортированный_массив) # [1 2 3 5 8 9] |
|
pandas и numpy используют оптимизированные алгоритмы сортировки, написанные на C, что обеспечивает превосходную производительность для больших наборов данных.
Сортировка .sort
Здравствуйте, подскажите пожалуйста как отсортировать числа в порядке возрастания
a = input("Введите все значения").split()
a.sort() ... Зачем python нужен? Работу всё-равно не найти: вот некоторый обзор требований
Ищем Python программиста в связи с расширением штата разработчиков. Проект связан с автоматизацией маркетинга (анализ поведения пользователя, Machine... Сортировка слиянием (Merge sort)
Пытаюсь реализовать сортировку слиянием на python(без рекурсии, чтоб не запутаться). Вопрос: Как сделать мой код более правильным алгоритмически?... Функция Sort(). Сортировка по заданным параметрам
Как можно задать sort() так, что бы он сортировал 3 входных числа так: Первое - самое большое, второе - самое маленькое, третье - среднее. Быстрая сортировка (quick sort) НЕ через рекурсию
Добрый день, переписал алгоритм быстрой сортировки с wiki, переделал под свою задачу, на малом количестве чисел работает, при более 991 (всего около... WAT Update (KB971033): подробный обзор
В блоге американского журналиста Эда Ботта есть интересная статья, в которой он подробно описывает антипиратское обновление WAT для Семерки. Статья... Сортировка двумерного массива Quick Sort и Selection Sort
В чем состоит задание . Отсортировать двумерный массив не переделывая его в одномерный. Те мы НЕ можем взять и последовательно переписать элементы в... Сортировка методом выбора в си (Selection Sort) / Сортировка структуры
Нужна помощь.
Нужно сделать сортировку на диске методом выбора.
Можно переделать готовую функцию но только она сортирует методом shell
void... Пирамидальная сортировка. Сортировка кучей, Heap Sort O(n + k log k)
Здравствуйте,
у меня есть отсортированный по возрастанию массив с n числами в котором неизвестных k чисел увеличивают на несколько неизвестных... Отсортировать массив методами Bubble Sort, Selection Sort и Insertion Sort
Дан одномерный массив из 10 целых чисел. Заполните массив автоматически случайными числами (используя функцию rand) и отсортируйте его методами... q-sort сортировка
Здраствуйте , не могу понять где в коде ошибка .
Выдает такое :d:\program... Сортировка Array.Sort
Я новичок, поэтому объясните как можно более прозрачно.
У меня есть массив, который сохраняет название хоккейных команд, в этом массиве хранятся...
|
