Tuple in Python: sequenze immutabili, spacchettamento e named tuple

Una tupla è una lista che non puoi modificare

A prima vista tuple e liste si somigliano: entrambe sono sequenze ordinate, entrambe supportano indicizzazione e iterazione. Ma una differenza cruciale cambia tutto: le tuple sono immutabili. Una volta creata una tupla, non puoi aggiungerci elementi, toglierne o sostituirne uno.

Le tuple si scrivono con le parentesi tonde (o a volte senza):

point = (3, 4)
rgb = (255, 128, 0)
name_age = ("Rosa", 30)

print(point, rgb, name_age)

Una tupla con un solo elemento ha bisogno di una virgola finale, altrimenti Python tratta le parentesi come un semplice raggruppamento:

not_a_tuple = (42)     # solo il numero 42 tra parentesi
a_tuple = (42,)        # tupla di un elemento

print(type(not_a_tuple))
print(type(a_tuple))

E per le tuple vuote, usa ():

empty = ()
print(type(empty), len(empty))

L'immutabilità, in pratica

Prova a modificare una tupla e Python ti ferma:

point = (3, 4)
# point[0] = 10     # Questo solleverebbe TypeError.
# point.append(5)   # Idem: le tuple non hanno il metodo append.
print(point)

Puoi leggere liberamente da una tupla (indicizzazione, slicing, iterazione, in), ma non puoi modificarla. Se ti serve una tupla diversa, ne crei una nuova.

Perché dovresti volere qualcosa che non puoi cambiare?

L'immutabilità sembra un limite, ma spesso è proprio la caratteristica che ti serve.

1. Sicurezza. Una tupla che passi a una funzione non può essere modificata alle tue spalle.
2. Hashability. Le tuple di valori immutabili si possono usare come chiavi di dizionario o membri di un set; le liste no.
3. Intenzione. Una tupla dice "questo è un record dalla forma fissa". point = (3, 4) comunica "due coordinate" in modo più chiaro di point = [3, 4].

Le tuple danno il meglio per cose come:

• Coordinate: (x, y), (lat, lon)
• Colori RGB: (255, 128, 0)
• Record: (name, email, signup_date)
• Restituire più valori da una funzione

Spacchettamento

Tuple e sintassi di spacchettamento sono fatte l'una per l'altra:

point = (3, 4)
x, y = point
print(x, y)

È la virgola a sinistra a fare lo spacchettamento. Python vede due nomi e una tupla con due valori, e li associa a coppie.

Nel Python idiomatico questo schema è ovunque:

# Scambiare due variabili.
a, b = 1, 2
a, b = b, a
print(a, b)

# Spacchettare il valore restituito da una funzione.
def minmax(values):
    return min(values), max(values)

low, high = minmax([5, 3, 9, 1, 7])
print(low, high)

# Spacchettare dentro un ciclo.
points = [(0, 0), (1, 1), (2, 4), (3, 9)]
for x, y in points:
    print(f"x={x}, y={y}")

Puoi usare * per raccogliere "tutto il resto":

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

Comodo quando ti interessano solo il primo e l'ultimo elemento.

Tuple come chiavi di dizionario

Siccome le tuple sono hashable (purché lo sia anche il loro contenuto), puoi usarle come chiavi di un dict. Le liste non possono farlo:

cache = {}
cache[(3, 4)] = "point A"
cache[(10, 20)] = "point B"

print(cache[(3, 4)])

Questo schema, cioè usare come chiave una combinazione di valori, è sorprendentemente utile. Pensa a "il punteggio dell'utente X nel giorno Y" o "il percorso migliore da A a B".

Tuple per restituire più valori

Una funzione che deve restituire più di una cosa di solito restituisce una tupla:

def divmod_custom(a, b):
    return a // b, a % b

quotient, remainder = divmod_custom(17, 5)
print(quotient, remainder)

La funzione integrata divmod() di Python fa esattamente questo. L'assegnazione con spacchettamento nel codice chiamante la rende naturale da leggere.

Named tuple, quando la posizione non basta

Quando le tue tuple superano i due o tre elementi, ricordare quale posizione significa cosa diventa noioso. collections.namedtuple risolve il problema:

from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])

p = Point(3, 4)
print(p.x, p.y)
print(p)

Ora gli elementi della tupla hanno un nome. È ancora immutabile, è ancora una tupla (quindi spacchettamento e indicizzazione funzionano), ma l'accesso è molto più comodo. Per qualsiasi cosa più complessa ci sono le dataclasses, che incontreremo più avanti nel capitolo sulle classi.

Tupla o lista: una guida rapida alla scelta

• Forma fissa, ogni posizione ha un significato → tupla.
• Una collezione che potrebbe crescere o ridursi → lista.
• Restituire più valori da una funzione → tupla.
• Ti serve una chiave di dict o un membro di un set → tupla (la lista non funziona).
• La modificherai → lista (la tupla non te lo permette).

Andiamo avanti

Le tuple coprono un estremo dello spettro: fisse, piccole, strutturate. Prossimo argomento: i set, che svolgono un compito completamente diverso, cioè controlli di appartenenza veloci e unicità.