STRUCTURI DE DATE ÎN PYTHON

STRUCTURI DE DATE ÎN PYTHON

INDICE

TU RETO ÎN ACEASTĂ UNITATE........................................................................ 3

1. STRUCTURI DE DATE..................................................................... 5
1.1. SECVENȚ E
1.1.1. LISTELE....................................................................................................6
[Link]. Metode de consultare ș i modificare a listelor ..................................... 13
1.1.2. TUPLAS................................................................................................19
1.1.3. ÎNAPOI CU SIRURILE..................................................................22
1.2. CONJUNTE (DATASET).............................................................................22
1.3. DICȚ IONARE.............................................................................................26
1.4. DEFINIȚ II PENTRU ÎNȚ ELEGERE ..........................................................29
1.5. GENERATOARE
CE AI ÎNVĂȚ AT? .......................................................................... 37
BIBLIOGRAFIE ......................................................................................... 39

1
 STRUCTURI DE DATE ÎN PYTHON

TU RETO ÎN ACEASTĂ UNITATE

Ai ajuns până aici... felicitări! Începi să ai cunoș tinț e de...

tos pentru a crea propriile tale programe, dar încă îț i lipseș te să vezi ceva esenț ial ș i
de importanț ă deosebită: structurile de date.

Ș tii să spui în câteva cuvinte ce sunt acest tip de structuri? Nu

nu te îngrijora dacă acum nu ș tii să-l descrii cu exactitate. La finalizarea acestuia
unitate, vei înț elege perfect utilizarea sa ș i cele diferite tipuri care există,
la fel ca proprietăț ile fiecăreia.

Hai să ne apucăm de treabă...

3
 STRUCTURI DE DATE ÎN PYTHON

1. STRUCTURI DE DATE
Python încorporează nativ mai multe tipuri de date compuse. Putem
ver un tip compus ca o structură de date care ne permite să stocăm
nar o colecț ie de elemente sau valori. Dacă ai lucrat cu alte limbaje,
un exemplu simplu ar fi un vector array de elemente. Python ne oferă
mai multe alternative, cu caracteristici diferite în funcț ie de cum se alma-
cenzurarea valorilor în cadrul structurii ș i ce operaț ii putem face.

Deș i am putea include ș i lanț urile (stryunicode) ș i conjunț iarul

tos(setyfrozenset)o constructorii din această clasificare, în această
unitatea o să vedem cele trei structuri principale de date din Python:

Tuple.

Liste.
Dicț ionare (sau tablouri de dispersie).

Rezumând, ș i pentru a începe cu unitatea, modalităț ile de accesare a acestora sunt-

structuri de control (indiferent de tipul lor) sunt:

Prin intermediul indicilor: secvenț ă[0], secvenț ă[1], secvenț ă[2]...

secvenț ă[n].

Medianteslicingo porț iuni:secvenț ă[început:sfârș it:pas].

Prin intermediul iteratoarelor ș i structurilor de control (buclă for).

5
STRUCTURI DE DATE ÎN PYTHON

Structurile de date din Python le-am putea împărț i în două grupuri, lasse-
cuenciales (formate din secvenț e de date ordonate) ș i conjuntos de
date, care nu sunt ordonate. La rândul său, putem să le împărț im ș i după structură
datele mutabile ș i nemutabile, aș a cum am văzut în unitatea de iniț iere.
Să aprofundăm puț in mai mult în toate aceste termeni.

[Link] Ț E

Vom începe cu structurile de tip secvenț ial. Sunt tipuri de date...

puse de o serie de elemente, păstrând ordinea sau poziț ia în care
se adaugă la structură. Din acest motiv, se spune că sunt tipuri ordonate.

Cum uneori se pretează la confuzie, vom sublinia asta. Aici nu este ordonat.
înseamnă că atunci când adaugi elemente, acestea se reordonează (de exemplu, numeric)
te o alfabéticamente). Solo face referire la faptul că păstrează ordinea în care
sunt adăugate, adică, ordinea lor poziț ională.

Toate subtipurile de secvenț e din Python au în comun mai multe operaț ii

nes, cum ar fi accesul indexat după poziț ie, felierea (pentru ceea ce mai vrea-
ras, nu-l numi niciodată aș a) sau „tăiere”, concatenarea sau apartenenț a. Va-
să vedem totul mai în profunzime.

[Link]

Începem cu această structură de date secvenț ială ș i mutabilă (putem

accesa componentele sale ș i a le modifica prin intermediul propriilor metode).
În Python, listele sunt probabil cel mai utilizat tip compus.
datorită versatilităț ii ș i simplităț ii sale. O listă este o secvenț ă ordonată de ele-
mentos. Spre deosebire de vectori sau arrayuri din alte limbaje, într-o listă se
pot amesteca elemente de tipuri diferite fără probleme. Deș i este obiș nuit
este ca toate elementele să aibă acelaș i tip.

Forma comună de a defini o listă este includerea elementelor separate prin

comas între un pătrat de colț .

6
 STRUCTURI DE DATE ÎN PYTHON

Exemple de liste

Ș i ai observat că ultima listă de exemplu are liste închise ca elemente.

Câte elemente ai spune că are lista de nivel superior? Ai fi capabil să
identificaț i-i? Putem folosi ceea ce am învăț at despre bucle pentru a verifica-
barlo...

pentru element în listele_nidiate:

print(elemento)

Aici este

['listas', 'anidadas']

[1, 2]

Pentru a accesa elementele unei liste prin indexul sau poziț ia sa, punem
indice între corchete, de asemenea.

7
STRUCTURI DE DATE ÎN PYTHON

Primul element al unei liste (ș i al oricărei se-

secvenț a) are indicele zero. Aș a că, dacă o listă are
nelementos, pentru a accesa ultimul va trebui să
folosiț i indexul (n - 1).

Dacă dorim să obț inem lungimea unei liste (numărul de elemente care
tine), doar trebuie să folosim funcț ia len().

Lungimea listei

len(lista_nums)

# Rezultatul: 6

Lungimea listei închise:

fiecare "sub-listă" internă este văzută ca un element unic

len(listas_anidadas)

# Resultado: 3

# Selectaț i un element

lista_nums[0] # Primul valor îl obț inem cu indexul zero

lista_nums[5] # Elementul pentru indexul 5

lista_nums[len(lista_nums)‐1] # Ultimul element este în LEN‐

1

Al selecta într-o listă imbricată

listas_anidadas[1] # Elementul returnat poate fi o altă listă

# Resultado: ['listas', 'anidadas']

8
 STRUCTURI DE DATE ÎN PYTHON

Dacă folosim indecș i negativi, începem să numărăm de la sfârș it

lista_nums[-1] # Returnează ultimul element al listei

# Resultado: 4

lista_nums[‐len(lista_nums)] # Returnează primul element al listei

sta

# Rezultatul: 1

Pentru a în ț elege mai bine cum func ț ionează indicii pentru a accesa un
element, imaginează-ț i că avem lista[ 'A', 'B', 'C', 'D', 'E', 'F' ].
Figura următoare arată la ce poziț ie se referă un indice pozitiv sau un
indice negativ.

În loc să vedem indicii "îndreptându-se" către fiecare element, să ne gândim că indicii -

ces marchează poziț iile între elementele secvenț ei. În acest caz, indicele
6 face referire la o poziț ie în afara limitei listei ș i ar produce o eroare.

Acum este mai uș or să vedem cum putem selecta un "slice" de elemente conti-
guos de o listă. Indicăm indicele sau poziț ia iniț ială de unde începe-
mos la selecț ie ș i poziț ia finală până unde vrem să ajungem, scriindu-le
în interiorul acoladelor separate prin două puncte (:). În feliile, elementul
corespunzător limitei iniț iale este întotdeauna inclus, dar elementul de la limită
final rămâne exclus.

9
STRUCTURI DE DATE ÎN PYTHON

letras = ['A','B','C','D','E','F']

Selectăm un "slice" cu primele două elemente

litere[0:2]

# Resultado: ['A', 'B']

litere[2:5]

# Resultado: ['C', 'D', 'E']

Dacă nu specificăm al doilea index, selectăm până la sfârș it

letras[2:]

# Resultado: ['C', 'D', 'E', 'F']

# ș i dacă nu specificăm primul indice, selectăm de la pr

încep

litere[:4]

# Resultado: ['A', 'B', 'C', 'D']

De asemenea, putem folosi notaț ia indicilor negativi.

Selectăm de la penultima poziț ie (inclusiv) până la

final

letras[-2:]

# Resultado: ['E', 'F']

Selectăm de la început până la penultima poziț ie

(exclusă)

letras[:‐2]

# Resultado: ['A', 'B', 'C', 'D']

Cum primul indice este întotdeauna inclus

# iar al doilea este întotdeauna exclus,

putem reconstrui lista astfel

letras[:2] + letras[2:]

# Resultado: ['A', 'B', 'C', 'D', 'E', 'F']

10
 STRUCTURI DE DATE ÎN PYTHON

Aș a cum am discutat la începutul secț iunii, listele sunt mutabile, este

A spune, putem modifica conț inutul elementelor dintr-o listă de...
următoarele forme...

print(lista_lenguajes)

["C", "python", "fortran", "cobol"]

modificăm un element individual

java

print(lista_lenguajes)

["java", "python", "fortran", "cobol"]

de asemenea, putem înlocui valorile dintr-o „felie”

lista_lenguajes[2:] = ["kotlin", "brainfuck"]

print(lista_lenguajes)

['java', 'python', 'kotlin', 'brainfuck']

# o eliminaț i unele valori, înlocuindu-le cu lista goală

lista_lenguajes[1:3] = []

print(lista_lenguajes)

['java', 'brainfuck']

s-o golesc pe totă

lista_lenguajes[:] = []

print(lista_lenguajes)

[]

O altă modalitate de a-i modifica valoarea este prin concatenare (sau replicare) de
listă. Adică, putem „suma” două liste sau replica conț inutul lor.

11
STRUCȚURI DE DATE ÎN PYTHON

lista_1 = ['a', 'b', 'c']

lista_2 = [100, 200, 300]

# concatenare

lista_1 + lista_2

['a', 'b', 'c', 100, 200, 300]

replică lista de trei ori

3 * lista_1

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

De asemenea, putem extrage elementele dintr-o listă ș i le putem atribui diferitelor

variabile simple cu o singură instrucț iune.

x, y, z = lista_2

print(x)

print(y)

print(z)

Rezultatul:

100

200

300

12
 STRUCTURI DE DATE ÎN PYTHON

[Link].Metode de consultare ș i modificare a listelor

Când va trebui să facem interogări sau să modificăm valorile acestora, în

În Python avem la dispoziț ie ajutorul unor metode pe care le putem utiliza în
beneficiul nostru. Să-i vedem...

Adăugaț i un element la sfârș itul listei: append().

Extrage ultimul element din listă: pop().

Inserarea unui element înaintea unei poziț ii concrete: insert().

Caută poziț ia concretă a unui element din listă: index()

Contorizaț i numărul de ori în care apare un element: count().

Ș terge primul element din listă: remove().

Ordonează valorile listei: sort().

Inversarea ordinii listei: reverse().

Curăț area elementelor dintr-o listă (golire): clear().

Apoi avem o comandă care ne permite să eliminăm o valoare concretă din interior
de una lista:

Ș terge un element indicând poziț ia: del.

Aceasta este diferită de metoda .pop(), care returnează o valoare. Instrucț iunea de
de asemenea, poate fi folosit pentru a elimina secț iuni dintr-o listă sau pentru a goli lista complet.

a = [‐1, 1, 66.25, 333, 333, 1234.5]

del a[0]

# Resultado: [1, 66.25, 333, 333, 1234.5]

ș terge a[2:4]

# Resultado: [1, 66.25, 1234.5]

del a[:]

# Rezultat: []

13
STRUCTURI DE DATE ÎN PYTHON

delpoate fi folosit ș i pentru a elimina variabile din

o listă.
de la.

Nu era nicio glumă când îț i povesteam despre beneficiile listelor ș i ale acestora
versatilitate, nu crezi? Hai să vedem un exemplu pentru fiecare metodă din lista care
tocmai ai citit pentru a rămâne ș i mai bine cu funcț ionarea sa.

lista_1 = ['a', 'b', 'c']

adăugaț i un element la sfârș itul listei

lista_1.append('d')

print(lista_1)

# Resultado: ['a', 'b', 'c', 'd']

extrage ultimul element din listă

ultimo_valor = lista_1.pop()

print(ultimo_valor)

print(lista_1)

# Rezultatul: d

#['a', 'b', 'c']

inseraț i un element în faț a unei poziț ii concrete

insera 'e' în poziț ia zero (la început)

lista_1.insert(0, 'e')

# inserează 'c' în poziț ia 2

lista_1.inserare(2, 'c')

print(lista_1)

# Resultado: ['e', 'a', 'c', 'b', 'c']

14
 STRUCTURI DE DATE ÎN PYTHON

caută în ce poziț ie se află un element

(ș i dacă nu există, va da o eroare)

lista_1.index('b')

# Resultado: 3

a număra de câte ori apare un element

lista_1.numără('c')

ș terge primul element din listă

care corespunde valorului dat

lista_1.remove('c')

print(lista_1)

# Resultado: ['e', 'a', 'b', 'c']

# ordona valorile listei

(în funcț ie de tip:alfabetic, numeric...)

lista_1.sort()

print(lista_1)

# Resultado: ['a', 'b', 'c', 'e']

inversarea ordinii listei

lista_1.inversare()

print(lista_1)

# Resultado: ['e', 'c', 'b', 'a']

a ș terge un element indicând poziț ia

del lista_1[2]

print(lista_1)

# Resultado: ['e', 'c', 'a']

# curăț aț i toate elementele din listă

lista_1.clear()

print(lista_1)

# Resultado: []

15
STRUCTURI DE DATE ÎN PYTHON

Înainte de a continua, să profităm de ocazie pentru a explica un detaliu suplimentar despre

variabile, conț inutul acestora ș i ceea ce se întâmplă atunci când se fac asocieri în Python.

Imaginează-ț i următorul caz obiș nuit. Ai o variabilă (să spunem lista1) ș i

îi iniț ializezi cu niș te valori la întâmplare. Mai târziu, poate după ce faci mai multe
calculuri ș i operaț ii cu prima variabilă, trebuie să creezi o altă variabilă nouă
ble (să zicem lista2) ș i a o inicializa cu aceeaș i listă pe care o are prima în acel
moment. Aș a că îi atribui prima variabilă ultimei.

Creăm ș i iniț ializăm prima variabilă

lista1 = [1, 2, 3]

Facem operaț iunile noastre ...

# Ș i acum trebuie să creăm o nouă variabilă

e iniț ializa cu aceeaș i listă care are lista1

lista2 = lista1

print(lista2)

# Resultado: [1, 2, 3]

Obviamente, acum trebuie să aibă aceeaș i valoare

lista1 == lista2

Adevărat

Însă, după asignare, ambele variabile au aceeaș i valoare.

că, de fapt, nu numai că au aceeaș i valoare, ci ș i vizează aceeaș i
conț inut.

Ambas sunt două nume sau referinț e la aceeaș i informaț ie, la aceeaș i listă, ș i nu două
copiaț i distincte cu aceleaș i valori (îș i aminteș te cineva de pointere în C++?).

O variabilă în Python nu este altceva decât un nume sau o referinț ă la o valoare

o structură de date care este stocată într-un anumit mod în memorie. În
Python, în operaț ia de atribuire a unei variabile la alta nu copiază conț inutul,
ci doar define un nou nume sau o referinț ă la acelaș i conț inut pe care-l va-
variabilă originală.

16
 STRUCTURI DE DATE ÎN PYTHON

Putem vedea că două variabile reprezintă acelaș i lucru

mo obiect cu operatoruleste.

Ș i ce implică asta? Gândeș te-te... Dacă modificăm un element în a doua va-

variabilă, ce se întâmplă cu prima? Deoarece ambele variabile nu sunt decât
nume sau referinț e pentru aceeaș i listă în memorie, prima variabilă mos-
va aduce ș i noua valoare.

Verificăm că cele două variabile

reprezintă acelaș i obiect

lista2 este lista1 # Adevărat

Adevărat

# Modificăm lista2

lista2[1] = 99

# Ș i vedem că lista1 ne returnează

# acelaș i conț inut modificat

print(lista1)

# Resultado: [1, 99, 3]

Cu toate acestea, dacă în loc să modifici valoarea elementelor din listă, asig
vom crea o listă diferită, vom defini un nou obiect sau structură de
date. Variabila folosită va numi acel nou obiect independent;
două variabile nu vor mai fi referinț e la acelaș i conț inut.

Ș i atribuim o nouă listă celei de-a doua variabile

lista2 = [7, 8, 9]

17
STRUCTURI DE DATE ÎN PYTHON

Dejan de a mai face referire la acelaș i conț inut

lista2 este lista1 # False

Chiar ș i atunci când folosim prima variabilă

în expresia pentru a defini a doua

lista2 = 2 * lista1 # Replicarea primei liste

Structurile de date la care fac referire sunt diferite

lista2 este lista1 # Fals

Când vine vorba de a lucra cu structuri de date mutabile (cum ar fi listele), trebuie-
este să ai totul în vedere pentru a evita modificarea accidentală a conț inutului
dă de o variabilă în manipularea unei a doua.

Dacă ai nevoie de o copie identică, dar independentă a unei liste, poț i folosi
métodocopy().

lista1 = [1, 2, 3]

# Cu .copy() creezi o nouă listă, o copie exactă a originalului,

dar independent de aceasta

lista2 = [Link]ă()

Valorile din liste sunt egale

lista2 == lista1 # Adevărat

Dar nu sunt acelaș i obiect!!

lista2 este lista1 # Fals

După cum vezi, ai la dispoziț ie o gamă largă de metode pentru a-ț i face viaț a
mai simplă ora de lucru cu listele. Vom trece la următoarea structură-
ra de date, care de asemenea îț i va plăcea, dar într-o altă formă.

18
 STRUCTURI DE DATE ÎN PYTHON

[Link]

Ultimele tupluri sunt un tip de date similar cu listele. Ca ele, ultimele tupluri sunt
formate dintr-o secvenț ă de elemente ordonate. Diferenț ele principale -
pales sunt două:

Din punct de vedere sintactic, se definesc folosind paranteze în

locul acoladelor (de aceea este uș or să te înș eli când le declari).

Din punct de vedere semantic, tuplele sunt imuabile.

Ce vrem să spunem prin imuabili? Ei bine, că odată ce ai creat o tu-

Odată ce a fost definită, nu mai poț i modifica valorile pe care le conț ine.

Hai să vedem un exemplu de tuplă pentru a înț elege mai bine această structură
de date.

#!/usr/bin/python

#‐*‐codare: utf‐8‐*‐

construim tuplurile punându-le elementele

# separaț i prin virgule între două paranteze

palos_baraja = ("bastos", "oros", "espadas", "copas")

valores_baraja = ('A', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'sota',

'caballo', 'rey')

as_de_copas = (valores_baraja[0], palos_baraja[3])

caballo_de_bastos = (valores_baraja[11], palos_baraja[0])

putem folosi tupluri ca elemente imbricate într-o altă tuplă

(as_de_copas, caballo_de_bastos)

print(mano)

# Resultado: (('A', 'copas'), ('caballo', 'bastos'))

print(mano[0])

# Resultado: ('A', 'copas')

19
STRUCTURI DE DATE ÎN PYTHON

print(mano[1])

# Resultado: ('caballo', 'bastos')

# putem folosi ș i liste ca elemente,

# orice obiect de fapt!

jugador = ("jugador_1", [as_de_copas, caballo_de_bastos])

print(jucător)

# Resultado: ('jugador_1', [('A', 'copas'), ('caballo', 'bastos')])

Dacă încerci să modifici tupla, vei obț ine o eroare.

ț ine-te de exemplul pe care îl ai chiar sus, adaugă-
gando această sentinț ă.
mano[0] = ('caballo', "bastos").

De fapt, Python ne permite să definim un tuple fără a folosi parantezele la

crea-o. Adică, punând pur ș i simplu elementele separate prin virgule.

Oricum, îț i recomandăm să foloseș ti întotdeauna parantezele. Pentru început,

pentru că astfel evidenț iezi că este un tuplu ș i înț elegi mai uș or codul tău. Ș i des-
pentru că atunci când foloseș ti tupluri anidate sau expresii mai complexe pentru
definirea elementelor, va trebui să incluzi obligatoriu parantezele.

Aș a că, de ce să facem distincț ii? Să simplificăm!

În plus, există două cazuri speciale de creare a tuplurilor: tupla goală ș i tupla
de un singur element. Tupletele goale se creează cu o pereche de paranteze
gol, fără niciun element în interior.

20
 STRUCTURI DE DATE ÎN PYTHON

Pentru a crea un tuplu cu un singur element, îl înconjurăm între paranteze, pe-

este necesar să adăugăm o virgulă chiar după element ș i înainte de închiderea lui
paranteze. Pare ciudat, dar deoarece parantezele servesc ș i pentru "encapsula-
lar" o o expresie (de exemplu, (3 * 4)), Python are nevoie de un indiciu pentru a distinge dacă
vrem să construim un tuplu cu o singură valoare sau nu.

# Creăm tupla goală cu o pereche de paranteze goale, fără

niciun

element

()

print(tupla_vacia)

# Rezultatul: ()

Creăm un tuplu cu un singur element

(1,)

print(tupla_un_elemento)

# Rezultatul: (1,)

În rezumat, există trei tipuri generale de tupluri:

tupla = ( ) # Instanț ă goală.

tupla = (1,2,3) # tupla omogenă.

tupla = ("hola", 20, [1, 2, 3]) # tupla heterogénea (varios tipos de datos).

Aș a cum vezi, în afară de particularitatea imuabilităț ii tuplelor, modul

a lucra cu această structură de date este similar cu listele.

21
STRUCTURI DE DATE ÎN PYTHON

1.1.3. ÎNAPOI CU STRINGURILE

Ș i îț i aminteș ti, când am prezentat sirurile de caractere într-o unitate

anterior, am văzut că puteam extrage un element folosind un index între coloană
chetes, ș i că puteam să selectăm ș i o "felie", sau să concatenăm ș iruri sau
replica o lanț de ori...

Ș tii unde vreau să ajung, nu-i aș a? Într-adevăr, ș irurile de caractere sunt

alt tip de secvenț ă în Python (aș a cum ț i-am spus atunci). Unele
secvenț e cu particularitatea că se compun doar din caractere de
text, ș i că, la momentul reprezentării lor, se foloseș te o notare mai compactă ș i
simplă pentru oameni, scriind pur ș i simplu textul între ghilimele.
În plus, sunt imutabile (ca tuplurile) ș i au adăugate o serie de funcț ii
funcț ii sau metode speciale doar pentru utilizarea cu ș iruri.

[Link] (DATASET)

Ai învăț at deja că în Python avem tipurile listă, tuplă ș i ș ir de caractere,

ș i că sunt tipuri secvenț iale, adică sunt colecț ii ordonate de elemente.

Bun, să lăsăm acum secvenț ele. În Python avem de asemenea tipuri com-
locuri de date care nu sunt ordonate. Adică, că elementele lor nu con-
servan ordinea în care sunt aș ezate.

Cel mai simplu tip compus neordonat este ansamblul (sau setul în)
Python). Un set este o colec ț ie neordonată de elemente, ș i unde
în plus, nu pot exista elemente repetate. O mulț ime poate fi modificabilă.
Putem elimina sau adăuga noi elemente, atâta timp cât nu sunt deja incluse
doi în ansamblu.

Utilitatea acestui tip vine tocmai atunci când avem nevoie să controlăm elemente
tos duplicate sau a ș ti dacă un element a fost deja inclus (aparț ine) unui con-
împreună, fără să ne pasă de poziț ie.

22
 STRUCTURI DE DATE ÎN PYTHON

Pentru a crea un set, scriem elementele între o pereche de acolade ș i sepa-

rados pentru comasare. Dacă dorim să creăm un set gol, vom folosi funcț ia
set(), ș i nu un parc de chei goale ({}) aș a cum ai putea crede. Un pic mai departe-
vă vom arăta că o pereche de chei goale creează un dicț ionar gol.

Hai să vedem un mic exemplu de campare, care cu siguranț ă îț i va lăsa lucrurile

mult mai clare cu seturile de date:

#!/usr/bin/python

#‐*‐coding: utf‐8‐*‐

Hai să controlăm ce obiecte

adăugăm în rucsacul nostru pentru o excursie.

Creăm un set gol

# (doar pentru a testa, pentru acest exemplu nu ne-ar fi necesar)

set()

'iniț ializăm' setul de date: includem mai multe obiecte

en_mochila = {"bocadillo", "agua", "linterna", "agua", "cuerda"}

# ș i dacă imprimăm valoarea dataset-ului, vom vedea că "apa"

# nu apare duplicată - ș tim că ducem apă

în rucsac

# Resultado: {'cuerda', 'linterna', 'bocadillo', 'agua'}

# notăm că băgăm un cuț it

en_ghiozdan.adaugă("cuț it")

print(en_mochila)

# Resultado: {'agua', 'cuchillo', 'bocadillo', 'cuerda', 'linterna'

}

# pentru a verifica dacă un element este în mulț ime

# folosim 'în'

sandwich

23
STRUCTURI DE DATE ÎN PYTHON

"cerillas" nu este în en_mochila # Adevărat

# de asemenea, putem elimina un element din ansamblu

en_rucsac.arunca("sfoară")

tipăreș te(en_mochila)

# Resultado: {'agua', 'cuchillo', 'bocadillo', 'linterna'}

În utilizarea dataset-ului, avem de asemenea operaț iunile obiș nuite.

între conjuntos: uniune, diferenț ă, intersecț ie, etc...

{1, 2, 3, 5, 8}

b = {1, 2, 4, 8, 16}

uniunea lui a ș i b

[Link](b)

{1, 2, 3, 4, 5, 8, 16}

# putem de asemenea să facem aș a: elemente care sunt în a sau în b

# Resultado: {1, 2, 3, 4, 5, 8, 16}

intersecț ia lui a ș i b

[Link](b)

{1, 2, 8}

# de asemenea, putem face astfel: elemente care sunt în a ș i în b

aș ib

{1, 2, 8}

# diferenț a între a ș i b

[Link]ț ă(b)

{3, 5}

24
 STRUCTURI DE DATE ÎN PYTHON

# putem face asta astfel: elemente care sunt în a dar nu

sunt în

a-b

{3, 5}

diferenta simetrică sau exclusivă între a ș i b

[Link]ț ă_simetrica(b)

{3, 4, 5, 16}

# putem face asta astfel: elemente care sunt exclusiv

bine în a sau bine în b (dar nu în ambele)

a^b

{3, 4, 5, 16}

{1, 2}

¿s este un subset al a?

s.este_submulț ime(a)

Adevărat

sau spus altfel: toate elementele din s sunt în a

s <= a

Adevărat

# Este un superconjunto de s?

[Link] superset de (s)

Adevărat

# sau...: include toate elementele care sunt în s

a >= s

Adevărat

25
STRUCTURI DE DATE ÎN PYTHON

După cum poț i observa, cantitatea de acț iuni pe care le putem realiza la dosar-
testele sunt brutale, ceea ce le poziț ionează ca o formă genială de a realiza sarcini
matematică cu seturi de date.

[Link] Ț IONARE

Un alt tip de date util inclus în Python în mod nativ este dicț ionarul. Los
dicț ionare se găsesc uneori în alte limbi precum „memorii asociate
tivas” sau “arreglos asociativi”. Spre deosebire de secvenț e, care sunt indexate
printr-un interval numeric, dicț ionarele sunt indexate cu chei, care pot-
orice tip de date inmutable; ș irurile ș i numerele pot fi întotdeauna
chei. Tuplurile pot fi folosite ca chei dacă conț in doar ș iruri,
numere sau tuple; dacă o tuplă conț ine orice obiect mutabil direct sau indirect
rectamente, nu poate fi folosit ca ș i cheie. Nu poț i folosi liste ca ș i chei,
deoarece listele pot fi modificate folosind atribuirea prin index, atribuirea
pe secț iune, sau metode precum append() ș i extend(). Rezumând, o cheie
trebuie să fie formată dintr-un element imuabil, nu se poate schimba o
vezi că a fost adăugat împreună cu valoarea sa în dicț ionar.

Cel mai bine este să ne gândim la un dicț ionar ca la un ansamblu neordonat de pă-
valoare, cu cerinț a ca cheile să fie unice (în cadrul
un dicț ionar în particular). Plasaț i o listă de perechi cheie: valoare separate
prin virgule între acolade adaugă perechi cheie:valoare iniț iale în dicț ionar; aceasta
de asemenea este modul în care dicț ionarele sunt prezentate în ieș ire. Pentru ac-
a ceda un valoare, folosim acoladele aș a cum am face într-o listă sau o
tupla, doar că în acest caz indicăm cheia ș i nu un indice de poziț ie.

Un set de chei fără conț inut creează un dicț ionar

gol{}.

26
 STRUCTURI DE DATE ÎN PYTHON

Operaț iile principale asupra unui dicț ionar sunt:

Salvează o valoare cu o cheie.

Extrage acel valorea dată cheia.

De asemenea, este posibil să ș tergi un pereche cheie:valoare din del. Dacă foloseș ti o cheie care deja

este utilizat pentru a salva o valoare, valoarea care era asociată cu această cheie a fost
pierde. Extrageț i o valoare folosind o cheie inexistentă ne va oferi un frumos
mesaj de eroare, cum este logic.

Vom vedea mai uș or cu câteva exemple simple:

extension = {'juan': 4098, 'pedro': 4139}

extension['guido'] = 4127

print(extension)

# Resultado: {'pedro': 4139, 'juan': 4098, 'guido': 4127}

extensie['juan']

# Resultado: 4098

del extension['pedro']

extension['ivan'] = 4127

printaț i(extensie)

# Resultado: {'juan': 4098, 'ivan': 4127, 'guido': 4127}

printează([Link]())

# Resultado: dict_keys(['juan', 'guido', 'ivan'])

print('guido' în extensie)

Adevărat

27
STRUCTURI DE DATE ÎN PYTHON

Metoda keys() a unui dicț ionar returnează o listă cu toate cheile din
folosirea acestui dicț ionar, dar într-o ordine arbitrară (dacă vrei să fie ordonat, sim-
implementează usa metoda sort() asupra lista de chei). Pentru a verifica dacă o
cheia se află în dicț ionar, foloseș te cuvântul cheie.

Avem diferite moduri de a itera un dic ț ionar. Putem itera asupra

cheile dicț ionarului într-un mod direct. De asemenea, putem itera prin perechile de-
jas (cheie, valoare).

Putem itera direct asupra cheilor unui dicț ionar

libreta_telefonos = {'Carlos': 5556033, 'Javier': 5556051,

'Daniel': 5556056}

pentru nume în libreta_telefonos:

print(nombre, "=", libreta_telefonos[nombre]) # Rezultatul:

5556033

5556051

5556056

# Putem itera prin perechile cheie, valoare

pentru nume, telefon în liberia_telefonos.items():

print(nombre, "=") telefo = telefonul # Rezultatul:

5556033

5556051

5556056

# Ș i dacă ceea ce vrem este să iterăm doar valorile,

putem să o facem aș a

pentru telefon în libreta_telefonos.values():

print(telefon) # Rezultatul:

5556033

5556051

5556056

28
 STRUCTURI DE DATE ÎN PYTHON

Constructorul dict() creează un dicț ionar direct din liste de perechi

cleva‐valorguardados comotuplas. Când perechile urmează un model, se
poate specifica în mod compact lista de perechi cheie:valoare prin înț elegere
sesiune.

dict([('pedro', 4139), ('guido', 4127), ('juan', 4098)])

# Salida: {'pedro': 4139, 'juan': 4098, 'guido': 4127}

dict([(x, x**2) for x in (2, 4, 6)])

# Salida: {2: 4, 4: 16, 6: 36}

Poț i continua să cercetezi pe contul tău mai multe utilizări ale dicț ionarelor, cum ar fi
magazin de informaț ii, de exemplu… Îț i amintesc de semantica limbii-
ce este JSON?

[Link] Ț II PENTRU COMPRENDURE

Acum că am văzut principalele tipuri de date compuse pe care le oferă

Python în formă nativă, vom să-ț i prezentăm un tip de expresii foarte utile
y puternice pentru a crea ș i a lucra cu aceste structuri de date.

Definiț iile prin înț elegere sunt o formă foarte concisă ș i simplă de gene-
culege colecț ii de date în mod automat. Se utilizează în principal cu liste,
dar sunt aplicabile tuturor tipurilor de compuș i, făcând ajustările necesare.

În engleză apar de obicei sub formă de list comprehensions, iar în spaniolă unele
autorii denumesc aceste expresii liste prin în ț elegere sau, de asemenea,
înț elegerea listelor. Toate fac referire la acelaș i concept.

Definiț iile prin înț elegere sunt expresii care permit construirea unei
noua colecț ie definind-o pe baza unei alte colecț ii de start, o expre-
sesiunea generatoare a noilor elemente de inclus ș i un predicat sau condiț ie.

29
STRUCTURI DE DATE ÎN PYTHON

Scris aș a, poate părea complex, dar vei vedea că este foarte simplu. Lo
cel mai bine va fi să începem cu un caz de exemplu. Imaginează-ț i că vrem să salvăm
en una lista la tabla de multiplicar del 7. Una forma de hacerlo con lo que has
învăț at până acum ar fi printr-o buclă.

Pregătim o listă goală pentru a pune rezultatele

tabla_del_7 = []

Iterăm numerele de la 0 la 9

pentru x în interval(0, 10):

# adăugăm la listă următoarea valoare

# de la tabla de multiplicar a 7

tabla_del_7.append(7 * x)

print(tabela_de_7)

# Resultado: [0, 7, 14, 21, 28, 35, 42, 49, 56, 63]

A trebuit să creăm o variabilă cu o listă goală la început, ș i apoi

utilizaț i un bucle for pentru a itera prin valorile de la 0 la 9 ș i a modifica în fiecare
îț i dau lista, pentru a adăuga fiecare valoare din tabela de înmulț ire.

Nu este un cod foarte complicat sau lung. Dar Python ne permite

a face asta mai simplu ș i mai scurt.

tabla_del_7 = [ 7 * x for x in range(0, 10) ]

print(tabla_del_7)

Ș i ob ț inem acela ș i rezultat... nu-i grozav? Să continuăm pu ț in.

mai mult...

30
 STRUCTURI DE DATE ÎN PYTHON

Domeniul valorilor de intrare poate fi orice obiect sau expresie iterabilă.

lista_frutas = ["pera", "manzana", "ciruela", "cereza"]

[[Link]() for fruta in lista_frutas if [Link]("c")]

# Resultado: ['CIRUELA', 'CEREZA']

De asemenea, putem combina două sau mai multe clauze pentru domeniile lor de în-
trada pentru a construi colecț ia.

[ x * y pentru x în (1, 2, 3) pentru y în (4, 5, 6) ]

# Resultado: [4, 5, 6, 8, 10, 12, 12, 15, 18]

Această expresie este evaluată pentru toate combinaț iile de valori ale lui x ș i y. Dacă o
crezi, este ca ș i cum ai avea două bucle for închise. Să includem în fiecare
elementul generat valorile dexey, astfel va fi mai clar.

[ (x, y, x * y) pentru x în (1, 2, 3) pentru y în (4, 5, 6) ]

Rezultat

[(1, 4, 4),

(1, 5, 5)

(1, 6, 6)

(2, 4, 8)

(2, 5, 10)

(2, 6, 12)

(3, 4, 12)

(3, 5, 15)

(3, 6, 18)]

31
STRUCTURI DE DATE ÎN PYTHON

În acest caz, am făcut ca expresia generator să returneze un tuplu cu

valorile dex, yy dex * y. Se poate folosi orice expresie, tot ce
complexă de care este nevoie, atâta timp cât returnează un element valid.

Si în loc să generăm o listă dorim să construim un set, doar

trebuie să înlocuim parantezele cu acolade.

{ x pentru x în intervalul(10) dacă x % 2 != 0 }

# Resultado: {1, 3, 5, 7, 9}

Dacă dorim un tuplu, nu va fi suficient să folosim paranteze. Va trebui

ce să foloseș ti constructorul tuple()

tupă ( x pentru x în intervalul (5) )

(0, 1, 2, 3, 4)

Ș i pentru a construi un dicț ionar folosind mecanismul de înț elegere, ade-

mai degrabă să folosească cheile în locul acoladelor, expresia generatorului de-
berá va avea forma cheie:valoare

aici cheia este factorul de multiplicare,

ș i valoarea este rezultatul înmulț irii

dict_tabla_7 = { num : 7 * num for num in range(0, 10) }

print(dict_tabla_7[3])

# Resultado: 21

32
 STRUCTURI DE DATE ÎN PYTHON

Ca provocare, îț i propunem să încerci toate exemplele

plos pe care îi vezi în fiecare unitate ș i testează-i în interpretul tău

preț de Python pentru a vedea rezultatul. Unele deja le

ai pe campus pentru a-i putea descărca în
apartat „Exemple ale unităț ii”. Altele va trebui să
copiază-i ș i încearcă-i tu singur. Vezi codul altora
este o modalitate bună de a învăț a ș i a înț elege
explicând funcț ionarea unui limbaj.

[Link]

Cu câteva paragrafe mai sus, tocmai am văzut că, dacă vrem să creăm un...
pladefinita prin înț elegere nu este suficient să înlocuiț i parantezele cu paranteze rotunde
tesis, trebuie să folosim constructortuple().

Bun, ș i ce obț inem atunci dacă folosim doar parantezele? În

în acest caz, în loc să returneze imediat o secvenț ă completă cu
toate valorile, Python ne returnează un tip special de obiect pe care îl denumim-
namosgenerador.

Să spunem că un generator este un obiect care se ocupă de efectuarea calculilor.

pentru a genera valorile rezultate unul câte unul, pe măsură ce avem nevoie de ele ș i
să cerem, iterând prin colecț ia de intrare, în loc să construim
secvenț a întreagă dintr-o dată.

Utilitatea acestui mecanism este că astfel se economiseș te spaț iu de memorie (nu

trebuie să stocăm toate rezultatele) ș i se dovedeș te a fi mai eficient în cazurile de-
sos în care nu avem nevoie de secvenț a rezultatului complet dintr-o dată, din cauza
exemplu, dacă dorim să iterăm valorile într-o buclă.

Construim un generator pentru tabelul înmulț irii cu 7

( 7 * x pentru x în intervalul(0, 10) )

# ș i încercăm să imprimăm conț inutul lui 'gen_tabla_7'...

print(gen_tabla_7)

33
STRUCTURI DE DATE ÎN PYTHON

# nu vom vedea o secvenț ă, ci un mesaj

# indicând că este un obiect de tip 'generator'

<generator object <genexpr> at 0x7f9d9438dca8>

haideț i să-l folosim într-o buclă

pentru v în gen_tabla_7:

print(v)

generatorul va returna o nouă valoare

de fiecare dată când i se cere

până când epuizează toate valorile domeniului său de intrare

# Iesirea ar fi următoarea:

14

21

28

35

42

49

56

63

34
 STRUCTURI DE DATE ÎN PYTHON

Ș i dacă avem un generator ș i vrem să extragem valorile sale într-o listă, putem
utilizaț i constructorul list.

ș i dacă avem un generator

(3 * x pentru x în intervalul(0, 10))

# ș i dorim să transferăm toate elementele sale într-o listă, folosim 'list'

lista_tabla_3

print(lista_tabla_3)

# Resultado: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

Observă că, dacă încerci să foloseș ti din nou generatorul după ce ai iterat
toate elementele sale (într-un bucle sau când le extragi într-o listă), nu vei obț ine nimic
da, exceptând posibilitatea unei erori. Generatorul a rămas gol, este epuizat-
nu mai are valori de returnat. L-am "ars".

alte_lista_tabel_3

obț ii o listă goală []

print(otra_lista_tabla_3)

# Resultado: []

Profitaț i de tot ce vă oferă generatoarele pentru a vă extinde abilităț ile.

programator de Python.

35
 STRUCTURI DE DATE ÎN PYTHON

CE AI ÎNVĂȚ AT?

Am văzut pe parcursul unităț ii că există 3 structuri de date importante

tante, fără a conta ansamblurile (datasets) ș i ș irurile de caractere (strings):

Tuples.

Liste.

Dicț ionare.

Fiecare dintre aceste structuri are caracteristici proprii. De exemplu,

ultimele liste sunt imutabile, listele pot fi modificate cu propriile lor modificări
toț i dicț ionarele dispun de o structură cheie:valoare care ne oferă
sunt multe posibilităț i.

Ceea ce este comun pentru toate este că putem selecta elemente independente.
dinti de fiecare dintre ele pentru a lucra. Este flexibilitatea lor atunci când este vorba de a trata
date care conț in ceea ce conferă versatilitate acestor structuri.

Exersează cu exerciț iile pe care ț i le propunem ș i cu exemplele unităț ii pentru

a înț elege perfect funcț ionarea sa.

37
 STRUCTURI DE DATE ÎN PYTHON

BIBLIOGRAFIE

Incedere în Big Data cu Python. MasterD.

39