Pareggio (Tuple) in Python

Un tuple in Python è simile aListaLa differenza tra i due è che una volta assegnato un tuple, non è possibile modificare i suoi elementi, mentre in una lista è possibile farlo.

Creare un tuple

Creare un tuple tramite la collocazione di tutti gli elementi tra parentesi tonde () (separati da virgola) è una buona abitudine. Le parentesi sono opzionali, ma la loro utilizzo è consigliato.

Un tuple può avere una quantità arbitraria di elementi e può avere diversi tipi (interi, numeri a virgola mobile, liste,字符串String

etc.).

It is also possible to create a tuple without using parentheses. This is called tuple wrapping.

Creating a tuple with a single element is a bit special. The parentheses containing only one element are not enough. We will need a comma at the end to indicate that it is actually a tuple.

my_tuple = ("hello")
print(type(my_tuple))  # <class 'str'>
# Create a tuple with a single element
my_tuple = ("hello",)　　
print(type(my_tuple))  # <class 'tuple'>　
# Parentheses are optional
my_tuple = "hello",
print(type(my_tuple))  # <class 'tuple'>

Accessing Tuple Elements

We can access tuple elements in various ways.

1. Index

We can use the index operator [] to access items in the tuple starting from index 0.

Therefore, a tuple with 6 elements will have indexes from 0 to 5. Attempting to access elements outside the tuple (such as 6, 7 ...) will raise an IndexError.

Indexes must be integers; therefore, we cannot use float or other types. If we do, it will cause a TypeError.

Similarly, access nested tuples using nested indexing, as shown in the following example.

my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
print(my_tuple[0])  # 'p'　
print(my_tuple[5])  # 't'
# IndexError: List index out of range
# print(my_tuple[6])
# Index must be an integer
# TypeError: List index must be an integer, not a float
# my_tuple[2.0]
# Nested Tuple
n_tuple = ('mouse', [8, 4, 6], (1, 2, 3))
# Nested Indexing
print(n_tuple[0][3])  # 's'
print(n_tuple[1][1])  # 4

2. Negative Indexing

Python allows negative indexing on sequences.

Index -1 represents the last item, -2 represents the second to last item, and so on.

my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
# Output: 't'
print(my_tuple[-1])
# Output: 'p'
print(my_tuple[-6])

3. Slicing

We can use the slicing operator - colon ':' to access a series of items in a tuple.

my_tuple = ('p','r','o','g','r','a','m','i','z')
# The 2nd to 4th elements
# Output: ('r', 'o', 'g')
print(my_tuple[1:4])
# Dall'inizio al secondo elemento
# Output: ('p', 'r')
print(my_tuple[:-7])
# Elemento 8 alla fine
# Output: ('i', 'z')
print(my_tuple[7:])
# Gli elementi dall'inizio alla fine
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple[:])

Considerando l'indice tra gli elementi, è possibile visualizzare meglio le sezioni come segue. Quindi, per accedere a un intervallo, è necessario utilizzare l'indice della sezione parte del tuple.

Sostituisci tuple

Diversamente dalla lista, il tuple è immutabile.

Questo significa che una volta assegnati gli elementi di un tuple non possono essere modificati. Tuttavia, se l'elemento stesso è un tipo di dati variabile (come una lista), è possibile modificare i suoi elementi嵌套.

Possiamo anche assegnare un tuple a diversi valori (riassegnare).

my_tuple = (4, 2, 3, [6, 5])
# Errore di tipo: l'oggetto 'tuple' non supporta l'assegnamento degli elementi
# my_tuple[1] = 9
# Ma puoi modificare l'elemento di un elemento variabile
my_tuple[3][0] = 9  # Output: (4, 2, 3, [9, 5])
print(my_tuple)
# Un tuple può essere riassegnato
my_tuple = ('p','r','o','g','r','a','m','i','z')
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple)

Possiamo usare l'operatore + per unire due tuple. Questo viene anche chiamatoConcatena.

Possiamo anche usare l'operatore *, per concatenare gli elementi di un tuple.RipetiDato il numero di volte.

Ogni operazione con + e * crea un nuovo record.

# Concatena
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))
# Ripeti
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3)

Elimina tuple

Come descritto sopra, non possiamo modificare gli elementi di un tuple. Questo significa che non possiamo né eliminare né aggiungere elementi nel tuple.

Ma puoi usare la parola chiavedelElimina completamente un tuple.

my_tuple = ('p','r','o','g','r','a','m','i','z')
# Non puoi eliminare l'elemento
# Errore di tipo: l'oggetto 'tuple' non supporta la rimozione di elementi
# del my_tuple[3]
# Puoi eliminare l'intero tuple
del my_tuple
# Errore di nome: nome non definito “my_tuple”
print(my_tuple)

Metodi di tupla

Le tuple non offrono metodi per aggiungere o rimuovere elementi. Sono disponibili solo due metodi.

Esempi di alcuni metodi di tupla di Python:

my_tuple　=　('a','p','p','l','e',)
print(my_tuple.count('p'))　　#　Output:　2
print(my_tuple.index('l'))　　#　Output:　3

Altre operazioni di tupla

1. Test di qualificazione dei membri della tupla

Possiamo usare la parola chiave in per testare se un elemento esiste nella tupla.

my_tuple　=　('a','p','p','l','e',)
#　Operazione In
#　Output:　True
print('a'　in　my_tuple)
#　Output:　False
print('b'　in　my_tuple)
#　Operazione Not in
#　Output:　True
print('g'　not　in　my_tuple)

2. Esplorazione della tupla

Usando un ciclo for, possiamo esplorare ogni elemento di una tupla.

#　Output:　
#　Hello　John
#　Hello　Kate
for　name　in　('John','Kate'):
　　　　　print("Hello",name)

Vantaggi delle tuple rispetto alle liste

Poiché le tuple sono molto simili alle liste, vengono utilizzate in situazioni simili.

Ma ci sono alcuni vantaggi nell'implementare tuple su liste. Di seguito elenchiamo alcuni dei principali vantaggi:

• Di solito usiamo le tuple per dati eterogenei (diversi) e le liste per dati omogenei (simili).

• Poiché le tuple sono immutabili, è più veloce esplorare una tupla rispetto a una lista. Di conseguenza, c'è un leggero miglioramento delle prestazioni.

• Le tuple contenenti elementi immutabili possono essere utilizzate come chiavi di dizionario. Per le liste, questo non è possibile.

• Se hai dati immutabili, implementali come tuple per garantire che rimangano protetti dalla scrittura.