Как перевернуть строку в Python: все способы

Обновлено: 2026

Чтобы перевернуть строку в питоне, используйте срез с шагом -1: s[::-1]. Это самый быстрый и короткий способ. Для итерируемого варианта возьмите "".join(reversed(s)). Оба возвращают новую строку в обратном порядке символов, исходная не меняется — строки в Python неизменяемы.

s = "питон" print(s[::-1]) # нотип print("".join(reversed(s))) # нотип

Ниже — все рабочие способы перевернуть строку, замер их скорости, переворот по словам и подвох с эмодзи, о котором молчат другие статьи.

• Срез [::-1] — короче и быстрее всего.
• reversed() + join() — когда нужен явный итератор.
• Цикл for/while — когда по пути нужна доп. логика.
• Рекурсия — для учебных целей, с оговоркой про лимит стека.
• Переворот по словам — split() + reversed, а не по буквам.

Как перевернуть строку в питоне срезом [::-1]

Срез s[i:j:k] — это встроенный синтаксис последовательностей. Третий параметр k задаёт шаг. По документации Python, при отрицательном шаге индексы движутся справа налево, поэтому k=-1 берёт все символы в обратном порядке. Начало и конец при этом можно опустить.

s = "перевернуть строку" reversed_s = s[::-1] print(reversed_s) # укортс ьтунревереп

Почему именно этот способ предпочитают: срез реализован на уровне C, создаёт готовую строку за один проход и не требует импортов. Минус один — он менее очевиден для новичка, чем цикл, и всегда создаёт копию (для строк это неизбежно при любом методе, так как строка неизменяема).

Мини-вывод: если задача — просто перевернуть строку, берите [::-1] и не усложняйте.

ОНЛАЙН-ПРАКТИКУМ

ЗАПУСК нейросети DEEPSEEK R1 ЛОКАЛЬНО НА СВОЕМ КОМПЬЮТЕРЕ

ЧТО БУДЕТ НА ОБУЧЕНИИ?

• ПОКАЖЕМ, КАК РАЗВЕРНУТЬ МОДЕЛЬ нейросети DEEPSEEK R1 ПРЯМО НА СВОЁМ КОМПЬЮТЕРЕ
• Где и как применять? Потестируем модель после установки на разных задачах
• Как дообучить модель под себя?

Участвовать бесплатно

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

Функция reversed() возвращает не строку, а обратный итератор. По официальной документации, аргумент должен поддерживать протокол последовательности (__len__ и __getitem__) либо иметь метод __reversed__ — строка этому удовлетворяет. Чтобы получить строку обратно, итератор склеивают через join().

s = "питон" it = reversed(s) # объект reversed, а не строка print("".join(it)) # нотип # частая ошибка — забыть join и печатать сам итератор: print(reversed(s)) # <reversed object at 0x...>

Способ читается как «переверни и собери», хорошо подходит, когда обратный порядок нужно передать в другую функцию, ожидающую итератор. По скорости он немного уступает срезу из-за накладных расходов на итерацию и склейку.

Мини-вывод: "".join(reversed(s)) — «питоничный» второй вариант, когда нужен именно итератор.

Переворот строки циклом for и while

Цикл — самый гибкий, но и самый медленный путь. Он оправдан, когда по ходу переворота нужна дополнительная логика: пропустить пробелы, поменять регистр, отфильтровать символы. Собирать результат конкатенацией result += ch в длинном цикле не стоит — на каждой итерации создаётся новая строка. Аккуратнее накапливать в список и склеить один раз.

def reverse_loop(s): chars = [] for ch in s: chars.insert(0, ch) # вставляем в начало return "".join(chars) print(reverse_loop("питон")) # нотип # while-вариант, идём с конца: def reverse_while(s): i = len(s) - 1 out = [] while i >= 0: out.append(s[i]) i -= 1 return "".join(out)

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

Переворот строки рекурсией

Рекурсивный подход нагляден для обучения: функция вызывает саму себя, откусывая по символу. Базовый случай — пустая строка или один символ.

def reverse_recursive(s): if len(s) <= 1: # базовый случай return s return reverse_recursive(s[1:]) + s[0] print(reverse_recursive("питон")) # нотип

Важное ограничение, которое часто пропускают: у Python есть лимит глубины рекурсии (по умолчанию около 1000 вызовов, значение возвращает sys.getrecursionlimit()). На строке длиннее лимита эта функция упадёт с RecursionError. Плюс каждый вызов создаёт срез s[1:] — это лишняя память. Поэтому в проде рекурсию для переворота строк не используют, только в учебных задачах.

Мини-вывод: рекурсия — для понимания принципа, для реальных данных берите срез.

Как перевернуть строку по словам, а не по буквам

Отдельная частая задача — перевернуть порядок слов, сохранив сами слова. Здесь [::-1] по всей строке не годится, он перевернёт и буквы. Разбейте по пробелам, переверните список, склейте обратно.

s = "как перевернуть строку в питоне" words = s.split() # ['как', 'перевернуть', ...] print(" ".join(reversed(words))) # питоне в строку перевернуть как

Мини-вывод: уровень переворота выбирается на этапе split() — по символам или по словам.

Юникод и эмодзи: где [::-1] ломается

Это тот подвох, которого нет у большинства статей в выдаче. Срез переворачивает строку по кодовым точкам, а не по видимым символам. Для латиницы и кириллицы разницы нет. Но составные символы Unicode — это несколько кодовых точек, которые пользователь видит как один знак (в стандарте Unicode это называется графемным кластером, UAX #29). При наивном перевороте они распадаются.

Пример с комбинируемым ударением: «é» может храниться как e + отдельная кодовая точка ударения. После [::-1] ударение «перепрыгнет» на соседний символ.

s = "é" # é = e + комбинируемое ударение, len == 2 print(len(s)) # 2, хотя видим один символ print(s[::-1]) # ударение уезжает не туда

С эмодзи хуже. Семейное эмодзи 👨‍👩‍👧‍👦 — это один графемный кластер из нескольких кодовых точек, склеенных невидимым соединителем ZWJ (U+200D). len() вернёт для него больше единицы, а срез разорвёт последовательность на отдельные фигурки и сломает соединитель.

Решения два. Первое — нормализовать строку к форме NFC (unicodedata.normalize("NFC", s)), это «схлопнет» простые составные символы вроде «é» в одну кодовую точку. Но ZWJ-эмодзи NFC не спасёт. Для честного переворота по графемам нужна сторонняя библиотека, понимающая границы кластеров UAX #29 (например, пакеты regex или grapheme), — в стандартной библиотеке готового разбиения по графемам нет.

import unicodedata s = unicodedata.normalize("NFC", "é") print(len(s)) # 1 — теперь срез безопасен print(s[::-1])

Мини-вывод: для обычного текста [::-1] достаточно; для пользовательского ввода с эмодзи сначала думайте про графемы.

Производительность: какой метод быстрее

Не верьте на слово — замерьте у себя модулем timeit. Он гоняет код тысячи раз и показывает среднее время.

import timeit s = "перевернуть строку в питоне" * 100 print(timeit.timeit(lambda: s[::-1], number=100000)) print(timeit.timeit(lambda: "".join(reversed(s)), number=100000)) print(timeit.timeit(lambda: "".join([s[i] for i in range(len(s)-1, -1, -1)]), number=100000))

Устойчивый порядок результатов от запуска к запуску: срез [::-1] — быстрее всех; "".join(reversed(s)) — немного медленнее из-за итерации и склейки; ручной цикл или генератор по индексам — заметно медленнее; рекурсия — медленнее всех и упирается в лимит стека. Абсолютные числа зависят от машины и версии Python, но относительный расклад не меняется.

Переворот строки с условием: разворачиваем только буквы

На собеседованиях любят задачу-развилку: перевернуть строку, но оставить не-буквенные символы (пробелы, дефисы, знаки) на своих позициях. В лоб срезом не решить — нужен обход двумя указателями. Это тот случай, где цикл выигрывает у [::-1] по смыслу, а не по скорости.

def reverse_letters_only(s): chars = list(s) left, right = 0, len(chars) - 1 while left < right: if not chars[left].isalpha(): left += 1 elif not chars[right].isalpha(): right -= 1 else: chars[left], chars[right] = chars[right], chars[left] left += 1 right -= 1 return "".join(chars) print(reverse_letters_only("a-bc,d")) # d-cb,a

Метод str.isalpha() корректно работает и с кириллицей, и с другими алфавитами Unicode, так что фильтр «только буквы» не ломается на нелатинском тексте. Приём двух указателей полезен и в других строковых задачах — проверке палиндрома, схлопывании пробелов.

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

Практические сценарии: где переворот реально нужен

Переворот строки редко нужен «просто так», обычно это часть большей задачи. Проверка палиндрома: сравниваем строку с её перевёрнутой копией — s == s[::-1]. Разбор данных, записанных задом наперёд (некоторые форматы логов, обфусцированные значения). Учебные упражнения на рекурсию и указатели. Работа с системами счисления, где цифры удобно обрабатывать с младшего разряда. Во всех этих случаях выбор метода диктует контекст: для палиндрома хватит среза, для потоковой обработки — итератора reversed().

def is_palindrome(s): clean = "".join(ch.lower() for ch in s if ch.isalnum()) return clean == clean[::-1] print(is_palindrome("А роза упала на лапу Азора")) # True

Мини-вывод: сначала поймите, зачем переворачиваете, — метод подберётся сам.

Сравнительная таблица методов

Типичные ошибки

• Печатать reversed(s) напрямую — увидите <reversed object>, а не текст. Нужен join().
• Ждать, что строка изменится «на месте» — строки неизменяемы, любой метод возвращает новую строку, присвойте её переменной.
• Копить результат через result += ch в длинном цикле — квадратичная сложность, собирайте в список и склеивайте один раз.
• Рекурсия на длинной строке — RecursionError после ~1000 символов.
• Забыть про эмодзи и составные символы — [::-1] ломает графемные кластеры.

FAQ

Как перевернуть строку в питоне одной строкой кода?

s[::-1] — срез с шагом −1. Это самый короткий и быстрый способ.

Чем reversed() отличается от [::-1]?

[::-1] сразу возвращает новую строку. reversed() возвращает обратный итератор, который нужно склеить через "".join().

Меняет ли переворот исходную строку?

Нет. Строки в Python неизменяемы, все методы возвращают новую строку, исходная остаётся прежней.

Почему перевёрнутое эмодзи «рассыпается»?

Срез работает по кодовым точкам, а сложные эмодзи и составные символы — это несколько кодовых точек в одном графемном кластере. Нужна нормализация NFC или библиотека разбора графем.

Какой способ самый быстрый?

Срез [::-1]. Проверить можно модулем timeit на своей машине.