Metodi delle Tuple

Una tupla Python è una sequenza ordinata e immutabile. Poiché le tuple non possono essere modificate dopo la creazione, espongono solo due metodi built-in: count() e index(). Questa pagina tratta entrambi i metodi in dettaglio, inclusi i loro parametri opzionali, le insidie comuni e le funzioni built-in (len(), min(), max(), sum(), sorted()) che funzionano altrettanto bene sulle tuple.

Se sei nuovo alle tuple, leggi prima Python Tuples. Per accedere agli elementi tramite posizione o slice, vedi Access Tuples.

Riferimento Rapido

Perché Così Pochi Metodi?

Le liste hanno più di una dozzina di metodi perché sono mutabili — puoi aggiungere, rimuovere, ordinare in-place e così via. Le tuple sono immutabili: una volta create, i loro elementi non possono essere aggiunti, rimossi o riordinati. Di conseguenza, le uniche operazioni che hanno senso come metodi di istanza sono quelle di sola lettura: contare le occorrenze e trovare le posizioni.

Il Metodo count()

tuple.count(value) scansiona l'intera tupla e restituisce il numero di volte in cui value appare. Restituisce 0 se il valore non viene trovato — non genera mai un errore.

count() con Tuple Annidate

count() utilizza l'uguaglianza (==) per il confronto, quindi funziona con qualsiasi tipo di elemento, incluse le tuple annidate:

points = ((0, 0), (1, 2), (0, 0), (3, 4))

print(points.count((0, 0)))  # 2
print(points.count((1, 2)))  # 1

Attenzione: True e 1 Sono Uguali

Python considera True == 1 e False == 0, quindi count() li conta in modo intercambiabile:

data = (1, True, 0, False, 1)

print(data.count(1))     # 3  (counts 1, True, 1)
print(data.count(True))  # 3  (same three elements)
print(data.count(0))     # 2  (counts 0 and False)

Questo è il comportamento standard di uguaglianza di Python, non una particolarità delle tuple.

Il Metodo index()

tuple.index(value) restituisce l'indice della prima occorrenza di value. Se il valore non è presente, genera un ValueError.

Parametri Opzionali start e stop

La firma completa è tuple.index(value, start, stop). Puoi restringere l'intervallo di ricerca per evitare di trovare nuovamente un'occorrenza già nota:

numbers = (10, 20, 30, 20, 40, 20)

# Find first occurrence of 20 starting at index 2
print(numbers.index(20, 2))     # 3

# Find 20 only within numbers[2:5]  →  (30, 20, 40)
print(numbers.index(20, 2, 5))  # 3

L'indice stop è esclusivo, in linea con le convenzioni degli slice Python.

Gestire il ValueError

Proteggi sempre index() quando il valore potrebbe essere assente:

animals = ("cat", "dog", "bird")

target = "fish"
if target in animals:
    pos = animals.index(target)
    print(f"Found {target!r} at index {pos}")
else:
    print(f"{target!r} is not in the tuple")
# fish is not in the tuple

In alternativa, usa un blocco try / except:

try:
    pos = animals.index("fish")
except ValueError:
    pos = -1  # sentinel value when not found

print(pos)  # -1

Funzioni Built-in Che Funzionano sulle Tuple

Sebbene non siano metodi delle tuple, le seguenti funzioni built-in accettano qualsiasi iterabile — comprese le tuple — e vengono spesso usate con esse.

len()

Restituisce il numero totale di elementi:

min() e max()

Restituiscono l'elemento più piccolo e quello più grande. Gli elementi devono essere confrontabili (tutti numeri, o tutte stringhe):

scores = (72, 95, 88, 61, 100)

print(min(scores))  # 61
print(max(scores))  # 100

sum()

Restituisce la somma aritmetica di una tupla numerica:

prices = (9.99, 4.49, 14.99)
print(sum(prices))   # 29.47
print(sum(prices, 5.00))  # 34.47  — optional start value

sorted()

Restituisce una nuova lista (non una tupla) con gli elementi ordinati in ordine crescente. La tupla originale rimane invariata:

letters = ("d", "a", "c", "b")

asc = sorted(letters)          # ascending (default)
desc = sorted(letters, reverse=True)  # descending

print(asc)   # ['a', 'b', 'c', 'd']
print(desc)  # ['d', 'c', 'b', 'a']
print(letters)  # ('d', 'a', 'c', 'b')  — unchanged

Per ottenere una tupla ordinata invece di una lista, usa tuple():

sorted_tuple = tuple(sorted(letters))
print(sorted_tuple)  # ('a', 'b', 'c', 'd')

Operazioni Comuni sulle Tuple (Non Metodi)

Sebbene i seguenti pattern non usino .count() o .index(), emergono spesso quando si lavora con le tuple.

Concatenazione

Usa + per combinare due tuple in una nuova:

Vedi Join Tuples per ulteriori tecniche di unione.

Convertire una Tupla in Lista (e Viceversa)

Poiché le tuple sono immutabili, converti in list quando hai bisogno di modificare il contenuto, poi riconverti:

t = (1, 2, 3)
lst = list(t)
lst.append(4)
t2 = tuple(lst)
print(t2)  # (1, 2, 3, 4)

Per una guida completa sui pattern di mutazione, vedi Update Tuples.

Verifica dell'Appartenenza

Usa in e not in invece di index() quando hai bisogno solo di una risposta sì/no:

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

print("banana" in fruits)      # True
print("mango" not in fruits)   # True

Questo è più leggibile e permette di evitare il ValueError che index() genera per i valori mancanti.

Scegliere Tra count() e index()

Capitoli Correlati

• Python Tuples — nozioni di base sulle tuple e sintassi di creazione
• Access Tuples — indicizzazione e slicing
• Update Tuples — soluzioni alternative all'immutabilità
• Unpack Tuples — assegnazione per destrutturazione
• Loop Tuples — iterazione con for e while
• List Methods — la controparte mutabile con molti più metodi

Pratica