Iterare sulle Tuple in Python

Iterare su una tupla permette di visitare ogni elemento uno alla volta e agire su di esso. Poiché le tuple sono sequenze immutabili — il loro contenuto non può cambiare — iterare su di esse è sicuro e diretto. Questa pagina copre ogni tecnica comune: cicli for, cicli while, enumerate(), range(len()), zip(), attraversamento di tuple annidate e controllo del ciclo con break/continue.

Se sei nuovo alle tuple, leggi prima Python Tuples. Per la sintassi generale dei cicli vedi Python For Loops e Python While Loops.

Usare un ciclo for

Il modo più semplice e più pythonico per iterare su una tupla è il ciclo for. Python scorre ogni elemento nell'ordine e lo assegna alla variabile del ciclo.

Itera su una tupla con un ciclo for

Output:

1
2
3
4
5

Il ciclo termina automaticamente quando raggiunge l'ultimo elemento — nessuna operazione aritmetica sugli indici richiesta.

Usare un ciclo while

Un ciclo while ti dà il controllo manuale sull'indice. È utile quando devi avanzare o tornare indietro di più di un passo, oppure quando la condizione di arresto dipende da qualcosa di diverso dalla lunghezza della tupla.

Itera su una tupla con un ciclo while

my_tuple = ('apple', 'banana', 'cherry')
i = 0

while i < len(my_tuple):
    print(my_tuple[i])
    i += 1

Output:

apple
banana
cherry

Incrementa sempre i all'interno del corpo del ciclo, altrimenti il ciclo viene eseguito all'infinito.

Accedere all'indice con enumerate()

Quando hai bisogno sia della posizione che del valore, usa enumerate(). Essa associa ogni elemento al suo indice a base zero e restituisce entrambi insieme.

Itera su una tupla usando enumerate

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors):
    print(index, color)

Output:

0 red
1 green
2 blue

Puoi iniziare a contare da qualsiasi numero passando un secondo argomento:

Avvia enumerate da 1

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors, start=1):
    print(index, color)

Output:

1 red
2 green
3 blue

enumerate() è preferibile a range(len()) ogni volta che hai bisogno sia dell'indice che del valore, perché è più leggibile ed evita il passaggio di indicizzazione aggiuntivo.

Accedere all'indice con range(len())

Un pattern più vecchio ma ancora valido usa range(len()) per generare gli indici validi, quindi accede a ogni elemento per posizione.

Itera su una tupla usando range e len

fruits = ('apple', 'banana', 'cherry')

for i in range(len(fruits)):
    print(i, fruits[i])

Output:

0 apple
1 banana
2 cherry

Questo approccio è utile quando devi confrontare elementi adiacenti o modificare una lista derivata in base alla posizione, perché sia l'indice che il valore sono disponibili nello stesso momento.

Iterare su Tuple Annidate

Una tupla può contenere altre tuple. Usa un ciclo for annidato per raggiungere i valori interni.

Itera su una tupla annidata (matrice)

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

for row in matrix:
    for value in row:
        print(value, end=' ')
    print()

Output:

1 2 3 
4 5 6 
7 8 9 

Ogni iterazione del ciclo esterno restituisce una tupla interna (row). Il ciclo interno scorre quindi quella tupla interna elemento per elemento.

Puoi anche decomprimere la tupla interna direttamente nell'intestazione del ciclo se la forma è fissa:

Decomprimi le tuple interne durante il ciclo

points = ((0, 0), (1, 2), (3, 4))

for x, y in points:
    print(f'x={x}, y={y}')

Output:

x=0, y=0
x=1, y=2
x=3, y=4

Questo rende il codice quasi leggibile come un testo normale ed evita i subscript row[0] / row[1]. Per ulteriori informazioni sulla decompressione, vedi Unpack Tuples.

Iterare su Due Tuple in Parallelo con zip()

zip() abbina gli elementi di due (o più) tuple per posizione e ti permette di decomporli in un unico ciclo.

Itera su due tuple in parallelo

names = ('Alice', 'Bob', 'Carol')
scores = (95, 87, 92)

for name, score in zip(names, scores):
    print(name, score)

Output:

Alice 95
Bob 87
Carol 92

zip() si ferma non appena la tupla più corta è esaurita, quindi le lunghezze non corrispondenti non generano un errore — vengono silenziosamente troncate. Se hai bisogno di tutte le coppie e vuoi riempire i vuoti, usa invece itertools.zip_longest() dalla libreria standard.

Controllo del Ciclo: break e continue

Interrompere Anticipatamente con break

break esce immediatamente dal ciclo quando una condizione è soddisfatta.

Interrompi anticipatamente un ciclo su una tupla con break

numbers = (1, 2, 3, 4, 5, 6)

for n in numbers:
    if n == 4:
        break
    print(n)

Output:

1
2
3

Il ciclo stampa 1, 2, 3, quindi si ferma quando incontra 4.

Saltare Elementi con continue

continue passa all'iterazione successiva senza eseguire il codice rimanente nel corpo del ciclo.

Salta i numeri pari usando continue

numbers = (1, 2, 3, 4, 5, 6)

for n in numbers:
    if n % 2 == 0:
        continue
    print(n)

Output:

1
3
5

Vengono stampati solo i numeri dispari; i numeri pari vengono silenziosamente saltati.

Costruire una Lista da un Ciclo su una Tupla

Poiché le tuple sono immutabili, non puoi modificarle direttamente. Un pattern comune è iterare su una tupla e raccogliere i risultati in una nuova lista.

Crea una lista di quadrati da una tupla

numbers = (1, 2, 3, 4, 5)
squares = [n ** 2 for n in numbers]
print(squares)

Output:

[1, 4, 9, 16, 25]

La list comprehension itera sulla tupla esattamente come un ciclo for ed è più concisa per trasformazioni semplici. Vedi Python Tuples e Tuple Methods per ulteriori informazioni sul lavoro con i dati delle tuple.

Quando Usare Ciascuna Tecnica

Esercitati