Понимание обращения строк с помощью нарезки

StackOverflow https://stackoverflow.com/questions/766141

  •  12-09-2019
  •  | 
  •  

Вопрос

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

Предполагать a является строковой переменной.Это вернет a строка наоборот:

a[::-1]

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

Это было полезно?

Решение

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

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

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

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 «поступит правильно» при заполнении начала и остановки, поэтому он выполняет итерацию по списку в обратном направлении и выдает вам [10,9,8,7,6,5,4,3,2,1].

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

Другие советы

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

Итак, вкратце, если a = '12345':

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

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

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

Это расширенное обозначение среза:

sequence[start:end:step]

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

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

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

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

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

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

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

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

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

и он печатает:гнирт

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

-> получить фрагмент «a» от начала до конца с шагом 1 назад.

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

а[2:4:2]

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

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

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]

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

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

    return ''.join(o)

Без использования реверса или [::-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]

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

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

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

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

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

name="ravi"
print(name[::-1]) #ivar
Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top