Wiem, że mogę użyć czegoś takiego, string[3:4]aby uzyskać podciąg w Pythonie, ale co oznacza 3 somesequence[::3]?

oznacza „nic dla pierwszego argumentu, nic dla drugiego i przeskocz o trzy”. Pobiera co trzeci element sekwencji. Rozszerzone plastry są tym, czego chcesz. Nowości w Python 2.3

Adresy wycinków sekwencji w Pythonie mogą być zapisywane jako [start: koniec: krok], a każdy z początkowych, końcowych lub końcowych można usunąć. 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]

Możesz więc zrobić:

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

Wyjaśnienie

s[i:j:k]jest, zgodnie z dokumentacją „plaster s od i do j z etapem k”. Kiedy ii jsą nieobecne, zakłada się całą sekwencję, a zatem s[::k]oznacza „każdy k-ty element”.

Przykłady

Najpierw zainicjujmy 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 element z s:

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

Weźmy co 3 ^rd element 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 co 3 ^rd element z 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 element 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 pokazuje, jak starannie wybrać elementy w NumPy Matrix (tablica 2-wymiarowa) w całkiem zabawny sposób (obiecuję). Krok 2 poniżej ilustruje użycie omawianych „podwójnych dwukropków” ::.

(Uwaga: jest to przykład specyficzny dla tablicy NumPy w celu zilustrowania 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).

Jeden konkretny przykład rządzenia nimi wszystkimi ...

Powiedzmy, że mamy macierz NumPy, która wygląda następująco:

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

Powiedz 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 kierunkach wierszy, jak i kolumn.

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 otrzymaliśmy nasz podzbiór, używając prostej techniki indeksowania początkowego i końcowego. Następnie, jak zrobić to „skakanie” ... (czytaj dalej!)

Krok 2 - Wybierz elementy (z argumentem „skok kroku”)

Możemy teraz określić „kroki przeskoku” w kierunkach rzędów i kolumn (w celu wybrania elementów w sposób „skokowy”) w następujący sposób:

W kodzie (zwróć uwagę na 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! :)

 Konsoliduj krok 1 (początek i koniec) i krok 2 („skakanie”)

Znając już tę koncepcję, możemy z łatwością połączyć krok 1 i krok 2 w jeden skonsolidowany krok - dla zwartości:

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

Gotowe!

Podczas krojenia w Pythonie trzecim parametrem jest krok. Jak wspomniano inni, zobacz Rozszerzone plasterki, aby uzyskać ładny przegląd.

Dzięki tej wiedzy [::3]oznacza to tylko, że nie określiłeś żadnych początkowych ani końcowych wskaźników dla swojego plasterka. Ponieważ określiłeś krok, 3zajmie to co trzeci wpis, somethingzaczynając od pierwszego indeksu. Na przykład:

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

Możesz również użyć tej notacji we własnych 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

Następnie możemy otworzyć obiekty plasterków jako:

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

Jest to szczególnie stosowane w Numpy do krojenia tablic wielowymiarowych w dowolnym kierunku.

Oczywiście, każdy rozsądny API powinien być używany ::3ze zwykłym semantycznym „co 3”.

Temat pokrewny Ellipsisznajduje się w dalszej części: Co robi obiekt Ellipsis?

Trzeci parametr to krok. Zatem [:: 3] zwróci co 3 element listy / łańcucha.

Python używa :: do oddzielenia wartości End, Start i Step.