testo - unire due liste python




Qual è la differenza tra liste e tuple? (12)

Differenza tra lista e tupla

Le tuple e le liste sono entrambi tipi di sequenza apparentemente simili in Python.

  1. Sintassi letterale

    Usiamo la parentesi ( ) per costruire tuple e parentesi quadre [ ] per ottenere una nuova lista. Inoltre, possiamo usare la chiamata del tipo appropriato per ottenere la struttura richiesta - tupla o lista.

    someTuple = (4,6)
    someList  = [2,6] 
    
  2. Mutabilità

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

  3. Utilizzo della memoria

    A causa della mutabilità, hai bisogno di più memoria per gli elenchi e meno memoria per le tuple.

  4. Estensione

    Puoi aggiungere un nuovo elemento a entrambe le tuple e le liste con la sola differenza che l'id della tupla sarà cambiata (cioè avremo un nuovo oggetto).

  5. hashing

    Le tuple sono lavabili e le liste non lo sono. 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
    
  6. Semantica

    Questo punto riguarda più le migliori pratiche. Dovresti usare le tuple come strutture dati eterogenee, mentre le liste sono sequenze omogenee.

Qual è la differenza?

Quali sono i vantaggi / svantaggi delle tuple / liste?


È stato detto che la differenza è in gran parte semantica: le persone si aspettano una tupla e lista per rappresentare informazioni diverse. Ma questo va oltre una linea guida; alcune librerie si comportano in realtà in modo diverso in base a ciò che sono passati. Prendi NumPy ad 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, sebbene NumPy non faccia parte della libreria standard, è una libreria Python importante , e all'interno di NumPy le liste e le tuple sono cose completamente diverse.


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

Se la tuple contiene una list o un dictionary al suo interno, questi possono essere modificati anche se la tuple stessa è 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 fa apparire una nuova tupla

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

possiamo anche cambiare il dizionario dentro 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 dictionary sono gli oggetti e questi oggetti non cambiano, ma i contenuti puntano a.

Quindi la tuple rimane immutabile senza eccezioni


Differenza tra lista e tupla

  1. Letterale

    someTuple = (1,2)
    someList  = [1,2] 
    
  2. Taglia

    a = tuple(range(1000))
    b = list(range(1000))
    
    a.__sizeof__() # 8024
    b.__sizeof__() # 9088
    

    A causa delle ridotte dimensioni di un'operazione di tupla, diventa un po 'più veloce, ma non tanto da menzionare fino a quando non si dispone di un numero enorme di elementi.

  3. Operazioni consentite

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

    Ciò significa anche che non è possibile eliminare un elemento o ordinare una tupla. Tuttavia, puoi aggiungere un nuovo elemento a entrambi gli elenchi e tupla con l'unica differenza che cambierai id della tupla aggiungendo 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
    
  4. uso

    Poiché una lista è mutabile, non può essere usata come chiave in un dizionario, mentre una tupla può essere usata.

    a    = (1,2)
    b    = [1,2] 
    
    c = {a: 1}     # OK
    c = {b: 1}     # Error
    

I valori dell'elenco possono essere modificati in qualsiasi momento, ma i valori delle tuple non possono essere modificati.

I vantaggi e gli svantaggi dipendono dall'uso. Se si dispone di dati di questo tipo che non si desidera modificare, è necessario utilizzare la tupla, altrimenti l'elenco è l'opzione migliore.


Il PEP 484 - Type Hints dice che i tipi di elementi di una tuple possono essere tipizzati individualmente; in modo che tu possa dire Tuple[str, int, float] ; ma una list , con List typing class può prendere solo un parametro di tipo: List[str] , che suggerisce che la differenza del 2 è 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 il C restituisce una struct .


La differenza fondamentale che ho trovato è che le liste sono mutabili dove le tuple sono immutabili. Le tuple sono utili per i calcoli in cui non è necessario cambiarle.


La differenza principale è che le tuple sono immutabili. Ciò significa che non è possibile modificare i valori in una tupla dopo averlo creato.

Quindi se hai bisogno di cambiare i valori usa una lista.

Vantaggi per le tuple:

  1. Leggero miglioramento delle prestazioni.
  2. Come una tupla è immutabile può essere usata come chiave in un dizionario.
  3. Se non puoi cambiarlo nessuno può farlo, il che vuol dire che non devi preoccuparti di funzioni API ecc. Cambiando la tua tupla senza essere chiesta.

Le liste sono mutabili e le tuple sono immutabili. Prendi in considerazione questo esempio.

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

Adesso cambia i valori dell'indice di lista 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.

Di conseguenza, il codice seguente non è valido con tuple, perché abbiamo tentato di aggiornare una tupla, che non è consentita.


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 il disimballaggio (vedere più avanti in questa sezione) o l'indicizzazione (o persino l'attributo nel caso di namedtuples). Le liste sono mutabili e i loro elementi sono solitamente omogenei e sono accessibili ripetendo l'elenco.


Questo è un esempio di liste Python:

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

Questo è un esempio di tupla Python:

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

Gli elenchi e le tuple Python sono simili in quanto entrambi sono raccolte di valori ordinati. Oltre alla differenza superficiale che gli elenchi vengono creati usando parentesi "[..., ...]" e tuple usando parentesi "(..., ...)", la differenza di base tecnica "hard coded in Python syntax" tra loro è che gli elementi di una particolare tupla sono immutabili mentre le liste sono mutabili (... quindi solo le tuple sono lavabili e possono essere usate come chiavi di dizionario / hash!). Ciò dà origine a differenze nel modo in cui possono o non possono essere utilizzate (applicate a priori per sintassi) e differenze nel modo in cui le persone scelgono di usarle (incoraggiate come "migliori pratiche", a posteriori, questo è ciò che fanno i programmatori intelligenti ). La differenza principale a posteriori nella differenziazione quando si usano le tuple rispetto a quando vengono usate 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 conservare le informazioni. Quali valori si trovano nel primo campo possono essere facilmente commutati nel secondo campo poiché ciascuno fornisce valori attraverso due diverse dimensioni o scale. Forniscono risposte a diversi tipi di domande e sono tipicamente della forma: per un dato 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 dopo 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 è diverso.

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 forchettone per il loro corso principale. Alla fine della giornata, va tutto bene e in genere entrambi possono portare a termine il lavoro.

Per riassumere alcuni dei dettagli più fini

Analogie:

  1. Duplicati : entrambe le tuple e le liste consentono duplicati
  2. Indicizzazione, selezione e suddivisione : entrambe le tuple e l'indice delle liste utilizzano valori interi compresi tra parentesi. Quindi, se vuoi i primi 3 valori di una determinata lista o tupla, la sintassi sarebbe la stessa:

    >>> my_list[0:3]
    [0,1,2]
    >>> my_tuple[0:3]
    [a,b,c]
    
  3. Confronto e ordinamento - Due tuple o due liste sono entrambe confrontate 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

  1. Sintassi - Gli elenchi usano [], usano le tuple ()

  2. Mutabilità - Gli elementi di una data lista 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
    
  3. Hashtables (dizionari) - Poiché hashtables (dizionari) richiedono che le sue chiavi siano lavabili e quindi immutabili, solo le tuple possono fungere da chiavi di dizionario, non da 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

  1. Homo vs. Eterogeneità degli elementi - Generalmente gli oggetti di lista sono omogenei e gli oggetti di tupla sono eterogenei. Cioè, le liste sono usate per oggetti / soggetti dello stesso tipo (come tutti i candidati presidenziali, o tutti i brani, o tutti i corridori) mentre sebbene non sia forzato da), mentre le tuple sono più per oggetti eterogenei.

  2. Looping vs. Strutture - Sebbene entrambe consentano il looping (per x in my_list ...), è davvero sensato farlo 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", "Morto"))


Se sei andato a fare una passeggiata, potresti notare le tue coordinate in qualsiasi istante in una tupla (x,y) .

Se si desidera registrare il viaggio, è possibile aggiungere la posizione ogni pochi secondi a un elenco.

Ma non potevi farlo al contrario.







tuples