Aggiornare le Tuple in Python

Le tuple Python sono sequenze immutabili — una volta create, la loro struttura non può cambiare. Non è possibile aggiungere, rimuovere o riassegnare elementi direttamente. Nonostante ciò, è sempre possibile produrre una nuova tupla modificata a partire da una esistente. Questa pagina illustra ogni tecnica pratica: conversione in lista, concatenazione, slicing, sostituzione di tutte le occorrenze di un valore e altro ancora. Spiega inoltre l'unica vera insidia — gli oggetti mutabili annidati all'interno di una tupla.

Perché le Tuple Sono Immutabili

La garanzia di immutabilità di Python è intenzionale. Le tuple possono essere usate come chiavi di dizionario o membri di set proprio perché la loro identità non cambia mai. Tentare di modificare una tupla in-place genera un TypeError:

Il tentativo di assegnazione diretta genera un TypeError

t = (1, 2, 3, 4, 5)
t[2] = 6  # TypeError: 'tuple' object does not support item assignment

Ogni tecnica descritta di seguito crea una tupla completamente nuova anziché modificare l'originale.

Conversione in Lista

L'approccio più leggibile per modifiche complesse: convertire in lista, apportare tutte le modifiche desiderate, poi riconvertire.

Convertire una tupla in lista, aggiornarla e riconvertirla

Output:

(1, 2, 6, 4, 5)

Usa questo approccio quando devi apportare più modifiche contemporaneamente — ad esempio, ordinare, filtrare o applicare una trasformazione a tutti gli elementi — perché le liste supportano tutte le operazioni di mutazione.

Sostituire un Valore con Slicing e Concatenazione

Per scambiare un singolo elemento, puoi eseguire lo slicing della tupla attorno all'indice target e concatenare il nuovo valore. Non è necessaria la conversione in lista.

Sostituire un elemento tramite slice + concatenazione

t = (1, 2, 3, 4, 5)

# Replace the element at index 2 (value 3) with 6
t = t[:2] + (6,) + t[3:]

print(t)

Output:

(1, 2, 6, 4, 5)

Lo slice t[:2] restituisce (1, 2), il letterale (6,) è il valore sostitutivo (nota la virgola finale — è ciò che lo rende una tupla), e t[3:] restituisce (4, 5). La concatenazione unisce i tre elementi in una nuova tupla.

Sostituire Tutte le Occorrenze di un Valore

Usa un'espressione generatore all'interno di tuple() per sostituire ogni occorrenza di un valore con un altro.

Sostituire tutte le occorrenze di un valore in una tupla

t = (1, 2, 2, 3, 2)

# Replace every 2 with 5
t = tuple(5 if x == 2 else x for x in t)

print(t)

Output:

(1, 5, 5, 3, 5)

Questo è più conciso dell'approccio con conversione in lista quando l'unico obiettivo è una sostituzione di valore.

Aggiungere Elementi

Aggiungere in Fondo

Usa l'operatore + per aggiungere elementi in coda. Il lato destro deve essere anch'esso una tupla — da qui la virgola finale in (4,).

Aggiungere un elemento a una tupla

t = (1, 2, 3)
t = t + (4,)
print(t)

Output:

(1, 2, 3, 4)

La forma abbreviata con assegnazione aumentata += funziona allo stesso modo:

Usare += per estendere una tupla

t = (1, 2, 3)
t += (4, 5)
print(t)

Output:

(1, 2, 3, 4, 5)

Nota: += non modifica l'oggetto tupla originale — Python riassocia il nome della variabile a una tupla appena creata. Se un'altra variabile fa ancora riferimento all'originale, questa rimane invariata.

Aggiungere in Testa

Aggiungere un elemento all'inizio di una tupla

t = (1, 2, 3)
t = (0,) + t
print(t)

Output:

(0, 1, 2, 3)

Inserire nel Mezzo

Non esiste un metodo insert() diretto per le tuple. Combina due slice attorno alla posizione desiderata:

Inserire un elemento in una posizione specifica

t = (1, 2, 4, 5)

# Insert 3 at index 2
t = t[:2] + (3,) + t[2:]

print(t)

Output:

(1, 2, 3, 4, 5)

Rimuovere Elementi

Rimuovere per Indice

Esegui lo slicing attorno all'indice che vuoi eliminare:

Rimuovere l'elemento all'indice 2

t = (1, 2, 3, 4, 5)

# Remove the element at index 2 (value 3)
t = t[:2] + t[3:]

print(t)

Output:

(1, 2, 4, 5)

Rimuovere per Valore

Usa un'espressione generatore per filtrare i valori corrispondenti:

Rimuovere tutte le occorrenze di un valore specifico

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

t = tuple(x for x in t if x != 'banana')

print(t)

Output:

('apple', 'cherry')

Questo rimuove ogni occorrenza del valore in un unico passaggio. Se vuoi rimuovere solo la prima occorrenza, converti in lista, chiama .remove() e riconverti.

Usare il Disimballaggio delle Tuple

Il disimballaggio di una tupla in variabili con nome permette di ricostruirla con posizioni specifiche modificate. È più utile quando la tupla è piccola e vuoi rinominare i pezzi per chiarezza.

Ricostruire una tupla disimballandola e riassegnando variabili specifiche

t = (1, 2, 3, 4, 5)
a, b, c, d, e = t

# Replace the third element
t = (a, b, 6, d, e)

print(t)

Output:

(1, 2, 6, 4, 5)

Evita questo approccio per tuple grandi — finiresti per scrivere una variabile per ogni elemento, il che è verboso e soggetto a errori.

Attenzione: Oggetti Mutabili all'Interno di una Tupla

L'immutabilità di una tupla si applica solo ai riferimenti che contiene, non agli oggetti a cui quei riferimenti puntano. Se una tupla contiene un oggetto mutabile — come una lista — puoi modificare la lista, e la modifica sarà visibile attraverso la tupla.

Modificare una lista annidata all'interno di una tupla

t = ([1, 2], [3, 4])

# The tuple itself is immutable, but its elements (lists) are not
t[0].append(5)

print(t)

Output:

([1, 2, 5], [3, 4])

La tupla contiene ancora gli stessi due riferimenti alle liste — quella parte è immutabile. Ma l'oggetto lista a cui punta t[0] è stato mutato. Questa è una fonte comune di confusione quando le tuple vengono usate come chiavi di dizionario; solo le tuple completamente immutabili (che non contengono liste, dizionari o altri oggetti mutabili) sono hashable.

Scegliere l'Approccio Giusto

Per ulteriori informazioni sull'utilizzo delle tuple, consulta Accedere alle Tuple, Disimballare le Tuple, Iterare le Tuple e Metodi delle Tuple.

Pratica