Tuple Python: Una Guida Completa

Una tuple è una sequenza ordinata e immutabile in Python. Può contenere elementi di qualsiasi tipo — interi, string, float, altre tuple — e questi elementi mantengono la loro posizione in modo permanente dopo la creazione della tuple. Questa pagina tratta tutto ciò che occorre sapere per lavorare con le tuple: come crearle, leggerle, combinarle e quando sceglierle rispetto a una lista Python.

Cos'è una Tuple Python?

Una tuple si scrive come una sequenza di valori separati da virgole racchiusi tra parentesi:

Tre proprietà fondamentali definiscono le tuple:

• Ordinate — gli elementi hanno una posizione fissa (indice 0, 1, 2, …).
• Immutabili — non è possibile modificare, aggiungere o rimuovere elementi dopo la creazione.
• Ammettono duplicati — lo stesso valore può comparire più di una volta.

Tuple vs. Liste

Sia le tuple che le liste memorizzano sequenze ordinate, ma la loro mutabilità differisce in modo fondamentale:

Usa una tuple quando i dati non devono cambiare — costanti di configurazione, valori restituiti da funzioni che portano più informazioni correlate, o chiavi di dizionario.

Creare Tuple

Sintassi di base

Elenca valori separati da virgole all'interno di parentesi:

Tipi misti

Una tuple può contenere elementi di tipi diversi, incluse altre tuple:

mixed = (1, 'hello', 3.14, True)
print(mixed)
# Output: (1, 'hello', 3.14, True)

Tuple vuota

empty = ()
print(empty)        # Output: ()
print(type(empty))  # Output: <class 'tuple'>

Tuple con un solo elemento

Questo è un errore comune. Senza la virgola finale, Python tratta le parentesi come raggruppamento, non come una tuple:

not_a_tuple = (42)
print(type(not_a_tuple))  # Output: <class 'int'>

real_tuple = (42,)
print(type(real_tuple))   # Output: <class 'tuple'>

La virgola finale la rende una tuple — includila sempre per le tuple con un solo elemento.

Creazione da un iterabile

Usa il costruttore integrato tuple() per convertire qualsiasi iterabile in una tuple:

Tuple senza parentesi (packing)

Python consente di creare una tuple semplicemente elencando valori separati da virgole — le parentesi sono facoltative:

packed = 1, 2, 3
print(packed)        # Output: (1, 2, 3)
print(type(packed))  # Output: <class 'tuple'>

Accedere agli Elementi di una Tuple

Indicizzazione positiva

Gli indici partono da 0 per il primo elemento:

Indicizzazione negativa

Gli indici negativi contano dalla fine. -1 è l'ultimo elemento:

Slicing

Usa [start:stop:step] per estrarre una sotto-tuple. L'indice stop è escluso:

t = (0, 1, 2, 3, 4)
print(t[1:4])   # Output: (1, 2, 3)
print(t[:3])    # Output: (0, 1, 2)
print(t[2:])    # Output: (2, 3, 4)
print(t[::2])   # Output: (0, 2, 4)

Tuple annidate

Accedi agli elementi annidati concatenando le parentesi quadre degli indici:

nested = ((1, 2), (3, 4), (5, 6))
print(nested[1])     # Output: (3, 4)
print(nested[1][0])  # Output: 3

Verifica dell'appartenenza

L'operatore in verifica se un valore è presente in una tuple:

fruits = ('apple', 'banana', 'cherry')
print('banana' in fruits)  # Output: True
print('mango' in fruits)   # Output: False

Per ulteriori tecniche di indicizzazione e slicing, consulta Access Tuples.

Immutabilità delle Tuple

Una volta creata, gli elementi di una tuple non possono essere modificati:

my_tuple = (1, 2, 3)
my_tuple[0] = 99  # TypeError: 'tuple' object does not support item assignment

Se hai bisogno di una versione modificata, costruisci una nuova tuple tramite slicing e concatenazione:

Nota che una tuple può contenere oggetti mutabili come le liste. La tuple stessa è immutabile (non è possibile sostituire il riferimento alla lista), ma la lista al suo interno può comunque essere modificata.

Consulta Update Tuples per una discussione completa delle soluzioni alternative.

Operazioni sulle Tuple

Concatenazione con +

Unire due tuple con + crea una nuova tuple:

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)
# Output: (1, 2, 3, 4)

Ripetizione con *

Ripeti il contenuto di una tuple con *:

t = (0,) * 3
print(t)
# Output: (0, 0, 0)

Per tutte le strategie di unione, consulta Join Tuples.

Metodi delle Tuple

Le tuple hanno esattamente due metodi integrati, perché l'immutabilità esclude qualsiasi operazione che modificherebbe la collezione.

count()

Restituisce il numero di volte in cui un valore compare:

index()

Restituisce l'indice della prima occorrenza di un valore. Solleva ValueError se il valore non viene trovato:

Consulta Tuple Methods per un riferimento completo.

Funzioni Integrate con le Tuple

Le funzioni integrate di Python funzionano con qualsiasi iterabile, incluse le tuple:

sorted() restituisce sempre una list, anche quando viene fornita una tuple come input. Racchiudila in tuple() se hai bisogno di una tuple ordinata come risultato.

Unpacking delle Tuple

L'unpacking assegna ogni elemento di una tuple a una variabile separata in un'unica istruzione:

Unpacking esteso con *

Una variabile con asterisco assorbe un numero qualsiasi di elementi rimanenti in una lista:

first, *rest = (10, 20, 30, 40)
print(first)  # Output: 10
print(rest)   # Output: [20, 30, 40]

Scambio di variabili

L'unpacking delle tuple rende lo scambio di variabili possibile in una sola riga — senza bisogno di una variabile temporanea:

x, y = 5, 10
x, y = y, x
print(x, y)
# Output: 10 5

Consulta Unpack Tuples per altri pattern, incluso l'unpacking annidato.

Iterare su una Tuple

Un ciclo for visita ogni elemento in ordine:

fruits = ('apple', 'banana', 'cherry')
for fruit in fruits:
    print(fruit)
# Output:
# apple
# banana
# cherry

Usa enumerate() quando hai bisogno anche dell'indice:

for i, fruit in enumerate(fruits):
    print(i, fruit)
# Output:
# 0 apple
# 1 banana
# 2 cherry

Consulta Loop Tuples per i cicli while, zip() e l'attraversamento di tuple annidate.

Costruire Tuple con le Comprensioni

Python non ha una sintassi per la comprensione delle tuple, ma puoi passare un'espressione generatore a tuple() per ottenere lo stesso risultato:

L'espressione x**2 for x in my_list all'interno di tuple() è un generatore — produce valori uno alla volta senza costruire una lista intermedia.

Quando Usare le Tuple

Le tuple eccellono in situazioni specifiche:

• Valori restituiti multipli. Le funzioni possono restituire più valori in modo pulito come tuple: return x, y.
• Chiavi di dizionario. Le liste non possono essere chiavi di dizionario perché sono mutabili; le tuple sì.
• Integrità dei dati. Se una collezione non deve cambiare — valori RGB, righe di database, coordinate geografiche — una tuple lo impone a livello di linguaggio.
• Leggero vantaggio in termini di prestazioni. L'iterazione e la creazione di tuple sono marginalmente più veloci rispetto alle operazioni sulle liste per gli stessi dati.

# Using a tuple as a dictionary key
locations = {}
locations[(48.8566, 2.3522)] = 'Paris'
locations[(51.5074, -0.1278)] = 'London'
print(locations[(48.8566, 2.3522)])
# Output: Paris

Esercitazione