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

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

Это важный вопрос, потому что обе функции сортируют данные в Python, но решают разные задачи и имеют разные характеристики.

sort() — метод списка

sort() — это метод, который работает только со списками и сортирует их на месте (in-place).

# sort() сортирует на месте
my_list = [3, 1, 4, 1, 5]
result = my_list.sort()  # Возвращает None!

print(my_list)  # [1, 1, 3, 4, 5] — исходный список изменился
print(result)   # None

Характеристики:

• Работает только со списками (list.sort())
• Возвращает None (не возвращает новый список)
• Сортирует на месте (не требует дополнительной памяти)
• Более эффективно по памяти (O(1) extra space в худшем случае)
• Быстрее для больших данных (нет копирования)

# Правильное использование sort()
numbers = [5, 2, 8, 1, 9]
numbers.sort()  # Сортируем на месте
print(numbers)  # [1, 2, 5, 8, 9]

# С параметрами
numbers.sort(reverse=True)  # От большего к меньшему
numbers.sort(key=lambda x: -x)  # По абсолютному значению

sorted() — встроенная функция

sorted() — это встроенная функция, которая работает с любыми итерируемыми объектами и возвращает новый отсортированный список.

# sorted() возвращает новый список
my_list = [3, 1, 4, 1, 5]
result = sorted(my_list)  # Возвращает новый список

print(my_list)  # [3, 1, 4, 1, 5] — исходный список не изменился
print(result)   # [1, 1, 3, 4, 5] — новый отсортированный список

Характеристики:

• Работает с любыми итерируемыми объектами (список, кортеж, строка, словарь и т.д.)
• Возвращает новый список (исходные данные не меняются)
• Требует дополнительную память (O(n) extra space)
• Медленнее на больших данных (нужно копирование)
• Безопаснее (не меняет исходные данные)

# sorted() работает с любыми итерируемыми объектами
numbers = (5, 2, 8, 1, 9)  # Кортеж
result = sorted(numbers)
print(result)  # [1, 2, 5, 8, 9] — список!

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

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

result = sorted(dictionary.values())  # Сортирует значения
print(result)  # [1, 2, 3]

Сравнение

Практические примеры

sort() для оптимизации памяти:

import numpy as np

# У нас есть миллион чисел
large_list = list(np.random.rand(1000000))

# Если использовать sorted():
# - Создаём копию (1M чисел в памяти)
# - Сортируем копию
# - Память: 2M чисел!

sorted_data = sorted(large_list)  # Требует 2 миллиона элементов в памяти

# Если использовать sort():
# - Сортируем на месте
# - Память: 1M чисел!

large_list.sort()  # Требует только 1 миллион элементов в памяти

sorted() для безопасности:

# Плохо: sort() меняет исходный список
users_by_age = [("Alice", 25), ("Bob", 30), ("Charlie", 20)]
users_by_age.sort(key=lambda x: x[1])

# Теперь исходный порядок потерян!
print(users_by_age)  # [("Charlie", 20), ("Alice", 25), ("Bob", 30)]

# Хорошо: sorted() сохраняет исходный список
users = [("Alice", 25), ("Bob", 30), ("Charlie", 20)]
users_by_age = sorted(users, key=lambda x: x[1])

print(users)          # [("Alice", 25), ("Bob", 30), ("Charlie", 20)] — не изменился
print(users_by_age)   # [("Charlie", 20), ("Alice", 25), ("Bob", 30)] — новый список

sorted() с разными типами данных:

# Работаем с DataFrames в pandas
import pandas as pd

df = pd.DataFrame({'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 20]})

# sort() не работает с DataFrames
# df.sort()  # AttributeError!

# Используем sorted()
sorted_ages = sorted(df['age'])
print(sorted_ages)  # [20, 25, 30]

# Или специальный метод DataFrame
df_sorted = df.sort_values('age')

Стабильность сортировки

Обе функции используют Timsort (стабильная сортировка), что означает, что элементы с одинаковыми ключами сохраняют исходный порядок:

data = [("Alice", 25), ("Bob", 25), ("Charlie", 25)]

# sorted сохраняет исходный порядок для элементов с одинаковыми ключами
result = sorted(data, key=lambda x: x[1])
print(result)  # [("Alice", 25), ("Bob", 25), ("Charlie", 25)] — порядок сохранён

# sort также стабильна
data.sort(key=lambda x: x[1])
print(data)  # [("Alice", 25), ("Bob", 25), ("Charlie", 25)] — порядок сохранён

Выводы

• Используй sort(), когда:

  • Работаешь со списками
  • Нужна максимальная производительность
  • Не жаль менять исходные данные
  • Работаешь с миллионами элементов

• Используй sorted(), когда:

  • Нужно работать с разными типами данных
  • Нужно сохранить исходные данные
  • Хочешь цепочку операций (functional style)
  • Код должен быть безопасным

# Функциональный стиль с sorted()
result = sorted(
    filter(lambda x: x > 5, data),
    key=lambda x: -x,
    reverse=False
)