Перевернуть строку в Python

Question

Я искал способ напечатать строку в обратном направлении, и после быстрого поиска в Google, я нашел этот метод:

Предположим, что "a" является строковой переменной. Это вернет строку 'a' в обратном направлении:

a[::-1]

Кто-нибудь может объяснить, как это работает?

Answer 1

Конечно, [::] является оператором расширенного среза. Это позволяет вам брать подстроки. По сути, он работает, указывая, какие элементы вы хотите, как [begin:end:step], и работает для всех последовательностей. Две интересные вещи об этом:

• Вы можете опустить один или несколько элементов, и это "правильно"
• Отрицательные числа для начала, конца и шага имеют значение

Для начала и конца, если вы дадите отрицательное число, это означает, что отсчитывать с конца последовательности. Например, если у меня есть список:

l = [1,2,3]

затем l[-1] это 3, l[-2] 2, и l[-3] это 1.

Для step аргумент, отрицательное число означает работать в обратном порядке в последовательности. Итак, для списка::

l = [1,2,3,4,5,6,7,8,9,10]

Вы могли бы написать l[::-1] что в основном означает использовать размер шага -1 при чтении списка. Python будет "делать правильные вещи" при заполнении start и stop, поэтому он перебирает список в обратном направлении и дает вам [10,9,8,7,6,5,4,3,2,1],

Я привел примеры со списками, но строки - это просто другая последовательность и работают так же. Так a[::-1] означает построить строку, соединив символы, которые вы получаете, проходя назад по строке.

Answer 2

Часть "-1" представляет часть "шага" среза - в этом случае она проходит по строке 1 символ за раз, но в обратном направлении (отрицательный шаг означает начало с конца строки). Например, если указать шаг равным 2, вы получите все остальные символы строки, начиная с первого. Если вы укажете шаг -2, вы получите все остальные символы строки, начиная с последнего символа и работая в обратном направлении.

Итак, в двух словах, если a = '12345':

• a[::2] становится 135
• a[::-1] становится 54321
• a[::-2] становится 531

Answer 3

Я думаю, что следующее имеет немного больше смысла для печати строк в обратном порядке, но, возможно, это только я:

for char in reversed( myString ):  
  print( char, end = "" )

Answer 4

Это расширенная запись среза:

sequence[start:end:step]

В этом случае шаг -1 означает задом наперед, а пропуск начала и конца означает, что вы хотите всю строку.

Answer 5

Я бы сделал это так:

variable = "string"
message = ""
for b in variable:
    message = b+message
print (message)

и это печатает: gnirts

Answer 6

Это называется Slice Notation в Python, и вы можете прочитать немного больше о том, как это работает здесь:

Объясните обозначение среза Python

Answer 7

[::-1] дает фрагмент строки a. полный синтаксис a[begin:end:step]который дает [начало], [начало + шаг],... а [конец-1]. Когда шаг отрицательный, вы начинаете в конце и двигаетесь, чтобы начать.

Наконец, начало по умолчанию - начало последовательности, конец до конца и шаг -1.

Answer 8

Он использует расширенную нарезку - строка представляет собой последовательность в Python и разделяет некоторые методы с другими последовательностями (а именно списками и кортежами). Нарезка состоит из трех частей - начало, остановка и шаг. Все они имеют значения по умолчанию - начальные значения по умолчанию равны 0, конечные значения по умолчанию равны len(sequence), а значение шага по умолчанию равно 1. Указывая [::-1], вы говорите "все элементы в последовательности a, начиная с начала, до конца идти назад по одному.

Эта функция была представлена ​​в Python 2.3.5, и вы можете прочитать больше в документах Что нового.

Answer 9

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

-> получить часть "а" от начала до конца с шагом 1 назад.

Answer 10

Использование расширенного синтаксиса слайса

word = input ("Type a word which you want to reverse: ")
def reverse(word):
  word = word[::-1]
  return word
print (reverse(word))

Answer 11

Это основной шаг обозначения, рассмотрим функциональность:

а [2:4:2]

Что происходит, если индекс разделен между позициями 2 и 4, третья переменная устанавливает размер шага, начиная с первого значения. В этом случае он вернул бы a[2], поскольку a[4] является верхней границей, возвращаются только два значения, и второй шаг не выполняется. Оператор (-) минус просто меняет шаг вывода.

Answer 12

Вы можете использовать функцию reversed(). Например

x = "abcd"
for i in reversed(x):
        print(i, end="")
print("\n")
L = [1,2,3]
for i in reversed(L):
        print(i, end="")

печать dcba а также 321

Answer 13

Первые две границы по умолчанию равны 0, а длина последовательности, как и прежде, и шаг -1 указывают на то, что срез должен идти справа налево вместо обычного слева направо. Следовательно, эффект состоит в том, чтобы изменить последовательность.

name="ravi"
print(name[::-1]) #ivar

Answer 14

Рассмотрим список ниже

l=[12,23,345,456,67,7,945,467]

Другой трюк для изменения списка может быть:

l[len(l):-len(l)-1:-1] [467, 945, 7, 67, 456, 345, 23, 12]

l[:-len(l)-1:-1] [467, 945, 7, 67, 456, 345, 23, 12]

l[len(l)::-1] [467, 945, 7, 67, 456, 345, 23, 12]

Answer 15

Без использования реверсирования или [::-1], вот простая версия, основанная на рекурсии, которую я считаю наиболее читаемой:

def reverse(s):

  if len(s)==2:
    return s[-1] + s[0]

  if len(s)==1:
    return s[0]

  return s[-1] + reverse(s[1:len(s)-1]) + s[0]

Answer 16

Мы можем использовать append и pop, чтобы сделать это

def rev(s):
    i = list(s)
    o = list()
    while len(i) > 0:
        o.append(t.pop())

    return ''.join(o)