Понимание обозначения среза Python

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

Мне эта запись нуждается в небольшом подборе.

Это выглядит очень мощно, но я не совсем понял, как это сделать.

вопрос задан 3.02.2009
Simon
30737 репутация

30 ответов


  • 3214 рейтинг

    Это действительно очень просто:

    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 представляет первое значение, которое является , а не в выбранном срезе. Таким образом, разница между 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 содержит только один элемент, вы получите пустой список вместо ошибки. Иногда вы бы предпочли ошибку, поэтому вы должны знать, что это может произойти.

    ответ дан Greg Hewgill, с репутацией 645957, 3.02.2009
  • 409 рейтинг

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

    Художественная диаграмма ASCII также полезна для запоминания работы срезов:

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

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

    ответ дан Hans Nowak, с репутацией 4537, 3.02.2009
  • 318 рейтинг

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

    >>> 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)'
    
    ответ дан ephemient, с репутацией 149435, 3.02.2009
  • 203 рейтинг

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

                    +---+---+---+---+---+---+
                    | 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 "", line 1, in 
    TypeError: can only assign an iterable
    

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

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

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

    >>> 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 "", line 1, in 
    IndexError: list index out of range
    

    Фактически, по сравнению с индексированием, разрезание по питону странно защищено от ошибок:

    >>> 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]
    

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

    ответ дан David M. Perlman, с репутацией 2371, 18.01.2011
  • 197 рейтинг

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

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

    sliceable[start:stop:step]
    

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

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

    Для начала давайте определимся с несколькими терминами:

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

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

    step: величина, на которую увеличивается индекс, по умолчанию равна 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:]
    

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

    Объяснение:

    Полная запись

    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!

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

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

     step_is_negative = step_sign < 0;
    

    Если это так, нижняя граница равна -1, что означает, что мы нарезаем весь путь вплоть до начала, а верхняя граница равна длине минус 1, что означает, что мы начинаем с конца. (Обратите внимание, что семантика этого -1 отличается от 3230269583 от -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__ ( - это то, что квадратные скобки делают ). Даже если вы не новичок в этом, он делает ваш код более читабельным, так что другие, которым, возможно, придется читать ваш код, могут более легко понять, что вы делаете.

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

    last_nine_slice = slice(-9, None)
    

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

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

    >>> 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 DataFrame, он может вернуть представление оригинала, а не его копию.

    ответ дан Aaron Hall, с репутацией 153756, 12.07.2014
  • 126 рейтинг

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

    >>> 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]
    
    ответ дан Dana, с репутацией 18860, 3.02.2009
  • 86 рейтинг

    Нашел эту замечательную таблицу по адресу http: // wiki. питон. 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)
    ответ дан AdrianoFerrari, с репутацией 1754, 6.09.2011
  • 85 рейтинг

    В 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 (исключая элемент с индексом b). Используйте приведенное выше правило индексации и помните, что вы найдете только элементы в этом диапазоне:

    -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]
    
    ответ дан abc, с репутацией 8101, 22.10.2012
  • 48 рейтинг

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

    (from:to:step)
    

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

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

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

    Это все равно работает для меня. , ,

    ответ дан Simon, с репутацией 30737, 19.02.2009
  • 33 рейтинг

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

    Поучительно сначала понять 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 всегда является исключенным концом, независимо от того, выше он или ниже. Если вы хотите, чтобы один и тот же срез находился в обратном порядке, гораздо проще сделать инверсию отдельно: e. г. 'abcde'[1:-2][::-1] срезает один символ слева, два справа, затем переворачивает. (См. Также reversed() . )

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

    TODO : В приведенном ниже коде была ошибка «никогда не выходить за пределы последовательности», когда abs (шаг) & gt; 1; Я думаю, Я исправил это, чтобы быть правильным, но это трудно понять.

    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) == []. Нормализацию иногда считают «по модулю длины», но обратите внимание, что она добавляет длину только один раз: e. г. 'abcde'[-53:42] это просто целая строка.

    ответ дан Beni Cherniavsky-Paskin, с репутацией 6355, 29.03.2012
  • 31 рейтинг

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

    mylist[X:Y]
    

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

    ответ дан Steve Losh, с репутацией 16780, 6.02.2009
  • 30 рейтинг
    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. питон. org / moin / MovingToPythonFromOtherLanguages ​​

    ответ дан xiaoyu, с репутацией 5092, 4.02.2013
  • 28 рейтинг

    Нотация Python:

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

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

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

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

    ответ дан nobar, с репутацией 23812, 28.04.2013
  • 25 рейтинг

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

    r = [1, 'blah', 9, 8, 2, 3, 4]
    >>> r[1:4] = []
    >>> r
    [1, 2, 3, 4]
    
    ответ дан dansalmo, с репутацией 7781, 5.04.2013
  • 25 рейтинг

    Это просто дополнительная информация. , , Рассмотрим список ниже

    >>> 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 выше

    ответ дан Arindam Roychowdhury, с репутацией 1305, 22.03.2012
  • 24 рейтинг

    Вот как я учу новичков ломтикам:

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

    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)
     in ()
    ----> 1 alpha[0,1]
    
    TypeError: list indices must be integers, not tuple
    

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

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

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

    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 & amp; необязательные параметры для нарезки и возврата start, stop, step & amp; длина среза для запрошенного среза.

    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, вы можете передать некоторые параметры & amp; проверьте, насколько грамотно он рассчитывает недостающие параметры.

    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. ком / 2015/03 / а-фрагментный из-питона-разведывательная позади. HTML

    ответ дан ChillarAnand, с репутацией 13641, 24.03.2015
  • 21 рейтинг

    Как правило, написание кода с большим количеством жестко закодированных значений индекса приводит к удобочитаемости и обслуживание беспорядок. Например, если вы вернетесь к коду год спустя, вы посмотрите на это и удивитесь, о чем вы думали, когда писали это. Решение показано это просто способ более четко заявить, что на самом деле делает ваш код. Как правило, встроенный 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
    >>>
    
    ответ дан Python_Dude, с репутацией 367, 7.12.2013
  • 20 рейтинг

    1. Обозначение среза

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

    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. Подводные камни

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

    Отрицательные показатели

    Самое первое, что сбивает с толку тех, кто изучает 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 - 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
    

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

    Будьте удивлены: срез не вызывает 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)
     in ()
    ----> 1 s[11]
    
    IndexError: list index out of range
    
    ответ дан cizixs, с репутацией 3951, 9.01.2017
  • 14 рейтинг

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

    Нарезка также применяется к многомерным массивам.

    # 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» после запятой действует во втором измерении.

    ответ дан Statham, с репутацией 1366, 1.03.2017
  • 11 рейтинг

    Мой мозг, кажется, рад принять, что 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.

    ответ дан Robert, с репутацией 637, 26.05.2016
  • 11 рейтинг

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

    variable[number1:number2]
    

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

    ответ дан someone-or-other, с репутацией 1556, 22.11.2013
  • 10 рейтинг
    #!/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.

    ответ дан mahmoh, с репутацией 647, 18.10.2014
  • 7 рейтинг

    В 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 - это шаг, который можно использовать для получения каждого -го -го элемента в 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 может привести к путанице. Кроме того, чтобы быть Pythonic, вы должны избегать использования 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]
    
    ответ дан lmiguelvargasf, с репутацией 9591, 4.09.2017
  • 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
    
    ответ дан Prince Dhadwal, с репутацией 134, 28.07.2017
  • 6 рейтинг

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

    enter image description here :

    Дополнительные примеры нарезки: 15 расширенных срезов

    ответ дан Roshan Bagdiya, с репутацией 462, 6.10.2017