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

От /

Когда мы работаем со строками в Python, бывают случаи, когда нам нужно их перевернуть и работать с их перевернутыми копиями. Но поскольку строки в Python неизменяемы, мы не можем просто взять и перевернуть их. Сегодня мы обсудим, как же все-таки это сделать.

В Python есть несколько способов перевернуть строку. В этом руководстве мы рассмотрим:

  • Реверсирование строк с помощью рекурсии. Мы поговорим о том, как работает рекурсия, и о логике, лежащей в основе «переворачивания» строк с ее помощью.
  • Использование срезов для переворота строк. Обсудим гораздо более простой способ перевернуть строку в Python.
  • Использование встроенных методов. Разберем еще один простой и интуитивно понятный способ перевернуть строку в Python.

Итак, приступим!

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

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

Рекурсия – это мощный инструмент в программировании. Рекурсивная функция вызывает себя несколько раз, пока не будет достигнут базовый вариант.

Вероятно, вы уже читали нечто подобное, когда изучали тему рекурсии.

Давайте перефразируем это определение простым языком.

Рекурсия простыми словами

Предположим, вы создали функцию для решения какой-то проблемы. Функция разработана таким образом, что каждый раз при вызове она вызывает сама себя снова и снова. Это называется рекурсивными вызовами функции.

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

[python_ad_block]

Как использовать рекурсию для реверсирования строк

Давайте теперь обсудим логику переворачивания строк. Для этого рассмотрим строку code.

Итак, наша задача – перевернуть строку code.

Давайте на время забудем о рекурсии и начнем с того, что мы уже знаем.

Первая буква исходной строки будет последней буквой в перевернутой строке, верно? Так что давайте вытащим первую букву – в данном случае с – и поставим её в самый конец.

Теперь у нас осталась строка ode. И проблема свелась к переворачиванию данной подстроки ode (поскольку c уже находится в нужном месте).

Теперь проделаем ту же самую задачу, снова вытащив первую букву, теперь о. И переместим её в последний доступный слот справа, перед с.

Теперь, когда мы позаботились о c и o, у нас осталась проблема переворачивания подстроки de.

Сделаем это еще пару раз – вытащим сначала d, а затем и e.

Теперь у вас осталось перевернуть "" – пустую строку.

Таким образом, мы поместили «e», «d», «o» и «c» в правильные позиции, и нам больше не нужно ничего делать. В контексте рекурсии мы достигли базового случая.

Что мы здесь сделали?

  1. На каждом шаге мы выполняли одну и ту же задачу – вытаскивали первую букву из каждой последующей подстроки.
  2. И уменьшали исходную задачу до переворота строки, которая на одну букву короче, чем была раньше.

Когда мы остановились?

Когда строка стала пустой – не осталось букв, которые нужно было вытаскивать.

На иллюстрации ниже показано, что мы сделали:

Теперь, когда мы разобрались, как на самом деле работает реверсирование строк с использованием рекурсии, давайте напишем код.

Рекурсия для реверсирования строк

Давайте напишем функцию reverseString(), которая делает именно то, что мы сделали выше. Функция reverseString() принимает any_string и возвращает перевернутую копию any_string.

def reverseString(any_string):
    if any_string == "":
        return any_string
    else:
        return reverseString(any_string[1:]) + any_string[:1]

Давайте разберем, как работает рекурсия, когда вы вызываете функцию reverseString().

reverseString("code")

# Output
# 'edoc'

Скажем, мы вызываем функцию reverseString() со строкой code в качестве аргумента. Это, в свою очередь, вызывает reverseString() с аргументом ode. Дальше снова вызывается reverseString(), но уже с аргументом de. И всё это продолжается до тех пор, пока, наконец, не будет выполнен вызов функции reverseString() с пустой строкой "" в качестве аргумента.

Это объясняется на изображении ниже:

Вы знаете, что, когда выполняется вызов функции с аргументом "", функция возвращает "" в сочетании с "e".

Следующий вызов возвращает ed, а следующий – edo. И дальше, наконец-то, мы получаем edoc – желаемую перевернутую строку.

Для удобства чтения можно опустить ситуацию склеивания "" и е на иллюстрации ниже. Также возвращаемые значения из предыдущего вызова были обозначены зеленым внутри стека вызовов.

Теперь вы можете вызвать reverseString() с любой допустимой строкой Python. Вот еще несколько примеров:

reverseString("Python")

# Output:
# nohtyP

reverseString("Python Reverse String")

# Output:
# gnirtS esreveR nohtyP

Что ж, для этого потребовалось немало усилий. Однако мы надеемся, что теперь вы лучше понимаете рекурсивные вызовы.

От редакции Pythonist. Рекомендуем статью «Примеры программ с использованием рекурсии на языке Python».

В следующих двух разделах мы рассмотрим более простые способы переворачивания строк. Итак, поехали!

Как перевернуть строку в Python с помощью срезов

Вы также можете перевернуть строку в Python, используя срезы. В Python строки можно «резать» точно также, как и списки.

Срезы строк в Python

<string>[start: stop: step] возвращает фрагмент строки <string>, начиная с начального индекса (start), до индекса stop - 1, с шагом step.

Вот несколько моментов о строках, о которых стоит помнить:

  • <string> – любая допустимая строка Python.
  • Начальный индекс не является обязательным. Если вы не укажете его, по умолчанию срез начинается с начала строки, т.е с индекса 0.
  • Стоп-индекс также не является обязательным. Если вы не укажете его, по умолчанию срез будет до конца строки, т.е. до последнего элемента.
  • Необязательный аргумент step определяет то, как вы хотите разрезать <string>. Если мы установим step = 2, срез будет начинаться с начала строки, заканчиваться на stop - 1 и включать каждый второй символ в строке, т.е. мы будем идти с шагом 2.

Таким образом, выражение <string>[:::] возвращает нам просто исходную строку.

Давайте посмотрим внимательнее:

  • без начального индекса срез начинается с индекса 0
  • без конечного индекса срез продолжается до последнего символа в строке
  • не указывая аргумент step, мы получаем срез, который включает все символы в строке

Однако, не стоит забывать, что вы также можете установить и отрицательные значения для шага. А отрицательные значения будут возвращать фрагменты строки, начиная с конца строки.

Установка step = -1 возвращает нам фрагмент строки, начиная с последнего символа и заканчивая первым символом. При этом не пропускается ни один символ.

Подождите, разве это не перевернутая строка? Да, это именно она и есть!

Итак, выражение <string>[::-1] возвращает перевернутую копию строки. Проще простого, не так ли?

any_string = "Python"

rev_string = any_string[::-1]

print(rev_string)

# Output
# nohtyP

Перейдем к следующему разделу, чтобы узнать еще один простой способ перевернуть строку.

Как перевернуть строку в Python с помощью методов reversed() и join()

Для начала посмотрим, что делает метод reversed().

Функция reversed() возвращает обратный итератор, то есть возвращает итератор, который перебирает элементы оригинала в обратном порядке.

any_string = "Python"

Давайте используем метод reversed(), чтобы получить символы any_string в обратном порядке:

for char in reversed(any_string):
    print(char)

# Output:
# n
# o
# h
# t
# y
# P

Теперь, когда у нас есть все символы в обратном порядке, нам нужно собрать их в строку. Дело в том, что метод reversed() возвращает символы по одному. Объединить их мы сможем с помощью метода join().

<sep>.join(<these>) объединяет <these> в строку, используя <sep> в качестве разделителя.

В нашем случае <these> – это полученные символы в обратном порядке.

Но каким должен быть <sep>? Что ж, в данном случае нам не нужен разделитель – нам нужно, чтобы все символы входили в строку с правильными индексами.

Так что же тогда делать? Просто вставьте "" вместо <sep>, как показано ниже:

"".join(reversed(any_string))
# Output
# nohtyP

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

" ".join(reversed(any_string))
# Output
# n o h t y P

Итак, мы разобрали еще один питонический способ перевернуть строку.

Заключение

Итак, мы разобрали три способа перевернуть строку в Python.

Первый способ — с применением рекурсии. Два других — более «питонические». Чтобы получить обратную копию <string>, можно использовать срез строки <string>[:: - 1] или "".join(reversed(<string>)).

Надеюсь, вы нашли этот урок полезным и интересным. Успехов в написании кода!

Перевод статьи «Python Reverse String – String Reversal in Python Explained with Examples».

Похожие записи

Прокрутить вверх