Pobieranie podkrotki

12.1 Zakres indeksów

Kod do pobierania podkrotki wygląda podobnie jak kod do pobierania podlisty. Pod tym względem krotki są do nich bardzo podobne. Nie chciałoby się powtarzać materiału, ale powtórka to matka nauki…

Pobieranie podkrotek, czyli slicing, pozwala na wyciąganie fragmentów krotki w celu tworzenia nowych krotek. Proces ten jest szczególnie przydatny, gdy trzeba pracować z określonymi segmentami danych zapisanymi w krotce.

Składnia wycinania

Wycinanie tworzy się przy użyciu nawiasów kwadratowych, w których podaje się indeks początkowy i końcowy, oddzielone dwukropkiem. Jeśli indeks początkowy nie jest podany, wycinanie zaczyna się od pierwszego elementu; jeśli indeks końcowy nie jest podany, wycinanie trwa do końca krotki.

Wycinanie krotki można uzyskać, używając składni tuple[start:stop:step], gdzie:

• start — indeks początkowy elementu (włącznie);
• stop — indeks końcowy elementu (bez włączenia);
• step — krok, z jakim następuje wybór elementów.

Przykłady:

my_tuple = (0, 1, 2, 3, 4, 5)
sub_tuple = my_tuple[1:4]  # Pobieramy podkrotkę z elementami od indeksu 1 do 3
print(sub_tuple) # Zwróci (1, 2, 3)
            
sub_tuple_with_step = my_tuple[0:6:2]  # Pobieramy co drugi element od 0 do 5
print(sub_tuple_with_step) # Zwróci (0, 2, 4) 
        

Jeśli start nie jest podany, domyślnie jest równy 0, a jeśli stop nie jest podany — jest równy len(tuple). Parametr step domyślnie wynosi 1.

Przykłady:

# Tworzymy krotkę z elementami od 0 do 5
my_tuple = (0, 1, 2, 3, 4, 5)

# Tworzymy nową krotkę, zaczynając od drugiego elementu oryginalnej krotki
sub_tuple = my_tuple[1:] 
print(sub_tuple)  # Zwróci: (1, 2, 3, 4, 5)

# Tworzymy nową krotkę, włączając elementy od początku do czwartego elementu 
# (indeks 4) oryginalnej krotki, z krokiem 1 (domyślnie)
sub_tuple_with_step = my_tuple[:5] 
print(sub_tuple_with_step)  # Zwróci: (0, 1, 2, 3, 4)

12.2 Indeksy ujemne

Indeksy ujemne w Pythonie zaczynają się od -1, co odpowiada ostatniemu elementowi listy (lub krotki). -2 wskazuje na przedostatni element i tak dalej. Użycie indeksów ujemnych upraszcza dostęp do elementów od końca krotki bez potrzeby obliczania ich pozycji od początku.

Przykłady użycia

Spójrzmy na użycie indeksów ujemnych do formowania wycinka. Załóżmy, że mamy krotkę z wartościami:

my_tuple = (10, 20, 30, 40, 50, 60, 70, 80)

Aby uzyskać podkrotkę zawierającą elementy od końca do środka krotki, możemy użyć indeksów ujemnych.

sub_tuple = my_tuple[-3:-1]
print(sub_tuple) # Zwróci (60, 70)

Tak więc, my_tuple[-3:-1] wybierze elementy z indeksami -3 (trzeci od końca) do -1 (bez włączenia ostatniego), co da nam krotkę (60, 70).

Pobieranie ostatniego elementu krotki:

my_tuple = (10, 20, 30, 40, 50)
last_element = my_tuple[-1]
print(last_element) # Zwróci 50 
    

Tutaj, my_tuple[-1] zawsze zwróci ostatni element krotki, co jest bardzo wygodne, gdy nie znamy dokładnej liczby elementów w krotce.

Odwracanie elementów krotki:

my_tuple = (10, 20, 30, 40, 50)
reversed_tuple = my_tuple[::-1]
print(reversed_tuple) # Zwróci (50, 40, 30, 20, 10) 
    

Użycie wycinka [::-1] pozwala łatwo i efektywnie odwrócić kolejność elementów w krotce, tworząc nową krotkę z elementami w odwrotnej kolejności.

12.3 Czy element jest w krotce

Sprawdzanie obecności elementu w krotce to standardowa operacja, pozwalająca dowiedzieć się, czy element jest w krotce. Odbywa się to za pomocą operatora in, który zwraca True, jeśli element jest w krotce, i False w przeciwnym przypadku.

Użycie operatora in

Operator in jest prostym i intuicyjnym sposobem na sprawdzenie obecności elementu:

my_tuple = (1, 2, 3, 4, 5)
element = 3
if element in my_tuple:
    print(f"{element} jest w krotce.")
else:
    print(f"{element} nie jest w krotce.")
    

Sprawdzanie, czy element jest nieobecny:

Jeśli chcesz się upewnić, że element jest nieobecny w krotce, po prostu użyj konstrukcji not in:

names = ('Alice', 'Bob', 'Charlie')
search_name = 'Alice'
if search_name not in names:
    print(f"{search_name} nie jest w krotce.")
else:
    print(f"{search_name} jest w krotce.")
    

Prawie nie różni się to od pracy z listą — w tym tkwi uniwersalność i prostota Pythona.