Introduzione
Le tuple sono una delle strutture dati più utili di Python quando si lavora con sequenze di valori che non devono cambiare durante l’esecuzione del programma. Spesso vengono introdotte come “liste immutabili”, ma questa definizione è solo un punto di partenza: nella pratica, le tuple sono molto efficaci per rappresentare record, coordinate, configurazioni e dati da leggere in modo ordinato e sicuro.
In questo tutorial ci concentriamo su un sotto-argomento molto pratico e spesso sottovalutato: come usare le tuple per iterare su collezioni di dati, contare elementi e organizzare sequenze di informazioni in modo chiaro. È un caso d’uso reale, utile in script, analisi dati e applicazioni backend.
Vedremo come:
- memorizzare dati eterogenei in una tuple;
- scorrere una sequenza di tuple con un ciclo for;
- usare enumerate per ottenere indice e valore;
- contare occorrenze e aggregare informazioni;
- scrivere codice leggibile e robusto.
Codice completo
# Esempio: gestione di una lista di ordini in un piccolo negozio online
# Ogni ordine è rappresentato da una tuple:
# (id_ordine, cliente, prodotto, quantita, prezzo_unitario)
ordini = [
(1001, "Alice", "Tastiera meccanica", 1, 89.90),
(1002, "Marco", "Mouse wireless", 2, 24.50),
(1003, "Alice", "Monitor 27 pollici", 1, 219.99),
(1004, "Sara", "Cuffie USB", 1, 39.00),
(1005, "Marco", "Supporto laptop", 1, 29.90),
(1006, "Alice", "Mouse wireless", 1, 24.50),
]
# 1) Iterazione semplice sulle tuple
print("Elenco ordini:")
for ordine in ordini:
id_ordine, cliente, prodotto, quantita, prezzo_unitario = ordine
totale = quantita * prezzo_unitario
print(f"- Ordine #{id_ordine} | Cliente: {cliente} | Prodotto: {prodotto} | Totale: {totale:.2f}€")
print()
# 2) Iterazione con enumerate per avere anche l´indice
print("Ordini numerati:")
for indice, ordine in enumerate(ordini, start=1):
id_ordine, cliente, prodotto, quantita, prezzo_unitario = ordine
print(f"{indice}. {cliente} ha ordinato {quantita} x {prodotto}")
print()
# 3) Conteggio delle occorrenze per cliente
conteggio_clienti = {}
for _, cliente, _, _, _ in ordini:
conteggio_clienti[cliente] = conteggio_clienti.get(cliente, 0) + 1
print("Numero di ordini per cliente:")
for cliente, numero_ordini in conteggio_clienti.items():
print(f"- {cliente}: {numero_ordini}")
print()
# 4) Calcolo del fatturato totale
fatturato_totale = 0.0
for _, _, _, quantita, prezzo_unitario in ordini:
fatturato_totale += quantita * prezzo_unitario
print(f"Fatturato totale: {fatturato_totale:.2f}€")
print()
# 5) Ricerca degli ordini di un cliente specifico
cliente_cercato = "Alice"
ordini_cliente = [ordine for ordine in ordini if ordine[1] == cliente_cercato]
print(f"Ordini di {cliente_cercato}:")
for ordine in ordini_cliente:
id_ordine, cliente, prodotto, quantita, prezzo_unitario = ordine
print(f"- #{id_ordine}: {prodotto} x{quantita}")
print()
# 6) Raggruppamento dei prodotti acquistati
prodotti_acquistati = {}
for _, _, prodotto, quantita, _ in ordini:
prodotti_acquistati[prodotto] = prodotti_acquistati.get(prodotto, 0) + quantita
print("Quantità totale venduta per prodotto:")
for prodotto, quantita_totale in prodotti_acquistati.items():
print(f"- {prodotto}: {quantita_totale}")
print()
# 7) Esempio di tuple annidate: coordinate di spedizione
spedizioni = [
("Roma", (41.9028, 12.4964)),
("Milano", (45.4642, 9.1900)),
("Napoli", (40.8518, 14.2681)),
]
print("Coordinate di spedizione:")
for citta, coordinate in spedizioni:
latitudine, longitudine = coordinate
print(f"- {citta}: lat {latitudine}, lon {longitudine}")Spiegazione
Il codice mostra un caso d’uso molto realistico: un elenco di ordini, dove ogni ordine è una tuple con campi in posizione fissa. Questo approccio è semplice, veloce da leggere e particolarmente adatto quando i dati hanno una struttura stabile.
1) Iterazione su una lista di tuple
La variabile ordini contiene una lista di tuple. Ogni tuple rappresenta un record:
- id ordine
- nome cliente
- nome prodotto
- quantità
- prezzo unitario
Con il ciclo for ordine in ordini scorriamo tutti i record. Poi facciamo il unpacking della singola tuple in variabili separate. Anche se il tutorial non è centrato sull’unpacking, qui è il modo più naturale per leggere i dati in modo chiaro.
2) Uso di enumerate
enumerate() è utile quando vuoi aggiungere un contatore alla tua iterazione. Nel nostro esempio serve per stampare gli ordini numerati. È una soluzione migliore rispetto a gestire manualmente una variabile indice, perché è più leggibile e meno soggetta a errori.
3) Conteggio delle occorrenze
Per contare quanti ordini ha effettuato ogni cliente, usiamo un dizionario. La logica è semplice:
- estraiamo il nome del cliente da ogni tuple;
- se il cliente è già presente, incrementiamo il contatore;
- se non è presente, inizializziamo il conteggio a 1.
Qui la tuple è utile perché rende l’accesso ai dati coerente: il cliente è sempre nel secondo elemento, quindi il codice resta prevedibile.
4) Calcolo di un totale
Sommiamo il fatturato totale moltiplicando quantità e prezzo unitario per ogni ordine. Questo è un esempio concreto di elaborazione dati basata su tuple: la struttura è semplice, ma permette di eseguire calcoli reali senza introdurre classi o oggetti più complessi.
5) Filtraggio con list comprehension
Per ottenere solo gli ordini di un cliente specifico, usiamo una list comprehension. La condizione ordine[1] == cliente_cercato funziona perché sappiamo che il cliente è sempre nella posizione 1 della tuple. È un pattern molto comune quando si lavora con record sequenziali.
6) Tuple annidate
Nell’ultima parte vediamo un esempio di tuple annidate: ogni spedizione contiene una città e una coppia di coordinate geografiche. Questo è utile quando un dato è composto da più livelli, ma vuoi mantenere una struttura compatta e immutabile.
Best practice
Le tuple sono semplici da usare, ma per sfruttarle bene conviene seguire alcune buone pratiche.
- Usale per dati stabili: se il numero e il significato dei campi non cambiano spesso, la tuple è una scelta ottima.
- Evita indici “magici” sparsi nel codice: se usi spesso ordine[3] o ordine[4], il codice diventa difficile da mantenere. In questi casi valuta namedtuple o dataclass.
- Preferisci unpacking chiaro: assegnare i valori a variabili con nomi espliciti rende il codice più leggibile.
- Non usare tuple per dati modificabili: se devi aggiungere o rimuovere elementi frequentemente, una lista è più adatta.
- Evita tuple troppo lunghe: una tuple con molti campi diventa difficile da leggere. Se il record cresce, è meglio passare a una struttura più descrittiva.
Un consiglio molto importante: quando una tuple viene usata come “record”, documenta sempre l’ordine dei campi. Senza una convenzione chiara, il codice può diventare fragile.
Se vuoi migliorare la leggibilità, puoi anche creare costanti per indicare gli indici:
ID = 0
CLIENTE = 1
PRODOTTO = 2
QUANTITA = 3
PREZZO = 4
# Esempio d´uso:
# ordine[CLIENTE]
# ordine[PRODOTTO]Questa tecnica non elimina del tutto il problema degli indici, ma rende il significato più esplicito.
Riepilogo
Le tuple non servono solo a “raggruppare valori”: sono molto utili quando devi gestire sequenze di dati coerenti, leggere e non modificabili. In questo tutorial hai visto come usarle per iterare su collezioni, numerare elementi, contare occorrenze, calcolare totali e lavorare con strutture annidate.
- Le tuple sono ideali per record semplici e stabili.
- Si integrano bene con for, enumerate e list comprehension.
- Permettono di scrivere codice compatto e ordinato.
- Per dati complessi o in evoluzione, meglio valutare strutture più esplicite.
In breve: usa le tuple quando vuoi rappresentare dati fissi e scorrerli in modo efficiente e leggibile.
Approfondisci con risorse ufficiali
- Documentazione Python sulle tuple: https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences
- Documentazione di enumerate(): https://docs.python.org/3/library/functions.html#enumerate
- Documentazione su list comprehension: https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions
- PEP 8 - Style Guide for Python Code: https://peps.python.org/pep-0008/