Tutorial sulle tuple in Python

Tuple vs Liste

Come avrai notato, le tuple sono molto simili alle liste. In effetti, si potrebbe dire che sono liste immutabili, il che significa che una volta creata una tupla non puoi eliminare o cambiare i valori degli elementi in essa memorizzati. Non puoi nemmeno aggiungere nuovi valori. Guarda qui:

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Append a number to the tuple
numbers_tuple.append(6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-26-e47776d745ce> in <module>()
      3 
      4 # Append a number to the tuple
----> 5 numbers_tuple.append(6)


AttributeError: 'tuple' object has no attribute 'append'

Viene generato un errore perché non puoi eliminare da o fare append a una tupla, mentre puoi farlo con una lista.

# Append numbers to the list
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Remove a number from the list
numbers_list.remove(7)
print(numbers_list)

[1, 2, 3, 4, 5, 6, 8]

Ma perché usare le tuple se sono immutabili?

Oltre a fornire un accesso "in sola lettura" ai valori dei dati, sono anche più veloci delle liste. Considera i seguenti frammenti di codice:

import timeit
timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)

0.0018976779974764213

timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)

0.019868606992531568

Cosa significa davvero immutabile in riferimento alle tuple?

Secondo la documentazione ufficiale di Python, immutabile è "un oggetto con un valore fisso", ma "valore" è un termine piuttosto vago; il termine corretto per le tuple sarebbe "id". "id" è l'identità della posizione di un oggetto in memoria.

Approfondiamo un po':

# Tuple 'n_tuple' with a list as one of its item.
n_tuple = (1, 1, [3,4])

#Items with same value have the same id.
id(n_tuple[0]) == id(n_tuple[1])

True

#Items with different value have different id.
id(n_tuple[0]) == id(n_tuple[2])

False

id(n_tuple[0])

4297148528

id(n_tuple[2])

4359711048

n_tuple.append(5)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-40-3cd258e024ff> in <module>()
----> 1 n_tuple.append(5)


AttributeError: 'tuple' object has no attribute 'append'

Non possiamo fare append di un elemento a una tupla, per questo ottieni l'errore sopra. Ecco perché la tupla è definita immutabile. Però, puoi sempre fare questo:

n_tuple[2].append(5)
n_tuple

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

Quindi, questo ti permette in realtà di mutare la tupla originale. Come può allora la tupla essere ancora chiamata immutabile?

Perché l'id della lista all'interno della tupla rimane lo stesso anche se hai fatto append di 5.

id(n_tuple[2])

4359711048

Riassumendo ciò che hai imparato finora:

Alcune tuple (che contengono solo oggetti immutabili: stringhe, ecc.) sono immutabili e altre tuple (che contengono uno o più oggetti mutabili: liste, ecc.) sono mutabili. Tuttavia, questo è spesso un tema dibattuto tra i Pythonisti e ti servirà più background per comprenderlo appieno. Questo è un articolo più approfondito sul tema. Per ora, diciamo semplicemente che in generale le tuple sono immutabili.

• Non puoi aggiungere elementi a una tupla a causa della sua proprietà di immutabilità. Non esistono metodi append() o extend() per le tuple,
• Non puoi rimuovere elementi da una tupla, sempre per via dell'immutabilità. Le tuple non hanno metodi remove() o pop(),
• Puoi cercare elementi in una tupla perché questo non la modifica.
• Puoi anche usare l'operatore in per verificare se un elemento esiste nella tupla.

Quindi, se stai definendo un insieme costante di valori e tutto ciò che devi fare è iterarci sopra, usa una tupla invece di una lista. Sarà più veloce da gestire rispetto alle liste e anche più sicura, dato che le tuple contengono dati "protetti in scrittura".

Se vuoi saperne di più sulle liste in Python, assicurati di consultare questo tutorial!

Operazioni comuni sulle tuple

Python ti mette a disposizione diversi modi per manipolare le tuple. Vediamo alcune tra le più importanti con esempi.

Slicing delle tuple

Il primo valore in una tupla ha indice 0. Proprio come con le liste Python, puoi usare i valori di indice in combinazione con le parentesi quadre [] per accedere agli elementi di una tupla:

numbers = (0,1,2,3,4,5)
numbers[0]

0

Puoi anche usare l'indicizzazione negativa con le tuple:

numbers[-1]

5

Mentre l'indicizzazione viene usata per ottenere singoli elementi, lo slicing permette di ottenere un sottoinsieme di elementi. Quando inserisci un intervallo da estrarre, si parla di slicing per intervallo. Il formato generale dello slicing per intervallo è:

[Start index (included):Stop index (excluded):Increment]

Qui Increment è un parametro opzionale e per impostazione predefinita l'incremento è 1.

# Item at index 4 is excluded
numbers[1:4]

(1, 2, 3)

# This provides all the items in the tuple
numbers[:]

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

# Increment = 2
numbers[::2]

(0, 2, 4)

Consiglio: puoi anche usare un incremento negativo per invertire la tupla.

numbers[::-1]

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

Addizione di tuple

Puoi combinare tuple per formare una nuova tupla. L'operazione di addizione esegue semplicemente una concatenazione tra tuple.

x = (1,2,3,4)
y = (5,6,7,8)

# Combining two tuples to form a new tuple
z = x + y 

print(z)

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

y = [5,6,7,8]
z = x + y
print(z)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-55-d352c6414a4c> in <module>()
      1 y = [5,6,7,8]
----> 2 z = x + y
      3 print(z)


TypeError: can only concatenate tuple (not "list") to tuple

Puoi aggiungere o combinare solo tipi di dati uguali. Quindi combinare una tupla e una lista genera un errore.

Moltiplicazione di tuple

L'operazione di moltiplicazione porta semplicemente alla ripetizione della tupla.

x = (1,2,3,4)
z = x*2
print(z)

(1, 2, 3, 4, 1, 2, 3, 4)

Funzioni per le tuple

A differenza delle liste Python, le tuple non hanno metodi come append(), remove(), extend(), insert() e pop() a causa della loro natura immutabile. Tuttavia, esistono molte altre funzioni integrate per lavorare con le tuple:

count() e len()

count() restituisce il numero di occorrenze di un elemento in una tupla.

a = [1,2,3,4,5,5]
a.count(5)

2

Con la funzione len(), puoi restituire la lunghezza della tupla:

a = (1,2,3,4,5)
print(len(a))

5

any()

Puoi usare any() per scoprire se qualche elemento di una tupla è iterabile. Otterrai True se è così, altrimenti restituirà False.

a = (1,)
print(any(a))

True

Nota la , nella dichiarazione della tupla a sopra. Se non specifichi una virgola quando inizializzi un singolo elemento in una tupla, Python assume che tu abbia aggiunto per errore una coppia extra di parentesi (il che è innocuo) ma allora il tipo di dato non è una tupla. Quindi ricorda di aggiungere una virgola quando dichiari un singolo elemento in una tupla.

Tornando alla funzione any(): in un contesto booleano, il valore di un elemento è irrilevante. Una tupla vuota è false, qualsiasi tupla con almeno un elemento è true.

b = ()
print(any(b))

False

Questa funzione può essere utile quando richiami una tupla in qualche punto del tuo programma e vuoi assicurarti che la tupla sia popolata.

tuple()

Usa tuple() per convertire un tipo di dato in tupla. Per esempio, nel blocco di codice qui sotto, converti una lista Python in una tupla.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

<class 'tuple'>

min() e max()

Mentre max() restituisce l'elemento più grande nella tupla, puoi usare min() per restituire l'elemento più piccolo della tupla. Considera il seguente esempio:

print(max(a))
print(min(a))

5
A

Puoi usare queste funzioni anche con tuple contenenti stringhe.

# The string 'Apple' is automatically converted into a sequence of characters. 
a = ('Apple') 
print(max(a))

p

sum()

Con questa funzione restituisci la somma totale degli elementi in una tupla. Può essere usata solo con valori numerici.

sum(a)

28

sorted()

Per restituire una tupla con gli elementi in ordine ordinato, usa sorted(), proprio come nel seguente esempio:

a = (6,7,4,2,1,5,3)
sorted(a)

[1, 2, 3, 4, 5, 6, 7]

Vale la pena notare che il tipo restituito è una lista e non una tupla. La sequenza nella tupla originale "a" non viene modificata e il tipo di dato di "a" rimane una tupla.

Bonus: assegnare più valori

Una cosa interessante che puoi fare con le tuple è usarle per assegnare più valori in una volta. Guarda qui:

a = (1,2,3)
(one,two,three) = a
print(one)

1

a è una tupla di tre elementi e (one,two,three) è una tupla di tre variabili. Assegnare la tupla (one,two,three) ad a assegna ciascuno dei valori di a a ognuna delle variabili: one, two e three, in ordine. Questo può essere utile quando devi assegnare un intervallo di valori a una sequenza memorizzata in una tupla.

Complimenti!

Sei arrivato alla fine di questo tutorial sulle tuple! Lungo il percorso, hai scoperto cosa sono le tuple in Python, come inizializzarle, quali sono le operazioni più comuni per manipolarle e quali sono i metodi più usati per ottenere più informazioni da queste strutture dati di Python. Come bonus, hai imparato che puoi anche assegnare più valori alle tuple in una volta sola.