В чем разница между sort и sorted?

# sort() vs sorted() в Python

Основные различия

1. Тип возврата

sort() — это метод списка, который изменяет список на месте и возвращает None

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()  # Изменяет исходный список
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]
print(numbers.sort())  # None — ничего не возвращает

sorted() — это встроенная функция, которая возвращает новый отсортированный список, не изменяя исходный

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)  # Новый список
print(sorted_numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]
print(numbers)  # [3, 1, 4, 1, 5, 9, 2, 6] — не изменился!

2. Объекты, к которым применяются

sort() — только для списков

numbers = [3, 1, 4]
numbers.sort()  # OK

tuple_nums = (3, 1, 4)
tuple_nums.sort()  # ❌ AttributeError: 'tuple' object has no attribute 'sort'

sorted() — для любых итерируемых объектов (списки, кортежи, словари, строки, множества и т.д.)

# Список
print(sorted([3, 1, 4]))  # [1, 3, 4]

# Кортеж
print(sorted((3, 1, 4)))  # [1, 3, 4]

# Строка
print(sorted("hello"))  # ['e', 'h', 'l', 'l', 'o']

# Множество
print(sorted({3, 1, 4}))  # [1, 3, 4]

# Словарь (сортирует ключи)
print(sorted({'c': 3, 'a': 1, 'b': 2}))  # ['a', 'b', 'c']

# Диапазон
print(sorted(range(5, 0, -1)))  # [1, 2, 3, 4, 5]

3. Производительность

sort() обычно быстрее, так как работает на месте (in-place)

import timeit

# Большой список для тестирования
big_list = list(range(10000, 0, -1))

# sort() — изменяет исходный список
time_sort = timeit.timeit(
    lambda: big_list.copy().sort(), 
    number=1000
)
print(f"sort(): {time_sort:.4f} sec")

# sorted() — создаёт новый список
time_sorted = timeit.timeit(
    lambda: sorted(big_list), 
    number=1000
)
print(f"sorted(): {time_sorted:.4f} sec")

# Результат: sort() обычно на 10-20% быстрее на больших данных

sorted() может быть медленнее из-за создания нового объекта, но разница незначительна для большинства задач.

4. Параметры

Оба поддерживают параметры key и reverse:

students = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78},
]

# sort() с параметрами
students.sort(key=lambda x: x['score'], reverse=True)
print(students)
# [{'name': 'Bob', 'score': 92}, {'name': 'Alice', 'score': 85}, {'name': 'Charlie', 'score': 78}]

# sorted() с параметрами
students2 = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78},
]
sorted_students = sorted(students2, key=lambda x: x['score'], reverse=True)
print(sorted_students)
# [{'name': 'Bob', 'score': 92}, {'name': 'Alice', 'score': 85}, {'name': 'Charlie', 'score': 78}]
print(students2)  # Исходный список не изменился

Таблица сравнения

Когда использовать что

Используй sort(), если:

• Нужно отсортировать список на месте
• Производительность критична (мало памяти, очень большой список)
• Не нужен исходный неотсортированный список

data = [5, 2, 8, 1, 9]
data.sort()  # Изменяет data
print(data)  # [1, 2, 5, 8, 9]

Используй sorted(), если:

• Нужно оставить исходный список неизменным
• Нужно сортировать не-списковые объекты (кортежи, строки и т.д.)
• Нужно передать отсортированный результат в другой код
• Нужна читаемость (функция явно показывает, что создаётся новый объект)

data = [5, 2, 8, 1, 9]
sorted_data = sorted(data)  # Не изменяет data
print(data)  # [5, 2, 8, 1, 9] — как было
print(sorted_data)  # [1, 2, 5, 8, 9]

# Сортировка кортежа
tuple_data = (5, 2, 8, 1, 9)
sorted_tuple = sorted(tuple_data)  # Работает!
print(sorted_tuple)  # [1, 2, 5, 8, 9]

Примеры практического использования

# Пример 1: Сортировка объектов сложного типа
from datetime import datetime

class Event:
    def __init__(self, name: str, date: datetime):
        self.name = name
        self.date = date

events = [
    Event("Meeting", datetime(2026, 3, 25)),
    Event("Deadline", datetime(2026, 3, 20)),
    Event("Review", datetime(2026, 3, 22)),
]

# Сортируем по дате (исходный список не меняется)
sorted_events = sorted(events, key=lambda e: e.date)
for event in sorted_events:
    print(f"{event.name}: {event.date.strftime('%Y-%m-%d')}")

# Пример 2: Сортировка со стабильностью
data = [("Alice", 85), ("Bob", 85), ("Charlie", 78)]

# sorted() гарантирует стабильность — порядок одинаковых элементов сохраняется
sorted_by_score = sorted(data, key=lambda x: x[1], reverse=True)
print(sorted_by_score)  # Alice будет раньше Bob, так как был раньше в исходном

# Пример 3: Цепочка сортировок
students = [
    {"name": "Alice", "grade": "A", "score": 85},
    {"name": "Bob", "grade": "A", "score": 92},
    {"name": "Charlie", "grade": "B", "score": 78},
]

# Сортируем по grade, потом по score (используем стабильность)
students_by_grade = sorted(students, key=lambda x: x['grade'])
final = sorted(students_by_grade, key=lambda x: x['score'], reverse=True)
print(final)

Заключение

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

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

В 90% случаев sorted() предпочтительнее** из-за универсальности и явности кода.