Как перевернуть строчку с помощью среза (slice)?

Переворот строки через slice (срез)

Это один из самых элегантных способов работать со строками в Python. Slice синтаксис очень мощный и быстрый.

1. Базовый способ: str[::-1]

Синтаксис [start:stop:step] с отрицательным шагом:

# Простейший способ
text = "Hello, World!"
reversed_text = text[::-1]
print(reversed_text)  # !dlroW ,olleH

# Это работает и с кортежами
tuple_data = (1, 2, 3, 4, 5)
reversed_tuple = tuple_data[::-1]
print(reversed_tuple)  # (5, 4, 3, 2, 1)

# И со списками
list_data = ['a', 'b', 'c', 'd']
reversed_list = list_data[::-1]
print(reversed_list)  # ['d', 'c', 'b', 'a']

2. Синтаксис среза [start:stop:step]

Полное понимание:

text = "Hello"

# [start:stop:step]
# start - индекс начала (включительно)
# stop  - индекс конца (исключительно)
# step  - шаг итерации

# Примеры
print(text[0:3:1])    # "Hel" (индексы 0,1,2)
print(text[::1])      # "Hello" (весь текст, шаг 1)
print(text[::2])      # "Hlo" (каждый второй символ)
print(text[::-1])     # "olleH" (в обратном порядке, шаг -1)
print(text[4:0:-1])   # "olleH" (от индекса 4 к индексу 0 в обратном порядке)
print(text[3::-1])    # "olleH" (от индекса 3 к началу в обратном порядке)

3. Разбор синтаксиса обратного среза

text = "Python"
# Индексы: P(0) y(1) t(2) h(3) o(4) n(5)

# text[::-1]
# start = None (означает конец для отрицательного step)
# stop = None (означает начало для отрицательного step)
# step = -1 (движемся в обратном направлении)
# Результат: nohtyP
print(text[::-1])  # "nohtyP"

# text[5::-1]
# start = 5 (начинаем с индекса 5 - буква 'n')
# stop = None (идём до начала)
# step = -1 (в обратном направлении)
# Результат: nohtyP
print(text[5::-1])  # "nohtyP"

# text[4:1:-1]
# start = 4 (начинаем с индекса 4 - буква 'o')
# stop = 1 (заканчиваем ПЕРЕД индексом 1)
# step = -1 (в обратном направлении)
# Результат: oth (индексы 4, 3, 2)
print(text[4:1:-1])  # "oth"

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

# Палиндром
def is_palindrome(word: str) -> bool:
    return word == word[::-1]

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

# Проверка последовательности цифр в обратном порядке
def check_reverse_order(number: int) -> str:
    num_str = str(number)
    reversed_str = num_str[::-1]
    return f"{num_str} -> {reversed_str}"

print(check_reverse_order(12345))  # "12345 -> 54321"

# Инверсия частей строки
text = "hello world"
words = text.split()
reversed_words = [word[::-1] for word in words]
result = ' '.join(reversed_words)
print(result)  # "olleh dlrow"

# Обратный порядок слов
text = "one two three four"
reversed_text = " ".join(text.split()[::-1])
print(reversed_text)  # "four three two one"

5. Производительность

Сравним разные способы развернуть строку:

import timeit

text = "Hello, World!" * 1000

# Способ 1: Slice [::-1]
t1 = timeit.timeit(lambda: text[::-1], number=10000)
print(f"Slice [::-1]: {t1:.6f}s")  # Самый быстрый

# Способ 2: reversed() с join
t2 = timeit.timeit(lambda: ''.join(reversed(text)), number=10000)
print(f"reversed() + join: {t2:.6f}s")  # Медленнее в 1.5-2 раза

# Способ 3: Цикл
def reverse_loop(s):
    result = ""
    for char in reversed(s):
        result += char
    return result

t3 = timeit.timeit(lambda: reverse_loop(text), number=10000)
print(f"Loop: {t3:.6f}s")  # Намного медленнее

# Способ 4: Рекурсия (очень медленно)
def reverse_recursive(s):
    if len(s) == 0:
        return s
    return reverse_recursive(s[1:]) + s[0]

t4 = timeit.timeit(lambda: reverse_recursive(text[:50]), number=100)
print(f"Recursive: {t4:.6f}s")  # Очень медленно

# Результат: [::-1] в 10+ раз быстрее других методов

6. Сложные операции со срезами

text = "abcdefghij"

# Переворот части строки
print(text[:5][::-1])  # "edcba" (первые 5 символов перевёрнуты)
print(text[5:][::-1])  # "jihgf" (остаток перевёрнут)

# Чередующиеся символы в обратном порядке
print(text[::2][::-1])  # "igeca" (каждый второй, потом перевёрнуто)
print(text[1::2][::-1]) # "jhfdb" (каждый второй начиная с 1, перевёрнуто)

# Инверсия и взятие подстроки
reversed_text = text[::-1]
print(reversed_text[2:5])  # "ghj" (индексы 2-4 развёрнутой строки)

# Комбинирование операций
text = "Hello World Python"
words = text.split()
result = [word[::-1] for word in words]
print(result)  # ['olleH', 'dlroW', 'nohtyP']

7. Срезы с переменными

# Развернуть от n-го символа
def reverse_from(text: str, from_index: int) -> str:
    return text[:from_index] + text[from_index:][::-1]

print(reverse_from("hello", 2))  # "helol" (от индекса 2 развёрнуто)

# Развернуть между индексами
def reverse_between(text: str, start: int, end: int) -> str:
    return text[:start] + text[start:end][::-1] + text[end:]

print(reverse_between("hello", 1, 4))  # "hlleo" (между индексами 1 и 4)

# Развернуть каждое слово
def reverse_each_word(text: str) -> str:
    return ' '.join(word[::-1] for word in text.split())

print(reverse_each_word("hello world"))  # "olleh dlrow"

8. Работа с разными типами данных

# Строка
text = "Python"
print(text[::-1])  # "nohtyP"

# Список
list_data = [1, 2, 3, 4, 5]
print(list_data[::-1])  # [5, 4, 3, 2, 1]

# Кортеж
tuple_data = (1, 2, 3, 4, 5)
print(tuple_data[::-1])  # (5, 4, 3, 2, 1)

# Диапазон
range_data = range(5)
print(list(range_data[::-1]))  # Error! range не поддерживает срезы отрицательным шагом
# Правильно:
print(list(reversed(range(5))))  # [4, 3, 2, 1, 0]

# Байты
bytes_data = b"Hello"
print(bytes_data[::-1])  # b'olleH'

# Вложенные структуры
matrix = [[1, 2], [3, 4], [5, 6]]
print([row[::-1] for row in matrix])  # [[2, 1], [4, 3], [6, 5]]

9. Дополнительные трюки

# Проверка на палиндром (один из способов)
text = "race car".replace(" ", "")
if text.lower() == text.lower()[::-1]:
    print("Palindrome")  # Palindrome

# Форматирование даты в обратном порядке
date = "2025-03-22"
reversed_date = date[::-1]
print(reversed_date)  # "22-03-5202" (наверное, не очень полезно)

# Переворот бинарного представления
num = 12
binary = bin(num)[2:]  # "1100"
reversed_binary = binary[::-1]  # "0011"
print(int(reversed_binary, 2))  # 3

# Двойной переворот (должен вернуть оригинал)
original = "hello"
twice_reversed = original[::-1][::-1]
print(twice_reversed == original)  # True

Почему [::-1] самый лучший способ

1. Читаемость — сразу видно что переворачиваем
2. Производительность — оптимизирован в CPython
3. Простота — одна строка кода
4. Универсальность — работает со строками, списками, кортежами
5. Семантика — явно говорит о намерении

Итого

text[::-1] — это идеальный способ развернуть строку в Python. Это:

• Быстро (оптимизировано в CPython)
• Читаемо (сразу понятна суть)
• Универсально (работает с любыми sequence типами)
• Питонический (Pythonic way)