Содержание
Реверс и сортировка списка в Python: полное руководство
Черновик готовит редакция с помощью ИИ. За стандарт издания отвечает главный редактор — Валерий Курземнек.
Чтобы перевернуть список в Python, есть три способа. Метод list.reverse() разворачивает список на месте и возвращает None. Функция reversed() отдаёт итератор в обратном порядке. Срез [::-1] создаёт новый перевёрнутый список, не трогая оригинал. Выбор зависит от того, нужен ли вам исходный список нетронутым.
my_list = [1, 2, 3, 4, 5]
# 1. На месте: меняет оригинал, возвращает None
my_list.reverse()
print(my_list) # [5, 4, 3, 2, 1]
# 2. Итератор: ничего не копирует до материализации
print(list(reversed(my_list))) # [1, 2, 3, 4, 5]
# 3. Срез: новый список, оригинал не меняется
print(my_list[::-1]) # [1, 2, 3, 4, 5]Три способа перевернуть список в Python
Разворот списка — базовая операция при обработке данных, работе с очередями и алгоритмах. Python предлагает три инструмента, и разница между ними принципиальна: одни меняют исходный объект, другие возвращают новый. Понимание этой разницы избавляет от труднонаходимых багов, когда переменная неожиданно оказывается изменённой.
Метод list.reverse() — разворот на месте
Метод reverse() изменяет список in-place: он переставляет элементы внутри того же объекта и возвращает None. Это его главная особенность и одновременно частый источник ошибок — присваивать результат нельзя.
data = [10, 20, 30]
result = data.reverse() # ОШИБКА логики
print(result) # None
print(data) # [30, 20, 10] — оригинал уже изменёнВнутри метод меняет местами i-й и (n−i)-й элементы, выполняя примерно n/2 перестановок. Дополнительная память не выделяется, поэтому это самый экономный по памяти вариант.
Функция reversed() — ленивый итератор
Встроенная функция reversed() не разворачивает список и не создаёт его копию. Она возвращает итератор (list_reverseiterator), который отдаёт элементы в обратном порядке по мере обхода. Это идеально для циклов, где полный перевёрнутый список не нужен.
data = [1, 2, 3]
for x in reversed(data):
print(x) # 3, затем 2, затем 1
# Если нужен именно список — материализуйте итератор
reversed_list = list(reversed(data))
print(reversed_list) # [3, 2, 1]
print(data) # [1, 2, 3] — оригинал не тронутСоздание итератора почти мгновенно и не зависит от размера списка — расход памяти на сам итератор постоянный. Элементы вычисляются только при обходе.
Срез [::-1] — новый перевёрнутый список
Синтаксис среза [start:stop:step] с шагом -1 создаёт новый список, являющийся перевёрнутой копией. Оригинал остаётся неизменным. Это самый компактный по записи способ, когда нужен именно новый объект.
data = [1, 2, 3, 4, 5]
reversed_copy = data[::-1]
print(reversed_copy) # [5, 4, 3, 2, 1]
print(data) # [1, 2, 3, 4, 5] — не изменёнСрез сразу выделяет новый список из n элементов, поэтому по памяти он дороже, чем reverse() или reversed(). Зато он читается однозначно и работает не только со списками, но и со строками и кортежами.
Сравнительная таблица методов реверса и сортировки
Ключевой вопрос при выборе инструмента: меняет ли он исходный объект (in-place) и что возвращает. Ниже сводка по всем встроенным способам.
| Метод / приём | Меняет оригинал (in-place)? | Что возвращает |
|---|---|---|
list.reverse() |
Да | None |
reversed(seq) |
Нет | итератор (обратный обход) |
seq[::-1] |
Нет | новый список / строку / кортеж |
list.sort() |
Да | None |
sorted(iterable) |
Нет | новый отсортированный список |
Правило простое: методы объекта (.reverse(), .sort()) работают на месте и возвращают None; встроенные функции (reversed(), sorted()) не трогают исходные данные и возвращают новый результат. Подробнее о самих структурах данных — в руководстве по работе со списками в Python.
Сортировка списка: sort() и sorted()
Сортировка упорядочивает элементы по возрастанию (по умолчанию) или убыванию. Как и с реверсом, есть метод, меняющий список на месте, и функция, возвращающая новый список.
Метод list.sort() — сортировка на месте
nums = [5, 3, 1, 4, 2]
nums.sort()
print(nums) # [1, 2, 3, 4, 5], метод вернул None
nums.sort(reverse=True)
print(nums) # [5, 4, 3, 2, 1]Функция sorted() — новый отсортированный список
Функция sorted() принимает любой итерируемый объект (список, кортеж, строку, множество) и возвращает новый отсортированный список, не изменяя источник.
nums = [5, 3, 1, 4, 2]
ordered = sorted(nums)
print(ordered) # [1, 2, 3, 4, 5]
print(nums) # [5, 3, 1, 4, 2] — не изменён
print(sorted(nums, reverse=True)) # [5, 4, 3, 2, 1]Параметры key и reverse
Аргумент reverse=True задаёт убывающий порядок. Аргумент key принимает функцию, по значению которой сравниваются элементы — так сортируют по длине, по полю словаря, без учёта регистра и т. д.
words = ["banana", "kiwi", "apple", "fig"]
# По длине слова
print(sorted(words, key=len)) # ['fig', 'kiwi', 'apple', 'banana']
# По алфавиту без учёта регистра, по убыванию
print(sorted(words, key=str.lower, reverse=True))
# Сортировка словарей по полю
users = [{"name": "Иван", "age": 30}, {"name": "Анна", "age": 25}]
print(sorted(users, key=lambda u: u["age"]))Сортировка в Python стабильна: элементы с равными ключами сохраняют относительный порядок. Это позволяет сортировать по нескольким критериям последовательными вызовами. Практический пример сортировки на уровне API — в статье про пагинацию и сортировку в FastAPI.
Реверс строк и кортежей
Строки и кортежи в Python неизменяемы (immutable), поэтому у них нет методов .reverse() или .sort(). Развернуть их можно срезом [::-1] или через reversed().
# Строка
text = "Python"
print(text[::-1]) # 'nohtyP'
print("".join(reversed(text))) # 'nohtyP'
# Кортеж
t = (1, 2, 3, 4)
print(t[::-1]) # (4, 3, 2, 1)
print(tuple(reversed(t))) # (4, 3, 2, 1)Для строк reversed() отдаёт итератор символов, который нужно собрать обратно через "".join(...). Разницу между изменяемыми списками и неизменяемыми кортежами разбираем отдельно в материале о списках и кортежах.
Сложность и производительность
Все три способа реверса линейны по времени — O(n), но отличаются по памяти и моменту вычисления:
- list.reverse() — время O(n), память O(1). Работает на месте, ничего не копирует.
- reversed() — создание итератора O(1), обход O(n). Память на итератор постоянна; список формируется только при
list(...). - [::-1] — время O(n), память O(n): сразу выделяется новый список.
Сортировка (sort() и sorted()) использует алгоритм Timsort со сложностью O(n·log n). Практический вывод: если исходный список менять нельзя, берите reversed() для обхода и [::-1]/sorted() когда нужен новый объект; если оригинал не важен и важна память — reverse() и sort().
Комбинирование реверса и сортировки
Нередко нужно отсортировать список, а затем развернуть его. Убывающий порядок достигается напрямую параметром reverse=True — это чище, чем сортировать и потом отдельно разворачивать.
names = ["Alice", "Bob", "Charlie", "Dave"]
# Два шага: сортировка + реверс на месте
names.sort()
names.reverse()
print(names) # ['Dave', 'Charlie', 'Bob', 'Alice']
# Один шаг — предпочтительно
print(sorted(names, reverse=True))
Официальное описание методов и параметров сортировки — в документации Python.
Частые ошибки
- Присваивание результата in-place методов.
x = my_list.reverse()запишет вxзначениеNone, а не перевёрнутый список. - Ожидание списка от reversed(). Функция возвращает итератор — оберните его в
list(), если нужен список. - Попытка вызвать .reverse() у строки или кортежа. Они неизменяемы; используйте срез
[::-1]. - Повторный обход итератора reversed(). Итератор исчерпывается после первого прохода — для второго обхода создайте его заново.
Часто задаваемые вопросы
Чем reversed() отличается от reverse()?
list.reverse() — метод, который меняет исходный список на месте и возвращает None. reversed() — встроенная функция, которая не меняет оригинал и возвращает итератор для обхода в обратном порядке.
Как перевернуть список, не меняя оригинал?
Используйте срез new = old[::-1] или new = list(reversed(old)). Оба варианта создают новый список, оставляя исходный нетронутым.
Почему my_list.reverse() возвращает None?
Потому что это операция на месте: она изменяет сам список, а по соглашению Python такие методы возвращают None. Результат уже находится в исходной переменной.
Как отсортировать список по убыванию?
Передайте reverse=True: my_list.sort(reverse=True) для изменения на месте или sorted(my_list, reverse=True) для нового списка.
Можно ли развернуть строку методом reverse()?
Нет, строки неизменяемы и не имеют метода reverse(). Разворачивайте строку срезом s[::-1] или через "".join(reversed(s)).
Заключение
Для реверса списка в Python выбирайте по задаче: reverse() — когда оригинал можно менять и важна память; reversed() — для обхода в обратном порядке без копирования; [::-1] — когда нужен новый перевёрнутый список, в том числе для строк и кортежей. Сортировка устроена симметрично: sort() меняет список на месте, sorted() возвращает новый. Разделение на «меняет оригинал / возвращает новый» — ключ к предсказуемому и безопасному коду.