Понимание нотации среза Python

Мне нужно хорошее объяснение (ссылки-это плюс) в нотации среза Python.

для меня эта нотация нуждается в некоторой подборке.

Он выглядит чрезвычайно мощным, но у меня не совсем голова вокруг него.

30 ответов


это довольно просто на самом деле:

a[start:end] # items start through end-1
a[start:]    # items start through the rest of the array
a[:end]      # items from the beginning through end-1
a[:]         # a copy of the whole array

есть еще step значение, которое можно использовать с любым из вышеперечисленных:

a[start:end:step] # start through not past end, by step

ключевой пункт, чтобы помнить, что :end value представляет первое значение, которое является не на выбранном интервале. Итак, разница между end и start - количество выбранных элементов (если step это 1, по умолчанию).

другой особенностью является то, что start или end может быть отрицательный число, что означает, что оно отсчитывается от конца массива вместо начала. Итак:

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

аналогично, step может быть отрицательным числом:

a[::-1]    # all items in the array, reversed
a[1::-1]   # the first two items, reversed
a[:-3:-1]  # the last two items, reversed
a[-3::-1]  # everything except the last two items, reversed

Python добр к программисту, если есть меньше элементов, чем вы просите. Например, если вы попросите a[:-2] и a содержит только один элемент, вы получаете пустой список вместо ошибки. Иногда вы предпочитаете ошибку, поэтому вы должны знать, что это может случаться.


на Python учебник говорит об этом (прокрутите немного вниз, пока не дойдете до части о нарезке).

диаграмма ASCII art также полезна для запоминания того, как работают срезы:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

один из способов запомнить, как работают срезы-думать о индексах, как указывает между символов, с левым краем первого символа, пронумерованного 0. Затем правый край последнего символа строки n символы имеют индекс n.


перечисление возможностей, разрешенных грамматикой:

>>> seq[:]                # [seq[0],   seq[1],          ..., seq[-1]    ]
>>> seq[low:]             # [seq[low], seq[low+1],      ..., seq[-1]    ]
>>> seq[:high]            # [seq[0],   seq[1],          ..., seq[high-1]]
>>> seq[low:high]         # [seq[low], seq[low+1],      ..., seq[high-1]]
>>> seq[::stride]         # [seq[0],   seq[stride],     ..., seq[-1]    ]
>>> seq[low::stride]      # [seq[low], seq[low+stride], ..., seq[-1]    ]
>>> seq[:high:stride]     # [seq[0],   seq[stride],     ..., seq[high-1]]
>>> seq[low:high:stride]  # [seq[low], seq[low+stride], ..., seq[high-1]]

конечно, если (high-low)%stride != 0, тогда конечная точка будет немного ниже, чем high-1.

если stride отрицательно, порядок немного изменен, так как мы отсчитываем:

>>> seq[::-stride]        # [seq[-1],   seq[-1-stride],   ..., seq[0]    ]
>>> seq[high::-stride]    # [seq[high], seq[high-stride], ..., seq[0]    ]
>>> seq[:low:-stride]     # [seq[-1],   seq[-1-stride],   ..., seq[low+1]]
>>> seq[high:low:-stride] # [seq[high], seq[high-stride], ..., seq[low+1]]

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

>>> class slicee:
...     def __getitem__(self, item):
...         return `item`
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'

ответы выше не обсуждают назначение среза. Чтобы понять назначение среза, полезно добавить еще одну концепцию в искусство ascii:

                +---+---+---+---+---+---+
                | P | y | t | h | o | n |
                +---+---+---+---+---+---+
Slice position: 0   1   2   3   4   5   6
Index position:   0   1   2   3   4   5

>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers: 
# indexing gives items, not lists
>>> p[0]
 'P'
>>> p[5]
 'n'
# slicing gives lists
>>> p[0:1]
 ['P']
>>> p[0:2]
 ['P','y']

одна эвристика, для среза от нуля до n, подумайте: "ноль-это начало, начните с начала и возьмите n элементов в списке".

>>> p[5] # the last of six items, indexed from zero
 'n'
>>> p[0:5] # does NOT include the last item!
 ['P','y','t','h','o']
>>> p[0:6] # not p[0:5]!!!
 ['P','y','t','h','o','n']

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

>>> p[0:4] # start at the beginning and count out 4 items
 ['P','y','t','h']
>>> p[1:4] # take one item off the front
 ['y','t','h']
>>> p[2:4] # take two items off the front
 ['t','h']
# etc.

первое правило назначения среза заключается в том, что с нарезки возвращает список, назначение фрагмент требует список (или другой метод):

>>> p[2:3]
 ['t']
>>> p[2:3] = ['T']
>>> p
 ['P','y','T','h','o','n']
>>> p[2:3] = 't'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable

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

>>> p[2:4]
 ['T','h']
>>> p[2:4] = ['t','r']
>>> p
 ['P','y','t','r','o','n']

третье правило назначение среза заключается в том, что назначенный список (iterable) не должен иметь одинаковую длину; индексированный срез просто вырезается и заменяется массово тем, что назначается:

>>> p = ['P','y','t','h','o','n'] # start over
>>> p[2:4] = ['s','p','a','m']
>>> p
 ['P','y','s','p','a','m','o','n']

самая сложная часть, к которой нужно привыкнуть, - это назначение пустых срезов. Используя эвристику 1 и 2, легко получить голову вокруг индексации пустой фрагмент:

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []

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

>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # assigned list is same length as slice
>>> p 
 ['P','y','x','y','o','n'] # result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # assigned list is longer than slice
>>> p 
 ['P','y','t','x','y','o','n'] # result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
 ['P','y','t','h','x','y','o','n'] # result is longer still

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

резервное копирование немного, что происходит, когда вы продолжаете идти с нашей процессией подсчета ломтика начало?

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []

с нарезкой, как только вы закончите, вы закончите; он не начинает нарезать назад. В Python вы не получите отрицательных шагов, если вы явно не попросите их, используя отрицательное число.

>>> p[5:3:-1]
 ['n','o']

есть некоторые странные последствия для правила "как только вы закончите, вы закончите":

>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []
>>> p[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

на самом деле, по сравнению с индексированием, нарезка python является странным доказательством ошибки:

>>> p[100:200]
 []
>>> p[int(2e99):int(1e99)]
 []

это может пригодиться иногда но это также может привести к несколько странному поведению:

>>> p
 ['P', 'y', 't', 'h', 'o', 'n']
>>> p[int(2e99):int(1e99)] = ['p','o','w','e','r']
>>> p
 ['P', 'y', 't', 'h', 'o', 'n', 'p', 'o', 'w', 'e', 'r']

в зависимости от вашего приложения, что может... или, возможно, не... будь тем, на что ты надеялся!

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

>>> r=[0,1,2,3,4]
>>> r[1:1]
[]
>>> r[1:1]=[9,8]
>>> r
[1, 9, 8, 2, 3, 4]
>>> r[1:1]=['blah']
>>> r
[1, 'blah', 9, 8, 2, 3, 4]

это также может прояснить разницу между нарезкой и индексированием.


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

короче говоря, двоеточия (:) в подстрочное обозначение (subscriptable[subscriptarg]) сделайте нотацию среза-которая имеет необязательные аргументы,start, stop, step:

sliceable[start:stop:step]

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

Важные Определения

для начала, давайте определим термины:

начало: начальный индекс среза, он будет включать элемент в этот индекс, если он не совпадает с остановка, значение по умолчанию-0, т. е. первый индекс. Если он отрицательный, это означает начать n элементы с конца.

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

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

Как Работает Индексация

вы можете сделать любой из этих положительных или отрицательных чисел. Значение положительных чисел является простым, но для отрицательных чисел просто как и индексы в Python, вы отсчитываете назад от конца для старт и остановка и шаг, вы просто уменьшаете свой индекс. Этот пример из руководства по документации, но я немного изменил его, чтобы указать, какой элемент в последовательности ссылается каждый индекс:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

Как Нарезка Работает

чтобы использовать нотацию среза с последовательностью, которая ее поддерживает, необходимо включить хотя бы одну двоеточие в квадратных скобках, которые следуют за последовательностью (которая на самом деле реализовать __getitem__ метод последовательности, согласно модели данных Python.)

срез нотации работает следующим образом:

sequence[start:stop:step]

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

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

my_list[-9:]

когда я вижу это, я читаю часть в скобках как " 9th от конца до конца.(На самом деле, я сокращаю его мысленно как "-9, on")

объяснение:

полное обозначение

my_list[-9:None:None]

и заменить значения по умолчанию (на самом деле, когда step отрицательно, stopпо умолчанию -len(my_list) - 1, так что None для остановки действительно просто означает, что он идет до какого бы конца ни дошел шаг):

my_list[-9:len(my_list):1]

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

list_copy = sequence[:]

и очистка их с:

del my_list[:]

(Python 3 получает list.copy и list.clear метод.)

, когда step отрицательно, значения по умолчанию для start и stop изменить

по умолчанию, когда step аргумент пуст (или None), он назначен +1.

но вы можете передать отрицательное целое число, и список (или большинство других стандартных срезов) будет разрезан от конца до начала.

таким образом, отрицательный срез изменит значения по умолчанию для start и stop!

подтверждение этого в источнике

мне нравится поощрять пользователей читать источник, а также документация. The исходный код для объектов среза, и эта логика находится здесь. Сначала мы определяем, если step отрицательные:

 step_is_negative = step_sign < 0;

если это так, нижняя граница -1 означает, что мы срезаем весь путь до начала и включая начало, а верхняя граница-длина минус 1, то есть мы начинаем в конце. (Обратите внимание, что семантика этого -1 is разные с -1 что пользователи могут передавать индексы в Python указание последнего пункта.)

if (step_is_negative) {
    lower = PyLong_FromLong(-1L);
    if (lower == NULL)
        goto error;

    upper = PyNumber_Add(length, lower);
    if (upper == NULL)
        goto error;
}

иначе step является положительным, и нижняя граница будет равна нулю, а верхняя граница (которую мы поднимаем, но не включаем) длина срезанного списка.

else {
    lower = _PyLong_Zero;
    Py_INCREF(lower);
    upper = length;
    Py_INCREF(upper);
}

тогда нам может потребоваться применить значения по умолчанию для start и stop - значение по умолчанию для start рассчитывается как верхняя граница, когда step отрицательные:

if (self->start == Py_None) {
    start = step_is_negative ? upper : lower;
    Py_INCREF(start);
}

и stop нижняя граница:

if (self->stop == Py_None) {
    stop = step_is_negative ? lower : upper;
    Py_INCREF(stop);
}

дайте вашим ломтикам описательное имя!

вы можете найти полезным отделить формирование среза от передачи его в list.__getitem__ метод (вот что делают квадратные скобки). Даже если вы не новичок в этом, он держит ваш код более читаемым, чтобы другие, которые могут прочитать ваш код, могли легче понять, что вы делаете.

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

last_nine_slice = slice(-9, None)

второй аргумент, None, требуется, чтобы первый аргумент интерпретировался как start аргумент в противном случае это будет stop аргумент.

затем вы можете передать объект slice в свою последовательность:

>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]

интересно, что диапазоны также взять ломтики:

>>> range(100)[last_nine_slice]
range(91, 100)

память Соображения:

поскольку срезы списков Python создают новые объекты в памяти, еще одна важная функция, о которой нужно знать, -itertools.islice. Обычно вы хотите перебирать срез, а не просто статически создавать его в памяти. islice идеально подходит для этого. Предостережение, оно не поддерживает отрицательные аргументы start, stop или step, поэтому, если это проблема, вам может потребоваться рассчитать индексы или отменить итерацию заранее.

length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)

и теперь:

>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]

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


и пару вещей, которые не сразу очевидны для меня, когда я впервые увидел синтаксис:

>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]

простой способ изменить последовательности!

и если вы хотели, по какой-то причине, каждый второй элемент в обратной последовательности:

>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]

нашел этот большой стол в http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.

Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]
Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]
                   +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]
                   | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]
                   +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]
Slice from front:  :   1   2   3   4   5   :    a[-2]==4
Slice from rear:   :  -5  -4  -3  -2  -1   :
                                                b=a[:]
                                                b==[0,1,2,3,4,5] (shallow copy of a)

В Python 2.7

нарезка на Python

[a:b:c]

len = length of string, tuple or list

c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.

a --  When c is positive or blank, default is 0. When c is negative, default is -1.

b --  When c is positive or blank, default is len. When c is negative, default is -(len+1).

понимание назначения индекса очень важно.

In forward direction, starts at 0 and ends at len-1

In backward direction, starts at -1 and ends at -len

когда вы говорите [a:b: c], вы говорите в зависимости от знака c (вперед или назад), начните с a и закончите на b (исключая элемент с индексом bth). Используйте правило индексирования выше и помните, что вы найдете только элементы в этом диапазоне:

-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1

но этот ряд продолжается в обоих направлениях бесконечно:

...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....

например:

             0    1    2   3    4   5   6   7   8   9   10   11
             a    s    t   r    i   n   g
    -9  -8  -7   -6   -5  -4   -3  -2  -1

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

и последнее: если a и b равны, то также вы получаете пустой список:

>>> l1
[2, 3, 4]

>>> l1[:]
[2, 3, 4]

>>> l1[::-1] # a default is -1 , b default is -(len+1)
[4, 3, 2]

>>> l1[:-4:-1] # a default is -1
[4, 3, 2]

>>> l1[:-3:-1] # a default is -1
[4, 3]

>>> l1[::] # c default is +1, so a default is 0, b default is len
[2, 3, 4]

>>> l1[::-1] # c is -1 , so a default is -1 and b default is -(len+1)
[4, 3, 2]


>>> l1[-100:-200:-1] # Interesting
[]

>>> l1[-1:-200:-1] # Interesting
[4, 3, 2]


>>> l1[-1:-1:1]
[]


>>> l1[-1:5:1] # Interesting
[4]


>>> l1[1:-7:1]
[]

>>> l1[1:-7:-1] # Interesting
[3, 2]

>>> l1[:-2:-2] # a default is -1, stop(b) at -2 , step(c) by 2 in reverse direction
[4]

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

(from:to:step)

любой из них являются необязательными

(:to:step)
(from::step)
(from:to)

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

это работает для меня в любом случае...


мне легче запомнить, как это работает, тогда я могу выяснить любую конкретную комбинацию start/stop/step.

полезно понять range() первый:

def range(start=0, stop, step=1):  # illegal syntax, but that's the effect
    i = start
    while (i < stop if step > 0 else i > stop):
        yield i
        i += step

начинается с start, приращение,step, не достигают stop. Очень просто.

вещь, чтобы помнить о негативном шаге, это stop всегда является исключенным концом, будь то выше или ниже. Если вы хотите тот же срез в противоположном порядке, это намного чище разворот отдельно: например 'abcde'[1:-2][::-1] отрезает один символ слева, два справа, а затем возвращается. (См. также reversed().)

нарезка последовательности такая же, за исключением того, что она сначала нормализует отрицательные индексы и никогда не может выходить за пределы последовательности:

TODO: в приведенном ниже коде была ошибка с "никогда не выходить за пределы последовательности", когда abs (Шаг)>1; I думаю я исправил это, чтобы быть правильным, но это трудно понимать.

def this_is_how_slicing_works(seq, start=None, stop=None, step=1):
    if start is None:
        start = (0 if step > 0 else len(seq)-1)
    elif start < 0:
        start += len(seq)
    if not 0 <= start < len(seq):  # clip if still outside bounds
        start = (0 if step > 0 else len(seq)-1)
    if stop is None:
        stop = (len(seq) if step > 0 else -1)  # really -1, not last element
    elif stop < 0:
        stop += len(seq)
    for i in range(start, stop, step):
        if 0 <= i < len(seq):
            yield seq[i]

не беспокойтесь о is None детали-просто помните, что опуская start и/или stop всегда делает правильную вещь, чтобы дать вам всю последовательность.

нормализация отрицательных индексов сначала позволяет начать и / или остановить подсчет с конца независимо: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc' несмотря на range(1,-2) == []. Нормализация иногда рассматривается как "по модулю длины", но обратите внимание, что она добавляет длину только один раз: например 'abcde'[-53:42] просто весь строка.


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

mylist[X:Y]

X-это индекс первого элемента, который вы хотите.
Y-это индекс первого элемента не хочу.


Index:
      ------------>
  0   1   2   3   4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
  0  -4  -3  -2  -1
      <------------

Slice:
    <---------------|
|--------------->
:   1   2   3   4   :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
:  -4  -3  -2  -1   :
|--------------->
    <---------------|

Я надеюсь, что это поможет вам смоделировать список в Python.

ссылка:http://wiki.python.org/moin/MovingToPythonFromOtherLanguages


обозначение нарезки Python:

a[start:end:step]
  • на start и end отрицательные значения интерпретируются как относительно конца последовательности.
  • положительные показатели end указать должность после последний элемент, который будет включен.
  • пустые значения по умолчанию следующие:[+0:-0:1].
  • использование отрицательного шага меняет интерпретацию start и end

в нотация распространяется на (numpy) матрицы и многомерные массивы. Например, чтобы нарезать целые столбцы, вы можете использовать:

m[::,0:2:] ## slice the first two columns

слайсы содержат ссылки, а не копии, элементов массива. Если вы хотите сделать копию массива, вы можете использовать deepcopy().


вы также можете использовать назначение среза для удаления одного или нескольких элементов из списка:

r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 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]

>>> l[::-1]
[467, 945, 7, 67, 456, 345, 23, 12]

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

см. ответ abc выше


вот как я преподаю ломтики новичкам:

понимание разницы между индексированием и нарезкой:

Wiki Python имеет эту удивительную картину, которая четко различает индексирование и нарезку.

enter image description here

Это список с 6 элементами в нем. Чтобы лучше понять нарезку, рассмотрим этот список как набор из шести ящиков, расположенных вместе. В каждой коробке есть алфавит.

индексирование похоже на дело с содержимое коробки. Вы можете проверить содержимое любого окна. Но вы не можете проверить содержимое нескольких ящиков одновременно. Вы даже можете заменить содержимое коробки. Но вы не можете поместить 2 шара в 1 коробку или заменить 2 шара за раз.

In [122]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [123]: alpha
Out[123]: ['a', 'b', 'c', 'd', 'e', 'f']

In [124]: alpha[0]
Out[124]: 'a'

In [127]: alpha[0] = 'A'

In [128]: alpha
Out[128]: ['A', 'b', 'c', 'd', 'e', 'f']

In [129]: alpha[0,1]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-129-c7eb16585371> in <module>()
----> 1 alpha[0,1]

TypeError: list indices must be integers, not tuple

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

вы можете даже пикап первые 3 коробки или последние 2 ящики и все коробки между 1 и 4. Таким образом, вы можете выбрать любой Набор коробок, если вы знаете начало и конец. Эти позиции называются позициями start & stop.

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

In [130]: alpha[0:1]
Out[130]: ['A']

In [131]: alpha[0:1] = 'a'

In [132]: alpha
Out[132]: ['a', 'b', 'c', 'd', 'e', 'f']

In [133]: alpha[0:2] = ['A', 'B']

In [134]: alpha
Out[134]: ['A', 'B', 'c', 'd', 'e', 'f']

In [135]: alpha[2:2] = ['x', 'xx']

In [136]: alpha
Out[136]: ['A', 'B', 'x', 'xx', 'c', 'd', 'e', 'f']

Нарезка С Шагом:

до сих пор вы постоянно собирали коробки. Но иногда вам нужно подобрать дискретно. Например, вы можете забрать каждый второе поле. Вы даже можете забрать каждую третью коробку с конца. Это значение называется размером шага. Это представляет собой промежуток между последовательными съемками. Размер шага должен быть положительным, если вы выбираете коробок от начала до конца и наоборот.

In [137]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [142]: alpha[1:5:2] 
Out[142]: ['b', 'd']

In [143]: alpha[-1:-5:-2]
Out[143]: ['f', 'd']

In [144]: alpha[1:5:-2]
Out[144]: []

In [145]: alpha[-1:-5:2]      
Out[145]: []

Как Python Вычисляет Отсутствующие Параметры:

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

если вы проверяете исходный код CPython, Вы найдете функцию pyslice_getindicesex, которая вычисляет индексы в срез для любых заданных параметров. Вот логический эквивалент кода в Python.

эта функция принимает объект Python и дополнительные параметры для нарезки и возвращает start, stop, step & slice length для запрошенного среза.

def py_slice_get_indices_ex(obj, start=None, stop=None, step=None):

    length = len(obj)

    if step is None:
        step = 1
    if step == 0:
        raise Exception("Step cannot be zero.")

    if start is None:
        start = 0 if step > 0 else length - 1
    else:
        if start < 0:
            start += length
        if start < 0:
            start = 0 if step > 0 else -1
        if start >= length:
            start = length if step > 0 else length - 1

    if stop is None:
        stop = length if step > 0 else -1
    else:
        if stop < 0:
            stop += length
        if stop < 0:
            stop = 0 if step > 0 else -1
        if stop >= length:
            stop = length if step > 0 else length - 1

    if (step < 0 and stop >= start) or (step > 0 and start >= stop):
        slice_length = 0
    elif step < 0:
        slice_length = (stop - start + 1)/(step) + 1
    else:
        slice_length = (stop - start - 1)/(step) + 1

    return (start, stop, step, slice_length)

это интеллект, который присутствует за срезы. Поскольку Python имеет встроенную функцию slice, вы можете передать некоторые параметры и проверить, как лихо он вычисляет недостающие параметры.

In [21]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [22]: s = slice(None, None, None)

In [23]: s
Out[23]: slice(None, None, None)

In [24]: s.indices(len(alpha)) 
Out[24]: (0, 6, 1)

In [25]: range(*s.indices(len(alpha)))
Out[25]: [0, 1, 2, 3, 4, 5]

In [26]: s = slice(None, None, -1) 

In [27]: range(*s.indices(len(alpha)))
Out[27]: [5, 4, 3, 2, 1, 0]

In [28]: s = slice(None, 3, -1)        

In [29]: range(*s.indices(len(alpha)))
Out[29]: [5, 4]

Примечание: этот пост изначально написан в моем блоге http://www.avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html


как правило, написание кода с большим количеством жестко закодированных значений индекса приводит к удобочитаемости и беспорядок обслуживания. Например, если вы вернетесь к коду через год, вы будете посмотрите на него и задумайтесь, о чем вы думали, когда писали его. Показанное решение это просто способ более четко указать, что на самом деле делает ваш код. В общем случае встроенный slice () создает объект slice, который можно использовать в любом месте среза разрешено. Например:

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]

Если у вас есть экземпляр среза s, Вы можете получить больше информации о нем, посмотрев на его s.начнем, с. стоп, и С. атрибуты шага, соответственно. Например:

>>> a = slice(10, 50, 2)
>>> a.start
10
>>> a.stop
50
>>> a.step
2
>>>

1. Срез Нотации

чтобы сделать его простым, помню slice имеет только одну форму:

s[start:end:step]

и вот как это работает:

  • s: объект, который можно нарезать
  • start: первый индекс для запуска итерации
  • end: последний индекс, обратите внимание, что end индекс не будет включен в полученный срез
  • step: выбрать каждый элемент step индекс

другое главное: все start,end, step можно опустить! и если они опущены, их значение по умолчанию будет использоваться:0,len(s),1 соответственно.

так что возможные варианты:

# mostly used variations
s[start:end]
s[start:]
s[:end]

# step related variations
s[:end:step]
s[start::step]
s[::step]

# make a copy
s[:]

Примечание: Если start>=end(учитывая только тогда, когда step>0), python вернет пустой срез [].

2. Подводные камни

вышеуказанная часть объясняет основные функции о том, как slice работает, он будет работать в большинстве случаев. Однако могут быть подводные камни, которые вы должны остерегаться, и эта часть объясняет их.

отрицательные индексы

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

например:

s[-5:]    # start at the 5th index from the end of array, 
          # thus returns the last 5 elements
s[:-5]    # start at index 0, end until the 5th index from end of array, 
          # thus returns s[0:len(s)-5]

негативный шаг

сделать вещи более запутанной, что step может быть отрицательным тоже!

отрицательный шаг означает итерацию массива назад: от конца к началу, с включенным конечным индексом и начальным индексом, исключенным из результата.

Примечание: если шаг отрицательный, значение по умолчанию для start to len(s)end не равен 0, потому что s[::-1] содержит s[0]). Например:

s[::-1]            # reversed slice
s[len(s)::-1]      # same as above, reversed slice
s[0:len(s):-1]     # empty list

ошибка вне диапазона?

удивлюсь: slice не вызывает IndexError, когда индекс находится вне диапазона!

если индекс находится вне диапазона, python постарается установить индекс в 0 или len(s) согласно ситуации. Например:

s[:len(s)+5]      # same as s[:len(s)]
s[-len(s)-5::]    # same as s[0:]
s[len(s)+5::-1]   # same as s[len(s)::-1], same as s[::-1]

3. Примеры

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

# create our array for demonstration
In [1]: s = [i for i in range(10)]

In [2]: s
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: s[2:]   # from index 2 to last index
Out[3]: [2, 3, 4, 5, 6, 7, 8, 9]

In [4]: s[:8]   # from index 0 up to index 8
Out[4]: [0, 1, 2, 3, 4, 5, 6, 7]

In [5]: s[4:7]  # from index 4(included) up to index 7(excluded)
Out[5]: [4, 5, 6]

In [6]: s[:-2]  # up to second last index(negative index)
Out[6]: [0, 1, 2, 3, 4, 5, 6, 7]

In [7]: s[-2:]  # from second last index(negative index)
Out[7]: [8, 9]

In [8]: s[::-1] # from last to first in reverse order(negative step)
Out[8]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In [9]: s[::-2] # all odd numbers in reversed order
Out[9]: [9, 7, 5, 3, 1]

In [11]: s[-2::-2] # all even numbers in reversed order
Out[11]: [8, 6, 4, 2, 0]

In [12]: s[3:15]   # end is out of range, python will set it to len(s)
Out[12]: [3, 4, 5, 6, 7, 8, 9]

In [14]: s[5:1]    # start > end, return empty list
Out[14]: []

In [15]: s[11]     # access index 11(greater than len(s)) will raise IndexError
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range

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

нарезки также применяется к Multi-мерных массивов.

# Here, a is a numpy array

>>> a
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> a[:2,0:3:2]
array([[1, 3],
       [5, 7]])

": 2 "перед запятой работает на первом измерении и "0:3: 2" после запятой работает на втором измерении.


получить определенный кусок повторяемое (как список), вот пример:

variable[number1:number2]

в этом примере положительное число для числа 1 - это количество компонентов, которые вы снимаете спереди. Отрицательное число-это полная противоположность, сколько вы держите от конца. Положительное число для числа 2 указывает, сколько компонентов вы намерены сохранить с самого начала, а отрицательное-сколько вы намерены снять с конца. Это несколько противоречит интуиции, но вы правы в предположении, что нарезка списка чрезвычайно полезна.


мой мозг, кажется, счастлив принять это lst[start:end] содержит start-й пункт. Я мог бы даже сказать, что это "естественное предположение".

end-го элемента.

в эти моменты я полагаюсь на эту простую теорему:

for any n,    lst = lst[:n] + lst[n:]

это красивое свойство говорит мне, что lst[start:end] не содержит end-й пункт, потому что он находится в lst[end:].

отметим, что эта теорема верна для любого n на всех. Например, вы можете проверить, что

lst = range(10)
lst[:-42] + lst[-42:] == lst

возвращает True.


#!/usr/bin/env python

def slicegraphical(s, lista):

    if len(s) > 9:
        print """Enter a string of maximum 9 characters,
    so the printig would looki nice"""
        return 0;
    # print " ",
    print '  '+'+---' * len(s) +'+'
    print ' ',
    for letter in s:
        print '| {}'.format(letter),
    print '|'
    print " ",; print '+---' * len(s) +'+'

    print " ",
    for letter in range(len(s) +1):
        print '{}  '.format(letter),
    print ""
    for letter in range(-1*(len(s)), 0):
        print ' {}'.format(letter),
    print ''
    print ''


    for triada in lista:
        if len(triada) == 3:
            if triada[0]==None and triada[1] == None and triada[2] == None:
                # 000
                print s+'[   :   :   ]' +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] == None and triada[2] != None:
                # 001
                print s+'[   :   :{0:2d} ]'.format(triada[2], '','') +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] != None and triada[2] == None:
                # 010
                print s+'[   :{0:2d} :   ]'.format(triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] != None and triada[2] != None:
                # 011
                print s+'[   :{0:2d} :{1:2d} ]'.format(triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] == None and triada[2] == None:
                # 100
                print s+'[{0:2d} :   :   ]'.format(triada[0]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] == None and triada[2] != None:
                # 101
                print s+'[{0:2d} :   :{1:2d} ]'.format(triada[0], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] != None and triada[2] == None:
                # 110
                print s+'[{0:2d} :{1:2d} :   ]'.format(triada[0], triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] != None and triada[2] != None:
                # 111
                print s+'[{0:2d} :{1:2d} :{2:2d} ]'.format(triada[0], triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]

        elif len(triada) == 2:
            if triada[0] == None and triada[1] == None:
                # 00
                print s+'[   :   ]    ' + ' = ', s[triada[0]:triada[1]]
            elif triada[0] == None and triada[1] != None:
                # 01
                print s+'[   :{0:2d} ]    '.format(triada[1]) + ' = ', s[triada[0]:triada[1]]
            elif triada[0] != None and triada[1] == None:
                # 10
                print s+'[{0:2d} :   ]    '.format(triada[0]) + ' = ', s[triada[0]:triada[1]]
            elif triada[0] != None and triada[1] != None:
                # 11
                print s+'[{0:2d} :{1:2d} ]    '.format(triada[0],triada[1]) + ' = ', s[triada[0]:triada[1]]

        elif len(triada) == 1:
            print s+'[{0:2d} ]        '.format(triada[0]) + ' = ', s[triada[0]]


if __name__ == '__main__':
    # Change "s" to what ever string you like, make it 9 characters for
    # better representation.
    s = 'COMPUTERS'

    # add to this list different lists to experement with indexes
    # to represent ex. s[::], use s[None, None,None], otherwise you get an error
    # for s[2:] use s[2:None]

    lista = [[4,7],[2,5,2],[-5,1,-1],[4],[-4,-6,-1], [2,-3,1],[2,-3,-1], [None,None,-1],[-5,None],[-5,0,-1],[-5,None,-1],[-1,1,-2]]

    slicegraphical(s, lista)

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

  +---+---+---+---+---+---+---+---+---+
  | C | O | M | P | U | T | E | R | S |
  +---+---+---+---+---+---+---+---+---+
  0   1   2   3   4   5   6   7   8   9   
 -9  -8  -7  -6  -5  -4  -3  -2  -1 

COMPUTERS[ 4 : 7 ]     =  UTE
COMPUTERS[ 2 : 5 : 2 ] =  MU
COMPUTERS[-5 : 1 :-1 ] =  UPM
COMPUTERS[ 4 ]         =  U
COMPUTERS[-4 :-6 :-1 ] =  TU
COMPUTERS[ 2 :-3 : 1 ] =  MPUT
COMPUTERS[ 2 :-3 :-1 ] =  
COMPUTERS[   :   :-1 ] =  SRETUPMOC
COMPUTERS[-5 :   ]     =  UTERS
COMPUTERS[-5 : 0 :-1 ] =  UPMO
COMPUTERS[-5 :   :-1 ] =  UPMOC
COMPUTERS[-1 : 1 :-2 ] =  SEUM
[Finished in 0.9s]

при использовании отрицательного шага обратите внимание, что ответ сдвинут вправо на 1.


в Python самая основная форма для нарезки следующая:

l[start:end]

здесь l это какая-то коллекция,start является инклюзивным индексом и end является эксклюзивным индексом.

In [1]: l = list(range(10))

In [2]: l[:5] # first five elements
Out[2]: [0, 1, 2, 3, 4]

In [3]: l[-5:] # last five elements
Out[3]: [5, 6, 7, 8, 9]

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

In [5]: l[:3] == l[0:3]
Out[5]: True

In [6]: l[7:] == l[7:len(l)]
Out[6]: True

отрицательные целые числа полезны при выполнении относительных смещений в конце коллекции:

In [7]: l[:-1] # include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [8]: l[-3:] # take the last 3 elements
Out[8]: [7, 8, 9]

возможно обеспечить индексы которые из пределов отрезая как:

In [9]: l[:20] # 20 is out of index bounds, l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: l[-20:] # -20 is out of index bounds, l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

In [16]: l[2:6] = list('abc') # assigning less elements than the ones contained in the sliced collection l[2:6]

In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]

In [18]: l[2:5] = list('hello') # assigning more elements than the ones contained in the sliced collection l [2:5]

In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]

если вы опустите начальный и конечный индекс, вы сделаете копию коллекции:

In [14]: l_copy = l[:]

In [15]: l == l_copy and l is not l_copy
Out[15]: True

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

In [20]: l[:] = list('hello...')

In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']

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

l[start:end:step]

здесь l это коллекция start - это инклюзивный индекс,end является эксклюзивным индексом, и step это шаг, который можно использовать, чтобы взять каждый nth элемент l.

In [22]: l = list(range(10))

In [23]: l[::2] # take the elements which indexes are even
Out[23]: [0, 2, 4, 6, 8]

In [24]: l[1::2] # take the elements which indexes are odd
Out[24]: [1, 3, 5, 7, 9]

используя step предоставляет полезный трюк, чтобы отменить коллекцию в Python:

In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

также можно использовать отрицательные целые числа для step в качестве следующего примера:

In[28]:  l[::-2]
Out[28]: [9, 7, 5, 3, 1]

однако, используя отрицательное значение для step может стать очень запутанной. Кроме того, для того, чтобы быть Обновления, вы должны избегать использования start, end и step в одном куске. Если это необходимо, подумайте о том, чтобы сделать это в двух назначениях (одно для среза, а другое для шага).

In [29]: l = l[::2] # this step is for striding

In [30]: l
Out[30]: [0, 2, 4, 6, 8]

In [31]: l = l[1:-1] # this step is for slicing

In [32]: l
Out[32]: [2, 4, 6]

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

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

пример нарезки: [начало: конец: шаг]

str[start:end] # items start through end-1
str[start:]    # items start through the rest of the array
str[:end]      # items from the beginning through end-1
str[:]         # a copy of the whole array

Ниже приведен пример использования

print str[0]=N
print str[0:2]=Na
print str[0:7]=Name st
print str[0:7:2]=Nm t
print str[0:-1:2]=Nm ti

большинство приведенных выше ответов очищает о нотации среза. Расширенный синтаксис индексирования, используемый для нарезки, -aList[start:stop:step] основные примеры:

enter image description here:

другие примеры нарезки: 15 Расширенных Ломтиков


Я хочу добавить один пример Hello world, который объясняет основы срезов для самых начинающих. Это мне очень помогло.

давайте список с шестью значениями ['P', 'Y', 'T', 'H', 'O', 'N']:

+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5 

теперь простейшими фрагментами этого списка являются его подсписки. Нотация [<index>:<index>] и ключ должен прочитать его так:

[ start cutting before this index : end cutting before this index ]

теперь, если вы сделаете срез [2:5] из списка выше, это будет происходить:

        |           |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
  0   1 | 2   3   4 | 5 

вы сделали разрез до элемент с индексом 2 и еще до элемент с индексом 5. Таким образом, результатом будет срез между этими двумя срезами, список ['T', 'H', 'O'].


хехехе, странно видеть, что я пытаюсь дать лучшее и более простое объяснение после 2600 + голосов на том, что было отмечено как правильный ответ от Грю Хьюгилла.

поехали ...

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

давайте работать со следующей строкой ...

azString = "abcdefghijklmnopqrstuvwxyz"

для тех, кто не знает, вы можете создать любая подстрока из azString используя обозначение azString[x:y]

исходя из других языков программирования, это когда здравый смысл скомпрометирован. Что такое x и y?

мне пришлось сесть и запустить несколько сценариев в моем поиске техники запоминания, которая поможет мне вспомнить, что такое x и y, и поможет мне правильно нарезать строки с первой попытки.

мой вывод заключается в том, что x и y следует рассматривать как граничные индексы, окружающие струны, которые мы хотим добавить. Поэтому мы должны видеть выражение как azString[index1, index2] или даже более ясно, как azString[index_of_first_character, index_after_the_last_character].

вот пример визуализации, что ...

Letters a b c d e f g h i j ... ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ Indexes 0 1 2 3 4 5 6 7 8 9 ... | | cdefgh index1 index2

поэтому все, что вам нужно сделать, если установить index1 и index2 в значения, которые будут окружать нужную подстроку. Например, чтобы получить подстроку "cdefgh", вы можете использовать azString[2:8] потому что индекс на левой стороне "c" 2 и один на правом размере "h" 8.

помните, мы устанавливаем границы.

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

надеюсь, это поможет.


фрагмент :- змея появится возле вашей ноги. Она движется от невидимого к видимому. Наше видение открывает (как кусочек) только часть мира. аналогично, фрагмент Python извлекает элементы на основе start и stop. Мы берем срезы на многих типах в Python. Мы указываем необязательный первый индекс, необязательный последний индекс и необязательный шаг.

values[1:3]  Index 1 through index 3.
values[2:-1] Index 2 through index one from last.
values[:2]   Start through index 2.
values[2:]   Index 2 through end.
values[::2]  Start through end, skipping ahead 2 places each time.

вы можете получить хорошие примеры по ссылке ниже:- python срез нотации пример


Если вы чувствуете, что отрицательные индексы в нарезке сбивают с толку, вот очень простой способ подумать об этом: просто замените отрицательный индекс на len - index. Так, например, замените -3 на len(list) - 3.

лучший способ проиллюстрировать, что нарезка делает внутри, это просто показать его в коде, который реализует эту операцию:

def slice(list, start = None, end = None, step = 1):
  # take care of missing start/end parameters
  start = 0 if start is None else start
  end = len(list) if end is None else end

  # take care of negative start/end parameters
  start = len(list) + start if start < 0 else start
  end = len(list) + end if end < 0 else end

  # now just execute for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

основной метод нарезки заключается в определении начальной точки, точки остановки и размера шага, также известного как шаг.

во-первых, мы создадим список значений для использования при нарезке.

создайте два списка для среза, первый-числовой список от 1 до 9 (список A). Второй также является числовым списком, от 0 до 9 (список B)

A = list(range(1,10,1)) # start,stop,step
B = list(range(9))

print("This is List A:",A)
print("This is List B:",B)

индексируйте число 3 из A и число 6 из B.

print(A[2])
print(B[6])

базовый Нарезка

расширенный синтаксис индексирования, используемый для нарезки, - aList[start:stop: step]. Аргумент start и аргумент step по умолчанию равны none-единственным обязательным аргументом является stop. Вы заметили, что это похоже на то, как диапазон использовался для определения списков A и B? Это связано с тем, что объект slice представляет набор индексов, заданных диапазоном(start, stop, step). Документация по Python 3.4

как вы можете видеть, определение только stop возвращает один элемент. Начиная с начала значение по умолчанию-none, это означает получение только одного элемента.

важно отметить, что первым элементом является индекс 0, а не Индекс 1. Вот почему мы используем 2 списка для этого упражнения. Элементы списка A нумеруются в соответствии с порядковым номером (первый элемент-1, второй элемент-2 и т. д.), А элементы списка B-это числа, которые будут использоваться для их индексации ([0] для первого элемента 0 и т. д.).

с расширенным синтаксисом индексирования мы получаем диапазон значений. Например, все значения извлекаются двоеточием.

A[:]

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

учитывая шаблон aList[start: stop], извлеките первые два элемента из списка A