Как перевернуть строку в питоне: Три элегантных способа перевернуть строку в Python

Три элегантных способа перевернуть строку в Python

Строки

Строки в Python — упорядоченная последовательность символов. В Python нет встроенных методов, позволяющих перевернуть строку, «отзеркалить» ее. Но вообще это сделать можно, причем несколькими способами. 

Существует три способа перевернуть строку.

1. Срезы

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

Делается это так:

stringname[stringlength::-1] # метод 1 

Длиной строки можно и пренебречь:

stringname[::-1] # метод 2

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

Заканчивается он на индексе 0, а шаг — -1 (то есть, шаг назад).

str="pythonist" # исходная строка
stringlength=len(str) # вычисление длины строки
slicedString=str[stringlength::-1] # срез 
print (slicedString) # вывод в консоль перевернутой строки

Вывод:

 tsinohtyp

2. Цикл

Мы можем перевернуть строку и в цикле.

Для начала создадим массив (список) reversedString[].

После этого мы можем запустить цикл, где итерируемой переменной будет index — длина списка.

На каждой итерации цикла в reversedString добавляется символ из строки с индексом [index-1]. После этого index уменьшается на 1. 

Цикл продолжается до тех пор, пока переменная

index не станет равна 0.

str = "pythonist" # исходная строка
reversedString=[]
index = len(str) # вычисляем длину строки и сохраняем ее в переменной index
while index > 0: 
    reversedString += str[ index - 1 ] # сохраняем значение str[index-1] в reverseString
    index = index - 1 # уменьшаем значение index на 1
print(reversedString) # перевернутая строка

Вывод:

 ['t', 's', 'i', 'n', 'o', 'h', 't', 'y', 'p']

3.

Метод join()

Это мощный метод, использующий протокол итератора Python. Этот способ работает следующим образом. Строка поворачивается путем обратной итерации при помощи метода reversed(). После этого происходит объединение символов в новую строку при помощи метода join(). 

Синтаксис выглядит так:

 str="pythonist" 
 reversedstring=''.join(reversed(str))

Пример: 

str = 'pythonist' # исходная строка
reversed=''.join(reversed(str)) # метод .join() объединяет все символы, полученные в результате обратной итерации, в новую строку
print(reversed) # вывод перевернутой строки

Вывод:

 tsinohtyp

Как перевернуть строку в 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».

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

❮ Предыдущая Далее ❯

---

Узнайте, как инвертировать строку в Python.

---

В Python нет встроенной функции для обращения строки.

Самый быстрый (и самый простой?) способ — использовать срез, который делает шаг назад, -1 .

Пример

Перевернуть строку «Hello World»:

txt = «Hello World»[::-1]
print(txt)

Попробуйте сами »

Объяснение примера

У нас есть строка «Hello World», которую мы хотим инвертировать:

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

txt = «Hello World» [::-1]
print(txt)

Создать фрагмент который начинается в конце строки и движется назад.

В этом конкретном примере оператор slice [::-1] означает начало в конец строки и закончить в позиции 0, переместите с помощью шаг -1 , минус единица, что означает один шаг назад.

Разрезать строку

txt = «Hello World» [::-1]
print(txt)

Теперь у нас есть строка txt , которая читает «Hello World» в обратном порядке.

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

Распечатайте список

txt = «Hello World»[::-1]
print(txt)

---

---

Создание функции 90 024

Если вы хотелось бы иметь функцию, в которой вы можете отправлять свои строки и возвращать их назад, вы можете создать функцию и вставить код из пример выше.

Пример

def my_function(x):
  вернуть x[::-1]

mytxt = my_function(«Интересно, как этот текст выглядит наоборот»)

print(mytxt)

Попробуйте сами »

Объяснение примера

Создайте функцию, которая принимает строку в качестве аргумента.

Создать функцию

def my_function(x):
  return x[::-1]

mytxt = my_function(«Интересно, как этот текст выглядит задом наперед»)

печать (mytxt)

Разрежьте строку, начиная с конца строки, и двигайтесь назад.

Разрезать нить

def my_function(x):
  return x [::-1]

mytxt = my_function(«Интересно, как этот текст выглядит задом наперед»)

print(mytxt)

Вернуть обратную строку

Вернуть строку

def my_function(x):
  вернуть х[::-1]

mytxt = my_function(«Интересно, как этот текст выглядит задом наперед»)

печать (mytxt)

Вызов функции со строкой в ​​качестве параметра:

Вызов функции

def my_function(x):
 возврат x[::-1]

mytxt = my_function(«Я интересно, как этот текст выглядит наоборот»)

print(mytxt)

Распечатать результат:

Распечатать результат

def my_function(x):
 возврат x[::-1]

mytxt = my_function(«Интересно, как этот текст выглядит задом наперед»)

печать (mytxt)

---

❮ Предыдущий Далее ❯

ВЫБОР ЦВЕТА

---

---

---

Лучшие учебники

Учебник по HTML
Учебник по CSS
Учебник по JavaScript
Учебник How To
Учебник по SQL
Учебник по Python
Учебник по W3. CSS
Учебник по Bootstrap
Учебник по PHP
Учебник по Java
Учебник по C++
Учебник по jQuery
9000 3

Основные каталожные номера

Справочник по HTML
Справочник по CSS
JavaScript ссылка
SQL Ссылка
Ссылка на Python
W3.CSS Ссылка
Справочник по начальной загрузке
Справочник PHP
HTML Colors
Java Справочник
Angular Research
JQUERY. Примеры HTML
Примеры CSS
Примеры JavaScript
Примеры инструкций
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery

---

ФОРУМ | О

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

Copyright 1999-2023 Refsnes Data. Все права защищены.
W3Schools работает на основе W3.CSS.

Перевернуть строку в Python (6 разных способов)

Читать

Обсудить

Улучшить статью

Сохранить статью

Нравится Статья

Библиотека строк Python не поддерживает встроенный « reverse() », как это делают другие контейнеры Python, такие как список, поэтому знание других методов реверсирования строки может оказаться полезным. В этой статье обсуждается несколько способов достижения этого в Python.

Пример:

  Ввод:  Компьютерщики
  Вывод:  skeegrofskeeG 

Обратное преобразование строки в Python с использованием цикла

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

Временная сложность: O(n)
Вспомогательное пространство: O(1)

Реализация:

Python3

def реверс(и):      стр = 90 011 «»      для i в s: стр = i + стр      возврат стр 9 0012   с = "Geeksforgeeks"   print ( "Исходная строка: " , конец = 9 0011 "") печать (с)   print ( "Перевернутая строка (с использованием циклов): " , end = "") print 90 011 (реверс(ы))

Вывод

 Исходная строка: Geeksforgeeks
Перевернутая строка (с использованием циклов): skeegrofskeeG 

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

Строка передается в качестве аргумента рекурсивной функции для обращения строки. В функции базовым условием является то, что если длина строки равна 0, строка возвращается. Если он не равен 0, рекурсивно вызывается обратная функция, которая вырезает часть строки, кроме первого символа, и объединяет первый символ с концом разрезанной строки.

Реализация:

Python3

def реверс(ы):      if len (s) = = 0 :          возврат s      else : 900 12          обратный обратный(s[ 1 :]) + s[ 0 ]     90 021 s = "Geeksforgeeks"   печать ( " Исходная строка: " , end = "") print (s)   print ( "Перевернутая строка (с использованием рекурсии): , конец = "") печать (оборот(ы))

9 0021 Вывод

 Исходная строка: Geeksforgeeks
Перевернутая строка (с использованием рекурсии): skeegrofskeeG 

Временная сложность : O(n), для рекурсии на обратную 
Вспомогательный пробел : O(n), для стека вызовов рекурсии

Обратная строка в Python с использованием стека

Создан пустой стек. Один за другим символ строки помещается в стек. Один за другим все символы из стека извлекаются и помещаются обратно в строку.

Временная сложность: O(n)
Вспомогательное пространство: O(n)

Реализация:

Python3

90 259

def createStack():      стек = []      возврат стек   по умолчанию размер (стопка):      return len (стек)   def isEmpty (стек) :      if размер (стопка) = = 0 :          возврат истина   def push(stack, item):      stack. append(item) 900 02   def pop(stack):      , если isEmpty(stack):          return      return stack.pop() 900 12   по умолчанию реверс(строка):      n = len (строка)             стек = createStack()        90 003      для i в диапазон ( 0 , n, 1 ): 900 03          push(stack, string[i])                  строка = ""             9002 1      для i в диапазон ( 0 , n, 1 ): 900 03          строка + = pop(stack)        return string 9000 3     s = "Geeksforgeeks" print ( "Исходная строка: " , конец = "") ( "Перевернутая строка (с использованием стека): , конец = "") печать (оборот(ы))

9 0021 Вывод

 Исходная строка: Geeksforgeeks
Перевернутая строка (с использованием стека): skeegrofskeeG 

Обратная строка в Python с использованием расширенного фрагмента

Расширенный фрагмент предлагает поместить поле «шаг» как [начало, стоп, шаг] и не дает поле как начало и конец указывает по умолчанию на 0 и длину строки соответственно, и « -1 ”обозначает начало с конца и остановку в начале, следовательно, переворачивание строки.

Временная сложность : O(n)
Вспомогательное пространство : O(1)

Реализация:

Python3

по умолчанию реверс(строка):      строка = строка[:: - 1 ]      return string   s = "Geeksforgeeks"   90 003 print ( "Исходная строка: " , конец = " ") print (s)   print ( "Перевернутая строка (с использованием расширенного синтаксиса слайса): " , конец = "") печать (реверс(ы))

Выход

9023 2 Исходная строка: Geeksforgeeks Перевернутая строка (с использованием расширенного синтаксиса среза): skeegrofskeeG

Обратная строка в Python с использованием метода reversed()

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

Временная сложность : O(n)
Вспомогательное пространство : O(n)

Реализация:

Python3

9 0259

по умолч. реверс(строка):      string = "".join( reversed (string))      900 11 возврат строка   с = "Geeksforgeeks"   print ( "Исходная строка: " , конец 9 0012 = "") печать (с)   print ( "Перевернутая строка (использование перевернутой): " , end = "") 9 0003 печать (оборот(ы))

Вывод

 Исходная строка: Geeksforgeeks
Перевернутая строка (с использованием перевернутого): skeegrofskeeG 

Обратная строка в Python с использованием понимания списка ()

Понимание списка создает список элементов строки в обратном порядке, а затем его элементы соединяются с помощью соединения (). И формируется строка обратного порядка.

Временная сложность: O(n)
Вспомогательное пространство: O(1)

Реализация:

Python3

9036 6

def reverse(string):      строка = [строка[i] для i в диапазон ( len (строка) - 1 , - 1 900 11 , - 1 )]      return "".join(string)   s = "Geeksforgeeks"   print ( "Исходная строка : " , s)   print ( "Перевернутая строка (используя перевернутое значение): " , перевернутое(ые))

Вывод

 Исходная строка: Гиксфоргикс
Перевернутая строка (с использованием перевернутого): skeegrofskeeG 

Обратное преобразование строки в Python с помощью вызова функции

Функция для обращения строки путем преобразования строки в список, затем ее обращения и повторного преобразования в строку.