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

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

Перевёртывание списка — одна из базовых операций. В Python есть несколько способов, каждый с разными характеристиками по скорости, памяти и читаемости.

1. Встроенный метод .reverse()

Самый эффективный способ — использовать встроенный метод, который изменяет список на месте (in-place).

original_list = [1, 2, 3, 4, 5]

# Перевёртываем список (изменяет исходный список)
original_list.reverse()

print(original_list)  # [5, 4, 3, 2, 1]

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

• Сложность: O(n)
• Память: O(1) (изменяет на месте)
• Скорость: Самая быстрая (на C)
• Побочный эффект: Изменяет исходный список

2. Срез с отрицательным шагом [::-1]

Стандартный Python способ для создания нового перевёрнутого списка:

original_list = [1, 2, 3, 4, 5]

# Создаёт новый список в обратном порядке
reversed_list = original_list[::-1]

print(original_list)   # [1, 2, 3, 4, 5] (не изменился)
print(reversed_list)   # [5, 4, 3, 2, 1] (новый список)

Срезы с шагом:

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

print(arr[::2])      # [0, 2, 4, 6, 8]      — каждый второй
print(arr[1::2])     # [1, 3, 5, 7, 9]      — начиная со второго
print(arr[::-1])     # [9, 8, 7, 6, 5, ...]  — в обратном порядке
print(arr[5:1:-1])   # [5, 4, 3, 2]         — от индекса 5 к 1 в обратном
print(arr[::-2])     # [9, 7, 5, 3, 1]      — в обратном, каждый второй

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

• Сложность: O(n)
• Память: O(n) (создаёт новый список)
• Скорость: Очень быстрая (оптимизирована)
• Побочный эффект: Не изменяет исходный список

3. Функция reversed()

Возвращает итератор в обратном порядке (ленивое вычисление):

original_list = [1, 2, 3, 4, 5]

# reversed() возвращает итератор, не список
reversed_iterator = reversed(original_list)

print(list(reversed_iterator))  # [5, 4, 3, 2, 1] (преобразуем в список)

# Или просто итерируемся
for item in reversed(original_list):
    print(item)  # 5, 4, 3, 2, 1 (по одному)

# Или распакуем
a, b, c, d, e = reversed(original_list)
print(a, b, c, d, e)  # 5 4 3 2 1

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

• Сложность: O(1) для создания, O(n) для итерации
• Память: O(1) (только итератор, не копирует данные)
• Скорость: Медленная для одноразового использования, эффективна если не нужен список
• Побочный эффект: Не изменяет исходный список

4. Ручная реализация с циклом

Этот способ редко используется, но полезен для понимания:

original_list = [1, 2, 3, 4, 5]

# Способ 1: Обмен элементов (in-place)
original_list_copy = original_list.copy()
left, right = 0, len(original_list_copy) - 1

while left < right:
    original_list_copy[left], original_list_copy[right] = \
        original_list_copy[right], original_list_copy[left]
    left += 1
    right -= 1

print(original_list_copy)  # [5, 4, 3, 2, 1]

# Способ 2: Создание нового списка
reversed_list = []
for i in range(len(original_list) - 1, -1, -1):
    reversed_list.append(original_list[i])

print(reversed_list)  # [5, 4, 3, 2, 1]

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

Пример 1: Проверка палиндрома

def is_palindrome(s: str) -> bool:
    """Проверяет, является ли строка палиндромом"""
    # Удаляем пробелы и приводим к нижнему регистру
    cleaned = s.replace(" ", "").lower()
    # Сравниваем с перевёрнутой версией
    return cleaned == cleaned[::-1]

print(is_palindrome("А роза упала на лапу Азора"))  # True
print(is_palindrome("Hello"))                         # False

Пример 2: Обработка файла в обратном порядке

# Чтение файла в обратном порядке
def read_file_reversed(filename: str) -> list[str]:
    with open(filename, "r") as f:
        lines = f.readlines()
    return lines[::-1]  # Обратный порядок строк

# Или с использованием reversed() для экономии памяти
def read_file_reversed_lazy(filename: str):
    with open(filename, "r") as f:
        lines = f.readlines()
    for line in reversed(lines):
        yield line

Пример 3: Реверс битов в числе

def reverse_bits(n: int, num_bits: int = 32) -> int:
    """Переворачивает биты в числе"""
    # Преобразуем в бинарную строку
    binary = bin(n)[2:].zfill(num_bits)  # bin(5) = 0b101 → 00000101
    # Переворачиваем строку
    reversed_binary = binary[::-1]
    # Преобразуем обратно в число
    return int(reversed_binary, 2)

print(reverse_bits(5))  # 5 (бинарно: 00000...00101 → 10100...00000)

Пример 4: Реверс матрицы (2D список)

def reverse_matrix_rows(matrix: list[list[int]]) -> list[list[int]]:
    """Переворачивает каждую строку матрицы"""
    return [row[::-1] for row in matrix]

def reverse_matrix_order(matrix: list[list[int]]) -> list[list[int]]:
    """Переворачивает порядок строк"""
    return matrix[::-1]

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

print(reverse_matrix_rows(matrix))
# [[3, 2, 1], [6, 5, 4], [9, 8, 7]]

print(reverse_matrix_order(matrix))
# [[7, 8, 9], [4, 5, 6], [1, 2, 3]]

6. Сравнение производительности

import timeit

size = 1_000_000
test_list = list(range(size))

# Способ 1: reverse()
time_1 = timeit.timeit(
    lambda: test_list.copy().__reverse__(),
    number=100
)
print(f".reverse(): {time_1:.6f}s")  # Самый быстрый

# Способ 2: [::-1]
time_2 = timeit.timeit(
    lambda: test_list[::-1],
    number=100
)
print(f"[::-1]: {time_2:.6f}s")  # Быстрый

# Способ 3: reversed()
time_3 = timeit.timeit(
    lambda: list(reversed(test_list)),
    number=100
)
print(f"reversed(): {time_3:.6f}s")  # Медленнее

# Результаты (примерно):
# .reverse(): 0.001234s   ← Самый быстрый
# [::-1]: 0.003456s       ← Быстрый
# reversed(): 0.005678s   ← Медленнее

7. Выбор правильного способа

Используй .reverse() если:

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

data = [1, 2, 3, 4, 5]
data.reverse()  # Изменил исходный список
print(data)  # [5, 4, 3, 2, 1]

Используй [::-1] если:

• Нужен новый перевёрнутый список
• Исходный список не должен меняться
• Нужна хорошая производительность
• Это самый читаемый способ

original = [1, 2, 3, 4, 5]
reversed_copy = original[::-1]
print(original)   # [1, 2, 3, 4, 5] (не изменился)
print(reversed_copy)  # [5, 4, 3, 2, 1]

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

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

data = [1, 2, 3, 4, 5]
for item in reversed(data):
    print(item)  # Не создаёт новый список, экономит память

8. Реверс специальных структур

from collections import deque

# Реверс deque
q = deque([1, 2, 3, 4, 5])
q.reverse()
print(q)  # deque([5, 4, 3, 2, 1])

# Реверс строки
s = "Hello"
print(s[::-1])  # olleH

# Реверс tuple (создаёт новый кортеж)
t = (1, 2, 3, 4, 5)
print(tuple(reversed(t)))  # (5, 4, 3, 2, 1)

Итоговая рекомендация

В 99% случаев [::-1] — ваш ответ. Это стандартный Python способ, который используется везде.