Понимание нотации фрагмента Python

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

Для меня эта нотация требует немного поднять.

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

2300
задан Simon 04 февр. '09 в 1:31
источник поделиться

31 ответ

  • 1
  • 2

Это довольно просто:

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

3117
ответ дан Greg Hewgill 04 февр. '09 в 1:48
источник поделиться

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

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

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

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

396
ответ дан Hans Nowak 04 февр. '09 в 1:49
источник поделиться

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

>>> 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)'
310
ответ дан ephemient 04 февр. '09 в 2:08
источник поделиться

В ответах выше не обсуждаются назначения срезов:

>>> r=[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]

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

200
ответ дан David M. Perlman 19 янв. '11 в 0:37
источник поделиться

Объяснить нотацию фрагмента 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, 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.

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

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

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

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

 step_is_negative = step_sign < 0;

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

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

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

187
ответ дан Aaron Hall 12 июля '14 в 16:19
источник поделиться

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

>>> 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]
125
ответ дан Dana 04 февр. '09 в 2:15
источник поделиться

Нашел эту отличную таблицу в 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)
85
ответ дан AdrianoFerrari 06 сент. '11 в 9:50
источник поделиться

В 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]
84
ответ дан abc 22 окт. '12 в 8:33
источник поделиться

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

(from:to:step)

любой из них необязателен

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

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

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

47
ответ дан Simon 19 февр. '09 в 23:52
источник поделиться

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

Поучительно сначала понять range():

def range(start=0, stop, step=1):  # illegal syntax, but that 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] срезает один char слева, два справа, а затем меняет направление. (См. Также reversed().)

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

TODO. В приведенном ниже коде была ошибка с "никогда не выходить за пределы последовательности", когда abs (step) > 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) == []. Нормализацию иногда называют "по модулю длины", но обратите внимание, что она добавляет длину только один раз: например. 'abcde'[-53:42] - это целая строка.

32
ответ дан Beni Cherniavsky-Paskin 29 марта '12 в 13:15
источник поделиться

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

mylist[X:Y]

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

31
ответ дан Steve Losh 07 февр. '09 в 0:16
источник поделиться
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

30
ответ дан xiaoyu 04 февр. '13 в 10:20
источник поделиться

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

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

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

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

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

28
ответ дан nobar 28 апр. '13 в 22:49
источник поделиться

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

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

25
ответ дан Arindam Roychowdhury 22 марта '12 в 20:20
источник поделиться

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

r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]
25
ответ дан dansalmo 05 апр. '13 в 4:59
источник поделиться

Вот как я преподаю кусочки новичков:

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

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. Итак, вы можете выбрать любой набор ящиков, если знаете начало и конец. Эти позиции называются начальными и конечными положениями.

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

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

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 имеет встроенную функцию, называемую срезом, вы можете передать некоторые параметры и проверить, насколько эффективно он вычисляет отсутствующие параметры.

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

24
ответ дан ChillarAnand 24 марта '15 в 19:08
источник поделиться

Как правило, при написании кода с большим количеством жестко заданных значений индекса читаемость и обслуживание беспорядок. Например, если вы вернетесь к коду через год, вы будете взгляните на него и задайтесь вопросом, что вы думаете, когда вы его написали. Показанное решение это просто способ более четко указать, что делает ваш код на самом деле. В общем, встроенный 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.start, s.stop и s.step соответственно. Например:

>>> a = slice(10, 50, 2)
>>> a.start
10
>>> a.stop
50
>>> a.step
2
>>>
21
ответ дан Python_Dude 07 дек. '13 в 19:52
источник поделиться

1. Обозначение фрагментов

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

s[start:end:step]

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

  • s: объект, который можно нарезать
  • start: первый индекс для запуска итерации
  • end: последний индекс, ЗАМЕЧАНИЕ: индекс end не будет включен в приведенный фрагмент
  • step: выбрать элемент каждый step index

Еще одна вещь для импорта: все 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) (while 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)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range
20
ответ дан cizixs 09 янв. '17 в 15:52
источник поделиться

В ответах выше не обсуждаются многомерные массивы, которые можно использовать с помощью знаменитого пакета 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" после того, как запятая работает во втором измерении.

13
ответ дан Statham 01 марта '17 в 5:31
источник поделиться

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

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

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

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

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

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

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

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

11
ответ дан Robert 26 мая '16 в 11:16
источник поделиться

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

variable[number1:number2]

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

11
ответ дан someone-or-other 22 нояб. '13 в 5:53
источник поделиться
#!/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)

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

  +---+---+---+---+---+---+---+---+---+
  | 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.

10
ответ дан mahmoh 18 окт. '14 в 20:40
источник поделиться

В 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 является шагом, который может использоваться для каждого n-го элемента в 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]
7
ответ дан lmiguelvargasf 04 сент. '17 в 19:00
источник поделиться

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

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

str="Name string"

пример slicing: [start: end: step]

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
6
ответ дан Prince Dhadwal 28 июля '17 в 13:12
источник поделиться

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

enter image description here:

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

5
ответ дан Roshan 07 окт. '17 в 1:30
источник поделиться

Я хочу добавить один пример 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'].

4
ответ дан Jeyekomon 04 апр. '18 в 12:52
источник поделиться

Если вы чувствуете, что отрицательные индексы в нарезке запутывают, вот очень простой способ подумать об этом: просто замените отрицательный индекс на 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)]
3
ответ дан ShitalShah 19 дек. '17 в 9:12
источник поделиться

Slice: - рядом с вашей ногой появляется змея. Он движется от невидимого до видимого. Наше видение показывает (как срез) только часть мира. Аналогично, фрагмент Python извлекает элементы, основанные на запуске и остановке. Мы берем фрагменты на многих типах в 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.

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

3
ответ дан SHASHI BHUSAN 12 апр. '18 в 22:17
источник поделиться

Хехех, странно видеть, что я пытаюсь дать лучшее и более простое объяснение после 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.

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

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

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

3
ответ дан asiby 12 дек. '17 в 7:13
источник поделиться

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

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

Создайте два списка для среза, первый - это числовой список от 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? Это связано с тем, что объект среза представляет собой набор индексов, заданных диапазоном (начало, стоп, шаг). Документация Python 3.4

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

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

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

A[:]

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

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

0
ответ дан Babu Chandermani 23 июля '18 в 16:06
источник поделиться
  • 1
  • 2

Другие вопросы по меткам