În Python, un tip de date fundamental este tuplul, conceput pentru a reține o grupare de elemente. Acesta se aseamănă cu o listă, dar prezintă o viteză superioară în anumite operații.
Cu toate acestea, datorită anumitor restricții, listele rămân preferabile în anumite scenarii. În acest articol, îți voi oferi toate informațiile necesare pentru a începe să utilizezi tuplurile cu încredere.
Ce reprezintă un tuplu?
După cum am menționat, tuplul este un tip de date încorporat în Python, utilizat pentru a gestiona colecții de date. Acesta funcționează similar unei liste, stocând date într-un format iterabil, tipic unui array. Însă, spre deosebire de liste, tuplurile sunt imuabile. Aceasta înseamnă că, odată creat, conținutul său nu mai poate fi modificat.
Nu se pot adăuga elemente suplimentare și nici elimina cele existente. Prin urmare, tuplurile sunt ideale pentru stocarea datelor care nu suferă modificări. Pot conține chiar și o combinație de date de diferite tipuri. În continuare, vom analiza metodele de creare a tuplurilor în Python.
Modalități de a crea un tuplu în Python
Există cel puțin trei abordări pentru crearea tuplurilor în Python. În această secțiune, vom explora cele mai frecvente trei metode, pe care le vei întâlni des în codul sursă.
Pentru a testa exemplele de cod ce urmează, trebuie să ai Python instalat. Dacă nu ai deja Python, există numeroase ghiduri online disponibile. Alternativ, poți utiliza un mediu de rulare Python online, cum este Google Colab.
#1. Utilizarea parantezelor rotunde (literal tuplu)
Cel mai întâlnit mod de a defini un tuplu în Python este prin includerea unei serii de valori între paranteze rotunde, separate prin virgulă. Exemplul următor demonstrează această tehnică:
# Crearea unui tuplu prin plasarea valorilor între paranteze
valori = (1, 2, 3)
# Afișarea tuplului pe ecran
print(valori)
# Afișarea tipului variabilei "valori"
print(type(valori))
Executând acest cod, vei obține:
După cum se vede, tuplul conține valorile inițializate. Tipul său este, de asemenea, identificat ca <class ‘tuple’>.
În Python, parantezele rotunde nu sunt strict necesare la crearea tuplurilor. Astfel, `valori = 1, 2, 3` este la fel de valid ca `valori = (1, 2, 3)`. Totuși, utilizarea parantezelor face codul mai ușor de interpretat.
Crearea unui tuplu cu un singur element în Python necesită o atenție specială. În loc să plasezi doar un element în paranteze, trebuie să adaugi și o virgulă la final. Iată un exemplu:
# Fără virgulă la final, nu se creează un tuplu
nu_e_tuplu = (1)
# Cu virgulă, se creează un tuplu
un_tuplu = (1,)
# Afișarea variabilei "nu_e_tuplu"
print(nu_e_tuplu)
# Afișarea tipului variabilei "nu_e_tuplu"
print(type(nu_e_tuplu))
# Afișarea variabilei "un_tuplu"
print(un_tuplu)
# Afișarea tipului variabilei "un_tuplu"
print(type(un_tuplu))
Dacă rulezi codul de mai sus, vei observa că `nu_e_tuplu` devine un `int` cu valoarea 1. Este important să reții acest aspect când creezi tupluri.
#2. Utilizarea funcției constructor
O altă metodă de a crea tupluri în Python este prin folosirea funcției constructor `tuple()`. Aici, se apelează funcția, transmițând un obiect iterabil, cum ar fi o listă, ca argument. Acesta va fi transformat într-un tuplu. Iată un exemplu:
# Crearea unui tuplu dintr-o listă de valori
valori = tuple([1, 2, 3])
# Afișarea valorilor
print(valori)
# Afișarea tipului de date al variabilei "valori"
print(type(valori))
După cum observi, funcția produce același rezultat ca și literalul. Însă, funcția permite crearea unui tuplu bazat pe valori dinamice, precum o listă ale cărei valori sunt cunoscute doar în timpul execuției. Cu prima metodă, valorile sau identificatorii tuplului trebuie cunoscuți la momentul scrierii codului.
#3. Crearea unui tuplu gol
Când lucrezi cu tupluri, uneori este necesară crearea unor tupluri goale. Acestea se creează intuitiv. Poți utiliza fie constructorul `tuple()`, fie literalul tuplu, la crearea lor. Iată un exemplu care ilustrează ambele metode:
# Utilizarea literalului tuplu
tuplu_gol_1 = ()
# Utilizarea constructorului
tuplu_gol_2 = tuple()
Tuplurile goale sunt utile pentru a reprezenta un set de rezultate vid. Imaginează-ți funcția:
def genereaza_interval(inceput, sfarsit):
return tuple(range(inceput, sfarsit))
Această funcție creează un tuplu cu valori de la `inceput` până la `sfarsit`. Dacă vrei să iterezi rezultatele, ai utiliza un cod de genul:
valori_mele = genereaza_interval(0, 5)
for valoare in valori_mele:
pass
Dacă transmiți `5` și `5` funcției `genereaza_interval`, rezultatul ar fi un tuplu gol. Dacă încerci să iterezi peste el, nu ar exista nicio iterație, iar codul ar continua normal.
Pe de altă parte, dacă nu ar exista tupluri goale și ai primi în schimb `None`, atunci încercarea de a itera ar genera o eroare. Pentru a preveni blocarea programului, ar trebui să testezi cazul limită în care funcția `genereaza_interval` returnează `None` sau altă valoare care semnifică un tuplu gol.
Aceasta ar complica codul. Ideal, ar trebui să eviți pe cât posibil cazurile speciale. Valoarea returnată de toate funcțiile ar trebui să aibă aceeași interfață, astfel încât codul să funcționeze cât mai mult în cazul general. În acest caz, înseamnă să returnezi un tuplu mereu, chiar și gol uneori.
Cum se accesează elementele
În Python, există două metode principale de a accesa elementele unui tuplu. Prima implică indexarea, iar a doua, destructurarea elementelor. Mai întâi, vom vedea cum să accesăm elementele prin indexare.
Accesarea elementelor folosind indexul
Accesarea elementelor prin index funcționează similar cu accesarea elementelor unei liste. Se folosește notația cu paranteze pătrate. Tuplurile au un sistem de indexare bazat pe zero, ceea ce înseamnă că primul element are indexul `0`, cel de-al doilea indexul `1`, și așa mai departe până la ultimul element.
Exemplul următor arată cum să accesezi elementele folosind indexul:
# Crearea unui tuplu
valori = (1, 2, 3, 4)
# Accesarea primului element
primul_element = valori[0]
# Accesarea celui de-al patrulea element (index 3)
al_patrulea_element = valori[3]
Se poate folosi și indexarea negativă. Elementul cu indexul `-1` este ultimul element, iar cel cu indexul `-2` este penultimul.
# Crearea tuplului
valori = (1, 2, 3, 4)
# Accesarea ultimului element
ultimul_element = valori[-1]
# Accesarea penultimului element
penultimul_element = valori[-2]
În plus, poți accesa subcolectii de elemente dintr-un tuplu prin feliere. Această metodă este similară cu felierea unei liste. Notația este `tuplu[<început>:
# Crearea tuplului
valori = (1, 2, 3, 4, 5, 6, 7)
# Obținerea primelor trei elemente
valori[0: 3]
# Obținerea fiecărui al doilea element
valori[::2]
Iterarea elementelor
Tuplul este un obiect iterabil în Python. Prin urmare, poți itera peste elementele sale folosind o buclă `for`, după cum se arată în exemplul următor:
valori = (1, 2, 3, 4)
for valoare in valori:
print(valoare)
Această metodă este ideală atunci când vrei să accesezi fiecare element al tuplului.
Accesarea elementelor prin destructurare
Pentru a explica destructurarea, să ne gândim la un scenariu în care vrem să extragem diferite elemente dintr-un tuplu.
# Crearea unui tuplu pentru a înregistra datele unui utilizator inregistrare_persoana = (1, 'Ion Popescu', '[email protected]') # Accesarea elementelor tuplului pentru a fi folosite în cod id = inregistrare_persoana[0] nume = inregistrare_persoana[1] email = inregistrare_persoana[2]
Python ne permite o metodă mai elegantă pentru a accesa valorile, după cum este ilustrat mai jos:
# Crearea tuplului pentru a înregistra datele unui utilizator inregistrare_persoana = (1, 'Ion Popescu', '[email protected]') id, nume, email = inregistrare_persoana
Acesta este procesul de destructurare. Prima variabilă, `id`, primește prima valoare din tuplu, a doua variabilă al doilea element, și așa mai departe. Exemplul de mai sus este similar cu:
id, nume, email = (1, 'Ion Popescu', '[email protected]')
În acest caz, în loc să stocăm tuplul într-o variabilă, îl destructurăm direct. Combinând asta cu faptul că parantezele rotunde nu sunt necesare la crearea tuplurilor, codul se poate scrie astfel.
id, nume, email = 1, 'Ion Popescu', '[email protected]'
La final, vei avea variabilele `id`, `nume` și `email` cu valorile `1`, `Ion Popescu` și `[email protected]`. Aceasta este o metodă succintă și eficientă de a defini variabile în Python, pe care o vei întâlni des în codul de producție. Este important să înțelegi că în spatele acestei sintaxe elegante se află conceptul de tuplu.
Diferențe între tupluri și liste
Deși ambele sunt similare, anumite diferențe cheie le fac potrivite pentru cazuri specifice. Înțelegerea acestor diferențe te va ajuta să alegi tipul de date optim și să scrii un cod mai eficient.
| Aspect | Tuplu | Listă |
| Stocarea în memorie | Stocat în memorie continuă. | Stocat în locații diferite din memorie. |
| Utilizare | De obicei, folosit pentru a stoca o colecție de valori eterogene. | De obicei, folosit pentru a stoca o colecție de valori omogene. |
Avantajele unui tuplu
#1. Este mai rapid
Datorită modului în care valorile unui tuplu sunt stocate într-o memorie contiguă, accesarea lor este mai rapidă comparativ cu o listă. Însă, cum nu pot fi modificate odată create, tuplurile nu sunt întotdeauna cea mai bună structură de date pentru a stoca colecții de valori.
Cazul lor ideal este stocarea în memorie a unor date care nu se schimbă, dar care vor fi accesate de mai multe ori în timpul execuției programului. În acest scenariu, programul va beneficia de performanța sporită a tuplurilor.
#2. Returnează valori multiple
Poți utiliza tupluri pentru a returna mai multe valori dintr-o funcție și pentru a destructura rezultatul. De exemplu:
from random import randint
def genereaza_doua_numere():
primul_numar = randint(0, 9)
al_doilea_numar = randint(0, 9)
return primul_numar, al_doilea_numar
primul_numar, al_doilea_numar = genereaza_doua_numere()
În acest exemplu, avem o funcție care generează două numere aleatoare și le returnează pe ambele într-un tuplu. Instrucțiunea `return primul_numar, al_doilea_numar` este echivalentă cu `return (primul_numar, al_doilea_numar)`. Asta pentru că parantezele rotunde sunt opționale la crearea tuplurilor. Pentru a accesa rezultatul, îl destructurăm.
#3. Valorile sunt protejate la scriere
Tuplurile sunt imuabile odată create. Prin urmare, sunt ideale pentru stocarea datelor care nu se modifică în timpul execuției programului. Aceasta asigură că nu suprascrii accidental datele în altă parte a codului.
#4. Stochează tipuri de date multiple
Tuplurile permit stocarea valorilor pentru mai multe tipuri de date. Astfel, poți crea înregistrări de date, de exemplu, detaliile unui utilizator într-un tuplu. Se pot stoca și elemente mai complexe, precum funcții, dicționare, alte tupluri și chiar liste.
Metode uzuale ale tuplurilor
#1. `count()`
Obiectul tuplu dispune de metoda `count`, care numără aparițiile unui anumit element. De exemplu:
# Crearea unui tuplu cu mai multe numere
valori = (1, 2, 3, 4, 5, 4, 4, 6)
# Numărarea aparițiilor numărului 4
nr_patru = valori.count(4)
# Afișarea numărului de apariții ale lui 4
print(nr_patru)
În acest exemplu, observăm că numărul 4 apare de exact trei ori în tuplul nostru.
#2. `index()`
Metoda `index` este folosită pentru a localiza indexul primei apariții a unei valori într-un tuplu. Dacă valoarea nu există, se va genera o excepție `ValueError`. Iată un cod care ilustrează funcționarea metodei `index`:
# Crearea unui tuplu cu mai multe numere
valori = (1, 2, 3, 4, 5, 4, 4, 6)
# Căutarea indexului lui 4
index_patru = valori.index(4)
print("Indexul lui patru:", index_patru)
# Căutarea indexului lui 9
index_noua = valori.index(9)
print("Indexul lui nouă:", index_noua)
Rezultatul executării codului de mai sus este:
În acest caz, indexul lui 4 este 3, iar codul a rulat corect. Când a fost căutat indexul lui 9, programul a generat o excepție. Este important să gestionezi astfel de excepții atunci când scrii programe Python care folosesc metoda `index`.
#3. `len()`
La fel ca toate obiectele iterabile din Python, tuplurile au o proprietate de lungime, accesibilă prin utilizarea funcției `len()` și transmiterea tuplului ca argument.
# Crearea unui tuplu
valori = (1, 2, 3, 4)
# Obținerea lungimii
lungime = len(valori)
# Afișarea rezultatului
print(lungime)
Acesta este rezultatul rulării codului de mai sus.
#4. `min()` și `max()`
Metodele `min` și `max` iterează prin fiecare element al unui iterabil și compară dacă este mai mare sau mai mic decât cel anterior. La final, `max` returnează cel mai mare element din iterabil, iar `min` cel mai mic.
Cu numere, operația este evidentă. Cu șiruri, Python va folosi ordinea alfabetică. Cel mai mic cuvânt returnat de `min` este primul cuvânt dacă șirurile ar fi sortate alfabetic. Cel mai mare cuvânt este ultimul. Dacă iterabilul conține un amestec de tipuri de date, operațiile vor eșua, deoarece Python nu știe cum să compare tipuri de date diferite.
Iată un exemplu de cod:
# Crearea unui tuplu cu valori
valori = (1, 2, 3, 4, 5)
# Obținerea celei mai mari valori
cea_mai_mare = max(valori)
# Obținerea celei mai mici valori
cea_mai_mica = min(valori)
# Afișarea rezultatelor
print(cea_mai_mare)
print(cea_mai_mica)
#5. `sorted()`
Funcția `sorted` din Python primește un obiect iterabil și returnează o listă cu elementele sortate. Poți apela funcția `sorted`, să transmiți un tuplu ca argument și să obții elementele sortate ale tuplului într-o listă. Pentru a converti lista sortată într-un tuplu, folosește funcția constructor. Iată un exemplu:
# Crearea unui tuplu cu valori în ordine aleatoare
valori = (1, 5, 3, 3, 2, 4)
# Utilizarea funcției sorted pentru a sorta valorile într-o listă
lista_sortata = sorted(valori)
# Conversia listei într-un tuplu
tuplu_sortat = tuple(lista_sortata)
# Afișarea rezultatului
print(tuplu_sortat)
#6. Adunarea și înmulțirea tuplurilor
Operația de adunare a două tupluri pur și simplu le concatenează. Operația de înmulțire repetă elementele unui tuplu de atâtea ori cât valoarea cu care l-ai înmulțit. Iată un exemplu care ilustrează cele două operații.
# Crearea unui tuplu cu anumite valori
valori = (1, 2, 3, 4, 5)
# Crearea unui nou tuplu prin adunare
adaugat = valori + valori
# Crearea unui nou tuplu prin înmulțire
inmultit = valori * 2
print("valori + valori =", adaugat)
print("valori * 2 =", inmultit)
Concluzii
În acest articol, ai învățat că:
- Tuplurile sunt obiecte similare listelor, folosite pentru a stoca colecții de valori.
- Spre deosebire de liste, tuplurile sunt imuabile.
- Sunt mai rapide și mai eficiente decât listele.
- Se pot construi folosind paranteze și separând valorile prin virgulă.
- Se pot construi și prin utilizarea funcției constructor `tuple()`.
- Poți accesa valori individuale folosind un sistem de indexare bazat pe zero.
- Poți destructura valori din tuplu.
- Poți itera valori folosind o buclă `for`.
- Există diverse metode pe care le poți folosi cu un tuplu.
În continuare, îți recomand să explorezi și alte subiecte Python, precum metodele Listelor și metodele Dicționarelor.