Pętle po elementach krotki

14.1 Pętla for

W Pythonie przechodzenie po elementach krotki zwykle realizuje się za pomocą pętli for. To najczęściej używana metoda, która pozwala po prostu dotrzeć do każdego elementu krotki i wykonać na nim blok kodu.

Pętla for

Pętla for przechodzi przez każdy element krotki, tymczasowo przypisując wartość bieżącego elementu zmiennej wskazanej po słowie kluczowym for. Przykład:

my_tuple = (1, 2, 3, 4, 5)
for number in my_tuple:
    print(number)

Masz już doświadczenie z listami i pętlą for, więc przeanalizujmy kilka praktycznych przykładów:

Przykład 1: Sumowanie elementów krotki

Zobaczmy przykład, w którym sumujemy wszystkie elementy krotki.

my_tuple = (10, 20, 30, 40, 50)
total = 0

for number in my_tuple:
    total += number

print(f"Suma elementów krotki: {total}")

W tym przykładzie tworzymy krotkę my_tuple i zmienną total do przechowywania sumy elementów. Używając pętli for, iterujemy po każdym elemencie krotki i dodajemy go do total. Na końcu otrzymujemy sumę wszystkich elementów krotki.

Przykład 2: Szukanie maksymalnego elementu

Teraz zobaczmy przykładowe wyszukiwanie maksymalnego elementu w krotce.

my_tuple = (5, 17, 23, 11, 2)
max_value = my_tuple[0]

for number in my_tuple:
    if number > max_value:
        max_value = number

print(f"Maksymalna wartość w krotce: {max_value}")

W tym przykładzie inicjalizujemy zmienną max_value pierwszym elementem krotki. Następnie iterujemy po wszystkich elementach krotki, porównując każdy element z bieżącą maksymalną wartością i aktualizując max_value, jeśli znajdziemy większą wartość.

14.2 Zagnieżdżone krotki

Krotki mogą zawierać inne krotki, a pętla for może być użyta do iterowania po zagnieżdżonych strukturach danych.

nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

for inner_tuple in nested_tuple:
    for number in inner_tuple:
        print(number, end=' ')
    print()

W tym przykładzie nested_tuple zawiera krotki. Używamy zagnieżdżonych pętli for do iteracji po każdym elemencie zagnieżdżonych krotek. Wynik działania:

1 2 3 
4 5 6 
7 8 9 

14.3 Pętla for z indeksami

Podobnie jak lista, elementy krotki mają indeksy, więc można je przechodzić z pomocą pętli for (w połączeniu z funkcją range()). To pozwala pracować nie tylko z samymi elementami, ale również z ich pozycjami, co bywa konieczne przy bardziej złożonych operacjach na danych.

Podstawy iteracji z indeksami

Aby iterować po krotce z dostępem do indeksu każdego elementu, możemy użyć kodu typu:

my_tuple = ('a', 'b', 'c', 'd')
for i in range(len(my_tuple)):
    print(f'indeks: {i}, Element: {my_tuple[i]}')

Zalety użycia indeksów

Z indeksami łatwo realizować algorytmy wymagające jednoczesnego dostępu do kilku elementów krotki, na przykład do porównania bieżącego elementu z poprzednim lub następnym.

Przykład:

my_tuple = (15, 20, 23, 18, 22, 19, 21)
for i in range(1, len(my_tuple)):
    if my_tuple[i] > my_tuple[i - 1]:  # Porównujemy element z poprzednim
        print(f'{my_tuple[i]} jest większe od {my_tuple[i - 1]}')

Użycie pętli for z indeksami do przetwarzania danych

Załóżmy, że mamy krotkę z danymi o temperaturze tygodniowej i chcemy obliczyć średnią temperaturę, pomijając wartości ekstremalne (najniższą i najwyższą temperaturę).

temperatures = (15, 20, 23, 18, 22, 19, 21)
sorted_temps = sorted(temperatures)

# Pomijamy pierwszą i ostatnią temperaturę
filtered_temps = sorted_temps[1:-1]

average_temp = sum(filtered_temps) / len(filtered_temps)
print(f"Średnia temperatura w tygodniu (bez ekstremalnych wartości): {average_temp}")

14.4 Użycie funkcji enumerate()

W Pythonie, funkcja enumerate() oferuje wygodny sposób iteracji po elementach krotki z jednoczesnym dostępem do ich indeksów. To szczególnie przydatne, gdy konieczne jest przetwarzanie zarówno indeksu, jak i wartości elementu listy w ramach pętli.

Podstawy funkcji enumerate()

Funkcja enumerate() opakowuje krotkę w specjalny obiekt i zwraca iterator, który produkuje krotki par wartości, składające się z indeksu i wartości elementu krotki:

my_tuple = ('apple', 'banana', 'cherry')
for index, element in enumerate(my_tuple):
    print(f'indeks: {index}, Element: {element}')

Teraz masz nie tylko element, ale i jego indeks.

Zalety enumerate()

Użycie enumerate() czyni kod bardziej czytelnym i pozwala uniknąć konieczności ręcznego zarządzania indeksami za pomocą range(len(…)). To upraszcza manipulacje elementami listy, takie jak modyfikacja, dostęp do elementów i wykonywanie warunkowych sprawdzeń.

Przykłady użycia

Czasem trzeba znaleźć wszystkie indeksy, gdzie występuje określona wartość w krotce.

my_tuple = (1, 2, 3, 2, 4, 2, 5)
search_value = 2
indices = []

for index, value in enumerate(my_tuple):
    if value == search_value:
        indices.append(index)

print(f"Wartość {search_value} występuje na indeksach: {indices}")

Ten kod znajdzie wszystkie indeksy, gdzie wartość 2 występuje w krotce:

Wartość 2 występuje na indeksach: [1, 3, 5]

Filtrowanie danych na podstawie indeksów

Rozważmy przykład, gdzie filtrujemy dane na podstawie indeksów, pozostawiając tylko elementy z parzystymi indeksami.

my_tuple = ('a', 'b', 'c', 'd', 'e', 'f')

filtered_tuple = tuple(value for index, value in enumerate(my_tuple) if index % 2 == 0)
print(f"Krotka z elementami na parzystych indeksach: {filtered_tuple}")

Ten kod stworzy nową krotkę, zawierającą tylko elementy z parzystymi indeksami:

Krotka z elementami na parzystych indeksach: ('a', 'c', 'e')