Aiutaci a continuare a fornirti tutorial gratuiti e di qualità disattivando il blocco degli annunci, altrimenti abbonati al nostro sito.
Indice dei contenuti

Come creare e usare un le Tuple in Python

20 gen 2021 5 min di lettura
Come creare e usare un le Tuple in Python

Introduzione

Python ha diversi tipi di dati sequenziali che consentono di archiviare raccolte di dati in modo organizzato ed efficiente. I tipi di sequenza di base sono stringhe, elenchi, tuple e oggetti intervallo.

Questo articolo ti guiderà attraverso le basi delle tuple Python. Ti mostreremo come creare una tupla, accedere agli elementi, decomprimere una tupla e altro ancora.

Le tuple sono simili alle liste, con la differenza principale che le liste sono mutabili mentre le tuple sono immutabili. Ciò significa che le tuple non possono essere modificate dopo la creazione.

Le tuple possono archiviare dati sia eterogenei che omogenei, ma vengono generalmente utilizzate per archiviare raccolte di elementi eterogenei.

Creare le tuple

Le tuple vengono create inserendo gli elementi all'interno di una coppia di parentesi tonde [], separate da virgole. Possono avere un numero qualsiasi di elementi, che possono essere di diversi tipi. Ecco un esempio:

colors = ('orange', 'white', 'green')

Una tupla può avere elementi con tipi di dati misti. Puoi anche dichiarare tuple annidate dove un altro dei suoi elementi sono elenchi, tuple o dizionari:

my_tuple = (1, False, ["red", "blue"], ("foo", "bar"))

Le parentesi tonde senza elementi tra di loro indicano una tupla vuota:

my_tuple = ()

Per creare una tupla con un solo elemento devi aggiungere una virgola dopo l'elemento:

my_tuple = (1)
type(my_tuple)
my_tuple = (1,)
<class 'tuple'>

Le tuple possono essere costruite anche usando il costruttore tuple():

colors_list = ['orange', 'white', 'green']
colors_typle = tuple(colors_list)
print(type(colors_typle))
<class 'tuple'>

Un altro modo per costruire una tupla è usare la funzione di impacchettamento della tupla, che consente di creare una tupla da una sequenza di oggetti separati da virgole:

directions = "North", "South", "East", "West"
print(type(directions))
<class 'tuple'>

Accedere agli elementi della tupla

È possibile fare riferimento a un elemento tupla tramite il suo indice. Gli indici sono numeri interi e iniziano da 0 a n-1 dove n è il numero di elementi:

my_tuple = ["a", "b", "c", "d"]
             0    1    2    3

In Python gli indici sono specificati con parentesi quadre:

my_tuple[index]

Ad esempio, per accedere al terzo elemento della tupla, dovresti tuple_name[2]:

directions = ("North", "South", "East", "West")
directions[2]
'East'

Se fai riferimento a un indice che non esiste, viene sollevata un'eccezione IndexError:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range

Per accedere agli elementi in una tupla annidata utilizzare più indici:

my_tuple = (1, False, ["red", "blue"], ("foo", "bar"))
my_tuple[3][1]
'bar'

È inoltre possibile accedere agli elementi della tupla utilizzando indici negativi. L'ultimo elemento viene indicato come -1, il penultimo elemento come -2 e così via:

my_tuple = ("a", "b", "c", "d")
            -4   -3   -2   -1
directions = ("North", "South", "East", "West")
directions[-2]
'East'

Dividere le tuple (Slicing)

In Python, puoi suddividere una tupla e altri tipi di dati sequenziali utilizzando il modulo seguente:

sequence[start:stop:step]
  • start è l'indice in cui inizia l'estrazione. Quando viene utilizzato un indice negativo, indica un offset dalla fine della tupla. Se questo argomento viene omesso, il taglio inizia dall'indice 0.
  • stop è l'indice prima del quale terminare l'estrazione; il risultato non include l'elemento "stop". Quando viene utilizzato un indice negativo, indica un offset dalla fine della tupla. Se questo argomento viene omesso o è maggiore della lunghezza della tupla, il taglio va alla fine della tupla.
  • step è un argomento facoltativo e specifica il passaggio dell'affettatura. Quando non è specificato, il valore predefinito è 1. Se viene utilizzato un valore negativo, la sezione accetta gli elementi in ordine inverso.

Il risultato del taglio di una tupla è una nuova tupla contenente gli elementi estratti.

Le seguenti forme sono legali in Python:

T[:] # copy whole tuple
T[start:] # slice the tuple starting from the element with index "start" to the end of the tuple.
T[:stop] # slice the tuple starting from the begging up to but not including the element with index "stop".
T[start:stop] #  slice the tuple starting from the element with index "start" up to but not including the element with index "stop".
stop"
T[::step] # slice the tuple with a stride of "step"

Di seguito è riportato un esempio di come suddividere una tupla partendo dall'elemento con indice 1 fino all'elemento  4 ma non includendolo:

vegetables = ('Potatoes', 'Garlic', 'Celery', 'Carrots', 'Broccoli')
vegetables[1:4]
('Garlic', 'Celery', 'Carrots')

Estrazione delle tuple (Unpacking)

L'estrazione della sequenza in una funzionalità Python che consente di eseguire l'assegnazione di oggetti sequenza alle variabili. Ecco un esempio:

colors = ('orange', 'white', 'green')
a, b, c = colors
print(a)
print(b)
print(c)

I valori degli elementi della tupla in base alla loro posizione, vengono assegnati alle variabili a sinistra:

orange
white
green

Quando si scompattano le tuple, il numero di variabili sulla tupla di sinistra deve essere uguale al numero degli elementi della tupla. Altrimenti, otterrai un'eccezione ValueError.

colors = ('orange', 'white', 'green')
a, b = colors
ValueError: too many values to unpack (expected 2)

La decompressione è utile quando un metodo o una funzione restituisce una sequenza di oggetti:

def square_area_circumference(side_lenght):
  return side_lenght * side_lenght, side_lenght * 4

area, circumference = square_area_circumference(5)

print(area)
print(circumference)
def square_area_circumference(side_lenght):
  return side_lenght * side_lenght, side_lenght * 4

area, circumference = square_area_circumference(5)

print(area)
print(circumference)
25
20

Modificare una tupla

Poiché le tuple sono strutture di dati immutabili, non possiamo aggiornarle direttamente. Non è possibile aggiungere, modificare, rimuovere elementi nelle tuple.

Se provi a cambiare un elemento tupla otterrai un'eccezione TypeError:

colors = ("orange", "white", "green")
colors[1] = "blue"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Gli elementi di una tupla modificabile possono essere modificati. Ad esempio, se la tupla ha una lista come uno dei suoi elementi, puoi aggiornare gli elementi della lista:

my_tuple = (1, 2, [5, 6, 7])
my_tuple[2][1] = 4
print(my_tuple)
(1, 2, [5, 4, 7])

Lunghezza della tupla

La funzione len() incorporata restituisce il numero totale di elementi di un determinato oggetto.

Per trovare la lunghezza di una tupla, passala come argomento alla funzione len():

len(L)

Ecco un esempio:

colors = ("orange", "white", "green")
lenght = len(colors)
print(lenght)
3

Iterare attraverso una tupla

Per scorrere tutti gli elementi in una tupla, puoi usare il forciclo:

directions = ("North", "South", "East", "West")
for direction in directions:
  print(direction)
North
South
East
West

Se hai bisogno di indici, hai diversi metodi a tua disposizione. I modi più comuni sono combinare le funzioni range() e len()o utilizzare la funzione enumerate() incorporata.

L'esempio seguente mostra come recuperare l'indice e il valore di ogni elemento nella tupla:

directions = ("North", "South", "East", "West")
for i in range(len(directions)):
  print("Index {} : Value {}".format(i, directions[i]))
Index 0 : Value North
Index 1 : Value South
Index 2 : Value East
Index 3 : Value West

Invece di usare il pattern range(len(...)), puoi usare la funzione enumerate() per eseguire il loop su una tupla in un modo più pitonico:

directions = ("North", "South", "East", "West")
for index, value in enumerate(directions): 
  print("Index {} : Value {}".format(index, value))
Index 0 : Value North
Index 1 : Value South
Index 2 : Value East
Index 3 : Value West

Controllare se esiste un elemento

Per verificare se un elemento esiste in una tupla, puoi usare gli operatori in e not in:

colors = ("orange", "white", "green")
print("orange" in colors)

L'output sarà True o False:

True

Ecco un altro esempio che utilizza l'istruzione if:

colors = ("orange", "white", "green")
if "blue" not in colors:
  print("no")
else:
  print("yes")
no

Metodi di tupla

L'oggetto tupla accetta i seguenti metodi:

  • count(x) - Restituisce il numero di volte in cui 'x' appare nella tupla.
  • index(x) - Restituisce la posizione della prima occorrenza di un elemento con un valore di "x".

Di seguito è riportato un semplice esempio che mostra come utilizzare i metodi:

my_tuple = ("a", "s", "s", "q", "a", "n")
print(my_tuple.count('a'))
print(my_tuple.index('a'))
2
0

Conclusione

In Python, le tuple sono sequenze immutabili di oggetti che non possono essere cambiate una volta create.

Se hai domande o commenti, non esitare a lasciare un commento.

Supportaci se ti piacciono i nostri contenuti. Grazie.

Buy me a coffeeBuy me a coffee

Partecipa alla conversazione

Sostienici con una donazione.

Successivamente, completa il checkout per l'accesso completo a Noviello.it.
Bentornato! Accesso eseguito correttamente.
Ti sei abbonato con successo a Noviello.it.
Successo! Il tuo account è completamente attivato, ora hai accesso a tutti i contenuti.
Operazione riuscita. Le tue informazioni di fatturazione sono state aggiornate.
La tua fatturazione non è stata aggiornata.