Понимание обращения строк через нарезку

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

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

Ответ 2

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

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

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

Ответ 3

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

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

Ответ 4

Это расширенная нотация фрагмента:

sequence[start:end:step]

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

Ответ 5

Он назвал нотацию фрагмента в Python, и вы можете прочитать немного больше о том, как он работает здесь:

Объяснить нотацию фрагмента Python

Ответ 6

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

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

Ответ 7

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

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

Ответ 8

Я бы сделал это следующим образом:

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

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

Ответ 9

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

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

Ответ 10

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

а [2: 4: 2]

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

Ответ 11

Рассмотрим приведенный ниже список

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]

Ответ 12

мы можем использовать append и pop для этого

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

    return ''.join(o)

Ответ 13

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

Ответ 14

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

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

Ответ 15

s = "python programming"
i = -1
n = len(s)
while i >= -n:
    print(s[i],end="")
    i=i-1

Ответ 16

Вы можете использовать функцию 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

Ответ 17

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

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