Простая строка Python (назад) Нарезка

Question

Да, я знаю, что есть много похожих вопросов. Но я просто не могу найти то, что искал.

Мое замешательство - это обратная нарезка.

my_jumble = ['jumbly', 'wumbly', 'number', 5] 
print(my_jumble[:1:-1]) 

Теперь я обнаружил, что результат будет

[5, 'number'] 

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

print(my_jumble[:2:-1]) 

Я был уверен, что Python бы дать мне что-то вроде

[5, 'number', 'wumbly'] 

Вместо этого он дал мне это, которое заставило меня полностью потерял ...

[5] 

Может кто-то объяснить, что здесь? Я новичок в Python и считаю это очень запутанным. Спасибо за любую помощь.

Answer 1

Я думаю, что один из самых простых способов понять, что происходит в коде, понимая, что назад нарезка переворачивает путь вы индекс ваш список (визуально, это как реверсивный список) до получение нарезанных , но указатели элементов в самом списке не изменение.

Таким образом, если у вас есть список, как это:

['jumbly', 'wumbly', 'number', 5] 
    0  1   2  3 #<-- index 

, сделав его назад чтение (добавление -1 в качестве третьего индексатор), вы сделаете это выглядит как это (потому что теперь индексирует от последнего к первому, а не от первого до последнего):

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 

, а затем, когда вы отрезаете от «начала» до одного (:1), вы получите все, от «начала» (ныне "Начало" является 3) и останавливается, когда видит 1:

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 
^ ^  x 
grab! grab!  nope! 

Таким образом, вы получили ваше возвращение:

[5, 'number'] 

Того же принцип применяется, когда вы отсталый кусочек с [:2:-1]:

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 
^  x 
grab! nope! 

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

[5] 

Теперь, используя этот принцип, вы знаете, что добавить в качестве второго индексатора, если вы хотите вернуть то, что хотите: zero! ->[:0:-1]:

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 
^ ^  ^  x 
grab! grab!  grab! nope! 

Тогда вы получите результат, который вы хотите:

[5, 'number', 'wumbly'] 

Answer 2

@HarryLens Чтобы сделать то, что вы на самом деле хотите, вам нужно будет сделать это вот так.

print(my_jumble[-1:0:-1]) 

Даже это будет делать:

print(my_jumble[:0:-1]) 

Я думаю, что вы считали, что, когда вы перешагнуть его на -1, список восстанавливается. Вы видите, что первое число представляет начальную позицию, а второе число - конечную позицию (нужного фрагмента) в текущем списке, а не перевернутый список. См this.

Answer 3

Синтаксис вы используете list[start:stop:step]

Если вы не вводите значение для start, нет даже нуля, тогда python решает подходящий старт. Это будет 0 для положительного шага и последнего элемента для отрицательного шага.

Итак, в первом примере вы фактически говорите, что выбираете все пункты, начиная с 0, до 1, но в обратном порядке. Так распечатано [5,'number']

В вашем втором примере, что вы говорите, выбирают все предметы, начиная с первого, до третьего, в обратном порядке. Итак, в обратном порядке, вы начинаете с 5, третий элемент в вашем списке - 'number', но так как вы сказали только до третьего, он останавливается прямо там.

Поскольку вы дали положительное значение для stop, оно будет находиться вправо-влево, следовательно, третий элемент в правильном порядке в вашем случае.

Также обратите внимание, что в python list[start: stop] эквивалентно [start: stop), считается первым элементом, не имеет правой границы.

Answer 4

array[start:end:step] означает, чтобы начать с индексом start затем на каждом цикле петли добавить к нему step и разорвать петлю, если индекс становится больше или равна end.Если start опущено, оно равно 0. Если end опущено, оно установлено на len(array). Если start или end отрицательный, оно установлено на len(array) + start или len(array) + end. Если step отрицательный, он добавляется к текущему индексу для каждого цикла цикла, но условие продолжения цикла равно current_index > end, а не current_index < end, когда step положителен.

Так ['jumbly', 'wumbly', 'number', 5][:1:-1] значит начать принимать элементы из индекса len(array) индексировать 1 (не включая) - поэтому мы, учитывая пункты ['number', 5]:

>>> ['jumbly', 'wumbly', 'number', 5][:1:-1] 
>>> [5, 'number'] 

['jumbly', 'wumbly', 'number', 5][:2:-1] значит начать принимать элементы из индекса len(array) индексировать 2 (значение 'number' хранится в списке с индексом 2) (не включая) - таким образом, мы имеем [5]:

Или лучше объяснить строкой, символами которой являются индексы:

>>> '0123'[:1:-1] 
>>> '32' 

>>> '0123'[:2:-1] 
>>> '3'