Qual è la differenza tra liste e tuple?

https://stackoverflow.com/questions/626759

06-07-2019
|

Domanda

Qual è la differenza?

Quali sono i vantaggi / gli svantaggi delle tuple / liste?

Soluzione

Oltre alle immutabili tuple, esiste anche una distinzione semantica che dovrebbe guidarne l'uso. Le tuple sono strutture di dati eterogenee (cioè, le loro voci hanno significati diversi), mentre gli elenchi sono sequenze omogenee. Le tuple hanno struttura, le liste hanno ordine.

L'uso di questa distinzione rende il codice più esplicito e comprensibile.

Un esempio potrebbe essere rappresentato dalle coppie di pagine e numero di riga per fare riferimento alle posizioni in un libro, ad esempio:

my_location = (42, 11)  # page number, line number

È quindi possibile utilizzare questo come chiave in un dizionario per memorizzare le note in posizioni. Un elenco d'altra parte potrebbe essere utilizzato per memorizzare più posizioni. Naturalmente si potrebbe desiderare di aggiungere o rimuovere posizioni dall'elenco, quindi ha senso che le liste siano mutabili. D'altra parte non ha senso aggiungere o rimuovere elementi da una posizione esistente, quindi le tuple sono immutabili.

Potrebbero verificarsi situazioni in cui si desidera modificare gli elementi all'interno di una tupla di posizione esistente, ad esempio quando si scorre tra le righe di una pagina. Ma l'immutabilità della tupla ti costringe a creare una nuova tupla di posizione per ogni nuovo valore. Ciò sembra inopportuno, ma l'utilizzo di dati immutabili come questo è una pietra angolare di tipi di valore e tecniche di programmazione funzionale, che possono avere vantaggi sostanziali.

Ci sono alcuni articoli interessanti su questo problema, ad es. " Pupon Tuples non sono solo elenchi costanti " o " Comprensione di tuple e liste in Python " . La documentazione ufficiale di Python menziona anche questo

" Le tuple sono immutabili e di solito contengono una sequenza eterogenea ... " ;.

In una lingua tipicamente statica come Haskell i valori in una tupla generalmente hanno tipi diversi e la lunghezza della tupla deve essere fissata. In un elenco i valori hanno tutti lo stesso tipo e la lunghezza non è fissa. Quindi la differenza è molto evidente.

Infine c'è namedtuple in Python, che rende senso perché una tupla dovrebbe già avere struttura. Ciò sottolinea l'idea che le tuple sono un'alternativa leggera a classi e istanze.

Altri suggerimenti

Differenza tra elenco e tupla

Letterale
```
someTuple = (1,2)
someList  = [1,2] 
```
Dimensioni
```
a = tuple(range(1000))
b = list(range(1000))

a.__sizeof__() # 8024
b.__sizeof__() # 9088
```
A causa delle dimensioni ridotte di un'operazione di tupla, diventa un po 'più veloce, ma non tanto da menzionare fino a quando non si ha un numero enorme di elementi.

Operazioni consentite

b    = [1,2]   
b[0] = 3       # [3, 2]

a    = (1,2)
a[0] = 3       # Error

Ciò significa anche che non puoi eliminare un elemento o ordinare una tupla. Tuttavia, potresti aggiungere un nuovo elemento sia all'elenco che alla tupla con l'unica differenza che cambierai l'id della tupla aggiungendo l'elemento

a     = (1,2)
b     = [1,2]  

id(a)          # 140230916716520
id(b)          # 748527696

a   += (3,)    # (1, 2, 3)
b   += [3]     # [1, 2, 3]

id(a)          # 140230916878160
id(b)          # 748527696

Utilizzo

Poiché un elenco è modificabile, non può essere utilizzato come chiave in un dizionario, mentre è possibile utilizzare una tupla.
```
a    = (1,2)
b    = [1,2] 

c = {a: 1}     # OK
c = {b: 1}     # Error
```
hashable Tupla è cancellabile mentre l'elenco no. Le funzioni hash restituiscono il valore hash dell'oggetto, se ne ha uno.

Se sei andato a fare una passeggiata, puoi annotare le tue coordinate in qualsiasi momento in una tupla (x, y) .

Se desideri registrare il tuo viaggio, puoi aggiungere la tua posizione ogni pochi secondi a un elenco.

Ma non puoi farlo al contrario.

La differenza fondamentale è che le tuple sono immutabili. Ciò significa che non è possibile modificare i valori in una tupla dopo averla creata.

Quindi, se hai bisogno di cambiare i valori, usa un Elenco.

Vantaggi per le tuple:

Leggero miglioramento delle prestazioni.
Poiché una tupla è immutabile, può essere utilizzata come chiave in un dizionario.
Se non puoi cambiarlo, non può farlo nessun altro, vale a dire che non devi preoccuparti di alcuna funzione API, ecc. cambiare la tua tupla senza che ti venga chiesto.

Le liste sono mutabili; le tuple non lo sono.

Da docs.python.org/2/tutorial/datastructures.html

Le tuple sono immutabili e di solito contengono una sequenza eterogenea di elementi a cui si accede tramite decompressione (vedere più avanti in questa sezione) o indicizzazione (o anche per attributo nel caso di namedtuples). elenchi sono mutabili e i loro elementi sono generalmente omogenei e lo sono a cui si accede ripetendo l'elenco.

È menzionato che la differenza è in gran parte semantica: le persone si aspettano che una tupla e un elenco rappresentino informazioni diverse. Ma questo va oltre una linea guida; alcune librerie si comportano in modo diverso in base a ciò che vengono passate. Prendi NumPy per esempio (copiato da un altro post dove chiedo altri esempi):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

Il punto è che, mentre NumPy potrebbe non far parte della libreria standard, è una major libreria Python, e all'interno di liste e tuple di NumPy sono cose completamente diverse.

Gli elenchi sono per il looping, le tuple sono per le strutture cioè "% s% s" % Tuple .

Le liste sono generalmente omogenee, le tuple sono generalmente eterogenee.

Gli elenchi sono per lunghezza variabile, le tuple sono per lunghezza fissa.

Questo è un esempio di elenchi Python:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

Questo è un esempio di tupla di Python:

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

Le liste e le tuple di Python sono simili in quanto entrambe sono raccolte ordinate di valori. Oltre alla differenza superficiale che gli elenchi vengono creati utilizzando le parentesi " [..., ...] " e tuple usando le parentesi "(..., ...)", il nucleo tecnico "hard codificato nella sintassi di Python" la differenza tra loro è che gli elementi di una particolare tupla sono immutabili mentre gli elenchi sono mutabili (... quindi solo le tuple sono cancellabili e possono essere usate come chiavi dizionario / hash!). Ciò comporta differenze nel modo in cui possono o non possono essere utilizzate (imposte a priori dalla sintassi) e differenze nel modo in cui le persone scelgono di usarle (incoraggiate come "migliori pratiche", a posteriori, questo è ciò che intelligente programmatori lo fanno). La principale differenza a posteriori nel differenziare quando vengono usate le tuple rispetto a quando vengono utilizzate le liste risiede nel significato che le persone danno all'ordine degli elementi.

Per le tuple, "ordine" non significa altro che una specifica "struttura" per contenere le informazioni. Quali valori si trovano nel primo campo possono essere facilmente commutati nel secondo campo poiché ognuno fornisce valori attraverso due diverse dimensioni o scale. Forniscono risposte a diversi tipi di domande e in genere hanno la forma: per un determinato oggetto / soggetto, quali sono i suoi attributi? L'oggetto / soggetto rimane costante, gli attributi differiscono.

Per gli elenchi, "ordine" indica una sequenza o una direzionalità. Il secondo elemento DEVE venire il primo elemento perché è posizionato al 2 ° posto in base a una scala o dimensione particolare e comune. Gli elementi sono presi nel loro insieme e forniscono principalmente risposte a una singola domanda tipicamente del modulo, per un dato attributo, come si confrontano questi oggetti / soggetti? L'attributo rimane costante, l'oggetto / soggetto differisce .

Ci sono innumerevoli esempi di persone nella cultura popolare e programmatori che non si conformano a queste differenze e ci sono innumerevoli persone che potrebbero usare un'insalata per il loro corso principale. Alla fine della giornata, va bene e di solito entrambi possono fare il lavoro.

Per riassumere alcuni dei dettagli più fini

Somiglianze:

Duplicati : sia le tuple che gli elenchi consentono duplicati
Indicizzazione, selezione e & amp; Slicing - Sia le tuple che gli elenchi si indicano utilizzando valori interi trovati tra parentesi. Quindi, se vuoi i primi 3 valori di un dato elenco o tupla, la sintassi sarebbe la stessa:
```
>>> my_list[0:3]
[0,1,2]
>>> my_tuple[0:3]
[a,b,c]
```
Confronto & amp; Ordinamento : due tuple o due elenchi sono entrambi confrontati dal loro primo elemento, e se c'è un pareggio, quindi dal secondo elemento e così via. Non viene prestata ulteriore attenzione agli elementi successivi dopo che elementi precedenti mostrano una differenza.
```
>>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
True
>>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
True
```

Differenze: - A priori, per definizione

Sintassi - Le liste usano [], le tuple usano ()

Mutabilità - Gli elementi di un determinato elenco sono mutabili, gli elementi di una determinata tupla NON sono mutabili.

# Lists are mutable:
>>> top_rock_list
['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
>>> top_rock_list[1]
'Kashmir'
>>> top_rock_list[1] = "Stairway to Heaven"
>>> top_rock_list
['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']

# Tuples are NOT mutable:       
>>> celebrity_tuple
('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
>>> celebrity_tuple[5]
'Dead'
>>> celebrity_tuple[5]="Alive"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Hashtables (Dictionaries) - Dato che gli hashtables (dizionari) richiedono che le sue chiavi siano hash e quindi immutabili, solo le tuple possono agire come chiavi del dizionario, non elenchi.

#Lists CAN'T act as keys for hashtables(dictionaries)
>>> my_dict = {[a,b,c]:"some value"}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

#Tuples CAN act as keys for hashtables(dictionaries)
>>> my_dict = {("John","Wayne"): 90210}
>>> my_dict
{('John', 'Wayne'): 90210}

Differenze - A posteriori, in uso

Omo vs. eterogeneità degli elementi - Generalmente gli oggetti elenco sono omogenei e gli oggetti tupla sono eterogenei. Cioè, le liste sono usate per oggetti / soggetti dello stesso tipo (come tutti i candidati presidenziali, o tutte le canzoni, o tutti i corridori) mentre sebbene non sia forzato da), mentre le tuple sono più per oggetti eterogenei.
Looping vs. Structures - Sebbene entrambi consentano il looping (per x in my_list ...), ha davvero senso farlo solo per un elenco. Le tuple sono più appropriate per strutturare e presentare informazioni (% s% s residente in% s è un% s e attualmente% s% ("John", "Wayne", 90210, "Attore", "Dead") )

I valori di elenco possono essere modificati in qualsiasi momento, ma i valori di tuple non possono essere modificati.

I vantaggi e svantaggi dipendono dall'uso. Se disponi di tali dati che non vuoi mai cambiare, dovresti usare la tupla, altrimenti l'elenco è l'opzione migliore.

Le liste sono intese come sequenze omogenee, mentre le tuple sono strutture di dati eterogenee.

Differenza tra elenco e tupla

Tuple ed elenchi sono entrambi tipi di sequenza apparentemente simili in Python.

Sintassi letterale

Usiamo le parentesi ( ) per costruire tuple e parentesi quadre [] per ottenere un nuovo elenco. Inoltre, possiamo usare la chiamata del tipo appropriato per ottenere la struttura e la tupla o lista richieste # 8202; & # 8212; & # 8202;
```
someTuple = (4,6)
someList  = [2,6] 
```
Mutabilità

Le tuple sono immutabili, mentre le liste sono mutabili. Questo punto è la base per i seguenti.
Utilizzo della memoria

A causa della mutabilità, è necessaria più memoria per gli elenchi e meno memoria per le tuple.
Estensione

Puoi aggiungere un nuovo elemento sia alle tuple che agli elenchi con l'unica differenza che l'id della tupla verrà modificato (ovvero, avremo un nuovo oggetto).
Hashing

Le tuple sono hash e gli elenchi no. Significa che puoi usare una tupla come chiave in un dizionario. L'elenco non può essere utilizzato come chiave in un dizionario, mentre una tupla può essere utilizzata
```
tup      = (1,2)
list_    = [1,2] 

c = {tup   : 1}     # ok
c = {list_ : 1}     # error
```
Semantica

Questo punto riguarda maggiormente le migliori pratiche. Dovresti usare le tuple come strutture di dati eterogenee, mentre gli elenchi sono sequenze omogenee.

Dato che le persone hanno già risposto qui che tuple sono immutabili mentre list sono mutabili, ma c'è un aspetto importante nell'uso delle tuple che dobbiamo ricordare

Se tuple contiene un list o un dizionario al suo interno, questi possono essere cambiati anche se tuple è di per sé immutabile.

Ad esempio, supponiamo di avere una tupla che contiene un elenco e un dizionario come

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

possiamo cambiare il contenuto dell'elenco come

my_tuple[3][0] = 400
my_tuple[3][1] = 500

che assomiglia alla nuova tupla

(10, 20, 30, [400, 500], {'a': 10})

possiamo anche cambiare il dizionario all'interno della tupla come

my_tuple[4]['a'] = 500

che farà apparire la tupla complessiva

(10, 20, 30, [400, 500], {'a': 500})

Ciò accade perché list e dizionario sono gli oggetti e questi oggetti non cambiano, ma i contenuti a cui punta.

Quindi il tuple rimane immutabile senza alcuna eccezione

Il PEP 484 - Suggerimenti sul tipo dice che i tipi di elementi di un tuple possono essere digitati individualmente; in modo da poter dire Tuple [str, int, float] ; ma un list , con la classe di digitazione List può accettare solo un parametro di tipo: List [str] , il che suggerisce che la differenza tra i 2 in realtà è che il primo è eterogeneo, mentre il secondo è intrinsecamente omogeneo.

Inoltre, la libreria standard utilizza principalmente la tupla come valore di ritorno da tali funzioni standard in cui la C restituisce un struct .

Una citazione di direzione dalla documentazione su 5.3. Tuple e sequenze :

Sebbene le tuple possano sembrare simili agli elenchi, vengono spesso utilizzate in diverse situazioni e per scopi diversi. Le tuple sono immutabili e di solito contengono una sequenza eterogenea di elementi a cui si accede tramite decompressione (vedere più avanti in questa sezione) o indicizzazione (o anche per attributo nel caso di namedtuples). Le liste sono mutabili , e i loro elementi sono generalmente omogenei e vi si accede ripetendo sulla lista.

Prima di tutto, entrambi sono gli oggetti non scalari (noti anche come oggetti composti) in Python.

Tuple, sequenza ordinata di elementi (che può contenere qualsiasi oggetto senza problemi di aliasing)
- Immutabile (tupla, int, float, str)
- Concatenazione usando + (ovviamente verrà creata una nuova tupla)
- indicizzazione
- affettare
- Singleton (3,) # - > (3) anziché (3) # - > 3
Elenco (array in altre lingue), sequenza di valori ordinata
- Mutevole
- Singleton [3[
- Clonazione new_array = origin_array [:]
- Comprensione elenco [x ** 2 for x in range (1,7)] ti dà [1,4,9,16,25,36] (non leggibile)

L'uso dell'elenco può anche causare un bug di aliasing (due percorsi distinti puntando allo stesso oggetto).

Le liste sono mutabili e le tuple sono immutabili. Considera solo questo esempio.

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

Ora cambia i valori dell'indice di elenco e tupla.

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

Quindi ha dimostrato che il seguente codice non è valido con la tupla, perché abbiamo tentato di aggiornare una tupla, che non è consentita.

L'elenco è modificabile e le tuple sono immutabili. La principale differenza tra mutabile e immutabile è l'utilizzo della memoria quando si tenta di aggiungere un elemento.

Quando si crea una variabile, alla variabile viene assegnata una parte di memoria fissa. Se è un elenco, viene assegnata più memoria di quella effettivamente utilizzata. Per esempio. se l'attuale assegnazione di memoria è di 100 byte, quando si desidera aggiungere il 101 ° byte, forse verranno assegnati altri 100 byte (in totale 200 byte in questo caso).

Tuttavia, se sai che non aggiungi spesso nuovi elementi, dovresti usare le tuple. Tuples assegna esattamente la dimensione della memoria necessaria e quindi risparmia memoria, specialmente quando si utilizzano grandi blocchi di memoria.

La differenza di base che ho riscontrato è che gli elenchi sono modificabili laddove le tuple sono immutabili. Le tuple sono utili per i calcoli in cui non è necessario modificarle.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow