Cicli sugli elementi di una tupla

14.1 Ciclo for

In Python il ciclo sugli elementi di una tupla è solitamente realizzato con un ciclo for. Questo è il modo più comune che ti permette di accedere facilmente a ciascun elemento della tupla ed eseguire per esso un blocco di codice.

Ciclo for

Il ciclo for passa attraverso ciascun elemento della tupla, assegnando temporaneamente il valore dell'elemento corrente alla variabile specificata dopo la parola chiave for. Esempio:

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

Hai già esperienza di lavoro con liste e il ciclo for, dunque vediamo alcuni esempi pratici:

Esempio 1: Sommatoria degli elementi di una tupla

Vediamo un esempio in cui sommiamo tutti gli elementi di una tupla.

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

for number in my_tuple:
    total += number

print(f"Somma degli elementi della tupla: {total}")

In questo esempio creiamo una tupla my_tuple e una variabile total per conservare la somma degli elementi. Utilizzando il ciclo for, iteriamo su ciascun elemento della tupla e lo sommiamo a total. Alla fine otteniamo la somma di tutti gli elementi della tupla.

Esempio 2: Trovare l'elemento massimo

Ora vediamo un esempio di ricerca dell'elemento massimo in una tupla.

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"Valore massimo nella tupla: {max_value}")

In questo esempio iniziamo la variabile max_value con il primo elemento della tupla. Poi iteriamo su tutti gli elementi della tupla, confrontando ciascun elemento con il valore massimo corrente e aggiornando max_value se troviamo un valore maggiore.

14.2 Tuple nidificate

Le tuple possono contenere altre tuple, e possiamo utilizzare un ciclo for per iterare su strutture di dati nidificate.

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

In questo esempio nested_tuple contiene delle tuple. Usiamo cicli for nidificati per iterare su ciascun elemento delle tuple nidificate. Il risultato finale:

1 2 3 
4 5 6 
7 8 9 

14.3 Ciclo for con indici

Come per le liste, anche gli elementi delle tuple hanno indici, quindi possiamo scorrere i suoi elementi usando un ciclo for (insieme alla funzione range()). Questo consente di lavorare non solo con gli elementi stessi, ma anche con le loro posizioni, il che è utile per eseguire manipolazioni più complesse sui dati.

Basi dell'iterazione indicizzata

Per iterare su una tupla con accesso all'indice di ciascun elemento, puoi usare del codice come:

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

Vantaggi dell'uso degli indici

Con gli indici è facile implementare algoritmi che richiedono accesso simultaneo a più elementi di una tupla, ad esempio, per confrontare l'elemento corrente con quello precedente o successivo.

Esempio:

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]:  # Confrontiamo l'elemento con il precedente
        print(f'{my_tuple[i]} è maggiore di {my_tuple[i - 1]}')

Utilizzo del ciclo for con indici per processare i dati

Supponiamo di avere una tupla con i dati delle temperature settimanali, e vogliamo calcolare la temperatura media, escludendo i valori estremi (la temperatura più bassa e quella più alta).

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

# Escludiamo la prima e l'ultima temperatura
filtered_temps = sorted_temps[1:-1]

average_temp = sum(filtered_temps) / len(filtered_temps)
print(f"Temperatura media della settimana (senza valori estremi): {average_temp}")

14.4 Utilizzo della funzione enumerate()

In Python, la funzione enumerate() offre un modo conveniente per iterare sugli elementi di una tupla con accesso simultaneo ai loro indici. Questo è particolarmente utile quando è necessario gestire sia l'indice che il valore dell'elemento nell'ambito di un ciclo.

Basi della funzione enumerate()

La funzione enumerate() avvolge la tupla in un oggetto speciale e restituisce un iteratore che produce tuple di coppie di valori, consistenti di indice e valore dell'elemento della tupla:

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

Ora hai non solo l'elemento, ma anche il suo indice.

Vantaggi di enumerate()

L'uso di enumerate() rende il codice più leggibile e consente di evitare la necessità di gestire manualmente gli indici con range(len(…)). Questo semplifica le manipolazioni con gli elementi della lista, come modificare, accedere agli elementi e svolgere controlli condizionali.

Esempi di utilizzo

A volte è necessario trovare tutti gli indici dove compare un determinato valore nella tupla.

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"Il valore {search_value} compare agli indici: {indices}")

Questo codice troverà tutti gli indici dove il valore 2 compare nella tupla:

Il valore 2 compare agli indici: [1, 3, 5]

Filtraggio dei dati basato sugli indici

Consideriamo un esempio in cui filtriamo i dati basandoci sugli indici, lasciando solo gli elementi con indici pari.

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"Tupla con elementi su indici pari: {filtered_tuple}")

Questo codice crea una nuova tupla, contenente solo gli elementi sugli indici pari:

Tupla con elementi su indici pari: ('a', 'c', 'e')