Python Sequence slice addresses can be written as a [start:end: step] and any of start, stop or end can be dropped. a[::3] to co trzeci element sekwencji.

seq[::n] jest sekwencją każdego n - tego elementu w całej sekwencji.

Przykład:

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

Składnia jest następująca:

seq[start:end:step]

Więc możesz zrobić:

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

Wyjaśnienie

s[i:j:k] jest, zgodnie z dokumentacją , "kawałek s od i do j z krokiem k". Gdy i i j są nieobecne, przyjmuje się całą sekwencję, a zatem s[::k] oznacza "każdy k-ten element".

Przykłady

Najpierw zainicjalizujmy listę:

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

Weźmy co 3 ^Rd pozycja z s:

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

Weźmy co 3 ^Rd pozycja z 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]

Weźmy każdy 3 ^rd element from s[5:12]:

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

Weźmy co 3 ^Rd pozycja z s[:10]:

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

TL;DR

Ten wizualny przykład pokaże Ci, jak starannie wybrać elementy w macierzy NumPy (tablica 2 wymiarowa) w dość zabawny sposób (obiecuję). Krok 2 poniżej ilustruje użycie "podwójnych dwukropków" :: w pytaniu.

(uwaga: jest to przykład tablicy NumPy mający na celu zilustrowanie przypadku użycia "podwójnych dwukropków" :: do przeskakiwania elementów w wielu osiach. Ten przykład nie obejmuje natywnych struktur danych Pythona, takich jak List).

Powiedzmy, że mamy macierz NumPy, która wygląda tak:

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

Powiedzmy, że z jakiegoś powodu twój szef chce, abyś wybrał następujące elementy:]}

"Ale Jak???"... Czytaj dalej! (Możemy to zrobić w podejściu dwuetapowym)

Krok 1-Uzyskaj podzbiór

Określ "indeks początkowy" i "indeks końcowy" zarówno w wierszach, jak i w kolumnach wskazówki.

W kodzie:

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

Zauważ, że właśnie uzyskaliśmy nasz podzbiór, używając prostej techniki indeksowania początkowego i końcowego. Następnie, jak zrobić to "skoki"... (Czytaj dalej!)

Krok 2-zaznaczenie elementów (z argumentem "skok krok")

Możemy teraz określić "kroki skoku" zarówno w kierunkach wierszowych, jak i kolumnowych (aby wybrać elementy w sposób "skokowy") w następujący sposób:

W kodzie (Uwaga podwójne dwukropki):

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

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

Właśnie wybraliśmy wszystkie elementy zgodnie z wymaganiami! :)

Konsolidacja kroku 1 (Początek i koniec) i Kroku 2 ("skoki")

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

Podczas wycinania w Pythonie trzecim parametrem jest krok. Jak inni wspominali, zobacz Rozszerzone plastry, aby uzyskać ładny przegląd.

Z tą wiedzą, [::3] oznacza po prostu, że nie podałeś żadnych indeksów początkowych lub końcowych dla Twojego plasterka. Ponieważ określiłeś Krok 3, będzie to trwało co Trzeci wpis something począwszy od pierwszego indeksu. Na przykład:

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

Trzeci parametr to krok. Tak więc [::3] zwróci każdy trzeci element listy / łańcucha.

Python używa :: do oddzielenia wartości końca, początku i kroku.

Możesz również użyć tej notacji w swoich klasach niestandardowych, aby zrobić to, co chcesz

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

Możemy następnie otworzyć obiekty slice jako:

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

Jest to szczególnie używane w Numpy do cięcia wielowymiarowych tablic w dowolnym kierunku.

Oczywiście, każde rozsądne API powinno używać ::3 ze zwykłym semantycznym "co 3".