În acest ghid, veți învăța 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 începe o REPL Python și puteți urma acest tutorial. De asemenea, puteți utiliza editorul online Python al tipstrick.ro pentru a codifica.
Cuprins
Python Tuple vs List: Care sunt asemănările?
Să începem prin a învăța asemănările dintre liste și tuple. Pentru a facilita o învățare mai bună, 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 este explicat 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(șir) 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 tuplu (secvență). 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 sfârșitul este ultimul element din iterabil.
Puteți tăia tupluri folosind aceeași sintaxă. Să creăm felii din lista și tuplul 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 început până la sfârșit – 1, în pași de pas.
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 testarea apartenenței 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 din iterabil este evaluat la True dacă iterabilul conține elementul; altfel, fals.
"Alex" in student_list # False "Jane" in student_tuple # True
Până acum, ați învățat asemănările dintre liste și tuplu î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, trebuie 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 culoare = (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ă dimensiuni. Apelul la find_volume() cu dimensiuni 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 va trebui 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 interval [0,num) and the length of that list.
Let’s set the value of num 20 and call the function.
num = 20
Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.
type(return_even(num)) # <class 'tuple'>
You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.
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ă!👩🏽💻