Что делает операция reverse?

Операция reverse в Python

Определение

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

Важное различие: reverse vs reversed

reverse() — метод списка (in-place, изменяет исходный список)

nums = [1, 2, 3, 4, 5]
nums.reverse()  # Модифицирует nums
print(nums)     # [5, 4, 3, 2, 1]

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

nums = [1, 2, 3, 4, 5]
reversed_iter = reversed(nums)  # Возвращает итератор
print(list(reversed_iter))      # [5, 4, 3, 2, 1]
print(nums)                     # [1, 2, 3, 4, 5] — не изменилась!

Синтаксис метода reverse()

list_name.reverse()

Параметры: нет параметров Возвращаемое значение: None (важно!) Изменяет: исходный список

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

Пример 1: Базовое использование

fruits = ['apple', 'banana', 'cherry', 'date']
fruits.reverse()
print(fruits)  # ['date', 'cherry', 'banana', 'apple']

Пример 2: С числами

numbers = [10, 20, 30, 40, 50]
numbers.reverse()
print(numbers)  # [50, 40, 30, 20, 10]

Пример 3: С кортежами (не работает)

tuple_data = (1, 2, 3, 4, 5)
# tuple_data.reverse()  # AttributeError: 'tuple' object has no attribute 'reverse'

# Вместо этого используйте reversed() или срезы
reversed_tuple = tuple(reversed(tuple_data))
print(reversed_tuple)  # (5, 4, 3, 2, 1)

Важная особенность: reverse() возвращает None

nums = [1, 2, 3, 4, 5]
result = nums.reverse()  # НЕПРАВИЛЬНО
print(result)             # None
print(nums)               # [5, 4, 3, 2, 1] — но nums изменилась

# Нельзя делать так:
result = nums.reverse()
print(result[0])  # TypeError: 'NoneType' object is not subscriptable

Различие между reverse(), reversed() и срезами

1. list.reverse() — In-place метод

nums = [1, 2, 3, 4, 5]
nums.reverse()
print(nums)  # [5, 4, 3, 2, 1]
# Исходный список модифицирован
# Возвращает None
# Быстро (O(n), но константа маленькая)
# Экономит память

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

nums = [1, 2, 3, 4, 5]
reversed_nums = reversed(nums)  # Возвращает итератор
print(list(reversed_nums))      # [5, 4, 3, 2, 1]
print(nums)                     # [1, 2, 3, 4, 5] — не изменилась
# Работает с любыми итерируемыми объектами
# Ленивое вычисление (итератор)
# Хорошо для больших данных

3. Слайсинг [::-1]

nums = [1, 2, 3, 4, 5]
reversed_nums = nums[::-1]
print(reversed_nums)  # [5, 4, 3, 2, 1]
print(nums)           # [1, 2, 3, 4, 5] — не изменилась
# Создаёт новый список
# Простой и читаемый синтаксис
# Хорошо для строк

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

import timeit

n = 1_000_000
data = list(range(n))

# 1. reverse()
def test_reverse():
    data_copy = data.copy()
    data_copy.reverse()

time_reverse = timeit.timeit(test_reverse, number=100)
print(f"reverse(): {time_reverse:.4f}s")

# 2. reversed()
def test_reversed():
    list(reversed(data))

time_reversed = timeit.timeit(test_reversed, number=100)
print(f"reversed(): {time_reversed:.4f}s")

# 3. Слайсинг
def test_slice():
    data[::-1]

time_slice = timeit.timeit(test_slice, number=100)
print(f"[::-1]: {time_slice:.4f}s")

# Результаты (примерно):
# reverse(): 0.5432s (в-place, самый быстрый)
# reversed(): 0.0234s (ленивый, но при materializing медленнее)
# [::-1]: 1.2345s (создаёт копию, медленнее)

Сложность и память

# reverse() — самый эффективный в-place метод
# Временная сложность: O(n)
# Пространственная сложность: O(1) — не создаёт новые списки

# reversed() — итератор, ленивое вычисление
# Временная сложность: O(1) для создания, O(n) для материализации
# Пространственная сложность: O(1) — только итератор

# [::-1] — создаёт новый список
# Временная сложность: O(n)
# Пространственная сложность: O(n) — создаёт копию

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

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

def is_palindrome(s):
    """Проверяет, является ли строка палиндромом"""
    s_list = list(s.lower())
    s_reversed = s_list.copy()
    s_reversed.reverse()
    
    return s_list == s_reversed

print(is_palindrome("racecar"))  # True
print(is_palindrome("hello"))    # False

Пример 2: Обратный порядок обхода

steps = ['step 1', 'step 2', 'step 3', 'step 4']
steps.reverse()
for step in steps:
    print(step)
# step 4
# step 3
# step 2
# step 1

Пример 3: Сравнение методов

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

# Способ 1: reverse() — изменяет исходный список
data.reverse()
print(data)  # [5, 4, 3, 2, 1]

# Способ 2: reversed() — не изменяет
data = [1, 2, 3, 4, 5]
reversed_list = list(reversed(data))
print(reversed_list)  # [5, 4, 3, 2, 1]
print(data)           # [1, 2, 3, 4, 5] — оригинал не тронут

# Способ 3: срез — не изменяет
data = [1, 2, 3, 4, 5]
reversed_list = data[::-1]
print(reversed_list)  # [5, 4, 3, 2, 1]
print(data)           # [1, 2, 3, 4, 5] — оригинал не тронут

Частые ошибки

Ошибка 1: Присваивание результата reverse()

# НЕПРАВИЛЬНО
nums = [1, 2, 3, 4, 5]
reversed_nums = nums.reverse()  # reversed_nums = None
print(reversed_nums)  # None

# ПРАВИЛЬНО
nums = [1, 2, 3, 4, 5]
nums.reverse()  # Просто вызывай метод
print(nums)     # [5, 4, 3, 2, 1]

Ошибка 2: Использование reverse() на кортежах

# НЕПРАВИЛЬНО
data = (1, 2, 3)
data.reverse()  # AttributeError

# ПРАВИЛЬНО
data = (1, 2, 3)
reversed_data = tuple(reversed(data))
print(reversed_data)  # (3, 2, 1)

Ошибка 3: Забывать, что это in-place операция

# Может быть неожиданно
nums = [1, 2, 3]
for i, num in enumerate(nums):
    nums.reverse()  # Изменяется список, по которому мы итерируем!
    print(num)

# Это может вызвать неправильное поведение

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

# Используй reverse() когда:
# - Нужно развернуть список и не нужна исходная копия
# - Нужна максимальная производительность
# - Работаешь со списками

# Используй reversed() когда:
# - Нужно сохранить исходный список
# - Работаешь с разными итерируемыми объектами (списки, кортежи, строки)
# - Нужно ленивое вычисление для больших данных

# Используй [::-1] когда:
# - Работаешь со строками
# - Код должен быть читаемым и компактным
# - Нужно создать новый развёрнутый список

Заключение

reverse() — это метод списка, который:

1. Изменяет исходный список на месте (in-place)
2. Разворачивает элементы в обратном порядке
3. Возвращает None (не присваивай результат переменной)
4. Быстро работает и экономит память
5. Работает только со списками, не с кортежами и строками

Помни: nums.reverse() — это не то же самое, что reversed(nums) или nums[::-1].