Что такое :: (двойное двоеточие) в Python при подписке последовательностей?

Question

Я знаю, что могу использовать что-то вроде string[3:4] для получения подстроки в Python, но что означает 3 в somesequence[::3]?

Answer 1

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

Answer 2

Адреса фрагментов последовательности Python могут быть записаны как [start: end: step], и любой из start, stop или end может быть отброшен.a[::3] - это каждый третий элемент последовательности.

Answer 3

seq[::n] - это последовательность каждого n -го элемента во всей последовательности.

Пример:

>>> range(10)[::2]
[0, 2, 4, 6, 8]

Синтаксис:

seq[start:end:step]

Так что вы можете сделать:

>>> range(100)[5:18:2]
[5, 7, 9, 11, 13, 15, 17]

Answer 4

Пояснение

s[i:j:k], в соответствии с документацией , «кусочек s от i до j с шагом k».Когда i и j отсутствуют, предполагается вся последовательность и, таким образом, s[::k] означает «каждый k-й элемент».

Примеры

Сначала давайте инициализируем список:

>>> s = range(20)
>>> s
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Давайте возьмем каждый элемент 3 ^rd из s:

>>> s[::3]
[0, 3, 6, 9, 12, 15, 18]

Давайте возьмем каждый элемент 3 ^rd из s[2:]:

>>> s[2:]
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> s[2::3]
[2, 5, 8, 11, 14, 17]

Давайте возьмем каждый элемент 3 ^rd из s[5:12]:

>>> s[5:12]
[5, 6, 7, 8, 9, 10, 11]
>>> s[5:12:3]
[5, 8, 11]

Давайте возьмем каждый элемент 3 ^rd изs[:10]:

>>> s[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> s[:10:3]
[0, 3, 6, 9]

Answer 5

TL; DR

Этот визуальный пример покажет вам, как аккуратно выбирать элементы в матрице NumPy (двумерный массив) довольно интересным способом (обещаю). Шаг 2 ниже иллюстрирует использование этих "двойных двоеточий" :: в вопросе.

(Внимание: это конкретный пример массива NumPy с целью иллюстрации варианта использования«двойные двоеточия» :: для прыжков элементов по нескольким осям. Этот пример не охватывает нативные структуры данных Python, такие как List).

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

Скажем, у нас есть матрица NumPy, которая выглядит следующим образом:

In [1]: import numpy as np

In [2]: X = np.arange(100).reshape(10,10)

In [3]: X
Out[3]:
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

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

"Но как ???" ... Продолжайте читать!(Мы можем сделать это с помощью двухэтапного подхода)

Шаг 1 - Получить подмножество

Укажите «начальный индекс» и «конечный индекс» как по строкам, так и по столбцам.

В коде:

In [5]: X2 = X[2:9,3:8]

In [6]: X2
Out[6]:
array([[23, 24, 25, 26, 27],
       [33, 34, 35, 36, 37],
       [43, 44, 45, 46, 47],
       [53, 54, 55, 56, 57],
       [63, 64, 65, 66, 67],
       [73, 74, 75, 76, 77],
       [83, 84, 85, 86, 87]])

Обратите внимание, что мы только что получили наше подмножество с использованием простого запускаи конец метода индексации.Далее, как сделать этот «прыжок» ... (читай дальше!)

Шаг 2 - Выбрать элементы (с аргументом «шаг перехода»)

Теперь мы можем указать "шаги перехода «как по ряду, так и по столбцам (для выбора элементов« путем прыжка ») следующим образом:

в коде(обратите внимание на двойные двоеточия):

In [7]: X3 = X2[::3, ::2]

In [8]: X3
Out[8]:
array([[23, 25, 27],
       [53, 55, 57],
       [83, 85, 87]])

Мы только что выбрали все элементы, как требуется!:)

Объедините Шаг 1 (начало и конец) и Шаг 2 («прыжок»)

Теперь мы знаем концепцию, мы можем легко объединить шаг 1 и шаг 2 в один консолидированный шаг -для компактности:

In [9]: X4 = X[2:9,3:8][::3,::2]

    In [10]: X4
    Out[10]:
    array([[23, 25, 27],
           [53, 55, 57],
           [83, 85, 87]])

Готово!

Answer 6

При нарезке в Python третьим параметром является шаг. Как уже упоминалось, см. Расширенные ломтики для хорошего обзора.

С этим знанием [::3] просто означает, что вы не указали никаких начальных или конечных индексов для своего среза. Поскольку вы указали шаг 3, он будет принимать каждую третью запись something, начиная с первого индекса. Например:

>>> '123123123'[::3]
'111'

Answer 7

Третий параметр - шаг.Поэтому [:: 3] будет возвращать каждый третий элемент списка / строки.

Answer 8

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

class C(object):
    def __getitem__(self, k):
        return k

# Single argument is passed directly.
assert C()[0] == 0

# Multiple indices generate a tuple.
assert C()[0, 1] == (0, 1)

# Slice notation generates a slice object.
assert C()[1:2:3] == slice(1, 2, 3)

# If you omit any part of the slice notation, it becomes None.
assert C()[:] == slice(None, None, None)
assert C()[::] == slice(None, None, None)
assert C()[1::] == slice(1, None, None)
assert C()[:2:] == slice(None, 2, None)
assert C()[::3] == slice(None, None, 3)

# Tuple with a slice object:
assert C()[:, 1] == (slice(None, None, None), 1)

# Ellipsis class object.
assert C()[...] == Ellipsis

Затем мы можем открывать объекты слайса как:

s = slice(1, 2, 3)
assert s.start == 1
assert s.stop == 2
assert s.step == 3

Это особенно используется в Numpy для нарезки многомерных массивов в любом направлении.

Конечно, любой нормальный API должен использовать ::3 с обычной семантикой "каждые 3".

Answer 9

Python использует :: для разделения значения End, Start и Step.