Pitone:qual è la differenza tra (1,2,3) e [1,2,3] e quando dovrei usarli ciascuno?

StackOverflow https://stackoverflow.com/questions/1983

  •  08-06-2019
  •  | 
  •  

Domanda

In molti posti, (1,2,3) (una tupla) e [1,2,3] (un elenco) può essere utilizzato in modo intercambiabile.

Quando dovrei usare l’uno o l’altro e perché?

È stato utile?

Soluzione

Dal Domande frequenti su Python:

Elenchi e tuple, sebbene simili sotto molti aspetti, vengono generalmente utilizzati in modi fondamentalmente diversi.Le tuple possono essere pensate come simili ai record Pascal o alle strutture C;sono piccole raccolte di dati correlati che possono essere di tipi diversi gestiti come gruppo.Ad esempio, una coordinata cartesiana è opportunamente rappresentata come una tupla di due o tre numeri.

Le liste, d'altra parte, sono più simili agli array in altri linguaggi.Tendono a contenere un numero variabile di oggetti, tutti dello stesso tipo e su cui vengono gestiti uno per uno.

Generalmente per convenzione non sceglieresti una lista o una tupla solo in base alla sua (im)mutabilità.Sceglieresti una tupla per piccole raccolte di dati completamente diversi in cui una classe completa sarebbe troppo pesante e un elenco per raccolte di dimensioni ragionevoli in cui si dispone di un insieme omogeneo di dati.

Altri suggerimenti

La lista [1,2,3] è dinamico e flessibile, ma tale flessibilità ha un prezzo in termini di velocità.

La tupla (1,2,3) è fisso (immutabile) e quindi più veloce.

Le tuple sono un modo rapido e flessibile per creare composito tipi di dati.Gli elenchi sono contenitori per, beh, elenchi di oggetti.

Ad esempio, potresti utilizzare un elenco per archiviare un elenco dei dettagli degli studenti in una classe.

I dettagli di ogni studente nell'elenco possono essere una tupla di 3 elementi contenente il numero di ruolo, il nome e il punteggio del test.

`[(1,'Mark',86),(2,'John',34)...]`

Inoltre, poiché le tuple sono immutabili, possono essere utilizzate come chiavi nei dizionari.

La nozione di tuple è altamente espressiva:

  • Pragmaticamente, sono ottimi per imballare e disimballare valori (x,y=coord).

  • In combinazione con i dizionari (tabelle hash), consentono forme di mappatura che altrimenti richiederebbero molti livelli di associazione.Ad esempio, considera di contrassegnare che (x,y) è stato trovato.

    // PHP
if (!isset($found[$x])) {
    $found[$x] = Array();
    $found[$x][$y] = true;
} else if (!isset($found[$x][$y])) {
    $found[$x][$y] = true;
}

# Python
found[(x,y)] = True # parens added for clarity

  • Le liste dovrebbero essere usate prevedendo operazioni sul loro contenuto (da qui i vari riferimenti all'immutabilità).Si vorrà estrarre, spingere, unire, affettare, cercare, inserire prima, inserire dopo, ecc. con un elenco.

  • Le tuple dovrebbero essere una rappresentazione di basso livello di un oggetto, in cui vengono effettuati semplici confronti o operazioni come l'estrazione dell'n-esimo elemento o n elementi in modo prevedibile, come nell'esempio delle coordinate fornito in precedenza.

  • Infine, le liste non sono hashable, quindi il tipo di mappatura eseguita con i dizionari (tabelle hash in Perl, array associativi in ​​PHP) deve essere eseguita con tuple.

    Ecco un semplice esempio di tuple e dizionari, finalmente insieme:

    """
couple is a tuple of two people
doesLike is a dictionary mapping couples to True or False
"""
couple = "john", "jane"
doesLike = dict()
doesLike[couple] = True
doesLike["jane", "john"] = False # unrequited love :'(

[1, 2, 3] è un elenco in cui è possibile aggiungere o eliminare elementi.
(1, 2, 3) è una tupla in cui, una volta definita, non è possibile apportare modifiche.

Ogni volta che devo passare una raccolta di elementi a una funzione, se voglio che la funzione non modifichi i valori passati, utilizzo le tuple.

Altrimenti, se voglio avere la funzione per modificare i valori, utilizzo list.

Se stai usando librerie esterne e devi passare un elenco di valori a una funzione e non sei sicuro dell'integrità dei dati, usa sempre una tupla.

Come altri hanno già detto, elenchi e tuple sono entrambi contenitori che possono essere utilizzati per archiviare oggetti Python.Le liste sono estensibili e il loro contenuto può cambiare in base all'assegnazione, d'altra parte le tuple sono immutabili.

Inoltre, le liste non possono essere usate come chiavi in ​​un dizionario mentre le tuple sì.

apri una console ed esegui python.Prova questo:

  >>> list = [1, 2, 3]     
  >>> dir(list)
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delsli
    ce__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getit
    em__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
     '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__r
    educe__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__'
    , '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 
'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Come puoi vedere, l'ultimo elenco dell'ultima riga ha i seguenti metodi:'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

Ora prova lo stesso per la tupla:

>>> tuple = (1, 2, 3)
>>> dir(tuple)
    ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__
    format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__get
    slice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__
    lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__'
    , '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

Soltanto 'conteggio' e 'indice' dai metodi dell'elenco viene visualizzato qui.

Questo perché le tuple sono immutabili e non supportano alcuna modifica.Sono invece più semplici e veloci nell’implementazione interna.

  • Una tupla potrebbe rappresentare una chiave nel dizionario, perché è immutabile.
  • Usa elenchi se si dispone di una raccolta di dati che non richiedono accesso casuale.

Se riesci a trovare una soluzione che funzioni con le tuple, usale, poiché impone l'immutabilità che ti guida lungo un percorso più funzionale.Non ti penti quasi mai di aver seguito il percorso funzionale/immutabile.

[1,2,3] è un elenco.

(1,2,3) è una tupla e immutabile.

(1,2,3) e [1,2,3] possono essere usati in modo intercambiabile in rare condizioni.

Quindi (1,2,3) è una tupla ed è immutabile.Qualsiasi modifica che desideri apportare dovrà sovrascrivere l'oggetto.

[1,2,3] è un elenco e gli elementi possono essere aggiunti e rimossi.

La lista ha più funzionalità di una tupla.

(1,2,3) è una tupla while [1,2,3] è un elenco.Una tupla è un oggetto immutabile mentre una lista è mutabile.

(1,2,3) è una tupla e [1,2,3] è un elenco.Uno dei due rappresenta sequenze di numeri ma nota che le tuple sono immutabili e le list sono oggetti Python mutabili.

(1,2,3) -tuple [1,2,3] -List elenchi sono mutabili su cui è possibile eseguire varie operazioni mentre le tuple sono immutabili che non possono essere estese. Non può aggiungere, eliminare o aggiornare qualsiasi elemento una volta è creato.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top