Ottenere sottotuples

12.1 Intervallo di indici

Il codice per ottenere un sottotuple sembra lo stesso che per ottenere una sottolista. In questo, i tuples sono molto simili ad essi. Non vorrei duplicare il materiale, ma la ripetizione è la madre dell'apprendimento...

Ottenere sottotuples, o slicing, permette di estrarre parti di un tuple per creare nuovi tuples. Questo processo è particolarmente utile quando è necessario lavorare con segmenti specifici di dati, memorizzati nel tuple.

Sintassi dello slicing

Gli slice sono creati utilizzando parentesi quadre, all'interno delle quali vengono indicati indici iniziale e finale, separati da due punti. Se l'indice iniziale non è indicato, lo slice inizia dal primo elemento; se l'indice finale non è indicato, lo slice prosegue fino alla fine del tuple.

È possibile ottenere uno slice di un tuple, usando la sintassi tuple[start:stop:step], dove:

• start — indice iniziale dell'elemento (inclusivo);
• stop — indice finale dell'elemento (non inclusivo);
• step — passo con cui viene effettuata la selezione degli elementi.

Esempi:

my_tuple = (0, 1, 2, 3, 4, 5)
sub_tuple = my_tuple[1:4]  # Otteniamo un sottotuple con gli elementi dall'indice 1 al 3
print(sub_tuple) # Mostra (1, 2, 3)
            
sub_tuple_with_step = my_tuple[0:6:2]  # Otteniamo ogni secondo elemento dal 0 al 5
print(sub_tuple_with_step) # Mostra (0, 2, 4) 
        

Se start non è indicato, di default è uguale a 0, e se stop non è indicato — è uguale a len(tuple). Il parametro step per default è uguale a 1.

Esempi:

# Creiamo un tuple con gli elementi da 0 a 5
my_tuple = (0, 1, 2, 3, 4, 5)

# Creiamo un nuovo tuple, iniziando dal secondo elemento del tuple originale
sub_tuple = my_tuple[1:] 
print(sub_tuple)  # Mostra: (1, 2, 3, 4, 5)

# Creiamo un nuovo tuple, includendo gli elementi dall'inizio fino al quarto elemento 
# (indice 4) del tuple originale, con passo 1 (di default)
sub_tuple_with_step = my_tuple[:5] 
print(sub_tuple_with_step)  # Mostra: (0, 1, 2, 3, 4)

12.2 Indici negativi

Gli indici negativi in Python iniziano da -1, che corrisponde all'ultimo elemento della lista (o tuple). -2 indicherà il penultimo elemento e così via. L'uso di indici negativi semplifica l'accesso agli elementi dalla fine di un tuple senza dover calcolare la loro posizione dall'inizio.

Esempi di utilizzo

Vediamo l'utilizzo degli indici negativi per creare uno slice. Supponiamo di avere un tuple con i valori:

my_tuple = (10, 20, 30, 40, 50, 60, 70, 80)

Per ottenere un sottotuple contenente elementi dalla fine fino al centro del tuple, possiamo utilizzare indici negativi.

sub_tuple = my_tuple[-3:-1]
print(sub_tuple) # Mostra (60, 70)

Così, my_tuple[-3:-1] selezionerà elementi con gli indici -3 (il terzo dalla fine) fino a -1 (non incluso l'ultimo), che ci darà un tuple (60, 70).

Ottenere l'ultimo elemento di un tuple:

my_tuple = (10, 20, 30, 40, 50)
last_element = my_tuple[-1]
print(last_element) # Mostra 50 
    

Qui, my_tuple[-1] restituirà sempre l'ultimo elemento del tuple, il che è molto comodo quando non si conosce il numero esatto di elementi nel tuple.

Invertire gli elementi di un tuple all'inverso:

my_tuple = (10, 20, 30, 40, 50)
reversed_tuple = my_tuple[::-1]
print(reversed_tuple) # Mostra (50, 40, 30, 20, 10) 
    

L'utilizzo dello slice [::-1] permette facilmente ed efficacemente di invertire l'ordine degli elementi in un tuple, ottenendo un nuovo tuple con elementi in ordine inverso.

12.3 C'è un elemento nel tuple

Verificare la presenza di un elemento in un tuple è un'operazione standard che consente di sapere se un elemento è all'interno di un tuple. Questo viene fatto usando l'operatore in, che restituisce True se l'elemento è presente nel tuple, e False altrimenti.

Utilizzo dell'operatore in

L'operatore in è un modo semplice e intuitivo per verificare la presenza di un elemento:

my_tuple = (1, 2, 3, 4, 5)
element = 3
if element in my_tuple:
    print(f"{element} è nel tuple.")
else:
    print(f"{element} non è nel tuple.")
    

Verifica che un elemento è assente:

Se vuoi assicurarti che un elemento è assente nel tuple, usa semplicemente la costruzione not in:

names = ('Alice', 'Bob', 'Charlie')
search_name = 'Alice'
if search_name not in names:
    print(f"{search_name} non è nel tuple.")
else:
    print(f"{search_name} è nel tuple.")
    

Non si differenzia quasi per nulla dal lavoro con una lista — è qui che sta l'universalità e la semplicità di Python.