Python Tuple vs List: Asemănări și diferențe, explicate

În acest ghid, veți afla asemănările și diferențele dintre tuplurile și listele Python. Veți înțelege și când ar trebui să utilizați un tuplu.

Lista și tuplurile sunt ambele structuri de date încorporate în Python. Ele pot fi folosite pentru a stoca o colecție de elemente.

De la suport pentru indexare și tăiere până la conținutul de tipuri de date eterogene, tuplurile și listele pot părea a avea funcționalități similare. Prin urmare, înțelegerea asemănărilor și diferențelor dintre cele două vă poate ajuta să decideți ce structură de date să utilizați.

Sa incepem.

Puteți porni un REPL Python și puteți urma acest tutorial. De asemenea, puteți utiliza editorul online Python al Geekflare pentru a codifica.

Python Tuple vs List: Care sunt asemănările?

Să începem prin a învăța asemănările dintre liste și tupluri. Pentru a facilita o mai bună învățare, prezentăm exemple atât de liste, cât și de tupluri.

#1 . Python Iterables

În Python, listele sunt incluse într-o pereche de paranteze pătrate, în timp ce tuplurile sunt incluse în paranteze. De asemenea, puteți crea un tuplu ca un set de valori separate prin virgule, fără paranteze.

Ambele sunt iterabile; astfel încât să puteți trece prin ele folosind o buclă for .

Celula de cod de mai jos arată cum să parcurgeți o listă.

 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

După cum se explică mai jos, puteți, de asemenea, să iterați printr-un tuplu folosind o buclă

 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 . Suport pentru crearea din alte secvențe

Următoarea similitudine între liste și tupluri este că acestea pot fi create din secvențe existente, cum ar fi șiruri.

 sample_str = "Coding!"

Următoarea celulă de cod arată cum list(string) returnează o listă, ale cărei elemente de listă sunt caracterele din șir.

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

În mod similar, un tuplu poate fi creat dintr-un șir sau altă secvență folosind tuple(sequence) . Celula de cod de mai jos arată cum puteți face acest lucru.

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

#3 . Suport pentru indexare și tăiere

Python acceptă indexarea zero în care primul element este la indicele zero, al doilea la indexul unu și așa mai departe. Python acceptă, de asemenea, indexarea negativă, unde ultimul element este la indexul -1, al doilea element este la indexul -2 și așa mai departe.

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

Elementul de la indexul -2 este al doilea articol, „g”.

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

Puteți utiliza tăierea când doriți să lucrați cu o mică secțiune a listei sau tuplu. list[start:end] returnează o porțiune a listei începând de la începutul indexului și extinzându-se până la sfârșit – 1. Valoarea implicită pentru un început este 0, iar finalul este ultimul element din iterabil.

Puteți tăia tupluri folosind aceeași sintaxă. Să creăm felii din lista și tuplele pe care le-am creat mai devreme.

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

Pe lângă valorile de început și de sfârșit, puteți specifica și o valoare de pas. tuple(start:end:step) returnează o porțiune din tuplu de la start până la end - 1 , în pași de step .

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

Aici, setăm valoarea pasului la 2. Deci felia conține fiecare al doilea element.

#4 . Colecții de mai multe tipuri de date

În exemplele pe care le-am luat în considerare, toate elementele din listă și tuplurile erau de același tip de date.

Cu toate acestea, puteți stoca valori ale diferitelor tipuri de date într-o singură listă sau un tuplu.

Fragmentul de cod de mai jos student_list conține numele unui student sub formă de șir, vârsta ca număr întreg și semnele securizate ca un 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'>

Putem veni cu un exemplu similar pentru un tuplu.

 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 . Suport pentru testarea abonamentului

Atât listele, cât și tuplurile vă permit să efectuați teste de membru pentru prezența anumitor articole. Dacă doriți să verificați dacă un anumit element este prezent într-o listă sau într-un tuplu, puteți utiliza operatorul in .

Elementul de expresie item in iterable evaluat la True dacă iterable conține item ; altfel, False .

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

Până acum, ați învățat asemănările dintre liste și tupluri în Python. În continuare, să învățăm diferențele cheie dintre cele două structuri de date.

Python Tuple vs List: Care sunt diferențele?

#1 . Mutabilitatea listelor și imuabilitatea tuplurilor în Python

Cea mai importantă diferență între o listă și un tuplu în Python este că un tuplu este imuabil . Aceasta înseamnă că nu puteți modifica un tuplu în loc.

️ Iată un exemplu.

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

O listă este o structură de date mutabilă, așa că putem modifica lista schimbând un articol la un index specific, ca în celula de cod următoare.

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

#2 . Liste cu lungime variabilă vs tuplu cu lungime fixă

Lista Python este o structură de date cu lungime variabilă.

Puteți face următoarele:

• Adăugați un articol la sfârșitul listei
• Adăugați articole dintr-o altă listă la sfârșitul listei curente
• Eliminați elementele dintr-un anumit index din listă

 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)

️ Ieșirea fragmentului de cod de mai sus.

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

Tuplurile sunt structuri de date cu lungime fixă. Deci nu puteți adăuga sau elimina elemente dintr-un tuplu existent. Dar puteți redefini tuplul pentru a conține elemente diferite.

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

#3 . Dimensiunea în memorie

Acum vom construi pe deasupra a ceea ce am învățat în secțiunea anterioară: lista este o structură de date cu lungime variabilă .

Când definiți lista inițial, o anumită dimensiune este alocată acesteia în memorie. Acum, când modificați o listă folosind metodele append() sau extend() , ar trebui să fie alocată memorie suplimentară pentru a stoca elementele adăugate. Această alocare se face aproape întotdeauna mai mult decât numărul de articole pe care le adăugați.

Așadar, este necesar să urmăriți numărul de articole din listă și spațiul alocat. În plus, deoarece listele au lungime variabilă, există un indicator care indică adresa elementelor din listă. Ca rezultat, listele cu lungimea k ocupă mai multă memorie decât un tuplu cu aceleași k elemente.

Iată o ilustrație simplă.

Puteți folosi metoda încorporată a modulului sys getsizeof() pe un obiect Python pentru a obține dimensiunea unui obiect din memorie.

 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}")

O listă ocupă mai multă memorie decât un tuplu pentru același număr și valoare de elemente, așa cum se verifică în rezultatul de mai jos.

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

Când ar trebui să utilizați un tuplu Python?

Din diferențele și asemănările dintre listele Python și tupluri, știți că, dacă aveți nevoie de o colecție mutabilă , ar trebui să utilizați o listă .

Dar când ar trebui să folosești un tuplu în schimb?

Vom trece peste asta în această secțiune.

#1 . Colecție numai pentru citire

Ori de câte ori doriți ca o colecție să fie imuabilă, ar trebui să o definiți ca un tuplu. Să presupunem color = (243,55,103) un tuplu care conține valorile RGB corespunzătoare unei nuanțe de culoare. Definirea culorii ca tuplu asigură că nu poate fi modificată.

În esență, atunci când aveți nevoie ca o colecție să fie doar în citire: valorile nu trebuie modificate în timpul programului, ar trebui să luați în considerare utilizarea unui tuplu. Acest lucru va preveni modificarea neintenționată a valorilor.

#2 . Dicţionar Keys

De exemplu, creați un dicționar folosind elementele listei key_list ca chei. Puteți utiliza metoda dict.fromkeys() pentru a crea un dicționar dintr-o listă.

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

Să presupunem că modificați lista pentru a conține „D” ca prim element (index 0) — înainte de a crea dicționarul.

Acum, ce se întâmplă cu cheia de dicționar „A”?

Dacă încercați să creați un dicționar din key_list și să accesați valoarea corespunzătoare cheii „A”, veți întâlni o 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'

Cheile unui dicționar ar trebui să fie unice. Deci nu puteți avea un al doilea „D” ca cheie.

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

Dacă folosiți în schimb un tuplu, o astfel de modificare este imposibilă și este mai puțin probabil să întâlniți erori. Prin urmare, ar trebui să preferați să creați un dicționar folosind elementele unui tuplu ca chei.

 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 . Argumente ale funcției

Imuabilitatea tuplurilor le face potrivite pentru a fi transmise ca argumente de funcție.

Luați în considerare următoarea funcție find_volume() care returnează volumul unui cuboid având în vedere dimensiunile: lungime, lățime și înălțime.

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

Să presupunem că aceste dimensiuni sunt disponibile într-o listă numită dimensions . Apelul la find_volume() cu dimensions ca argument returnează volumul.

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

Puteți schimba oricând dimensiunile stocate într-o listă.

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

Cu toate acestea, uneori veți avea nevoie ca valorile să rămână constante și să reziste modificării. Atunci ar trebui să luați în considerare stocarea argumentelor ca tuplu și utilizarea lor în apelul de funcție.

#4 . Valori returnate din funcții

În Python, veți întâlni tupluri în valorile returnate de la funcții. Când returnați mai multe valori dintr-o funcție, Python le returnează implicit ca un tuplu.

Luați în considerare următoarea funcție return_even() :

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

• Este nevoie de un număr num ca argument
• Returnează lista numerelor pare din intervalul [0,num) și lungimea acelei liste.

Să setăm valoarea num 20 și să apelăm funcția.

 num = 20

Apelarea return_even() returnează cele două valori dintr-un tuplu. Puteți apela funcția type() cu apelul funcției ca argument de verificare.

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

Puteți imprima valoarea returnată pentru a verifica dacă este un tuplu care conține lista de numere pare ca prim element și lungimea listei ca al doilea element.

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

Deoarece există două elemente în tuplu, le puteți despacheta în două variabile, așa cum se arată mai jos.

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

Concluzie

Sper că acest tutorial a oferit o comparație cuprinzătoare între tuplu Python vs listă.

Să încheiem tutorialul cu un rezumat rapid:

• Lista și tuplurile sunt structuri de date încorporate în Python.
• Asemănări : iterabile, suport pentru indexare, tăiere, diferite tipuri de date și operator pentru testarea apartenenței.
• Diferența cheie : listele sunt mutabile, iar tuplurile sunt imuabile.
• Alte diferențe : Lungime fixă ​​a tuplurilor și lungime variabilă a listelor, dimensiune mai mică în memoria tuplurilor.
• Când ar trebui să folosiți un tuplu? Pentru colecții imuabile, chei de dicționar și argumente de funcție.

Apoi, consultați proiectele Python pentru a exersa și a învăța. Sau aflați metode pentru a elimina elementele duplicat din listele Python. Învățare fericită! atunci, codare fericită!