Python: Care este diferența dintre (1,2,3) și [1,2,3] și când trebuie să folosesc fiecare?

Lista [1, 2, 3] este dinamică și flexibilă, dar această flexibilitate vine la un cost de viteză.

Talpa (1,2,3) este fixă ​​(imuabilă) și deci mai rapidă.

Tupele reprezintă o modalitate rapidă / flexibilă de a crea tipuri de date compuse . Listele sunt containere pentru, bine, liste de obiecte.

De exemplu, ați utiliza o listă pentru a stoca o listă cu detaliile studenților într-o clasă.

Fiecare detaliu al elevului din această listă poate fi o 3-picior care conține numărul de rolă, numele și scorul de test.

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

De asemenea, deoarece tuplurile sunt imuabile, ele pot fi folosite ca chei în dicționare.

Dacă găsiți o soluție care funcționează cu tupluri, folosiți-le, deoarece forțează imutabilitatea, care vă conduce pe o cale mai funcțională. Aproape niciodată nu regreți că mergeți pe calea funcțională / imuabilă.

După cum au menționat și alții, Liste și tuple sunt ambele containere care pot fi folosite pentru a stoca obiecte Python. Listele sunt extensibile, iar conținutul lor se poate modifica prin alocare, iar pe de altă parte, tuplurile sunt imuabile.

De asemenea, listele nu pot fi folosite ca chei într-un dicționar, în timp ce tuplurile pot.

Ori de câte ori am nevoie să trec într-o colecție de elemente pentru o funcție, dacă vreau ca funcția să nu schimbe valorile trecute - folosesc tuple.

Altfel, dacă vreau să am funcția de a modifica valorile, folosesc lista.

Întotdeauna dacă utilizați biblioteci externe și trebuie să treceți într-o listă de valori unei funcții și nu sunteți sigur de integritatea datelor, utilizați o tuplă.

Din FAQ Python :

Listele și tuplele, în timp ce sunt similare în multe privințe, sunt în general utilizate în mod fundamental diferite. Tupele pot fi considerate ca fiind similare cu înregistrările Pascal sau structurile C; acestea sunt colecții mici de date conexe care pot fi de diferite tipuri care sunt operate în grup. De exemplu, o coordonată carteziană este reprezentată în mod corespunzător ca o trupă de două sau trei numere.

     

Listele, pe de altă parte, seamănă mai mult cu arhitecturile în alte limbi. Acestea tind să dețină un număr variat de obiecte, toate având același tip și care sunt operate pe unu-unu.

În general, prin convenție nu ați alege o listă sau o tuplă bazată doar pe (im) mutability. Ați alege o tuplă pentru colecții mici de piese complet diferite de date în care o clasă plină cu suflet ar fi prea greu și o listă pentru colecții de orice dimensiune rezonabilă în cazul în care aveți un set omogen de date.

(1,2,3) is a tuple and [1,2,3] is a list. You either of the two represent sequences of numbers but note that tuples are immutable and list are mutable Python objects.

deschideți o consolă și rulați Python. Incearca asta:

  >>> 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']

As you may see the last on the last line list have the following methods: 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

Acum încercați la fel pentru tuple:

>>> 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']

Doar aici apar 'count' și 'index' din metodele de listă.

Acest lucru se datorează faptului că tuplurile sunt imuabile și nu acceptă modificări. În schimb, ele sunt mai simple și mai rapide în implementarea internă.

(1,2,3) is a tuple while [1,2,3] is a list. A tuple is an immutable object while a list is mutable.

[1,2,3] is a list.

(1,2,3) is a tuple and immutable.

Noțiunea de tuple este extrem de expresivă:

• Pragmatically, they are great for packing and unpacking values (x,y=coord).

• In combination with dictionaries (hash tables), they allow forms of mapping that would otherwise require many levels of association. For example, consider marking that (x,y) has been found.

  // 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
  

• Lists should be used with the expectation of operations on its contents (hence the various mentions of immutability). One will want to pop, push, splice, slice, search, insert before, insert after, etc with a list.

• Tuples should be a low-level representation of an object, where simple comparisons are made, or operations such as extracting the n'th element or n elements in a predictable fashion, such as the coordinates example given earlier.

• Lastly, lists are not hashable, so the type of mapping done with dictionaries (hash tables in Perl, associative arrays in PHP) must be done with tuples.

  Here's a simple example of tuples and dictionaries, together at last:

  """
  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 :'(
  

• O tuplă ar putea reprezenta o cheie în dicționar, pentru că este neschimbătoare.
• Utilizați liste dacă aveți o colecție de date care nu sunt nevoie de acces aleatoriu.

(1,2,3) și [1,2,3] pot fi utilizate interschimbabil în condiții rare.

Deci (1,2,3) este un tuplu și este imuabil. Orice modificare pe care doriți să o faceți trebuie să suprascrie obiectul.

[1,2,3] este o listă și elementele pot fi adăugate și eliminate.

Lista are mai multe caracteristici decât o tuplă.