Python Tuple vs List: somiglianze e differenze, spiegate

In questa guida imparerai le somiglianze e le differenze tra le tuple e le liste Python. Capirai anche quando dovresti usare una tupla.

List e tuple sono entrambe strutture dati integrate in Python. Possono essere utilizzati per memorizzare una raccolta di elementi.

Dal supporto per l'indicizzazione e lo slicing al contenimento di tipi di dati eterogenei, le tuple e gli elenchi possono sembrare avere funzionalità simili. Pertanto, comprendere le somiglianze e le differenze tra i due può aiutarti a decidere quale struttura di dati utilizzare.

Cominciamo.

Puoi avviare una REPL Python e seguire questo tutorial. Puoi anche utilizzare l'editor Python online di Geekflare per programmare insieme.

Python Tuple vs List: quali sono le somiglianze?

Iniziamo imparando le somiglianze tra liste e tuple. Per facilitare un migliore apprendimento, presentiamo esempi di liste e tuple.

#1 . Iterabili Python

In Python, le liste sono racchiuse tra una coppia di parentesi quadre, mentre le tuple sono racchiuse tra parentesi. Puoi anche creare una tupla come un insieme di valori separati da virgole, senza parentesi.

Sono entrambi iterabili; in modo da poterli scorrere usando un ciclo for .

La cella di codice seguente mostra come scorrere un elenco.

 nums = [2,6,7,10] print(f"Type of nums is {type(nums)}") for num in nums: print(num) # Output Type of nums is <class 'list'> 2 6 7 10

Come spiegato di seguito, puoi anche scorrere una tupla usando un ciclo

 nums = (2,6,7,10) # Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check! print(f"Type of nums is {type(nums)}") for num in nums: print(num) # Output Type of nums is <class 'tuple'> 2 6 7 10

#2 . Supporto per la creazione da altre sequenze

La successiva somiglianza tra liste e tuple è che possono essere create da sequenze esistenti come stringhe.

 sample_str = "Coding!"

La cella di codice seguente mostra come list(string) restituisce un elenco, le cui voci di elenco sono i caratteri nella stringa.

 list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']

Allo stesso modo, una tupla può essere creata da una stringa o da un'altra sequenza usando tuple(sequence) . La cella del codice qui sotto mostra come puoi farlo.

 tuple_from_str = tuple(sample_str) print(tuple_from_str) # Output ('C', 'o', 'd', 'i', 'n', 'g', '!')

#3 . Supporto per indicizzazione e affettatura

Python supporta l'indicizzazione zero in cui il primo elemento è all'indice zero, il secondo all'indice uno e così via. Python supporta anche l'indicizzazione negativa, dove l'ultimo elemento è all'indice -1, il penultimo elemento è all'indice -2 e così via.

 list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o

L'elemento all'indice -2 è il penultimo elemento, 'g'.

 tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!') print(tuple_from_str[-2]) # g

Puoi usare lo slicing quando vuoi lavorare con una piccola sezione dell'elenco o della tupla. list[inizio:fine] restituisce una parte dell'elenco che inizia dall'inizio dell'indice e si estende fino alla fine – 1. Il valore predefinito per un inizio è 0 e la fine è l'ultimo elemento nell'iterabile.

Puoi dividere le tuple usando la stessa sintassi. Creiamo sezioni dell'elenco e della tupla che abbiamo creato in precedenza.

 list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']

Oltre ai valori iniziale e finale, è anche possibile specificare un valore di passaggio. tuple(start:end:step) restituisce una fetta della tupla start alla end - 1 , nei passaggi di step .

 tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!') print(tuple_from_str[::2]) ('C', 'd', 'n', '!')

Qui, impostiamo il valore del passaggio su 2. Quindi la fetta contiene ogni secondo elemento.

#4 . Raccolte di più tipi di dati

Negli esempi che abbiamo considerato, tutti gli elementi nell'elenco e le tuple erano dello stesso tipo di dati.

Tuttavia, è possibile memorizzare valori di tipi di dati diversi all'interno di un singolo elenco o di una tupla.

Il frammento di codice sotto student_list contiene il nome di uno studente come stringa, età come numero intero e segni protetti come float.

 student_list = ["John",22,96.5] for item in student_list: print(f"{item} is of type {type(item)}") # Output John is of type <class 'str'> 22 is of type <class 'int'> 96.5 is of type <class 'float'>

Possiamo trovare un esempio simile per una tupla.

 student_tuple = ("Jane",23,99.5) for item in student_tuple: print(f"{item} is of type {type(item)}") # Output Jane is of type <class 'str'> 23 is of type <class 'int'> 99.5 is of type <class 'float'>

#5 . Supporto per test di appartenenza

Sia gli elenchi che le tuple consentono di eseguire test di appartenenza per la presenza di determinati elementi. Se vuoi controllare se un elemento specifico è presente in una lista o in una tupla, puoi usare l'operatore in .

L' item in iterable True se l' iterable contiene l' item ; altrimenti, False .

 "Alex" in student_list # False "Jane" in student_tuple # True

Finora, hai imparato le somiglianze tra elenchi e tuple in Python. Successivamente, impariamo le principali differenze tra le due strutture di dati.

Python Tuple vs List: quali sono le differenze?

#1 . Mutabilità delle liste e immutabilità delle tuple in Python

La differenza più cruciale tra una lista e una tupla in Python è che una tupla è immutabile . Ciò significa che non è possibile modificare una tupla sul posto.

️ Ecco un esempio.

 tuple1 = ("Java","Python","C++") tuple1[0] = "Rust" # Output ----> 2 tuple1[0] = "Rust" TypeError: 'tuple' object does not support item assignment

Un elenco è una struttura di dati mutevole, quindi possiamo modificare l'elenco modificando un elemento in un indice specifico, come nella cella di codice seguente.

 list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']

#2 . Elenchi a lunghezza variabile e tuple a lunghezza fissa

L'elenco Python è una struttura dati a lunghezza variabile.

Puoi fare quanto segue:

• Aggiungi un elemento alla fine dell'elenco
• Aggiungi elementi da un altro elenco alla fine dell'elenco corrente
• Rimuovere gli elementi in un indice specifico dall'elenco

 list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)

️ L'output del frammento di codice sopra.

 # Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]

Le tuple sono strutture dati a lunghezza fissa. Quindi non puoi aggiungere o rimuovere elementi da una tupla esistente. Ma puoi ridefinire la tupla per contenere elementi diversi.

 tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)

#3 . Dimensioni in memoria

Ora andremo a costruire su ciò che abbiamo imparato nella sezione precedente: l' elenco è una struttura di dati a lunghezza variabile .

Quando si definisce inizialmente l'elenco, viene assegnata una dimensione specifica in memoria. Ora, quando modifichi un elenco usando i metodi append() o extend() , dovrebbe essere allocata memoria aggiuntiva per memorizzare gli elementi aggiunti. Questa assegnazione viene quasi sempre eseguita più del numero di elementi aggiunti.

Quindi è necessario tenere traccia del numero di elementi nell'elenco e dello spazio assegnato. Inoltre, poiché gli elenchi sono di lunghezza variabile, è presente un puntatore che punta all'indirizzo degli elementi dell'elenco. Di conseguenza, elenchi di lunghezza k occupano più memoria di una tupla con gli stessi k elementi.

Ecco una semplice illustrazione.

È possibile utilizzare il metodo getsizeof() del modulo sys integrato su un oggetto Python per ottenere la dimensione di un oggetto in memoria.

 import sys list1 = [4,5,9,14] list_size = sys.getsizeof(list1) print(f"Size of list:{list_size}") tuple1 = (4,5,9,14) tuple_size = sys.getsizeof(tuple1) print(f"Size of tuple:{tuple_size}")

Un elenco occupa più memoria di una tupla per lo stesso numero e valore di elementi, come verificato nell'output seguente.

 # Output Size of list:104 Size of tuple:88

Quando dovresti usare una tupla Python?

Dalle differenze e somiglianze tra gli elenchi Python e le tuple, sai che se hai bisogno di una raccolta mutabile , dovresti usare un list .

Ma quando dovresti invece usare una tupla?

Ne parleremo in questa sezione.

#1 . Collezione di sola lettura

Ogni volta che vuoi che una raccolta sia immutabile, dovresti definirla come una tupla. Supponiamo che color = (243,55,103) una tupla contenente i valori RGB corrispondenti a una sfumatura di colore. Definire il colore come una tupla assicura che non possa essere modificato.

In sostanza, quando è necessario che una raccolta sia di sola lettura: i valori non devono essere modificati durante il programma, si dovrebbe considerare l'utilizzo di una tupla. Ciò impedirà la modifica involontaria dei valori.

#2 . Chiavi del dizionario

Ad esempio, crei un dizionario utilizzando gli elementi dell'elenco key_list come chiavi. È possibile utilizzare il metodo dict.fromkeys() per creare un dizionario da un elenco.

 key_list = list("ABCD") dict.fromkeys(key_list) {'A': None, 'B': None, 'C': None, 'D': None}

Si supponga di modificare l'elenco in modo che contenga 'D' come primo elemento (indice 0), prima di creare il dizionario.

Ora, cosa succede alla chiave del dizionario 'A'?

Se provi a creare un dizionario da key_list e accedi al valore corrispondente alla chiave 'A', ti imbatterai in un KeyError .

 key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'

Le chiavi di un dizionario dovrebbero essere uniche. Quindi non puoi avere una seconda "D" come chiave.

 dict.fromkeys(key_list) {'B': None, 'C': None, 'D': None} # A is no longer a key.

Se invece usi una tupla, tale modifica è impossibile e hai meno probabilità di incappare in errori. Pertanto, dovresti preferire creare un dizionario usando gli elementi di una tupla come chiavi.

 key_tuple = tuple("ABCD") dict.fromkeys(key_tuple) {'A': None, 'B': None, 'C': None, 'D': None} key_tuple[0] = 'D' --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-12-2cecbefa7db2> in <module>() ----> 1 key_tuple[0] = 'D' TypeError: 'tuple' object does not support item assignment

#3 . Argomenti di funzione

L'immutabilità delle tuple le rende inoltre adatte per essere passate come argomenti di funzione.

Considera la seguente funzione find_volume() che restituisce il volume di un cubo date le dimensioni: lunghezza, larghezza e altezza.

 def find_volume(dimensions): l,b,h = dimensions return l*b*h

Supponiamo che queste dimensioni siano disponibili in un elenco chiamato dimensions . La chiamata a find_volume() con dimensions come argomento restituisce il volume.

 dimensions = [2,8,5] find_volume(dimensions) 80

È sempre possibile modificare le dimensioni memorizzate in un elenco.

 dimensions = [20,8,5] find_volume(dimensions) 800

Tuttavia, a volte avrai bisogno che i valori rimangano costanti e resistano alle modifiche. È allora che dovresti considerare di archiviare gli argomenti come una tupla e di usarli nella chiamata di funzione.

#4 . Restituisce valori dalle funzioni

In Python, ti imbatterai in tuple nei valori restituiti dalle funzioni. Quando restituisci più valori da una funzione, Python li restituisce implicitamente come una tupla.

Considera la seguente funzione return_even() :

 def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)

• Richiede un numero num come argomento
• Restituisce l'elenco dei numeri pari nell'intervallo [0,num) e la lunghezza di tale elenco.

Impostiamo il valore di num 20 e chiamiamo la funzione.

 num = 20

La chiamata return_even() restituisce i due valori in una tupla. È possibile chiamare la funzione type() con la chiamata di funzione come argomento di verifica.

 type(return_even(num)) # <class 'tuple'>

È possibile stampare il valore restituito per verificare che sia una tupla contenente l'elenco di numeri pari come primo elemento e la lunghezza dell'elenco come secondo elemento.

 print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], 10)

Poiché ci sono due elementi nella tupla, puoi decomprimerli in due variabili, come mostrato di seguito.

 even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10

Conclusione

Spero che questo tutorial abbia fornito un confronto completo tra tupla Python e list.

Chiudiamo il tutorial con un breve riassunto:

• List e tuple sono strutture dati integrate in Python.
• Somiglianze : iterabili, supporto per indicizzazione, slicing, diversi tipi di dati e operatore per il test di appartenenza.
• Differenza fondamentale : le liste sono mutabili e le tuple sono immutabili.
• Altre differenze : lunghezza fissa delle tuple e lunghezza variabile delle liste, dimensione minore nella memoria delle tuple.
• Quando dovresti usare una tupla? Per raccolte immutabili, chiavi del dizionario e argomenti di funzione.

Quindi, dai un'occhiata ai progetti Python per esercitarti e imparare. Oppure impara i metodi per rimuovere gli elementi duplicati dagli elenchi Python. Buon apprendimento! allora, buona codifica!