Как перевернуть список или массив в Python

TL;DR

Кратко: в Python есть несколько простых способов перевернуть список — срезы, list.reverse(), встроенная функция reversed(), list comprehension и явный цикл. Выбирайте метод по требованиям: нужно ли сохранять исходный список, читаемость или вставлять дополнительную логику при перевороте.

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

Быстрый обзор методов

• Срез (slice): languages[::-1]
• Метод списка in-place: list.reverse()
• Встроенная функция: reversed()
• List comprehension с range()
• Явный for‑цикл и сбор в новый список

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

1. Создать копию с помощью for цикла

Когда нужен самый явный контроль над процессом (например, вставлять дополнительную логику при каждом шаге), используйте обычный цикл и формируйте новый список.

Пример — переворот списка целых чисел от 1 до 9, формируя новую копию:

languages = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Создаём пустой список для результата
reversed_list = []

# Начинаем с последнего индекса
index = len(languages) - 1

# Переворачиваем список циклом
while index >= 0:
    reversed_list.append(languages[index])  # добавляем текущий элемент
    index -= 1  # движемся влево

print(reversed_list)
# Вывод:
# [9, 8, 7, 6, 5, 4, 3, 2, 1]

Плюсы: легко вставлять дополнительную обработку на каждой итерации. Минусы: самый многословный вариант.

2. List comprehension (короткий цикл)

Списковые включения делают код короче, при этом остаётся гибкость (например, можно применять фильтры или преобразования элементов).

Корректный и компактный вариант:

languages = [1, 2, 3, 4, 5, 6, 7, 8, 9]
reversed_list = [languages[i] for i in range(len(languages) - 1, -1, -1)]
print(reversed_list)
# [9, 8, 7, 6, 5, 4, 3, 2, 1]

Плюсы: лаконично, можно модифицировать элементы на лету. Минусы: чуть сложнее для чтения новичкам.

3. Использовать оператор среза

Самый питоничный и короткий способ для создания копии в обратном порядке:

languages = [1, 2, 3, 4, 5, 6, 7, 8, 9]
rev_list = languages[::-1]
print(rev_list)
# [9, 8, 7, 6, 5, 4, 3, 2, 1]

Здесь синтаксис [::-1] означает «скопировать каждый элемент, начиная с конца и идя назад».

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

4. Метод списка reverse (in-place)

Если допустимо изменить исходный список, метод list.reverse() выполняет операцию на месте и возвращает None:

languages = [1, 2, 3, 4, 5, 6, 7, 8, 9]
languages.reverse()
print(languages)
# [9, 8, 7, 6, 5, 4, 3, 2, 1]

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

Важно: поскольку метод меняет список на месте, не используйте его, если нужно сохранить оригинал.

5. Встроенная функция reversed()

reversed() возвращает итератор, который даёт элементы в обратном порядке. Чтобы получить список, оберните результат в list():

languages = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(reversed(languages)))
# [9, 8, 7, 6, 5, 4, 3, 2, 1]

Плюсы: удобна, когда нужен итератор (экономия памяти), и вы не хотите менять исходный список. Минусы: для получения списка нужно обёртка list(), но часто это ожидаемо.

Сравнение методов — краткая шпаргалка

Когда какой метод использовать — эвристики

• Нужна копия и лаконичный код: используйте slice (languages[::-1]).
• Нужно сохранить память и менять список прямо: list.reverse().
• Работаете с генераторами/итераторами или больших объёмов — используйте reversed() и проходите по нему в цикле.
• Нужна дополнительная логика при обходе (фильтрация, сложные трансформации) — используйте list comprehension или явный цикл.

Когда переворот не подходит или может подвести

• Если порядок важен для других частей программы — не применяйте in-place reverse без клонирования.
• Если список очень большой и нужно минимизировать копии — используйте итератор reversed() и поэлементную обработку.
• Если элементы неиндексируемы или это потоковые данные — срезы не применимы; используйте буферную структуру или deque.

Пример, где срезы и индексирование неприменимы: итератор, который можно пройти только один раз (например, чтение строк из stdin). Тогда сначала придётся собрать элементы в список или использовать структуру deque для реверса по мере поступления.

Альтернативные подходы и структуры

• collections.deque: удобно, если вы хотите быстро добавлять элементы влево или вправо и при этом контролировать память.
• reversed view в некоторых библиотеках (например, NumPy имеет свои методы для массивов: np.flip).

Чек‑лист по ролям

Для разработчика:

• Выяснить, можно ли изменить исходный список.
• Оценить объём данных (память).
• Подумать о читаемости кода для команды.

Для ревьюера кода:

• Проверить, не ломает ли in-place reverse логику других функций.
• Предпочесть slice или reversed() для явных копий.
• Убедиться в покрытии тестами для граничных случаев (пустой список, один элемент).

Мини‑шпаргалка (cheat sheet)

• Быстро скопировать в обратном порядке: rev = a[::-1]
• Поменять порядок на месте: a.reverse()
• Итерировать в обратном порядке без копии: for x in reversed(a):
• Получить список из итератора: list(reversed(a))
• С инкрементальной логикой: [transform(a[i]) for i in range(len(a)-1, -1, -1)]

Краткое резюме

Перевернуть список в Python можно множеством способов — выбор зависит от потребностей: сохранить ли исходный список, нужен ли итератор, важна ли читаемость или экономия памяти. Для большинства задач достаточно среза [::-1] или list.reverse() по ситуации.

Важно: перед использованием in-place операций проверьте побочные эффекты на остальной код.

1‑строчная глоссарий

• in-place: операция, меняющая объект без создания копии.
• итератор: объект, который возвращает элементы по одному при обходе.