Unire le Tuple in Python

Le tuple Python sono sequenze immutabili — una volta create non è possibile aggiungere, rimuovere o modificare i loro elementi. Unire le tuple significa creare una nuova tupla che combina il contenuto di due o più tuple esistenti. Poiché le tuple sono immutabili, ogni operazione di unione restituisce una tupla nuova invece di modificare quelle originali.

Questa pagina illustra i principali modi per unire le tuple in Python:

• Operatore + — concatena due o più tuple
• Operatore * — ripete una tupla un numero fisso di volte
• Costruttore tuple() — costruisce una tupla da qualsiasi iterabile, utile quando si combinano sequenze non-tupla

Unire le Tuple con l'Operatore +

L'operatore + concatena due tuple in un'unica nuova tupla. Gli elementi dell'operando sinistro vengono prima, seguiti da quelli dell'operando destro. Nessuna delle tuple originali viene modificata.

Output:

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

Unire Tre o Più Tuple

Concatena l'operatore + per unire un numero qualsiasi di tuple in una singola espressione:

Output:

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

Unire Tuple con Tipi Misti

Le tuple possono contenere valori di tipi diversi e l'operatore + funziona allo stesso modo indipendentemente dal tipo:

t1 = (1, "hello", True)
t2 = (3.14, None)
result = t1 + t2
print(result)

Output:

(1, 'hello', True, 3.14, None)

Attenzione: Entrambi gli Operandi Devono Essere Tuple

Non è possibile usare + per concatenare una tupla con una lista o qualsiasi altro tipo — Python solleva un TypeError. Converti prima l'altra sequenza in una tupla:

my_tuple = (1, 2, 3)
my_list = [4, 5, 6]

# This raises TypeError:
# result = my_tuple + my_list

# Correct — convert the list to a tuple first:
result = my_tuple + tuple(my_list)
print(result)

Output:

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

Attenzione: Sintassi della Tupla con un Solo Elemento

Una tupla con un solo elemento richiede una virgola finale. Senza di essa, Python interpreta le parentesi come raggruppamento e non come una tupla letterale:

not_a_tuple = (42)    # int, not tuple
singleton   = (42,)   # tuple with one element

result = singleton + (1, 2)
print(result)

Output:

(42, 1, 2)

Ripetere una Tupla con l'Operatore *

L'operatore * ripete una tupla un numero specificato di volte e restituisce una nuova tupla. È utile quando si ha bisogno di una sequenza pre-riempita con un pattern ripetuto.

t = ("a", "b")
result = t * 3
print(result)

Output:

('a', 'b', 'a', 'b', 'a', 'b')

Il numero intero può comparire su entrambi i lati: t * 3 e 3 * t producono lo stesso risultato. Moltiplicare per 0 o per un numero negativo restituisce una tupla vuota.

t = (1, 2, 3)
print(t * 0)   # ()
print(t * 1)   # (1, 2, 3)

Output:

()
(1, 2, 3)

Costruire una Tupla Combinata con tuple()

Il costruttore built-in tuple() converte qualsiasi iterabile in una tupla. Puoi usarlo per costruire una tupla combinata da una lista assemblata tramite append, il che è più efficiente rispetto alle chiamate ripetute con + all'interno di un ciclo.

parts = [1, 2, 3]
parts += [4, 5, 6]        # build up a list first
combined = tuple(parts)   # convert to tuple once
print(combined)

Output:

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

Perché Evitare + All'interno di un Ciclo

Ogni chiamata a + crea un nuovo oggetto tupla e copia tutti gli elementi. Quando si uniscono molte tuple, questo comporta O(n²) copie. Il metodo efficiente consiste nel raccogliere tutti gli elementi in una lista e convertirla una sola volta alla fine:

tuples = [(1, 2), (3, 4), (5, 6), (7, 8)]

# Inefficient — creates a new tuple on each iteration
result = ()
for t in tuples:
    result = result + t   # many intermediate copies

# Efficient — build a list, convert once
result = tuple(item for t in tuples for item in t)
print(result)

Output:

(1, 2, 3, 4, 5, 6, 7, 8)

Unire vs. Annidare le Tuple

È facile annidare accidentalmente le tuple invece di unirle. L'operatore + appiattisce un livello; racchiudere le tuple in una nuova tupla crea una struttura annidata.

t1 = (1, 2)
t2 = (3, 4)

joined = t1 + t2      # flat: all four elements at the same level
nested = (t1, t2)     # two-element tuple of tuples

print("joined:", joined)
print("nested:", nested)

Output:

joined: (1, 2, 3, 4)
nested: ((1, 2), (3, 4))

Usa + quando vuoi un risultato piatto. Usa (t1, t2) quando vuoi intenzionalmente una tupla di tuple (ad esempio, una tabella di righe).

Scegliere l'Approccio Giusto

Argomenti Correlati

• Python Tuples — creare, indicizzare e fare slicing delle tuple
• Access Tuples — indicizzazione e slicing degli elementi di una tupla
• Update Tuples — soluzioni alternative per modificare tuple immutabili
• Unpack Tuples — assegnazione degli elementi di una tupla alle variabili
• Loop Tuples — iterazione sugli elementi di una tupla
• Tuple Methods — riferimento per count() e index()
• Join Lists — unire liste con +, extend() e altro

Esercitazione