Decomprimere le Tuple in Python: Guida Completa

La decompressione delle tuple (chiamata anche decompressione degli iterabili) consente di assegnare gli elementi di una tupla — o di qualsiasi iterabile — a variabili individuali in un'unica istruzione. Questa pagina tratta tutto, dalla sintassi di base ai pattern avanzati come le espressioni star, la decompressione annidata e quella nei cicli.

Cos'è la Decompressione delle Tuple?

Quando decomprimi una tupla, Python associa ciascun elemento alla variabile corrispondente sul lato sinistro di =. Il numero di variabili deve corrispondere esattamente al numero di elementi (a meno che non si utilizzi un'espressione star, trattata più avanti).

Le parentesi attorno alla tupla sono opzionali — 1, 2, 3 è anch'esso una tupla. Entrambe le righe seguenti sono equivalenti:

a, b, c = (1, 2, 3)
a, b, c = 1, 2, 3   # same result

Perché Usare la Decompressione delle Tuple?

Assegnazione concisa delle variabili

Senza decompressione è necessaria una riga per ogni elemento:

Scambio di variabili

La decompressione rende lo scambio di due valori un'operazione in una sola riga. Python valuta completamente il lato destro prima di effettuare l'assegnazione, quindi non è necessaria una variabile temporanea:

Lettura dei valori restituiti dalle funzioni

Le funzioni che restituiscono più valori restituiscono in realtà una tupla. La decompressione assegna immediatamente un nome significativo a ciascun valore:

def min_max(numbers):
    return min(numbers), max(numbers)

lo, hi = min_max([3, 1, 4, 1, 5, 9, 2, 6])

print(lo)  # 1
print(hi)  # 9

Senza decompressione si scriverebbe result[0] e result[1], che è meno leggibile.

Decompressione Estesa con l'Operatore Star

Quando non si conosce (o non interessa) il numero di elementi centrali, si può anteporre * a una variabile per raccogliere tutto ciò che non corrisponde a uno slot nominato. La variabile con l'asterisco riceve sempre una list, anche se raccoglie zero elementi.

Catturare la coda

first, *rest = (1, 2, 3, 4, 5)

print(first)  # 1
print(rest)   # [2, 3, 4, 5]

Catturare la testa

*start, last = (1, 2, 3, 4, 5)

print(start)  # [1, 2, 3, 4]
print(last)   # 5

Catturare una sezione centrale

first, *middle, last = (10, 20, 30, 40, 50)

print(first)   # 10
print(middle)  # [20, 30, 40]
print(last)    # 50

È consentita solo una variabile con asterisco per istruzione di decompressione. Usarne due o più genera un SyntaxError.

Ignorare Elementi con _

La convenzione Python usa _ come nome di variabile da scartare. È un identificatore valido — Python vi assegna il valore — ma per convenzione segnala "non ho bisogno di questo valore".

x, _, z = (10, 99, 30)

print(x)  # 10
print(z)  # 30
# _ holds 99 but we do not use it

Combina _ con un'espressione star per scartare molti elementi:

first, *_ = (10, 20, 30, 40)

print(first)  # 10
# *_ swallows 20, 30, 40

Decompressione Annidata delle Tuple

Se una tupla contiene un'altra tupla, è possibile decomprimere entrambi i livelli in un'unica istruzione, specchiando la struttura annidata con le parentesi:

Questo funziona a qualsiasi profondità, ma una struttura molto annidata penalizza la leggibilità — considera di decomprimere in più fasi.

Decompressione nei Cicli for

È possibile decomprimere ciascun elemento di un iterabile direttamente nell'istruzione for. Ciò è particolarmente utile con le liste di tuple:

pairs = [(1, 'one'), (2, 'two'), (3, 'three')]

for num, word in pairs:
    print(num, word)

# 1 one
# 2 two
# 3 three

Decompressione con enumerate()

enumerate() restituisce coppie (indice, valore), che è possibile decomprimere direttamente:

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

for i, fruit in enumerate(fruits):
    print(i, fruit)

# 0 apple
# 1 banana
# 2 cherry

Questo evita il tracciamento manuale degli indici ed è il pattern idiomatico Python per iterare su una sequenza quando si ha bisogno sia della posizione che del valore.

Decompressione con zip()

zip() accoppia gli elementi di due iterabili, e ogni coppia può essere decompressa nel ciclo:

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

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

# Alice 92
# Bob 87
# Carol 95

Errori Comuni

Troppi o troppo pochi valori

Python genera un ValueError se il numero di variabili non corrisponde al numero di elementi (e non è presente alcuna espressione star):

a, b = (1, 2, 3)
# ValueError: too many values to unpack (expected 2)

a, b, c = (1, 2)
# ValueError: not enough values to unpack (expected 3, got 2)

Correggi la discrepanza o usa un'espressione star per assorbire gli elementi in eccesso.

Due variabili con asterisco

first, *middle, *last = (1, 2, 3, 4)
# SyntaxError: multiple starred expressions in assignment

È consentita solo una variabile * per istruzione di decompressione.

Riferimento Rapido

Capitoli Correlati

• Python Tuples — creazione, indicizzazione e slicing delle tuple
• Access Tuples — lettura dei singoli elementi tramite indice
• Loop Tuples — iterazione sugli elementi di una tupla
• Join Tuples — combinazione di più tuple
• Tuple Methods — count() e index()
• Update Tuples — lavorare aggirando l'immutabilità

Pratica