Introducere in Programare Cu Python

#InvataProgramare - Introducere in Programare cu Python
___________________________________________________________________
Introducere in Programare cu
Python
_____________________________________________________________________
2
___________________________________________________________________
© Copyright 2021 Ramon Nastase – Toate drepturile rezervate.
Continutul acestei carti nu poate fi reprodus, duplicat sau transmis fara permisiunea
directa, scrisa din partea autorului. In nici un caz nu va fi suportata raspunderea juridica
sau vina de catre editor pentru orice reparare, dauna sau pierderi financiare datorate
informatiilor din aceasta carte, direct sau indirect.
Aviz juridic
Aceasta carte este protejată prin drepturi de autor. Acest lucru este numai pentru uz
personal. Nu puteti modifica, distribui, vinde, utiliza, cita sau parafraza orice parte sau
continutul acestei carti fara consimtamantul autorului.
Notificare privind renuntarea la raspundere
Retineti ca informatiile continute in acest document sunt numai pentru scopuri

educationale si divertisment. Au fost facute toate incercarile de a furniza informații
exacte, actualizate si fiabile. Nu sunt exprimate sau implicate garantii de niciun fel.
Cititorii recunosc ca autorul nu se angajeaza in furnizarea de consultanta juridica,
financiara, medicala sau profesionala. Continutul acestei carti a fost derivat din diverse
surse.
Prin citirea acestui document, cititorul este de acord ca in nici un caz autorul nu este
responsabil pentru orice pierderi, directe sau indirecte, care apar ca urmare a utilizarii
informatiilor continute in acest document, inclusiv, dar fara a se limita la omisiuni sau
inexactitati.
_____________________________________________________________________
3
___________________________________________________________________
Cuprins
Introducere 12
Cateva cuvinte despre Ramon Nastase, autorul cartii 12

Cateva cuvinte despre Gabriel Grecu, contribuitor al cartii 13
Ce vei obtine de la aceasta carte 13
Cum sa parcurgi aceasta carte 14
Cum sa abordezi partea practica 14
Capitolul 0 - Despre IT si Programare 17
De ce sa inveti programare? 17
Ce oportunitati de angajare ai ca programator? 17
Ce salarii sunt in IT? 18
Cine castiga cele mai mari salarii din IT? 21
“Ce limbaje de programare poti sa inveti pentru a deveni programator?” 22
De ce sa incepi cu programarea in Python? 24
Ce poti face cu limbajul Python? 24
Cum sa aprofundezi programarea folosindu-te de Google? 27
Capitolul 1 - Introducere in Python 29
Cum incepi sa programezi in Python? 29

I. Folosirea unui IDE Online - Repl.it 29
II. Folosirea unei aplicatii IDE - PyCharm 33
III. Folosirea unui interpretor din Windows 44
IV. Folosirea unui interpretor din Linux sau macOS 46
Codul scris in Python vs. alte limbaje de programare 51
Exercitii 53
_____________________________________________________________________
4
___________________________________________________________________
Capitolul 2 - Variabile in Python 55
Variabile de tip numere (intregi, reale) 55

Operatori in Programare 58
Variabile de tip String (siruri de caractere) in Python 61
Comentarea codului in Python 68
Citirea datelor de la tastatura in Python 69
Capitolul 3 - Instructiuni conditionale (if, for, while) 72
1) Instructiunea if 72
2) Instructiunea for 78
3) Instructiunea while 82
Exercitii 84
Capitolul 4 - Functii in Python 86
Ce este o Functie? 86
1) Functii care nu intorc un rezultat 87
2) Functii care intorc un rezultat 89
3) Functii recursive 93
4) Functia main() 95
Exercitii 97
Capitolul 5 - Structuri de Date in Python 98
Ce sunt structurile de date? 98

1) Liste 100
2) Tupluri (Tuples) 105
3) Multumi (Set) in Python 109
4) Dictionare 114
_____________________________________________________________________
5
___________________________________________________________________
Capitolul 6 - Programare Orientata pe Obiecte in Python 124
1) Concepte teoretice despre POO 124

2) Clase in Python 128
3) Constructori si Destructori 131
4) Encapsularea elementelor dintr-o clasa in Python 135
5) Mostenirea (Inheritance) unei clase in Python 142
Capitolul 7 - Exceptii si Operatii cu Fisiere in Python 149
I. Exceptii in Python 149

II. Operatii cu Fisiere in Python 158
Chapter 8 - Module in Python 167
Ce sunt modulele si de ce le folosim 167

Exemple de module folosite cu Python 167
a) Modulul “random” (have fun with random numbers) 167
b) Modulul “pillow” pentru procesarea de imagini 171
c) Folosire modul sys & argumentele unui program in Python 175
d) Alte exemple de folosire a modulelor in Python 178
Trimiterea unui mail cu Python 178
Descarcarea unei pagini web cu Python - urllib2 180
Folosirea unor module precum turtle sau calendar 180
Capitolul 9 - Versionarea codului cu Git si GitHub 184
Ce este Git si GitHub? 184

Cum folosim Git pentru versionarea codului? 185
Cum urcam codul pe GitHub? 186
_____________________________________________________________________
6
___________________________________________________________________
Introducere
In primul rand vreau sa te felicit si sa iti multumesc pentru faptul ca ai luat decizia de a
investi in tine si de a deveni mai bun. Vreau sa iti spun ca acest ghid te va lua de la 0 (in
domeniul programarii in Python) si te va duce la un nivel de baza astfel incat sa fii
constient de modul in care functioneaza programarea si mai ales modul in care poti crea
aceste programe.
Am conceput aceasta carte pentru a te ajuta sa inveti programare. Merita sa-i acorzi
timpul necesar? Daca tinem cont de noile abilitati pe care le vei avea pe termen lung si
de cresterea stimei de sine, atunci acesta unul dintre eforturile pe care merita sa le faci.
Cateva cuvinte despre Ramon Nastase, autorul cartii
Ma consider a fi un IT-ist Optimist, pasionat de Educatie. Cred in tehnologie, cred in

educatie si in puterea lor de a ne oferi Libertatea, Progresul si Bucuria de a face lucrurile
in fiecare zi, de care fiecare dintre noi avem nevoie.
Acesta este motivul pentru care eu am ales sa dau o forma simpla si clara, cunostintelor
pe care le-am obtinut in ultimii 10 ani si sa le pun intr-un format care sa-i ajute pe cei care
doresc o cariera in IT, sa inceapa si sa reuseasca.
Sunt trainer, autor si co-fondatorul platformei educationale TeachBit care se axeaza pe

formarea si training-ul persoanelor care vor sa-si inceapa o cariera in domeniul IT &
Digital. Imi place sa fac IT-ul pe intelesul tuturor.
Am fost trainer in corporatie si cunosc cat de important e sa se explice conceptele

complicate intr-un mod cat mai simplu si clar. In ultimii 10 ani de cand fac IT am avut
ocazia sa:
- am instruit personal peste 300 de persoane
- sustinut peste 1.000 de ore de training
- instruiesc peste 5.000 de cursanti online
- particip si sa vorbesc la zeci de conferinte in domeniu
- dezvolt o comunitate online de peste 100.000 de oameni
_____________________________________________________________________
7
___________________________________________________________________
Tot in aceasta perioada mi-am focusat atentia in a obtine cateva certificari de renume din
domeniu: Cisco CCNP, CCNA R&S, CCNA Voice, CCNA Security, CompTIA Security+,
Linux LPIC-102
Cateva cuvinte despre Gabriel Grecu, contribuitor al cartii

Salutare! Gabriel aici, pasionat despre stiinta, despre modul in care lucrurile sunt facute si
cum ele functioneaza, cu o gandire analitica si algoritmica cu scopul de a dezvolta, aplica
si evolua prin intermediul tehnologiei. Ma poti gasi pe LinkedIn aici.
Ne propunem ca acest material sa te ajute in a dobandi cunostintele de start in lumea

programarii (cu Python), astfel incat sa ajungi sa realizezi ceea ce ti-ai propus. Mult
succes iti dorim!
Ce vei obtine de la aceasta carte
Odata ce vei parcurge aceasta carte, vei putea sa intelegi elementele de baza si cele
medii care tin de programarea in Python. Practic vei fi capabil sa-ti creezi propriile
programe si vei fi pregatit sa incepi sa aprofundezi conceptele de programare. Dupa
terminarea cartii iti recomand sa te apuci de rezolvarea problemelor, cu scopul de a te
ajuta pe tine sa devii un programator si mai bun astfel incat sa obtii oricand doresti un job
in IT (in tara sau in strainatate). Hai sa-ti arat cateva dintre lucrurile pe care le vei invata
aici:
• Cum arata domeniul IT si care sunt trendurile

• Ce poti sa faci cu Python
• Cum sa incepi programarea in Python in doar 10 de minute (instalare si crearea
primului program)
• Elemente de sintaxa si programare in Python
• Folosirea instructiunilor conditionale (if, for, while, switch)
• Concepte fundamentale despre POO
• Lucrul cu fisiere si cu exceptii in Python
• Structuri de date folosite pentru crearea diferitilor algoritmi
• Si multe altele :)
_____________________________________________________________________
8
___________________________________________________________________
Un lucru pe care vreau sa-l stii este: daca acum incepi pentru prima oara in IT, aceasta
carte este un start destul de bun, oferindu-ti tot ce ai nevoie cand vine vorba de
elementele de baza.
Cum sa parcurgi aceasta carte
Aceasta carte este structurata pe 9 capitole cu teorie si cu exemple care cuprind diferite
teme, apartinand conceptelor de baza din Programare in Python. La finalul fiecarui capitol
gasesti un set de exercitii care au scopul de a sprijini abilitatile tale de a scrie cod.
Ca sa ramai cu toate informatiile care tin de programare, iti recomand sa parcurgi
capitolele pe rand, fara sa sari peste punctele care iti par cunoscute. Spun asta pentru ca
am intalnit persoane care intai citeau intreaga carte, iar abia apoi treceau la exercitii. Nu
spun ca ar fi o abordare gresita, insa te sfatuiesc sa parcurgi un capitol. Atunci cand
intalnesti exemple sau exerciitii, le practici si tu la tine pe PC. Scriind linie cu linie codul
de la un exemplu din aceasta carte, vei intelege cat de importanta este atentia la detaliu.
Iti propun sa nu treci mai departe pana nu ai inteles complet acel cod si pana nu-l stii
scrie si tu fara ajutor. (Atentie, daca doresti sa faci Copy-Paste din carte la cod si doresti
sa ii dai direct Run, sunt mari sanse sa nu functioneze. Am facut asta intentionat spentru
a incuraja sa scrii codul intreg chiar tu.) Stiu ca vor fi cateva momente in care va trebui sa
depui efort in a intelege un concept, de aceea te incurajez ca atunci cand te blochezi, sa
folosesti Google Search si sa insisti pe gasirea unei solutii. Stiu ca la scoala nu se
incuraja asta, insa aici suntem niste oameni maturi din viata reala si avem nevoie de
informatii si de sfaturi folositoare.
Cum sa abordezi partea practica
Ti-am explicat deja cum sa treci prin exemplele care vor aparea dupa explicarea unui
concept din teorie. Acum hai sa vedem cum sa abordezi partea practica in care tu trebuie
sa vii 100% cu rezolvarea: exercitiile de la finalul capitolelor si trei proiecte mari. Le-am
ales pentru a te ajuta sa iti exersezi noile cunostinte dupa parcurgerea activa a unui
capitol. Ele sunt un punct de plecare prin care iti poti masura progresul pe masura ce
parcurgi aceasta carte. Unele dintre ele posibil sa fie putin mai grele fata de ce
asteptarile initiale, tocmai pentru a-ti demonstra ca ai o logica pe care o poti dezvolta, ca
poti evolua si ca ai inteles cele explicate anterior in capitolul curent.
_____________________________________________________________________
9
___________________________________________________________________
Ce urmeaza
Dupa ce ai terminat aceasta carte, te sfatuiesc sa revii la primul capitol si sa iti alegi o arie
pe care vrei sa excelezi. Pe masura ce evoluezi, fii pregatit mereu de un nou upgrade a
cunosctintelor tale pentru ca IT-ul este un domeniu in continua evolutie. Tot ce ai tu de
facut este sa urmezi pas cu pas informatiile si sfaturile si sa depui efortul necesar pentru
a ajunge acolo unde iti doresti.
Iti doresc mult succes si spor la treaba!
Ramon, cel care te sustine in procesul tau de crestere.
PS: Daca ai intrebari nu ezita sa ma contactezi pe email, Facebook sau YouTube.
_____________________________________________________________________
10
___________________________________________________________________
Capitolul 0 - Despre IT si Programare
De ce sa inveti programare?
Probabil, aceasta intrebare are deja un raspuns in mintea ta. Fie ca motivul pentru care iti
doresti sa inveti programare este un salariu mai bun sau cunostinte noi pe care vrei sa le
dobandesti, iti apreciez initiativa. Vreau sa iti doresc mult succes si multa rabdare, pentru
ca drumul spre devenirea unui programator bun va fi greu, dar nu imposibil. Iti zic aceste
lucruri pentru ca vreau sa fii constient de la inceput ca vei avea anumite obstacole pe
care va trebui sa le depasesti. In acest sens vreau sa stii ca voi incerca sa fac tot ce imi
sta in putinta ca sa te ajut sa-ti implinesti visul de a avea o cariera de succes in IT. La
momentul actual, programarea este unul dintre domenii de activitate cu cea mai rapida
rata de dezvoltare. Pentru anul 2011, de exemplu, in Romania activau 9,823 de companii
de IT, iar la finele anului 2017 au fost inregistrate peste 17.000 de companii.
Privind din perspectiva start-up-urilor, numarul acestora s-a dublat. De la 1.806 de
start-up-uri pentru anul 2011, la 3.795 pentru anul 2016. Fie ca iti doresti o cariera intr-o
companie multinationala de IT sau start-up, piata din Romania este in continua crestere,
iar posibilitatile in domeniul IT sunt nelimitate. Si nici posibilitatea de a lucra in calitate de
freelancer nu trebuie exclusa. In mediul online gasesti o multime de site-uri ce fac
conexiunea intre cererea de munca (adica proiectele) cu oferta si potentialul de munca a
freelancerilor.
Ce oportunitati de angajare ai ca programator?
Dupa cum am mentionat si mai sus, totul depinde de ceea ce iti doresti. Fie ca visezi la
un job cu program fix sau la un program flexibil de munca din interiorul unei cafenele,
oportunitatile sunt nenumarate. Ca sa te fac sa intelegi mai bine despre ce vorbesc, hai
sa intram in detalii cu fiecare dintre cele trei optiuni de a-ti exercita activitatea de IT-st.
O sa incepem cu multinationalele. O companie multinationala, de regula, este inregistrata
in mai multe tari fiind structurata in filiale localizate pe mai multe teritorii nationale sau
chiar la nivel global. In continuare iti prezint top-ul multinationalelor in domeniul IT din
Romania:
_____________________________________________________________________
11
___________________________________________________________________
1. Adobe - Specializarea: Servicii Software, Web Development. Localitate: Bucuresti.

2. Endava - Specializare: Servicii IT. Localitate: Bucuresti, Iasi, Cluj-Napoca, Pitesti.
3. Luxoft - Specializare: Servicii IT. Localitate: Bucuresti.
4. Atos - Specializare: Servicii IT. Localitate: Bucuresti, Iasi, Timisoara, Brasov.
5. Microsoft - Specializare: Software. Localitate: Bucuresti, Cluj-Napoca, Brasov,
Timisoara.
6. Fortech - Specializare: Servicii IT. Localitate: Cluj-Napoca.
7. Ubisoft - Specializare: Gaming. Localitate: Bucuresti.
8. Deutsche Bank - Servicii IT (banking). Localitate: Bucuresti.
9. Ixia - Specializare: Computer & Wireless Networking. Localitate: Bucuresti.
10. 1&1 - Specializare: Servicii Web. Localitate: Bucuresti.
11. eMag - Specializare: E-commerce. Localitate: Bucuresti, Craiova, Iasi.
12. Avira - Specializare: Securitate IT, Localitate: Bucuresti.
13. Intel - Specializare: Servicii Software. Localitate: Bucuresti, galati, Cluj-Napoca.
14. EBS - Specializare: Servicii IT. Localizare: Cluj-Napoca.
15. Oracle - Specializare: Servicii Software. Localizare: Bucuresti.
16. Cegeka - Specializare: Servicii Software. Localizare: Bucuresti.
17. Continental - Specializare: Servicii Software. Localizare: Timisoara, Sibiu, Iasi.
18. Bosch: Specializare: Servicii Software. Localizare: Timisoara, Cluj-Napoca.
19. SAP - Specializare: Servicii Software. Localizare: Bucuresti, Cluj-Napoca,
Timisoara.
20. Zitec - Specializare: Aplicatii Online. Localizare: Bucuresti.
Daca privim din perspectiva start-up-urilor, in Romania, exista o multitudine de centre

pentru dezvoltare. Ca sa facem lucrurile clare de la inceput, vreau clarificam ce inseamna
conceptul de start-up. Cu toate ca exista o multime de definitii, atat tehnice, cat si
abstracte ale conceptului de start-up, nu exista o definitie unanima si complet acceptata.
Termenul de start-up a luat amploare abia in ultimii ani, cu toate ca este o forma de
afacere ce exista de mai multe decenii.
Ce salarii sunt in IT?
Fiind intr-o crestere continua, piata de IT din Romania inregistreaza peste 100.000 de
angajati pentru anul 2018, de 4 ori mai mult in comparatie cu anul 2008. Salariul de
pornire pentru un programator junior intr-o companie mare este circa 3.000 RON/luna.
Un programator senior poate avea intre 9.000 - 13.000 RON/luna, designerii intre 4.000
_____________________________________________________________________
12
___________________________________________________________________
si 9.000 RON/luna, iar programatorii arhitecti pot castiga intre 13.000 - 20.000 RON/luna.
In general cand vine vorba de domeniul IT din Romania salariile se impart pe 3 categorii
de nivele profesionale:
1) Junior
2) Middle
3) Senior
Daca vrei sa devii un specialist in domeniul IT, un aspect important care iti recomand sa-l
ai in vedere este ca in IT se fac bani multi, dar acesti bani se afla in a 3-a categorie. Cand
zic “bani multi” ma refer la un salariu de peste 10.000 RON / luna (adica peste 2000
EURO). Odata ce atingi acest nivel salarial poti spune ca ai un trai foarte bun, unul mult
peste medie si poti incepe sa-ti folosesti banii pentru a trai viata care ti-o doresti. Avand
in vedere cele 3 categorii (de experienta din domeniul IT), iata cam cat poti castiga
pentru fiecare nivel in parte:
1) Junior – salariu de 2500 – 4000 RON pe luna cu o experienta de 0 – 2 ani

2) Middle – salariu de 5000 – 8000 RON pe luna cu o experienta de 3 – 5 ani
3) Senior – salariu incepand de la 9000 RON pe luna cu o experienta de peste 6 ani
Acestea sunt doar anumite borne orientative, dar te asigur ca sunt oameni care castiga
un salariu cu mult peste 20.000 RON (in ROMANIA!) din domeniul IT. De ce? Pentru ca au
un nivel de expertiza si experienta foarte ridicat si aduc foarte multa valoare organizatiei.
Acum urmeaza sa iti descriu pe scurt care e procesul prin care trece in general o
persoana de lever Junior, atunci cand doreste sa se angajeze. Acesti pasi au un scop
orientativ, insa stiu ca e foarte probabil sa auzi anumite lucruri pentru prima data. O mare
parte dintre persoanele care imi scriu se afla in aceatsa categorie junior (cu experienta
mica, intre 0-2 ani). De aceea am decis ca le-ar fi folositor sa detaliez ma jos in cateva
punctele cheie pasii prin care vor trece in cazul in care opteaza sa se angajeze:
1. Aplicarea CV-ului - Primul pas este desigur sa iti depui CV-ul prin mediul online, la
targurile de job-uri sau chiar printr-o cunostinta care lucreaza deja acolo. Nu uita
sa te informezi despre firma cu care urmeaza sa iei contactul. Pregateste si o
scrisoare de intentie in care subliniezi de ce doresti sa te angajezi la ei, pe un ton
formal.
_____________________________________________________________________
13
___________________________________________________________________
2. Testul de logica - Daca esti selectat dupa criteriile folosite de firma, esti contactat
pentru un scurt interviu telefonic, urmat de anumite teste de logica la firma. Aici de
obicei se pune accentul pe modul de gandire al candidatului. Scopul acestor teste
este ca recruiterul sa observe daca ai o baza logica. Unii folosesc chiar anumite
jocuri de puzzle, betisoare de plastic sau obiecte de diferite forme care trebuie sa
fie aranjate dupa un anumit fel.
3. Testul de personalitate - Daca ai trecut de acestea (poate fi tot si in aceasi zi) are
loc un test de personalitate. In acest context cel care te evalueaza este atent la
soft-skill-urile pe care le ai. Unele dintre acestea pot fi: atentia la detaliu, rabdarea,
perseverenta in gasirea unei solutii, modul de reactie la o situatie descrisa. Pana in
acest punct nu se deschide subiectul despre salariul de programator.
4. Proba practica / tehnica - In penultima etapa are loc interviul tehnic, cel de
hard-skills. Aici esti testat in adevaratul sens al cuvantului: treci prin testele tehnice
(practice) de programare. Problemele primite la acest test au rolul de a verifica
daca esti pregatit in zona IT, pentru a ocupa viitorul tau post.
5. Aspectul financiar – viitorul tau salar! - Daca ai ajuns pana aici, esti chemat la
ultimul interviu de recrutare: cel in care are loc discutia despre salar si despre
beneficiile oferite. Tot aici poti deschide subiectul si despre asteptarile tale. De
exemplu poti intreba daca exista optiunea de home office (HO) de cateva ori pe
luna, poti afla cum te poti dezvolta mai departe in cadrul firmei si ce career-path
(traseu de cariera) poti urma pentru a ajunge pe un post superior.
Iata mai jos o lista cu salarii din domeniul IT pentru anul 2019:
I. http://www.cashit.ro/
II. https://www.paylab.ro/
_____________________________________________________________________
14
___________________________________________________________________
Cine castiga cele mai mari salarii din IT?
Acum probabil ca te gandesti ca oricine poate castiga un salariu de peste 10.000 RON, in
domeniul IT, dar din pacate nu este neaparat asa. Exista anumite job-uri cu specializari
care sunt platite mai mult, iar altele care sunt platite mai putin. Pe langa asta, companiile
mereu au nevoie de oameni care sunt la curent cu cele mai populare limbaje si cu
schimbarile care apar la acestea. Asta inseamna ca dupa ce esti acceptat la o firma de IT
si tii pasul cu cererea de pe rolul pe care il ocupi, ai si posibilitatea de a-ti dezvolta o
cariera spre beneficiul tau. De exemplu un software tester (o persoana care face testeaza
software-ul creat de catre echipa de developeri), indiferent de nivelul sau de experienta,
va avea un salariu mai mic fata de un software developer (o persoana care dezvolta activ
software pentru compania la care este angajat). De aceea, este foarte important sa
studiezi trendurile din domeniul IT, sa vezi ce tehnologii (si ce limbaje de programare)
sunt in top (sau urmeaza sa fie in urmatorii ani) si sa incepi sa le studiezi. Astfel ajungi sa
iti aprofundezi cunostintele si abilitatile in acea directie. Pe terment lung, vei avea
beneficii extrem de mari, crede-ma. Iata mai jos un tabel cu salariile din domeniul IT din
Bucuresti in functie de nivelul de experienta pentru mai multe posturi in parte. Daca
locuiesti in afara Bucurestiului, atunci salarile din IT pot varia cu 10 – 20% in functie de
zona in care te afli.
Figura 0.1
_____________________________________________________________________
15
___________________________________________________________________
“Ce limbaje de programare poti sa inveti pentru a deveni

programator?”
Primesc foarte des aceasta intrebare si consider ca si acum e un moment bun pentru a
raspunde la ea. Pe scurt raspunsul e … depinde. Depinde de ce iti doresti, depinde de ce
anume te pasioneaza atunci cand vine vorba de IT si depinde pe ce ramura vrei tu sa
dezvolti mai departe programe si aplicatii. Important de retinut este ca experienta nu
consta in numarul de limbaje cunoscute, ci mai de graba in cunostintele acumulate in
cadrul fiecarui limbaj de programare cunoscut, in parte.
O intrebare des intalnita inainte de inceperea parcurgerii unui limbaj este urmatoarea:
“Am nevoie de matematica in programare?”, raspunsul la aceasta intrebare este unul
impartit. O intrebare auxiliara care trebuie adresata este, “Ce vrei sa faci cu limbajul pe
care urmeaza sa il utilizezi?”. Daca vrei sa lucrezi ca Web Developer si va trebui sa
folosesti limbajele din aceasta speta, cel mai probabil nu, dar daca vei lucra pe post de
Machine Learning Expert, atunci probabil te vei lovi ceva mai mult de matematica. In
orice caz, important este sa nu te lasi descurajat de matematica. Un limbaj de
programare poate fi invatat si fara aceasta, iar rolul ei nu este esential, mai ales in primii
pasi. Pe langa toate acestea, nu exista un limbaj “nefolositor”. Fiecare limbaj are rolul sau
si este adaptat pentru un anumit set de nevoi si cerinte. Acum hai sa vedem ce limbaj de
programare poti sa inveti, in functie de ce iti doresti sa faci pe termen lung:
● C / C++ – Limbaje perfecte pentru proiecte low-level, des intalnite in

reprogramarea sistemului de operare si utilizate de placutele Arduino, pentru
diferite proiecte de automatizare si de robotica. C este un limbaj de programare
folosit in proiectele low-level, fiind orientat pe hardware. Este des intalnit in
reprogramarea sistemului de operare si utilizate de placutele Arduino (sunt niste
placute de dezvoltare bazate pe microcontrolere), pentru diferite proiecte de
automatizare / robotica. Avantajul este ca permite gestionarea memoriei la cel mai
mic nivel. Daca vrei sa lucrezi in game development sau in programarea
sistemelor (systems programming), C este limbajul recomandat. C este limbajul pe
care se bazeaza alte zeci de limbaje, fiind folosit in crearea acestora. Chiar si Java,
Javascript si multe altele se afla printre ele. Poate ai auzit deja ca limbajul C este
un limbaj procedural, versatil si flexibil, mai simplu spus programatorul are prin el
control maxim prin comenzi simple. Totusi, daca esti la inceput, o sa ai de lucru
daca doresti ca primul tau limbaj invatat sa fie C.
_____________________________________________________________________
16
___________________________________________________________________
● HTML + CSS + JavaScript – Un combo excelent pentru realizarea de pagini web

statice. Cel mai popular framework care include aceste limbaje de marcare este
Bootstrap, un framework dezvoltat de catre creatorii platformei Twitter. JavaScript
introduce un element de dinamica si varietate intr-o pagina web care (in momentul
incarcarii) este rulata direct de catre browser. Il poti folosi pentru a contrui site-uri
interactive, mai ales daca ti-ai propus sa intri pe web development. Ca sa fiu mai
precis, JavaScript e folosit de obicei pentru front-end development, fiind usor de
invatat de catre incepatori. Aceste cunostinte se imbina cu cele de HTML si CSS,
pentru un site functional si complet. Daca te-ai gandit ca ai invata JavaScript, am o
veste buna. Este usor de folosit, codul il poti schimba usor, rezultatele codului se
vad imediat, iar aici nu e necesar sa instalezi ceva in plus pe laptopul tau, ajunge
un web browser.
● PHP – Realizarea Backend-ului pentru o pagina web interactiva, limbaj intalnit si in

inlocuirea Shell Script-ului pe Linux. Doua dintre framework-urile populare pentru
acest limbaj sunt Laravel si Symfony, de asemenea PHP-ul este adesea folosit
impreauna cu SQL-ul, limbaj folosit in programarea bazelor de date.
● Java / C# / Swift – Limbaje destinate aplicatiilor mobile pentru Android, Microsoft

sau Apple. De exemplu Java este un limbaj de programare foarte cunoscut si des
utilizat, fiind un limbaj orientat pe obiecte. Daca ai auzit despre Android, atunci
trebuie sa stii ca acest sistem de operare este construit in Java. Astfel, aplicatiile
mobile si diferite programe (pentru continutul web) sunt create in Java. Mai exact,
aplicatiile enterprise, interfetele si platformele web pot fi construite folosind acest
limbaj de programare.
● Python, Perl, Ruby – Aceste trei limbaje, sunt catalogate ca limbaje de scripting,
deoarece sunt cel mai des intalnite in automatizari. Ultimul dintre acestea, Ruby,
poate fi folosit ca inlocuitor al PHP-ului, prin framework-ul Ruby on Rails, destinat
Web Developing-ului. Python - Acest limbaj de programare este catalogat ca fiind
un limbaj de scripting, deoarece este foarte des intalnit in automatizari. Asta
explica de ce este unul dintre cele mai cautate si cele mai utilizate limbaje de
programare, care inca este in trend ascendent. Cu Python mai poti programa
roboti, poate au auzit deja ca in ultima vreme e tot mai cunoscut, fiind folosit si in
inteligenta artificiala (AI). Il mai poti folosi pentru a construi platforme web, dar si
pentru a construi interfete grafice (GUI). Python este un limbaj usor de folosit si de
invatat, avand putine particularitati, iar flexibilitatea de a scrie codul cu el il face
extrem de popular.
_____________________________________________________________________
17
___________________________________________________________________
Cele de mai sus sunt cele mai populare din sutele de limbaje de programare existente.
Unele din aceste limbaje sunt compilate (C/C++/C#). La acestea este nevoie de un
compilator. Altele sunt interpretate (Python, PHP, Perl), unde sistemul citeste linie cu linie
cdul, pentru a pune in aplicare instructiunile. Cel mai important este sa iti alegi un limbaj
care se potriveste cu nevoile tale, apoi sa incepi sa il practici si sa il cunosti cat mai bine.
In cele ce urmeaza vom studia in detaliu limbajul Python si iti voi explica pas cu pas cum
sa-l setezi la tine pe laptop si cum sa te apuci in doar cateva minute de programare.
De ce sa incepi cu programarea in Python?
Avantajul limbajului Python este ca ea ofera foarte multa flexibilitate din partea
programatorului. In comparatie cu C++, care necesita multe linii de cod pentru a executa
o singura comanda, Python necesita o singura linie. De asemenea, programare in Python
se face la fel, indiferent de sistemul de operare (Windows, Linux). Toate acestea te ajuta
sa te axezi pe logica problemei, pe algoritmul construit de tine, scazand sansele de a
face greseli de sintaxa. Recomand ca acest limbaj sa fie printre primele limbaje de
programare pe care tu le inveti, tocmai pentru ca face trecerea de la teorie la practica
fara a te obliga sa insisti pe primul element (teoria :D). Odata ce ai scris un program in
Python, atunci cand il recitesti, iti dai imediat seama despre ce a fost vorba in problema,
ceea ce e vital atunci cand inveti bazele programarii. Te vei putea axa pe logica solutiei,
evitand analiza complexitatii codului in sine. Studiind intens acest limbaj intuitiv si usor de
inteles, poti ajunge programator in Python.
Ce poti face cu limbajul Python?
Ca sa incepem cu ce este mai simplu, vom vorbi despre un limbaj de programare pe cat
de popular, pe atat de simplu. Si anume, Python. Apropo, stiai ca pana si Netflix sau
Instagram foloseste limbajul de programare in Python? Nu glumesc. Compania Netflix a
detaliat ca foloseste acest limbaj de programare de la operatiunile de management si
analiza, pana la securitate si retea.
Python este un limbaj excelent pentru cei care sunt la inceput cu programarea si vor sa
faca primii pasi. Dar te rog sa nu subestimezi puterea si utilitatea acestui limbaj. El este
extrem de folosit in zilele noastre, cu o sintaxa usoara si cu o flexibilitate in a scrie codul,
cu mult peste fata de alte limbaje cunoscute (Java, C++, JavaScript, etc). Marea intrebare
este ce poti face cu acest limbaj de programare? Python, fiind un limbaj interpretat, are
un avantajul fata de limbajele compilate, tip C/C++, deoarece necesita mai putin cod
_____________________________________________________________________
18
___________________________________________________________________
pentru a realiza anumite instructiuni. Python este un limbaj de programare cheie atunci
cand vine vorba de dezvoltarea si testarea sistemelor automotive (ex: parcare inteligenta,
scaderea riscului de accidente la depasiri, semnalarea si evitarea obstacolelor pe timp de
noapte). Urmand explicatiile din aceasta carte de Introducere in Python, vei invata sa
gandesti cursiv in acest limbaj de programare prin rezolvarea unor probleme intuitive
care iti vor dezvolta logica si te vor ajuta sa inveti Python pe parcurs. Google, alaturi de
un pix si o foaie sunt cei mai buni prieteni ai unui programator. Asa ca nu trebuie sa iti fie
frica sa cauti pe Google moduri de rezolvare, dar nu trebuie sa cauti raspunsul direct,
asterne-ti pe o foaie ideile tale de rezolvare, si incearca sa transpui acele idei in cod, vei
reusi sa observi problemele mult mai repede in acest fel, si de asemenea, iti vei dezvolta
gandirea logica. Totusi, nu uita ca acest limbaj este unul puternic, folosit in multe arii si
dispune de numeroase biblioteci. Python este unul dintre cele mai cunoscute si cele mai
practice limbaje de programare, fapt care il incadreaza in topul limbajelor de prezent si
de viitor. Foarte multe tehnologii folosesc Python tocmai pentru ca e accesibil, lumea
intreaga gaseste diferite “inventii” prin care se poate bucura de flexibilitatea lui.
Poate ai auzit de testare in general. Acesta este un procedeu de verificare prin care nu
doar calitatea produsului software sau hardware poate fi cunoscuta, ci se pot gasi si
diferite functii anormale ale unui produs. Un exemplu simplu ar fi apasarea unui buton de
pe un aparat de cafea, care, in loc sa iti faca o cafea dubla, face o cafea scurta (asta daca
eliminam alte posibilitati a functionalitatii defectuoase). Testarea este atat de vasta, incat
fara Python ar fi greu de rulat anumite programe pe un produs ce urmeaza sa fie lansata
pe piata. Gandeste-te de exemplu la domeniul automotive. Poate ai stat intr-o masina
care are sistem de identificare a imaginilor. Atunci cand acesta detecteaza un obstacol
(unul real, de exemplu un om pe carosabil), activeaza sistemul de franare a masinii, astfel
evitand producerea unui accident. Sunt mari sanse ca anumite functii cheie ale acelui
sistem sa fi fost testate in Python, unele teste au rulat zile intregi, iar altele au fost rulate
de zeci de mii de ori. Un alt exemplu, mai simplu decat aceasta este urmatorul,
cunoscand Python (si folosind cateva fire si microfon), poti sa analizezi datele captate in
urma detectarii sunetelor de catre microfon, poti inregistra datele si apoi le poti cripta
intr-un fisier. Despre robotei nici nu mai deschid subiectul, pur si simplu sunt prea multe
de spus. Python e ca o usa care iti deschide multe alte usi, atata timp cat inveti bine
bazele si continui cu nivelul intermediar. Avantajul tau, cel care inveti programare
incepand chiar cu limbajul Python, este ca vei depune mult mai putin efort pentru a invata
bazele, in comparatie cu alte limbaje de programare. Fiind un limbaj intuitiv, da impresia
_____________________________________________________________________
19
___________________________________________________________________
ca scrii ceea ce logica iti dicteaza, fara a-ti mai face griji pentru spatii, linii, lipsa unei
bilbioteci, etc.. Ariile in care limbajul Python este des intalnit sunt cele de:
● Automatizare - Aceasta este des intalnita in partea de retelistica prin scripturi

pentru administrarea a mai multe device-uri.
● Cyber-Security - Python ajuta la principiile de Pen-Testing prin realizarea

automata de diferite atacuri asupra unui target.
● Web Development - Aici Python poate fi utilizat cu ajutorul framework-urilor

precum Pyramid sau Django pentru realizarea Backend-ului unui website.
● Quality Assurance (Controlul Calitatii) - Poate fi realizata testarea modulelor

software ce urmeaza sa fie lansate pe piata, in vederea functionarii corecte si a
vulnerabilitatii feature-urilor.
● GUI (Graphical User Interface) - In Python pot fi create meniuri interactive pentru
diferite programe. Un program foarte cunoscut pentru simularea retelelor creat in
Python este GNS3.
● Embedded si Internet of Things - Un bun exemplu sunt placutele de tip Raspberry

Pi si programarea senzorilor si sistemelor de securitate din industria automotiva.
In capitolele ce vor urma, iti voi prezenta cat mai multe din aceste arii ca sa le exploram
impreuna. Exista numeroase domenii care cer cunostinte de Python. De ce oare? Python
are una dintre cele mai mari procente de crestere in ultimii ani. Ca sa iti insir cateva
motive bune, cu Python poti face:
• Programarea robotilor
• Programare in Arduino
• Build-uirea unor aplicatii web (pe Django sau Flask)
• Creare de web scraper (scripturi care culeg date de pe site-uri, scanand paginile
unui site sau mai mai multor site-uri)
• Analiza de statistici
• Sisteme automate
• Manipulare de imagini (folosit mai ales in automotive)
• Manipularea de sunete si de texte.
_____________________________________________________________________
20
___________________________________________________________________
Din cate poti vedea, acest limbaj il poti folosi atat daca iti place hardware, cat si software.
Multi programatori au inceput initial cu Python pentru ca e un limbaj simplu de invatat,
intuitiv, dupa care au ramas pe acesta, l-au studiat intens si s-au specializat pe o nisa bine
definita, in domeniul in care ei au lucrat.
Cum sa aprofundezi programarea folosindu-te de Google?

In acesta sectiune vom discuta despre Google si cum poate acesta sa te dezvolte pe tine
ca si programator. Un skill foarte important pentru majoritatea celor care lucreaza in
domeniul IT este sa cunoasca metode de rezolvare a problemelor si cel mai important, sa
stie ce sa caute. Este foarte important sa stii ce cauti pentru o rezolvare mai rapida a
problemei iar Google este unul dintre cei mai buni prieteni ai omului cand vine vorba de
rezolvarea problemei.
Nu trebuie sa te temi sa iti cauti problema si sa iti spui ca un "programator adevarat" isi
rezolva singur problemele, deoarece aceasta este o conceptie gresita si trebuie
eliminata, de ce trebuie sa treci prin aceeasi pasi pentru a rezolva o problema daca un
om a facut deja treaba grea pentru tine. Cel mai mare avantaj al Internetului este ca prin
el putem afla multe raspunsuri care devin solutii pentru problemele noastre. Google aici
face partea “magica” de cautare. Acum e timpul sa iti spun si tie cum abordez eu si cum
te sfatuiesc si pe tine sa abordezi o anumita situatie:
1. “Nu stiu ceva?”
🙂
2. “Caut pe Google punand intrebarea (keyword-urile corecte) – how to X.”
3. “Gasesc ceea ce ma ajuta. O aplic.” Done
Frumusetea in cursurile de programare e ca poti invata logic fara a toci si fara a memora
exact totul. Ideea principala e ca Google are toate raspunsurile. Aici e fix invers in
comparatie cu scoala: daca auzim “nu cautati pe Internet”, aici in programare tocmai
acesta e skill-ul necesar. Nu exista programator care sa nu foloseasca Google de zeci si
chiar de sute de ori pe zi, nici in firmele mai mici si nici in corporatii.
In cazul nostru putem spune ca orice nu cunosti in Python are o solutie pe Internet. El
este si un limbaj accesibil, usor de descifrat chiar si la prima vedere si folosit de un numar
considerabil de programatori din toate domeniile. Ce se intampla de exemplu daca
doresti sa lucrezi cu listele in Python? Sa spunem ca nu cunosti in detaliu proprietatile
listelor si cum poti accesa o valoare din ele. Scrii pe Google un “how to access values in
lists” (sau ceva relevant pentru problema ta; daca nu stii engleza la acest nivel begginer,
nu-i nici o problema, foloseste Google Translate) si iti vor aparea o gramada de solutii.
_____________________________________________________________________
21
___________________________________________________________________
Google constituie o librarie enorma de documentatie pentru limbajele de programare

existente si cu siguranta te va ajuta sa te dezvolti pe plan profesional asa cum m-a ajutat
si pe mine. Nimic nu trebuie invatat pe de rost, totul merge pe logica in programare, iar
astazi ti-am explicat in detaliu ce trebuie sa faci pentru a intelege mai bine acest lucru. Ai
vazut si un exemplu despre o cautare bine structurata pe Google si despre ce indicii
cheie trebuie sa introduci pentru a reusi sa gasesti ceea ce iti doresti.
In continuare iti voi da sfaturi si despre ce platforme de rezolvare a problemelor sa
incerci prima oara pentru a gasi o solutie mai rapida si pertinenta impedimentului tau.
Important este in ziua de azi sa poti sa fii cat mai independent si sa gasesti singur
rezolvare la obstacolele tale fara a astepta ajutor din partea celorlalti. Asta te va ajuta sa
te dezvolti pe tine si iti va oferii un avantaj in fata celorlalti competitori din industrie. Sunt
multe site-uri care contin si explicatii si chiar exemple de cod. Ce recomand eu personal
sunt:
• https://stackoverflow.com – un site pentru comunitatea de developeri, care

share-uiesc intre ei cunostintele de programare, is gasesc greselile sau chiar
optimizarile unei secvente de cod. Practic, unii dintre ei chiar il folosesc 80% din
timpul de lucru atunci cand scriu cod la serviciu. Conform surselor din
https://insights.stackoverflow.com/survey/2017, peste 40 de milioane de
programatori, studenti, angajati si freelanceri, viziteaza aceasta platforma in
fiecare luna, iar in 2017 Python a fost cel mai dorit limbaj de catre programatori.
• https://www.tutorialspoint.com – e un site care iti arata cum sa programezi unele

lucruri de la zero, te ajuta daca esti blocat pe ceva peste care nu stii cum sa treci,
explicand in detaliu, teoretic, fiecare notiune dintr-un limbaj de programare.
Bineinteles ca exista multe alte site-uri de unde poti gasi raspunsurile. Tot ce trebuie sa
faci este sa cauti pe Google, adresand intrebarea corect. Ce iti recomand este sa treci la
treaba (asta daca nu ai facut-o deja) si sa incepi sa aplici ceea ce am studiat in acest
capitol, rezolvand exercitiile din sectiunile urmatoare.
_____________________________________________________________________
22
___________________________________________________________________
Capitolul 1 - Introducere in Python

In primul capitol mi-am propus sa te ajut sa intelegi din discutiile despre Python de ce
inveti acest limbaj. Vei vedea de ce setari ai nevoie pentru a-ti rula primul program scris
in Python. Incepand de aici, la finalul fiecarui capitol vei gasi cate un set de exercitii, care
te ajuta sa asimilezi si sa iti dezvolti logica si tehnica proprie de “problem-solving”. Prin
asta iti vei imbunatati cunostintele practice de programare (pentru ca, probabil stii si tu,
teoria poate uneori e greu de invatat, insa la practica se vede intr-adevar cat progresezi).
Da, stiu ca tocmai citesti o carte, deci focusul principal este pe teorie, de aceea facand
exemplele (chiar in mediul tau din PC) si prin diferite exercitii care vor fi la finalul fiecarui
capitol (si pe care te rog sa le parcuri si sa le rezolvi), vei invata si practic bazele
limbajului Python. Hai sa trecem la treaba!
Cum incepi sa programezi in Python?
Presupun ca esti nerabdator sa incepi sa programezi. Pentru a incepe sa programam in

Python, avem nevoie de un program special, denumit IDE (Integrated development
environment) care reprezinta un mediu de dezvoltare al programelor. Putem folosi un
astfel de IDE in mai multe moduri:
• Interpretor - aplicatie instalata pe laptop/PC si folosita printr-un terminal

• Online - printr-o aplicatie cloud - exemplu Repl.it
• Aplicatie instalat pe PC/laptop - exemplu PyCharm
In sectiunile urmatoare iti voi prezenta ambele variante, iar tu decizi cea pe care o vei
folosi. Scopul este sa alegi una dintre cele 3 variante de mai sus astfel incat sa faci
scrierea codului tau cat mai rapida si mai usoara.
I. Folosirea unui IDE Online - Repl.it
Vom incepe cu cea mai simpla si rapida metoda pentru a incepe sa scriem codul in
Python, folosind un IDE online. IDE-ul pe care ti-l recomand se numeste Repl.it si il poti
accesa apasand AICI (https://replit.com). Iti recomand sa-ti faci un cont pe site-ul lor, dupa
care, odata logat la ei in platforma te vei regasi in situatia din figura 1.1:
_____________________________________________________________________
23
___________________________________________________________________
Figura 1.1
Apasa pe butonul “new repl.it” din partea de sus (butonul albastru). Creaza-ti un proiect,
selectand Python ca limbaj de programare. Ofera un nume proiectului tau si apasa pe
butonul de creare. Acum, proiectul fiind creat, ti se va deschide o fereastra unde vei
putea scrie codul. Partea din stanga este rezervata ierarhiei de fisiere (in viitor probabil
vei avea mai multe fisiere care vor contine cod), la mijloc va fi locul unde vei scrie codul,
iar in partea din dreapta va aparea rezultatul odata ce rulezi codul (apasand pe butonul
RUN, de sus).
_____________________________________________________________________
24
___________________________________________________________________
Figura 1.2
Prima linie de cod in Python

Si acum a sosit momentul sa trecem la treaba si sa scriem prima linie de cod in Python.
Vom folosi un exemplu clasic, extrem de intalnit in programare, pe care il poti vedea mai
jos:
print("Hello World")
Click pe run, iar rezultatul afisat va fi:

Hello World
Acest lucru poti vedea si in figura 1.3 de mai jos (codul in partea din stanga, iar rezultatul
in partea din dreapta):
_____________________________________________________________________
25
___________________________________________________________________
Figura 1.3
De acum inainte ai tot ce-ti trebuie sa scrii cod. Folosind acest IDE online iti va fi extrem
de usor sa inveti programare rapid si usor. Pe termen lung, cand vei dori sa creezi
proiecte mai complexe care implica mai multe fisiere, module si framework-uri, iti
recomand sa folosesti varianta #2 despre care vom discuta in sectiunea urmatoare.
_____________________________________________________________________
26
___________________________________________________________________
II. Folosirea unei aplicatii IDE - PyCharm
In aceasta sectiune iti voi arata cum sa folosesti un IDE (local - pe laptop sau PC) pentru a
programare in Python. IDE-ul pe care ti-l recomand eu se numeste PyCharm si il poti
descarca de AICI (http://www.jetbrains.com/pycharm). Iti recomand sa alegi varianta
Community pentru ca aceea este gratuita.
Cum instalez si cum pornesc PyCharm?
Odata ce ai reusit sa descarci PyCharm, te poti apuca de instalare. Incepi prin a da dublu
click pe executabilul descarcat, iar apoi treci prin procesul de instalare care este destul
de simplu si intuitiv. La pornirea chitului de instalare vei intampina o fereastra similara cu
cea din figura de mai jos:
Figura 1.4
Mai departe vei avea de facut cateva setari mici, asadar te invit sa urmaresti figurile 1.3, si
1.4 de mai jos si sa bifezi casutele exact asa cum vezi in imagini:
_____________________________________________________________________
27
___________________________________________________________________
Figura 1.5
Figura 1.6
_____________________________________________________________________
28
___________________________________________________________________
Pe parcurs PyCharm te va intreba daca doresti sa instalezi anumite plugin-uri.

Deocamdata poti sa treci peste si poti sa dai skip, deoarece acelea nu sunt necesare in
aceasta faza. In figura de mai jos iti poti alege tema pe care o doresti de la IDE-ul tau. Eu
personal am mers pe cea inchisa (aka. “Darcula”), dar tu decizi cea pe care o doresti:
Figura 1.7
_____________________________________________________________________
29
___________________________________________________________________
Cum creezi un proiect in PyCharm?
Odata ce instalarea a avut loc este timpul sa pornesti PyCharm si sa iti creezi primul
proiect (vezi figura 1.8) astfel incat sa poti coda in Python:
Figura 1.8
Acum urmatorul lucru pe care il vom face este sa cream un proiect nou (sau sa
deschidem unul deja existent). Vei merge la “Create New Project”, unde poti vedea ca ai
mai multe optiuni. Ceea ce tu vei face este sa creezi un proiect in care vei pune codul
tau. Dar nu vei pune acolo cod pur si simplu. Python functioneaza in felul urmator, ai
nevoie de un proiect (gandeste-te la acest proiect ca la un folder), dupa care ai module
(in acest proiect - aka. fisierele proiectului cu terminatia .py). Acestea contin codul pe
care tu il vei scrie pentru ca programul sa indeplineasca scopul dorit.
_____________________________________________________________________
30
___________________________________________________________________
Figura 1.9
Creeaza proiectul si ofera-i o denumire specifica cu ce urmeaza sa faci in el. In cazul

acesta, eu am ales denumirea “PrimulProiect”. Acum se va deschide fereastra default, a
proiectului curent, dupa cum poti vedea in figura de mai jos:
_____________________________________________________________________
31
___________________________________________________________________
Figura 1.10
Odata ce am creat primul nostru proiect, urmeaza sa cream fisierul in care vom scrie
codul sursa. Acest procedeu il poti vedea in cele doua figuri de mai jos:
_____________________________________________________________________
32
___________________________________________________________________
Figura 1.11
Figura 1.12
Acum te afli in locul in care poti incepe sa scrii cod in Python, in IDE-ul PyCharm. Hai sa
vedem in sectiunea urmatoare cum arata acest cod si cum il poti executa.
_____________________________________________________________________
33
___________________________________________________________________
Primele linii de cod in PyCharm

Odata ce setupul de baza al PyCharm-ului a avut loc, tot ce trebuie sa facem mai departe
este sa incepem sa scriem cod. Reluam codul de baza pe care l-am scris si mai devreme.
print("Hello World")
Dupa asta trebuie sa apesi din bara meniului de sus “Run”, apoi pe butonul verde de
“Run”, care va interpreta si va rula programul pe care l-ai creat (vezi in figura 1.13 de mai
jos).
Figura 1.13
Dupa aceea te va pune sa selectezi fisierul pe care doresti sa-l rulezi (figura 1.14). Il
selectezi, iar apoi in consola se va afisa rezultatul in urma executarii codului (figura 1.15).
_____________________________________________________________________
34
___________________________________________________________________
Figura 1.14
Figura 1.15
In secventa de cod de mai jos am folosit de 3 ori functia print si vreau sa te uiti putin la
rezultatul afisat. Dupa cum poti sa vezi textul este afisat de 2 ori, de fiecare data pe un
rand nou (vezi figura 1.16). Acest lucru este important pentru ca Python face asta by
default prin aceasta functie. Alte limbaje de programare (precum C sau C++) nu fac acest
lucru si vor scrie intregul text pe o singura linie. De ce este acest lucru important? Vei
vedea in sectiunea cu exercitii.
_____________________________________________________________________
35
___________________________________________________________________
print("Hello World!")
print()
print("Text2")
Rezultatul afisat:
Hello World
Text2
Figura 1.16
Iata mai jos o lista cu beneficiile majore care ti le ofera un astfel de IDE:
• Organizeaza mai buna a codului
• Are feature de auto-complete si sugestii de utilizare a functiilor si a claselor
• Identifica rapid greselile de sintaxa aparute in cod
• Usureaza adaugarea de framework-uri si module noi
•Are posibilitatea integratii aplicatiei cu Git & GitHub pentru versionarea codului.
_____________________________________________________________________
36
___________________________________________________________________
Totodata, in timp ce ai scris acest cod cu functia print, banuiesc ca ai descoperit si

feature-ul de autocomplete al lui PyCharm. Este un feature pe care eu il consider extrem
de util si care iti va salva mult timp pe masura ce vei incepe sa-ti creezi propriile
programe si proiecte, precum si la job. Vei vedea pe parcurs ce inveti sa programezi mai
bine si faci mai mult cat de util iti va fi. Astfel poti programa mult mai usor fara a avea
nevoie de cunostinte legate de sintaxa exacta a liniei de cod. Python si PyCharm ne
permit sa facem astfel de lucruri.
Figura 1.17
_____________________________________________________________________
37
___________________________________________________________________
III. Folosirea unui interpretor din Windows
Daca folosesti Windows, iti poti instala Python descarcand de pe python.org

(https://www.python.org/downloads/windows/) executabilul cu versiunea 3.6 (sau orice
alta versiune mai noua doresti). Urmatorul pas este sa-l instalezi si sa-l pornesti. Python
este acum instalat si iti recomand sa folosesti functia Search din Windows si sa-l pornesti
pentru a putea incepe sa scrii cod in interpretor:
Figura 1.18
Odata pornita consola, putem scrie mai multe linii de cod care vor fi rulate odata ce
apasam Enter. Iata mai jos un exemplu concret care contine si cateva elemente pe care
le vom studia in capitolele urmatoare:
_____________________________________________________________________
38
___________________________________________________________________
Figura 1.19
Dezvantajul principal in cazul folosirii unui interpretor consta in faptul ca, codul tau nu va
fi salvat, ceea ce inseamna ca nu il vei putea refolosi. Aici intervin scripturile (asa cum vei
vedea in sectiunea urmatoare), ca o alternativa excelenta si, bineinteles, programele
scrise in cadrul unui IDE.
_____________________________________________________________________
39
___________________________________________________________________
IV. Folosirea unui interpretor din Linux sau macOS

Un alt mod prin care poti face programare in Python este prin folosirea unui terminal (pe
Linux sau macOS). In aceasta sectiune iti voi arata cum iti poti folosi terminalul pentru a
scrie cod in Python. In cazul in care folosesti Linux sau macOS, cel mai probabil ai Python
instalat pe PC-ul tau pentru ca aceste OS-uri folosesc multe aplicatii care au la baza
limbajul. In cazul in care nu il ai instalat, foloseste urmatoarea comanda pentru a-l instala:
Pe Linux: sudo apt-get install python3.5

Pe macOS: sudo brew install python
Prima interactiune cu Python din terminal

Acum iti recomand sa scrii in terminal comanda prin care vei porni interpretorul Python:
python3.5 sau python. Acum poti incepe sa scrii linii de cod, iar interpretorul le va
executa una dupa alta. Mai multe detalii poti vedea in figura de mai jos. Aici cel mai
simplu lucru pe care il poti face sunt operatiile de baza: adunari, scaderi, impartiri, etc. si
anumite afisari simple. Dupa cum poti observa in figura urmatoare, pentru a folosi functia
print, nu e nevoie de includerea unei biblioteci in mod explicit, pentru ca print este
built-in in Python.
_____________________________________________________________________
40
___________________________________________________________________
Figura 1.20
Ceva putin mai complex este folosirea anumitor variabile care retin diferite tipuri de date.
In figura urmatoare, in a doua parte a imaginii am incercat sa adunam a + b, variabilei a
fiind atribuit sirul de caractere Nume, iar b avand valoarea 3. Operatia de adunare nu s-a
putut face in acest caz pentru ca sunt doua variabile de tipuri diferite. In ultima parte a
figurii, variabilei a i-am atribuit sirul de caractere Ramon, iar %s pana la urma va tine locul
pentru acel sir de caractere. Observa ultima linie de print si rezultatul ei final.
_____________________________________________________________________
41
___________________________________________________________________
Figura 1.21
In continuare iti voi arata in ce sa lucrezi daca ai nevoie de scripturi si de ce iti este
folositor tie, ca programator, din punct de vedere al timpului, sa te folosesti de asta script.
De ce avem nevoie de scripturi in Python?
Un script te poate ajuta in automatizarea muncii tale, astfel tu nu trebuie sa faci task-uri
repetitive si enervante. Sa spunem ca ai un joc in care trebuie sa minezi aur. Daca vrei sa
faci si altceva, iar aurul sa se mineze singur pentru tine, poti crea un script care sa te
ajute in acest sens. Multi gameri folosesc aceasta metoda care este de fapt un cheat, dar
de mare folos cand vrei sa duci gaming-ul la un alt nivel. De asemenea, daca iti doresti o
cariera in IT, vei vedea ca nu poti rezista fara script-uri. Pur si simplu de foarte multe ori
va fi necesar sa repeti aceleasi activitati, iar acest lucru este imposibil de realizat fara un
script. Toti programatorii aleg sa foloseasca script-uri pentru ca astfel nu mai pierd timpul
cu lucruri marunte si nu mai scrie din nou 70% dintr-un cod scris ieri.
_____________________________________________________________________
42
___________________________________________________________________
Cum sa creezi un script in Python (pe Linux sau macOS)?
Crearea unui script in Python este adesea extrem de simplu de facut. Creezi un fisier, il
salvezi, creezi un executabil si rulezi codul. In cazul nostru, aici, in Python, vom folosi un
interpretor, care ia fiecare linie in parte si o executa. Un aspect important in acest caz, (al
limbajelor de programare interpretate - adica asa cum este Python) sa zicem ca avem de
exemplu un cod de 20 de linii, iar pe linia 13 interpretorul gaseste o eroare. Programul
tau va fi executat de la linia 1 pana la linia 12, chiar daca dupa aceea executia se opreste.
Vei vedea ca sunt doar cateva linii de cod pe care trebuie sa le scrii si script-ul in sine,
pentru ca lucrurile sa mearga exact cum vrei si ca munca ta sa devina mai usoara. Pe
Linux, daca vrei sa faci un script si nu ai mai creat asa ceva, iata cum poti face. In linia de
comanda, optional, mergi in locatia (exemplu pe Desktop) in care vrei sa ti se salveze
scriptul, apoi introduci urmatoarele comenzi pentru crearea fisierului:
cd ~/Desktop/
touch scriptul_meu.py
Si comanda pentru deschiderea lui cu editorul vim. Daca doresti sa folosesti orice alt
editor text (fie el din GUI sau din terminal), feel free to do it:
vim scriptul_meu.py
Odata deschis fisierul, e timpul sa introduci prima linie de cod care e specifica unui script:
#!/usr/bin/python3.8
Aceasta linie de cod se numeste shebang si specifica locatia unde se afla executabilul
Python. Tine minte aceste lucruri si exerseaza-le, pentru ca de acum incolo de cate ori
vei scrie un nou script, va fi nevoie sa faci acest lucru. Acum tot ce a ramas de facut este
sa scrii in script, pentru inceput, o simpla adunare:
a = 2
b = 3
print(a + b)
Apoi ca sa rulezi scriptul, foloseste in linia de comanda:

python3.8 scriptul_meu.py
_____________________________________________________________________
43
___________________________________________________________________
NOTA: Daca ai o alta versiune de Python instalata, atunci foloseste comanda cu acea
versiune, de exemplu:
python3.6 scriptul_meu.py
sau aceasta comanda care va apela versiunea default, setata:
python scriptul_meu.py
Acum vine acel avantaj al Python-ului de care tot ti-am povestit, poti refolosi codul scris
anterior. Cum? Scriind in linia de comanda vim scriptul_meu.py (sau folosind orice alt
editor text), dupa care poti modifica continutul scriptului. Odata ce vei trece si tu peste
acesti pasi pe calculator, de a face fisierul, a scrie in el si a-l executa, poti spune ca ai
invatat procesul.
Concluzie
Cateva sugestii pentru tine inainte de a merge mai departe:
1. Fiind la inceput iti recomand sa te “joci” cu interpretorul din Windows (sau

Linux/macOS) exact asa cum am vorbit in sectiunea III. al acestui capitol
2. Odata ce avansezi si te obisnuiesti cu sintaxa limbajului, poti merge mai departe
sa folosesti un IDE (exact asa cum am facut in sectiunea I.)
3. Cand esti pregatit sa faci aplicatii/programe cu o complexitate mai mare, iti
recomand sa folosesti un IDE (cum este PyCharm, studiat in sectiunea II.) pentru
ca iti va usura mult munca si iti va oferi foarte mare flexibilitate in scrierea
aplicatiilor.
_____________________________________________________________________
44
___________________________________________________________________
Codul scris in Python vs. alte limbaje de programare
Ok, acum ca ti-ai facut o mica idee legata de cum arata o secventa de cod scrisa in
Python, da-mi voie sa-ti faca o paralela intre acest limbaj si alte limbaje programare
pentru a vedea simplitatea si eficienta de a scrie cod. Iar bun exemplu pentru a
demonstra cat de simplu este acest limbaj, este numarul de linii necesar pentru a printa o
propozitie pe ecran, in C++, Java sau JavaScript este necesar un numar de aproximativ 4
sau 6 linii, Python scurteaza acest proces la doar o linie. Fiecare program in parte face
acelasi lucru, dar diferenta o face complexitatea si cantitatea de cod necesara intre
fiecare limbaj in parte. Priveste exemplele urmatoare:
~ C++
In C++ secventa de cod arata in felul urmator:
#include <iostream>
using namespace std;
int main()
{
cout << "Hello, World!";
return 0;
}
~ Java
In Java secventa de cod arata in felul urmator:
public class HelloWorld {

public static void main(String[] args) {
System.out.println("Hello World");
}
}
~ JavaScript
In JavaScript, codul trebuie sa faca parte dintr-o pagina web (cu o structura HTML):
_____________________________________________________________________
45
___________________________________________________________________
<!DOCTYPE HTML>
<html>
<body>
<p>Before the script...</p>
<script>
alert( 'Hello, world!' );
</script>
<p>...After the script.</p>

</body>
</html>
~ Python
Iar Python secventa de cod arata in felul urmator (dupa cum poti vedea este mult
simplificata):
print("Hello World!")
_____________________________________________________________________
46
___________________________________________________________________
Exercitii
Incepand cu acest capitol, la fiecare final de capitol iti voi pune la dispozitie un set de
exercitii pe care tu sa le practici. Ele te vor ajuta sa-ti intaresti in minte conceptele deja
studiate si astfel vei aprofunda si mai mult studiul programarii.
Setul de Exercitii #1
1) Scrie un program care sa afiseze prenumele tau pe primul rand, iar pe urmatorul
rand numele.
2) Acum, modifica codul de la punctul anterior, astfel incat la afisare, prima linie
(adica primul rand) sa fie goala, a doua linie sa contina prenumele, a treia linie sa
fie goala, iar pe a patra linie sa apara numele.
1) Daca ar trebui sa scrii un program care afiseaza cate o litera din numele si
prenume tau, cum l-ai scrie folosind doar cunostintele din acest capitol (fara a te
complica cu alte functii sau metode):
P
o
p
a
A
d
r
i
a
n
_____________________________________________________________________
47
___________________________________________________________________
1) Afiseaza prenumele astfel incat literele sa apara pe diagonala, in felul urmator:
P
o
p
a
A
d
r
i
a
n
_____________________________________________________________________
48
___________________________________________________________________
Capitolul 2 - Variabile in Python
In acest capitol trecem mai departe si incepem serios conceptele de programare, vorbind
despre variabile. Vei vedea teoretic si practic cum se folosesc acestea pentru diferite
operatii simple, cum ar fi calcule matematice si actiuni mai complexe de manipulare a
valorilor in Python.
Ce este o variabila?
Atunci cand vine vorba de programare, o variabila este o locatie de memorie in care tu
poti stoca valori (de acelasi tip). (Colocvial vorbind, e ca si cum ai avea un cos cu fructe,
unde tu desigur poti pune diferite tipuri de fructe.) Practic, imediat ce creezi o variabila,
automat rezervi un anumit spatiu de memorie. Frumusetea variabilelor in Python este ca
poti defini tipul lor, urmand ca interpretorul sa decida cum sa salveze in memoria alocata
anterior. Poti asigna astfel diferite tipuri de date: caractere, numere (intregi, reale),
expresii booleane (True sau False), etc. Pe langa aceste tipuri de date mai sunt si cele de
tipul: String, lista, tuple, dictionar despre care vom discuta in capitolele viitoare. In cele ce
urmeaza le vom lua pe rand pe fiecare in parte si vom vedea cum le putem defini si cum
se folosesc in programare.
Variabile de tip numere (intregi, reale)

Pentru inceput vom discuta despre variabilele de tip numar si vom invata cum sa le
folosim in functie de tipul lor. In programarea “clasica” variabilele sunt impartite pe tipuri,
iar in momentul crearii (declararii) unei variabile, specificarea titlului este obiligatorie. Iata
mai jos un exemplu cu o parte din tipurile de variabile:
● Numere intregi - integer (-19 sau 21)

● Numere reale - float/double (10.9)
Pe langa tipul acestor numere trebuie sa avem in vedere si valoarea pe care o stocam
intr-o variabila. Anumite numere consuma un procent mai mic de memorie (cum ar fi x =
23), iar altele au un consum de memorie mult mai mare (exemplu: x = 82124692L).
_____________________________________________________________________
49
___________________________________________________________________
Exemple de tipuri de date numerice folosite in Python:
a) tipuri de date de tip int: variabila stocheaza numere intregi, sunt numerele
intregi precum: 2; 34; -189; 700; -0x260; etc
b) tipuri de date de tip float: numere cu punct zecimal, sunt numerele reale, cele
cu virgula: 2.5; -1.5; 700.3; 10.0; -32.54e100; 70.2-E12 etc
c) tipuri de date de tip complex sau imaginare: fac parte din multimea numerelor
complexe, imaginare: 3.14j; 3e+26J; 4.53e-7; 45j
d) tipuri de date de tip long: sunt numerele ce necesita o capacitate de memorie

mai mare, sunt numere mari: 82124692L; -0x24331L; -052318172735L;
-4721885298529L;
Python este construit de asa natura incat isi da seama singur de ce tip este variabila pe
care noi o declaram. Cand vine vorba de numere, in Python acestea pot fi intregi (pot
avea valoare peste 0 sau sub 0) sau pot fii reale (au valoare cu virgula). Daca intr-un
limbaj de programare precum Java trebuie sa specificam in mod exact tipul variabilei, de
exemplu: int x = 5, in Python nu este deloc necesar sa facem acest lucru. Mai jos poti
sa vezi cum se declara aceste variabile si cum le putem atribuii o valoarea.
x = 5
y = -10
Acestea sunt exemple de variabile de tip integer (numar intreg) pe care tu le poti folosi in
Python sau in alte limbaje de programare. Acest tip de variabile, dupa cum spuneam, pot
fi atat pozitive cat si negative. Daca dorim sa avem numere reale (adica numere cu
virgula), le putem declara astfel:
a = 5.1
b = 6.2
Pentru a afisa aceste numere, codul complet va fi:
x = 5
y = -10
_____________________________________________________________________
50
___________________________________________________________________
a = 5.1
b = 6.2
print(x)
print(y)
print(a)
print(b)
Se va afisa:
5
-10
5.1
6.2
Acum, hai sa facem o operatie (matematica) cu aceste variabile, si anume sa calculam

suma dintre x si y:
suma = x + y
Printam ceea ce am scris mai devreme pe ecran:

print(suma)
Ruland programul, rezultatul afisat va fi 15. Acum hai sa scriem putin mai frumos. Tot
ceea ce scriem cu ghilimele in Python este un sir de caractere. Astfel, vom printa in
consola:
print("Suma este:", suma)
In final codul va arata astfel:
x = 5
y = 10
suma = x + y
_____________________________________________________________________
51
___________________________________________________________________
Si se va afisa:
Suma este: 15
Operatori in Programare
In aceasta sectiune vom vorbi despre operatori. Sunt absolut convins ca te-ai mai intalnit
cu acesti operatori pana acum (cel mai probabil in timpul scolii), ei ne ajuta sa facem
acele operatii matematice de baza. Scopul operatorilor este sa atribuie (=), sa compare
(exemplu: > sau <) sau sa dea o logica programelor noastre si nu numai. Dar lucrurile nu
se opresc aici. Mai jos poti vedea o lista intreaga cu operatorii existenti in programare. O
parte dinre acestea se aplica si in Python.
Operatorul de atribuire: =
Operatori matematici: + (adunare), - (scadere),

* (inmultire), / (impartire)
% (modulo - restul impartirii)
++ (incrementarea) //NOT IN PYTHON
-–(decrementarea) //NOT IN PYTHON
Operatorii de comparare: == (egal), != (diferit)

< (mai mic), > (mai mare)
<= (mai mic sau egal), >= (mai mare sau egal)
Operatorii logici: and (SI logic)

or (SAU logic)
not (NOT –negare logica)
Operatori pe biti: & (SI), | (SAU), ^ (XOR), ~ (complement)

<< (left shift), >> (right shift), >>> (zero fill
right shift)
Operatori combinati: +=, -=, /=, *=, %=, &=, |=, ^=, <<=, >>=, >>>=
(operatie + atribuire)
_____________________________________________________________________
52
___________________________________________________________________
Deja dupa cum ti-ai dat seama, acesti operatori au rolul de a face operatii matematice.
Nu-ti fa griji, nu trebuie sa cunosti matematica la un nivel inalt pentru a intelege aceste
elemente de baza. Pentru inceput poti folosi in exercitiile tale operatorii matematici
simpli:
• + (adunare), 2 + 3
• - (scadere), 2 - 3
• * (inmultire), 2 * 3
• / (impartire), 2 / 3
• (atribuire de valoare), a = 2, b = 3
• == (comparatie), a == b (rezultatul intors va fi de tip boolean - True sau False)
ATENTIE: Atribuirea de valoare (=) difera de comparatie (==)!
Prima este folosita pentru a asigna valoarea din partea dreapta (mai explicit, daca este
cazul, valoarea finala in urma operatiilor din partea dreapta) in variabila din partea stanga.
A doua este folosita pentru a verifica daca doua valori sunt sau nu egale. In cazul in care
conditia este adevarata (True), deducem ca cele doua valori sunt egale, altfel ele sunt
diferite, iar prin verificare se va returna false.
Acum ca am invatat operatiile de baza, hai sa ne focusam pe operatia % (pronuntat
“mod”). Aici ma voi referi la o operatie matematica. Operatia a % b intoarce valoarea
restului impartirii lui a la b. Daca folosim if a % b, se va verifica daca restul impartirii lui
a la b este sau nu egala cu 0 (zero). Daca da, valoarea expresiei va fi True, asltfel daca
exista un rest diferit de 0, oricare ar fi ea, valoarea va fi False. Iata mai jos o lista mai
lunga de exemple:
>>> 10 + 1
11
>>> 10 - 9
1
>>> a = 2
>>> b = 3
>>> a * b
6
>>> a / b
0
>>> a % b
_____________________________________________________________________
53
___________________________________________________________________
2
>>> b % a
1
>>> a > b
False
>>> a < b
True
>>> a == b
False
>>> a += 2
>>> a
4
O alta expresie pe care o putem face este += sau -=, *=, /= sau %=.
Cu varianta += putem face o adunare, in cazul nostru variabilei x i se va o noua valoare
rezultata din valoarea lui plus elementul din dreapta, astfel pentru:
x = 5
y = 10
suma = x + y
print(suma)
suma += 2
Se va afisa:
15
Suma este: 17
Iti recomand sa iei acelasi exemplu, dar sa inlocuiesti operatia matematica efectuata pe
variabila suma cu ceilalti operatori, pe rand, pentru a vedea rezultatul final:
suma -= 2
suma *= 2
_____________________________________________________________________
54
___________________________________________________________________
suma /= 2
suma %= 2
Printeaza rezultatul dupa fiecare operatie pentru a vedea si a intelege mai bine procesul
care a avut loc.
Variabile de tip String (siruri de caractere) in Python
In aceasta sectiune vom vorbi despre siruri de caractere (aka. String-uri), un tip de
variabila extrem de des intalnit si folosita in programare. Daca stam sa ne gandim, cand
vine vorba de calculatoare cuvintele sunt peste tot, deci implicit si String-urile vor fi peste
tot. Google este un motor de cautare care se bazeaza exclusiv de cuvintele care sunt
introduse de catre un utilizator pentru a oferi cele mai buna rezultate (in urma unei
analize semantice si a unui algoritm extrem de sofisticat).
trei_litere = "Abc"
print(trei_litere)
Daca rulam tot ceea ce am scris pana acum in program, va aparea pe ecran:
Abc
Daca ar fi sa scriem:
trei_litere = trei_litere + 'a'
print(trei_litere)
vom vedea pe ecran ca lui Abc i se va mai adauga inca o litera, inca un string care va fi
a. Astfel, ceea ce va aparea printat pe ecran va fi:
Abca
NOTA: in Python toate variabilele (int, float, string, obiecte) sunt scrise cu litere mici
String-urile ne ajuta foarte mult sa operam cu date de tip text. In cadrul acestora exista
numeroase functii built-in pe care le putem folosi pentru a ne face viata mai usoara. Una
_____________________________________________________________________
55
___________________________________________________________________
dintre acestea este functia len() care ne ofera numarul de litere din cadrului unui string.
Iata mai jos un exemplu de folosire a acesteia:
print(len(trei_litere))
si vom primi numarul de caractere din acest sir trei_litere. In final pentru codul
(atentie, ultimul print se intinde pe doua linii):
trei_litere = "Abc"
print(trei_litere)
trei_litere = trei_litere + 'a'
print(trei_litere)
print(len(trei_litere))
print("String-ul nostru este", trei_litere, "si are lungimea de",

len(trei_litere))
Rezultatul afisat va fi:
Abc
Abca
4
String-ul nostru este Abca si are lungimea de 4
String-urile pot fi foarte utile in comunicarea dintre program si utilizator pentru ca sunt
constituite din caractere si pot forma propozitii. Chiar si un simpu “Yes” sau “No” pot face
schimbari radicale intr-un program. Elementele primare din string-uri sunt caracterele, iar
acestea pot forma siruri de caractere, de exemplu in momentul in care sunt organizate in
cuvinte si propozitii. Iata mai jos modul in care creeam o variabila de tipul String.
sirA = "Dimineata am baut"

sirB = 'cafea'
sirC = 'ceai'
_____________________________________________________________________
56
___________________________________________________________________
Ele pot fi asignate unei variabile utilizand si ghilimele, dar si apostroafe. Avand o astfel de
variabila String, poti avea acces la fiecare caracter dintr-un sir de caractere cu ajutorul
unui index (care este folosit pentru a identifica valoarea unui caracter dintr-un sir aflat la
o anumita pozitie - index). Primul caracter (deci si prima pozitie din sir) va avea
intotdeauna valoarea 0, urmatorul caracter va avea pozitia 1, apoi pozitia 2 si asa mai
departe. Pentru a lucra cu caracterele dintr-un String, vom folosi aceste paranteze [ ] si
valoarea indexului, dupa cum urmeaza:
print("sirA[0] este ", sirA[0])
Care ne va afisa:
sirA[0] este D
Observa cum dupa apelarea de print se va afisa ceea ce exista in ghilimele (care contin si
un spatiu imediat dupa cuvantul este), dupa care afiseaza litera D, fiind primul caracter
pozitionat pe indexul 0. Pentru a afisa ultimul caracter din sirul sirA, va fi nevoie sa
accesam ultima pozitie din sir. Putem face asta prin mai multe metode, cea mai simpla
fiind:
print(sirA[16])
care va afisa: t
Daca dorim ca doar cuvantul neata sa fie afisat putem folosi parantezele patrate
impreuna cu doua punte in felul urmator:
print(sirA[4:9])
Partea interesanta este ca nu apare eroare (poate la asta te-ai asteptat) atunci cand scrii
print(sirA[-4:-1])
Ce sa va intampla? Ce se va afisa? Se va afisa al 4-lea element numarand de la capatul

cu indexul maxim (din dreapta), catre stanga (catre indexul 0). Se va afisa bau, unde b se
afla pe pozitia -4, a se afla pe pozitia -3, u se afla pe pozitia -2, iar la -1 se incheie afisarea
_____________________________________________________________________
57
___________________________________________________________________
caracterelor din sir (fara a lua in calcul litera t). Daca vrem sa cream un al patrulea sir de
caractere denumit propozitie care sa fie o propozitie compusa, iar rezultatul dorit sa
fie Dimineata am baut cafea, putem incerca urmatoarea secventa de cod:
sirA = "Dimineata am baut"

sirB = "cafea"
propozitie = sirA + sirB
print(propozitie)
Ce se va afisa mai exact?
Dimineata am bautcafea
Pentru a adauga un spatiu poti sa pui cu plus in felul urmator:
propozitie = sirA + ' ' + sirB
Incearca si tu pe propriul PC. Ce va afisa secventa urmatoare?
print("Ieri" + " d" + sirA[1:] + ' ' + sirB)
De asemenea, daca doresti ca afisarea sa aibe o anumita vizualizare, poti afisa cu

aceeasi functie print pe mai multe linii folosindu-te de ‘\n’.
trei_litere = "Abc\n"
print(trei_litere)
Se va afisa:
Abc
Alte utilitati ale functiei print
Poate ca se ruleaza un program, iar pana cand se ajunge acolo vrei sa folosesti un mesaj
intermediar:
_____________________________________________________________________
58
___________________________________________________________________
mesaj="Please wait while the program is loading”

print(mesaj)
Legat de concatenarea sirurilor de caractere, trebuie specificat faptul ca acestea trebuie

sa fie de acelasi timp, mai multe detalii in exemplul ce urmeaza
a=42
print(‘My age is’ + a)
acest program urmand sa semnaleze o eroare de tipul
Traceback (most recent call last):
File “<input>”, line 1, in <module>
‘My age is ‘ + a
TypeError: can only concatenate str(not “int”) to str
Iar dupa cum observi, daca citesti cu atentie eroarea, iti poti da seama foarte usor care
este problema codului. Aceasta regula nu se aplica pentru orice eroare, uneori nu iti poti
da seama exact care este greseala, dar este un prim pas important in depanarea
posibilelor erori. Iar pentru a depana aceasta eroare te poti folosi de urmatorul format:
a=42
print(‘My age is’+str(a))
Poti folosi si separator, ca in exemplul de mai jos
print(‘My age’,’ is 21’, sep=’\n’)
Cu rezultatul:
hello
world
La fel cum este utilizatorul sep, la fel se poate face si cu cel de tip end:
print(‘Prima propozitie’, end=’.’)
_____________________________________________________________________
59
___________________________________________________________________
print(‘A doua propozitie’, end=’.’)

print(‘A treia propozitie.’)
Afisandu-se:
Prima propozitie.A doua propozitie.A treia propozitie
Poti folosi si o combinatie intre aceste separatoare, precum:
print(‘A’,’B’,’C’, sep=’, ‘, end=’.’)
cu rezultatul:
A,B,C
Exerseaza si vezi cat de multe poti face cu lucruri atat de simple. String-urile, deci
atribuirea de caractere unei variabile, sunt folosite in toate limbajele de programare.
Daca vei invata totul despre cum functioneaza ele specific in Python, iti va fi mult mai
usor sa le folosesti in Java, C++ sau alte limbaje. Nu uita ca programarea se invata numai
prin practica, iar exercitiile pe care le-am pregatit pentru tine iti pot fi foarte utile.
Exemplu #2
Si acum hai sa iti explic ceea ce ziceam capitolul anterior, si anume, de ce Python este un
limbaj accesibil si usor de scris. Atunci cand creezi o variabila in Python, nu e nevoie sa
specifici explicit rezervarea unei spatii de memorie sau tipul ei. Nu trebuie sa te complici
sa “ii spui codului” ca variabilele nume si prenume vor contine cate un sir de caractere,
in variabila varsta va fi un numar intreg, iar variabila salariu va contine un numar
real, ci pur si simplu aloci valorile. Iata exemplul descris:
nume = "Pop"
prenume = "Mihaela"
varsta = 23
salariu = 3800.98
Daca vrei de asemenea sa afisezi aceste variabile, in print-ul lor nu trebuie sa precizezi
care este tipul de variabila care urmeaza sa fie afisata, ci doar variabila:
_____________________________________________________________________
60
___________________________________________________________________
print(nume)
print(prenume)
print(varsta)
print(salariu)
Dupa asta se va afisa:
Pop
Mihaela
23
3800.9
Vezi cum, desi numele si prenumele au fost alocate in varibile cu ajutorul ghilimelelor, la
afisare ghilimelele au lipsit, iar pentru Python cu versiunea 3.5 s-au afisat numele si
prenumele cu apostroafe. Reamintesc, modul de memorare a unor siruri de caractere
intr-o variabila se face folosind ghilimele, iar daca e vorba de un numar (intreg, real, etc)
atunci doar se specifica valoarea. Un alt aspect important de mentionat aici este ca
variabilele isi pot schimba valoarea. Exemplu concret: Daca in cazul nostru personajul
Mihaela se casatoreste si isi schimba numele din Pop de exemplu in Stan, in cod vom
putea introduce o noua linie in care alocam numelui o noua valoare: nume = "Stan".
Daca trece un an, Mihaela Stan implineste 24 de ani. Cum ii adaugam in plus un an?
varsta = varsta + 1 sau o alta metoda simpla ar fi: varsta += 1 sau si mai simplu,
schimbam direct 23 in 24: varsta = 24
Continuand pe acest exemplu: Daca vrem sa aflam restul impartirii salarului (care in cazul
nostru este de tip float, fiind numar real) la 1000, scriem salariu % 1000, iar asta ne va
afisa: 800.98. Asta facem prin operatie MOD (%).
Acum poti trece si tu prin acesti pasi pentru a exersa. Te poti juca in foarte multe moduri
pentru a “testa” limitele. Vor urma alte exercitii mai complexe. Pana atunci, poti incerca sa
faci alte lucruri: adaugare de elemente, scaderi, diferite operati, etc. Tine minte, valoarea
variabilelor se poate schimba in functie de conditiile si informatia introdusa in programul
la care lucrezi. Practic, orice program are in spate multe variabile ce lucreaza intre ele sa
faca posibila functionarea. Odata ce vei invata sa lucrezi cu variabile, logica din spatele
programarii ti se va parea destul de simpla si mai ales interesanta.
_____________________________________________________________________
61
___________________________________________________________________
Comentarea codului in Python

In Python, precum si in marea majoritate a limbajelor de programare, avem la dispozitie
sa comentam diverse aspecte ale codului. Aceste comentarii pot fi extrem de benefice
din mai multe puncte de vedere:
• unul dintre ele ar fi faptul ca poti lasa comentarii despre ce face o secventa de
cod - o functie, o clasa, etc (astfel documentezi codul, iar tu sau alte persoane veti
intelege ceea ce face acesta chiar si dupa cativa ani).
• un alt motiv ar fi sa invalidezi o secventa de cod deja existenta (adica vei face
ca acea secventa sa nu fie compilata si executata).
Acum propun sa iti arat 2 exemple astfel incat tu sa intelegi mult mai bine la ce ma refer:
# Linie cu comentariu
print("Se va afisa acest text") # afisare

"""
print (Nu se vor afisa aceste linii)
Bla-bla
"""
Dupa cum poti vedea in cele 2 exemple de mai sus, avem 2 moduri prin care putem lasa
un comentariu: primul fiind cel cu # (diez), iar cel al 2-lea fiind cel cu ””” (3 ghilimele
pentru a incepe sectiunea comentata si alte 3 ghilimele pentru a indica finalizarea
sectiunii comentate). Ambele variante sunt folosite, doar ca varianta a doua ne permite
sa comentam secvente mult mai lungi (care se intind pe mai multe randuri) de text.
Citirea datelor de la tastatura in Python
Inainte de a incepe sa citim datele dintr-un fisier, vreau sa-ti arat cum o poti face de la
tastatura. Probabil ca ai mai interactionat cu citirea datelor de la tastatura in capitolul 2, in
sectiunea de exercitii, iar daca nu ai reusit sa faci acel exercitiu, nici o problema pentru ca
iti voi explica in cele ce urmeaza ce inseamna si cum o poti face. Citirea datelor de la
tastatura (aka. Citirea datelor scrise de catre utilizator direct prin consola) inseamna sa
rulezi un program, iar aceasta sa-ti ceara introducerea datelor direct de la tastatura. Este
o metoda foarte buna de antrenament si de verificare a faptului ca programul tau
functioneaza corect. In aplicatii reale nu vei interactiona foarte mult cu acest mod, decat
_____________________________________________________________________
62
___________________________________________________________________
atunci cand ii ceri utilizatorului sa o faca (in rest vei opera cu fisere sau date transferate
prin retea). Iata mai jos un exemplu de citire a datelor de la tastatura pe care te incurajez
sa-l exersezi si sa-l adopti in programele tale pentru ca poate fi o metoda foarte buna de
testare a programelor lor. Modul prin care putem citi dintr-un program in Python datele
user-ului este prin folosirea functiei input()in felul urmator:
question = input ("Salut! Cum te simti astazi? ")

print("Raspunsul user-ului este:",question)
In urma folosirii codului input(), programul va stoca in variabila question prima linie de
text care va fi introdusa in consola. Un aspect important consta in faptul ca liniile citite
sunt de tipul String, iar asta iti ofera multa flexibilitate pentru ca astfel le poti interpreta si
modifica asa cum doresti tu. Functia input() o poti folosi si fara sa scrii un mesaj intre
paranteze.
_____________________________________________________________________
63
___________________________________________________________________
Exercitii
Felicitari pentru faptul ca ai ajuns la sectiunea de exercitii din acest capitol. Iata
programele pe care te rog sa le creezi:
1) Creeaza cate o variabila de tipul: string, int si float, dupa cum urmeaza:
Variabila de tip int va retine valoarea 20
Variabila de tip int va retine valoarea -5
Variabila de tip double va retine valoarea 8.73
Variabila de tip string retine valoarea “Python”
Variabila de tip string retine valoarea “Imi place programarea in ”
Variabila de tip string retine valoarea “ pentru ca suma acestor 2 numere este: ”
Avand aceste variabile, afiseaza pe ecran un mesaj (care sa aiba cat de cat sens :D ) cu
acestea.
2) Scrie un program care calculeaza valoarea pentru urmatoarele variabile de tip double:
x = -7 + 4/3*5
y = -7 + 4/(3*5)
z = (-7 + 4/3)*5
Afiseaza aceste valori in felul urmator pe ecran:
x = …valoare care se va calcula pentru x…

y = …valoare care se va calcula pentru y…
z = …valoare care se va calcula pentru z…
Observa care sunt diferentele dintre cele trei valori afisate.
_____________________________________________________________________
64
___________________________________________________________________
Capitolul 3 - Instructiuni conditionale (if, for, while)
In acest capitol vom discuta despre elementele de baza din programare care dau logica
programelor noastre. Aceste instructiuni ne contureaza programele si le ofera logica, pe
baza careia sa iau decizii cu privire la rezultatul pe care il vor genera. Cand vorbim
despre instructiunile conditionale ale limbajelor de programare, avem la dispozitie
urmatoarele:
• Instructiunea if - daca se respecta conditia X, atunci se intampla Y

• Instructiunea for - pentru o anumita conditie X, cat timp aceasta este
respectata se intampla Y
• Instructiunea while - cat timp se respecta conditia X, se intampla Y
1) Instructiunea if
Daca ai mai avut de-a face cu programarea, atunci cel mai probabil te-ai intalnit cu
aceasta instructiune if. Ea este una dintre cele mai folosite si cunoscute instructiuni si
este intalnita in marea majoritate a limbajelor de programare (C/C++, Java, Python, PHP,
Ruby, Bash, etc). Scopul ei: sa verifice valoarea de adevar a unei expresii (ex: “5 > 3?”,
aceasta expresie este adevarata). In cazul in care expresia este adevarata se va merge
mai departe cu executarea instructiunilor din blocul IF, iar daca este falsa, se sare peste
tot ce apare in acel bloc. Asadar, sintaxa de cod arata in felul urmator:
if conditie:
instructiune_1
instructiune_2
if conditie_2:
instructiune_3
instructiune_4
La nivel de baza asa se foloseste instructiunea if. Va exista o conditie care va rezulta o
valoare de adevar (fie ea adevarata sau falsa). In cazul in care aceasta valoare este
adevarata (ex: 5 > 3), se vor executa instructiunea 1, instructiunea 2 (si celelalte daca
exista in bloc). Altfel, in cazul in care nu este adevarata conditia (de exemplu pentru 5 >
8), programul va trece de blocul de date if si nu se vor executa cele 2 instructiuni. Poate
_____________________________________________________________________
65
___________________________________________________________________
te intrebi ce reprezinta aceste conditii. Ei bine, conditiile din instructiunea IF pot fi operatii
(comparatii) matematice, precum cele de mai jos:
• A > B - se verifica daca A este mai mare ca B

• A < B - se verifica daca A este mai mic ca B
• A >= B - se verifica daca A este mai mare SAU egal ca B
• A <= B - se verifica daca A este mai mic SAU egal ca B
• A == B - se verifica daca A este egal cu B
• A != B - se verifica daca A este diferit de B
Toate acestea sunt operatii matematice care vor rezulta o valoarea de adevar: fie ea falsa
sau adevarata. Daca instructiunea IF are o conditie ADEVARATA, atunci va continua cu
executarea instructiunilor dupa doua puncte “:”, aliniate corespunzator, in caz contrar
(daca acea conditie este FALSA), se va trece peste acele instructiuni. Da-mi voie sa-ti dau
un exemplu pentru a intelege mai bine :
a = 5
res = 0
if a > 3:
res = a + 1
print(res)
Acum, care crezi ca va fi rezultatul afisat al secventei de cod de mai sus? Dupa cum
probabil ai intuit, rezultatul este 6. Iar acum haide sa vedem de ce. Initial am declarat
doua variabile (a si res), dupa care am creat un bloc de instructiuni folosind if. Prin el
am testat (am verificat) daca valoarea lui a este mai mare decat numarul 3.
Expresia aceasta este adevarata pentru propozitia “5 este mai mare decat 3”, ceea
ce inseamna ca programul nostru merge mai departe si intra in blocul de date if, unde
are loc acea operatie matematica. Acolo se atribuie lui res rezultatul adunarii lui 1 cu 5,
adica 6. Astfel, in momentul afisarii, rezultatul res va fi 6.
NOTA: Un aspect foarte important la codul precedent consta in : (semnul doua puncte)
aflate dupa expresia logica din cadrul if si spatiul (echivalentul unui TAB) din fata
instructiunilor 1, respectiv 2. In programarea “clasica” se folosesc acolade { } pentru a
indica continutul unui bloc de instructiuni. In Python, pentru a pastra lucrurile cat mai
simple cu putinta, se foloseste acest spatiu la inceputul fiecarei instructiuni din cadrul
unui bloc de date. Daca nu apare spatiu la inceputul instructiunii dintr-un bloc conditional
_____________________________________________________________________
66
___________________________________________________________________
(if, for, while), atunci se va considera faptul ca acea instructiune nu apartine

blocului.
In exemplul de mai jos voi modifica conditia din cadrul instructiunii if, iar rezultatul va fi
unul diferit:
a = 5
res = 0
if a > 8:
res = a + 1
print(res)
Atunci rezultatul ar fi fost total diferit: valoarea afisata a lui res, in acest caz, este 0. De
ce? Pentru ca aici a (care are valoarea 5) este mai mic fata de 8, iar expresia a > 8
devine falsa, deci programul nu va mai executa codul dintre acolade dupa cele doua
puncte, aliniate corespunzator, ci va merge mai departe la afisarea valorii lui res. La
executare se va afisa 0. In sectiunea de exercitii de la sfarsitul acestui capitol vei avea
ocazia sa practici mai mult instructiunea if pentru ca vei avea mai multe programe pe
care sa le creezi.
Instructiunea else
Instructiunea if este extrem de benefica in programare pentru ca ne permite sa

comparam sau sa luam anumite decizii logice pe baza rezultatului conditiei (adevarat sau
fals). De multe ori in programare vor exista situatii in care trebuie sa verificam mai multe
conditii si sa luam decizii pe baza lor. Unele conditii sunt adevarate intr-o anumita
situatie, iar altele nu. Forma generala a acestor conditii alternative poate arata in felul
urmator:
if conditie:
instructiune_1
....
else:
instructiune_2
...
_____________________________________________________________________
67
___________________________________________________________________
Dupa cum poti sa vezi, avem if cu prima conditie (care daca este adevarata va fi
executata instructiunea 1), iar in cazul in care aceasta conditie nu este adevarata se
ajunge la executarea instructiunii 2 din else. Hai sa luam un exemplu prin care sa
intelegi mult mai bine ce vreau sa spun:
a = 2
res = 0
if a > 3:
res = a - 1
else:
res = a + 1
print(res)
In acest exemplu poti sa vezi ca in cazul in care a este mai mare decat 3, atunci res va
avea valoarea a - 1. Daca aceasta conditie este falsa (a nu este mai mic decat 3, ceea
ce in acest exemplu asa este), programul va trece de instructiunile din blocul if si va
merge mai departe in blocul else. Aici va executa instructiunea de adunare res = a +
1, iar apoi va afisa rezultatul 3. Orice valoarea a lui a care nu respecta a > 3, va ajunge
sa execute instructiunea din blocul else. Daca ar fi sa mergem mai departe si sa fim si
mai specifici in alegerea rezultatului dorit, putem structura if in formatul urmator:
if conditie_1:
instructiune 1
...
elif conditie_2:
instructiune_2
...
else:
instructiune_3
...
...
_____________________________________________________________________
68
___________________________________________________________________
Iar mai jos poti sa vezi exemplul:
a = 2
res = 0
if a > 3:
res = a - 1
elif a == 3:
res = a
elif a < 3:
res = a+1
else:
print("Nu exista un rezultat pentru res.")
print(res)
In exemplul de mai sus poti sa vezi in detaliu cum poti sa folosesti instructiunea if,
combinand si instructiunea else. Indiferent daca este vorba de elif sau pur si simplu
else, putem executa instructiuni diferite daca conditia initiala (din primul if) nu a fost
indeplinita. Acesta este o metoda foarte buna pe care o putem folosi cand vrem sa
rezolvam anumite probleme (cu programul nostru) pentru ca ne va fi mult mai usor sa
filtram si sa executam instructiunile corecte. In final se va afisa 3.
Exemplul #2
Inainte de a merge mai departe propun sa mai luam un exemplu. De data aceasta iti vom
rezolva o problema de programare care suna cam asa:
“Fiind data nota unui elev să se afișeze dacă acesta este corigent, promovat
sau premiant.”
Pentru a rezolva aceasta problema trebuie sa ne gandim la toate scenariile posibile:
Q1: In ce situatie ramane un elev corigent la o materie?

A: In situatia in care media lui este sub 5.
Q2: In ce situatie va fi un elev promovat la o materie?
A: In situatia in care media lui este o nota mai mare sau egala cu 5.
Q3: In ce situatie va fi un elev premiant la o materie?
A: In situatia in care media lui este 10 la materia respectiva.
_____________________________________________________________________
69
___________________________________________________________________
Acum ca am spart aceasta problema in mai multe bucati, haide sa le punem cap la cap
folosindu-ne de instructiunile invata anterior:
notaElev = 10
materie = "Matematica"
if notaElev < 5:
print("Elevul este corigent la materia: ", materie)
elif notaElev >= 5 and notaElev < 10:
print("Elevul a promovat materia: ", materie)
elif notaElev == 10:
print("Elevul este premiant la materia: ", materie)
else:
print("Nota introdusa nu este corecta")
Care crezi ca va fi mesajul afisat pe ecran? Ai ghicit, este vorba despre mesajul din cel
de-al treilea bloc if.
Elevul este premiant la materia: Matematica
Daca vei incerca sa modifici notaElev, vei putea vedea cum rezultatul va fi diferit in
functie de valoarea pe care o atribui.
_____________________________________________________________________
70
___________________________________________________________________
2) Instructiunea for
Mergand mai departe cu subiectul legat de instructiunile conditionale din programare,

am ajuns la instructiunea for. O instructiune care ne permite sa-i spunem programului
nostru sa execute un cod in mod repetat (atat timp cat se respecta o conditie).
Gandeste-te in felul urmator: cum ar fi daca am avea 100 operatiuni de verificat, iar in
urma fiecareia sa efectuam un anumit calcul sau sa afisam un rezultat. Cu cele invatate
pana acum, am vazut ca se poate face asta, doar ca mica problema ar consta in faptul ca
ar trebui sa facem totul manual. Practic, pentru fiecare operatiune de verificare (folosind
cate un if), ar trebui sa scriem manual fiecare secventa de cod. Problema cu metoda
asta e ca necesita mult timp, nu e scalabila, iar in timp va consuma multa memorie. Hai
sa-ti dau un exemplu concret. Iata mai jos o secventa de cod scrisa intr-un mod “clasic”:
i = 0
suma = 0
a = 5
if i == 0:
suma = suma + a
i += 1
if i == 1:
suma = suma + a + i
i += 1
if i == 2:
suma += a + i
i += 1
if i == 3:
suma += a + i
i += 1
print("Suma este: ", suma)
In aceasta secventa poti sa vezi ca am calculat o anumita suma in functie de variabila a

si i. Rezultatul acestei sume este: 26. In aceasta situatie, a este pur si simplu o variabila
int careia i-am asignat o valoare, iar i este un iterator (o variabila care contorizeaza
numarul de procesari). Dupa fiecare calculare a sumei, acest iterator i va fi incrementat
(prin i+=1), este echivalenta cu i = i + 1 iar valoarea acestuia va creste cu 1.
_____________________________________________________________________
71
___________________________________________________________________
ATENTIE: In Python nu putem folosi i++. In programarea in Java, C++, expresia i++ este
echivalenta aici in Python cu i = i + 1;. Acum hai sa-ti arat aceeasi secventa de cod,
dar de data asta scrisa cu for:
suma = 0
a = 5
ii = [0, 1, 2, 3]
for i in ii:
suma += a + i
Dupa cum poti sa vezi in aceasta secventa de cod, lucrurile au fost mult simplificate cu
ajutorul lui for specificand urmatoarele:
1. In el am declarat o variabila de tip lista (mai multe detalii in capitolul 5) denumit

ii care contine valori de la 0 la 3.
2. In cadrul instructiunii for, cu ajutorul keywordului in, am specificat faptul ca
variabilei nou create i se vor aloca (pe rand) fiecare valoare in parte existenta in lista.
3. Aceasta bucla se va executa pana cand variabila i a parcurs fiecare element
din lista ii.
Dupa cum poti sa vezi, in aceasta situatie for face diferenta dpvd. al codului, al executiei
acestuia si al memorie consumate. Ideea aici consta in task-uri repetitive. Prin for putem
crea bucle (loops) care sa verifice/opereze diferite secvente de cod, in mod repetat.
Vei vedea putin mai tarziu in aceasta carte, cum putem folosi for atunci cand vine vorba
de structuri de date (parcurgerea, modificarea, verificarea lor), de clase si obiecte, iar
astfel vei avea o idee mult mai buna despre utilizarea acestei instructiuni. Dupa cum am
spus si la inceputul acestui capitol, instructiunile conditionale (if, for, while) stau la
baza majoritatii limbajelor de programare si este modul prin care noi putem programa
calculatorul, astfel incat sa ne folosim intr-un mod cat mai simplu si eficient de resursele
acestuia. Mai jos poti sa vezi cum arata secventele de cod exemplificate mai devreme.
Pe langa acest exemplu de folosire a unei liste in cadrul for,se mai poate folosi functia
range(). Aceasta functie va genera un sir de numere in functie de parametrul acordat.
Iata un exemplu din interpretorul Python:
_____________________________________________________________________
72
___________________________________________________________________
>>> range(4)
[0, 1, 2, 3]
>>> range (8)
[0, 1, 2, 3, 4, 5, 6, 7]
Asadar, avand acest gand in minte, putem optimiza codul de mai devreme, astfel:
suma = 0
a = 5
for i in range(4):
suma += a + i
Dupa cum poti sa vezi, am eliminat lista precedenta ii si am folosit functia range() in
cadrul for. Rezultatul acestei secvente va fi acelasi:
Suma este: 26
Exemplul #2
Acum vom lua in alt exemplu de problema de programare pe care o vom putea rezolva
cu ajutorul instructiunii invatate anterior:
“Se dau trei numere naturale a b x. Sa se verifice daca numarul x apartine

intervalului [a,b].”
In cazul acesta ne vom seta un interval aleator (in exemplul de mai jos am ales de la 3 la
9) si vom parcurge fiecare numar intreg din interval pana in momentul in care il gasim pe
x. Daca x apartine intervalului vom afisa un mesaj afirmativ si vom intrerupe parcurgerea
buclei mai departe, iar in cazul in care x nu apartine intervalului, atunci vom afisa un
mesaj corespunzator. Iata rezolvarea acestei probleme in secventa de cod de mai jos:
a = 3
b = 9
x = 4
_____________________________________________________________________
73
___________________________________________________________________
for i in range(a,b+1):
if x == i:
print ("x se afla in intervalul [a,b]")
break
if i == b:
print ("x nu se afla in interval")
Dupa cum poti vedea, am creat o bucla for pe care o iteram de la 4 la 9 prin functia
range (care primeste ca argument o valoare de start si una de final). Apoi in interiorul for
comparam valoarea lui x cu valoarea lui i din momentul iteratie, iar in cazul in care
rezultatul este adevarat (x == i) se va afisa mesajul pe ecran si bucla se va opri (prin
instructiunea break). De ce folosim break pentru a opri bucla? Pentru odata gasita
valoarea lui x in interval, nu mai are sens sa cautam mai departe (astfel “economisim”
consum de memorie si procesare). Rezultatul afisat in acest caz va fi:
x se afla in intervalul [a,b]
Mai departe te invit pe tine sa testezi cu valori diferite ale lui x. Incearca cu x = 1, x =
8, x = 10, x = -1, x = 5.6. Ce rezultate ai obtinut si de ce? Noteaza raspunsul in
caietul tau de notite.
_____________________________________________________________________
74
___________________________________________________________________
3) Instructiunea while
Instructiunea while are o functionalitate similara cu cea de for, doar ca se foloseste

putin diferit. Cand folosim while putem gandi problema in felul urmator: cat timp se
intampla X, executa Y. Pe de alta parte, cand folosim for, gandim problema in urmatorul
mod: pentru o anumita conditie X, se intampla Y. Cele 2 abordari seamana, dar sunt
usor diferite (sunt folosite in contexte diferite). Buclele for sunt folosite mai des in
momentul in care se cunoaste numarul fix de iteratii care trebuie sa aiba loc pe parcursul
rularii programului, iar while folosim cand nu cunoastem acest numar. O bucla while se
poate folosi cand dorim sa rulam un program la infinit (prin while True). Deci formatul
standard pentru aceasta bucla este:
contor = 0
while contor < 100:

instructiune 1
...
contor += 1
In cazul instructiunii while (sau orice bucla in general) trebuie sa fim atenti sa nu
generam o bucla infinita (un program care ruleaza la nesfarsit si consuma resurse fara un
scop). In exemplul de mai sus, acest lucru s-ar fi produs daca instructiunea contor += 1
nu ar fi fost introdusa (contor ar fi ramas la valoarea 0 si bucla ar fi rulat in continuu
pentru ca valoarea acestei variabile nu se modifica). Sa reluam secventa de cod de mai
devreme:
suma = 0
a = 5
ii = [0, 1, 2, 3]
for i in ii:
suma += a + i
Iar acum iata aceeasi varianta, dar cu instructiunea while:
suma = 0
_____________________________________________________________________
75
___________________________________________________________________
a = 5
i = 0
while i <= 3:
suma += a + i
i += 1
print("Suma este: ",suma)
Exemplul #2
In aceasta sectiune propun sa luam exemplul #2 de la sectiunea precedenta (cea cu
instructiunea for) si sa “convertim codul” din for in while. Iti reamintesc enuntul
problemei si iata mai jos si rezultatul acestui cod:
“Se dau trei numere naturale a b x. Sa se verifice daca numarul x apartine intervalului [a,b].”
a = 3
b = 9
x = 5
i = a
while i <= b:
if x == i:
print ("x se afla in intervalul [a,b]")
break
if i == b:
print ("x nu se afla in interval")
i += 1
Rezultatul in urma executarii secventei de cod va fi acelasi ca in cazul folosirii for.

Intentia mea a fost sa-ti arat inca odata cum poti folosi si cum poti sa interschimbi cele
doua instructiuni. Vei vedea si in exercitiile urmatoare (si in capitolele viitoare) ca exista
situatii in care folosirea while are mai mult sens fata de for (si este chiar mai eficient
dpvd. computational) si invers.
_____________________________________________________________________
76
___________________________________________________________________
Exercitii
Felicitari! Acum ai ajuns la sectiunea in care e timpul sa creezi tu (cu cele invatate)
propriile programe folosind Python. Te rog sa incerci pe cat posibil sa faci singur aceste
exercitii, sa faci research pe Google doar daca lipseste ceva esential (fara sa cauti direct
solutia) sau daca nu stii ce ai gresit.
1) Creeaza un program care determina daca un numar (introdus de la tastatura) este par
sau impar. Se va afisa (print) in terminal un mesaj similar cu: "Numarul introdus X este
par", in cazul in care numarul este par, iar "Numarul nu este par" in rest.
NOTA: un numar este par daca se poate imparti la 2. Exemplu (2, 4, 8, 24150, etc.)
2) Creeaza un chestionar de intrebari pe care o persoana din departamentul de resurse

umane le poate adresa la interviul de angajare. Vor exista 5 intrebari (similare cu cele de
mai jos) pe care le vei adresa persoanei care va rula programul si care va putea sa le
raspunda prin inputul sau de la tastatura. In timpul executiei programului, acesta
stocheaza datele, iar la sfarsitul acestor intrebari se vor afisa sub forma urmatoare:
"Canditatul X a raspuns astfel la intrebarile de mai sus: ..."

Intrebarile: "Cum te numesti ?", "Ce job iti doresti ?", "In cat timp crezi ca poti obtine acest
job ?", "Care sunt pasii pe care trebuie sa-i urmezi pentru a te putea angaja ?", "De cand
doresti sa incepi ?"
3) Creeaza un program care determina daca un cuvant (string) introdus de catre utilizator
(de la tastatura) este Palindrom sau nu. Un palindrom este un sir de caractere care citit de
la stanga la dreapta sau de la dreapta la stanga ramane neschimbat.
Exemplu: lupul, capac, apa, cojoc - toate se citesc la fel din ambele parti.
WHILE / FOR
In aceasta parte a sectiunii practice ne vom juca putin si vom face putina matematica (de
fapt, calculatorul, nu noi... :D ):
4.1) Calculeaza suma tuturor numerelor de la 1 la 100. Creeaza o varianta a programului

folosind bucle FOR, iar alta varianta folosind bucle WHILE. Afiseaza rezultatul pe ecran
intr-un format precum: "Suma numerelor de A la Z este... ".
4.2) Dinamizeaza programul prin adaugarea optiunii de introducere a celor 2 numere (nr.
de inceput si cel de sfarsit) de la tastatura, de la punctul anterior.
_____________________________________________________________________
77
___________________________________________________________________
5) Creaza un joc “Hartie-Piatra-Foarfece” la care participa 2 persoane. (Nota: foloseste-te

de functia "input()" pentru a cere date de la jucatori; in momentul cand cineva castiga,
afiseaza un mesaj de felicitare si intreaba utilizatorii daca doresc sa inceapa un joc nou)
Amintiti-va regulile: Piatra bate foarfeca; Foarfeca bate hartia; Hartia bate piatra.
PS: foloseste-te de conditile logice discutate in lectile anterioare (if, for sau while)
_____________________________________________________________________
78
___________________________________________________________________
Capitolul 4 - Functii in Python

Continuam drumul nostru spre a invata programare cu un capitol in care vom vorbi
despre functii. Vom vedea ce sunt functiile, de ce avem nevoie de ele si cum le putem
folosi. La sfarsitul acestui capitol vei avea o sectiune cu exercitii pe care te rog sa le
rezolvi dupa ce termini de citit si de aplicat conceptele care vor fi explicate in
urmatoarele randuri. Nu uita faptul ca, pentru a deveni programator ai nevoie de foarte
multa practica. Nu ajunge doar sa stii si sa intelegi conceptele, ci ai nevoie sa le si faci. Sa
trecem la treaba!
Ce este o Functie?
O functie este o modalitate prin care putem grupa codul nostru astfel incat sa poata fi
folosit de mai multe ori (fara a necesita rescrierea acestuia). Practic, este o forma de a
grupa, de a structura codul nostru, astfel incat noi sa scriem cod mai eficient, mai rapid si
cu mult mai multa usurinta. Putem spune ca este un subprogram. Acest lucru este bine
atat pentru noi cat si pentru program pentru ca astfel va consuma mai putine resurse si
va fi mai usor de inteles datorita structurii sale. Exista mai multe tipuri de functii:
• functii (grupari de cod) care nu intorc nici un rezultat, adica functii void (ex:
efectueaza o operatie “in spate”)
• functii (grupari de cod) care intorc un anumit rezultat (ex: numele unei persoane)
Mai intai vom vorbi despre primul tip de functii, cele void, care nu intorc un rezultat.
_____________________________________________________________________
79
___________________________________________________________________
1) Functii care nu intorc un rezultat
Acum vom lua un exemplu de program in care iti voi arata cum functioneaza aceste
functii. Ce vom face este sa cream o functie, iar modul in care vom face asta este
exprimat in secventa de cod de mai jos:
def primaFunctie():
pass
In exemplul precedent am definit o functie (denumita primaFunctie) care in momentul de

fata nu contine nici o instructiune (in afara de pass). Instructiunea pass specifica
interpretorului sa mearga mai departe. Ea se pune de obicei intr-o functie sau intr-o clasa
goala cu scopul de a fi completata mai tarziu, astfel programul poate sa ruleze in
continuare. Pentru a extinde functia precedenta putem introduce urmatoarele linii de
cod:
def primaFunctie():
print("Salut!")
print("Aceasta este prima mea functie")
print("Ma simt bine, progresez :)")
Functia a fost definita, dar nu va face nimic daca nu va fi apelata, iar pentru asta vom
adauga o linie noua de cod astfel:
primaFunctie()
iar rezultatul generat va fi:
Salut!
Aceasta este prima mea functie
Ma simt bine, progresez :)
Atat! Lucrurile nu sunt deloc complicate si dupa cum ai vazut, functiile reprezinta blocuri
de cod cu scopul de a-l reutiliza in viitor. Deci, practic noi putem creea o functie care sa o
folosim in n (zeci, sute) de situatii, cum de exemplu este functia print() din Python care
este o functie built-in pe care am folosit-o de foarte multe ori pana acum.
_____________________________________________________________________
80
___________________________________________________________________
Argumentele unei functii in Python
Functiile noastre nu trebuie sa fie secvente banale de cod care sa faca lucruri marunte si
care sa fie total lipsite de contextul programului nostru. Pentru asta exista anumite
argumente (variabile) care pot fi atribuite functiilor ca in exemplul de mai jos:
def functieArgumente(nume, varsta):

print("Numele meu este ", nume," si am varsta de ", varsta," ani")
functieArgumente("Ramon", 25)
Iar rezultatul afisat va fi:
Numele meu este Ramon si am varsta de 25 ani
De asemenea putem adauga si variabile ca parametrii ale functiei, nu doar valori, iar
rezultatul va fi acelasi:
def functieArgumente(nume, varsta):

print("Numele meu este ", nume," si am varsta de ", varsta," ani")
name = "Ramon"
age = 25
functieArgumente(name, age)
In urmatoarea sectiune vom discuta despre metodele care pot intoarce un rezultat pe
care noi sa-l putem folosi.
Exemplul #2
Vom lua urmatoarea problema si o vom rezolva folosindu-ne de ceea ce am invatat mai
devreme:
“Scrie un program care sa afiseze numarul maxim dintre doua numere aleatoare.”
Solutia pentru aceasta problema este urmatoarea:
_____________________________________________________________________
81
___________________________________________________________________
def valoareaMaxima( x, y ):
if x > y:
print(x)
else:
print(y)
valoareaMaxima(31, 7)
Iar rezultatul afisat va fi: 31. Exemplul este destul de simplu, dar vei vedea in sectiunile
urmatoarea cum vom construi pe baza lui. Acum, te invit sa testezi acelasi cod cu mai
multe variante, modificand valorile variabilelor.
2) Functii care intorc un rezultat
O functie (dupa cum am spus si mai devreme) reprezinta o grupare structurata a unei
secvente de cod cu scopul de a face codul reutilizabil si usor de inteles (fapt care duce la
edificentizarea volumului de munca depusa). Ca exemplu practic ne putem gandi la un
blender care contine multe fructe. Ele toate vor ramane acolo. Nu vor putea fi turnate
intr-un pahar. Acum vrem sa le si turnam intr-un pahar, astfel incat sa ne si putem folosi
de rezultatul pe care aceasta metoda sau functie il genereaza. In cele ce urmeaza vom
lua exemplul de mai devreme pentru ati arata concret cum sa folosesti acest tip de functii
in Python:
if x > y:
return x
else:
return y
res = valoareaMaxima(31, 7)
print("Rezultatul final este", res)
Dupa cum poti sa vezi, singura diferenta (semnificativa) intre acest tip de functie si cel
precedent are de a face cu keywordul return, care specifica valoarea variabilei care sa
fie intoarsa ca rezultat in momentul in care functia este apelata. O functie poate fi folosita
_____________________________________________________________________
82
___________________________________________________________________
pentru a ne oferi un anumit rezultat (de care noi sa ne folosim ulterior) sau pentru a face
anumite modificari in cadrul ei, neavand nevoie de rezultatul specific. In final se va afisa:
Rezultatul final este 31
Daca nu am fi folosit secventa res = valoareaMaxima(31, 7) nu am fi putut sa

stocam rezultatul si sa ne folosim de el ulterior pentru a face alte operatiuni.
Exemplu #2
Acum ca ai inteles principiile de baza, iti propun sa facem ceva putin mai complex. Vom
creea un program care va prelua datele de la utilizator (nume, username, parola) si va
cripta (securiza) parola astfel incat ea sa nu poate fi descifrata de catre un hacker. Pentru
asta vom avea nevoie de doua functii: una care obtine si stocheaza informatia oferita de
catre user si cealalta care securizeaza (cripteaza) parola. Codul nostru pentru prima parte
va arata in felul urmator:
def getNume():
nume = input("Introdu numele tau:")
return nume
def getUser():
user = input("Introdu usernamul pe care il doresti:")
return user
def getParola():
parola = input("Introdu parola pe care o doresti:")
while len(parola) < 5:
print("Parola ta e prea scurta. Mai incearca")
parola = input("Introdu parola pe care o doresti:")
return parola
nume = getNume()
user = getUser()
parola = getParola()
_____________________________________________________________________
83
___________________________________________________________________
In secventa de mai sus am creat trei functii, fiecare avand rolul de a obtine datele
specifice de la utilizator. Functiei getParola(), i-am adaugat o masura mai mare de
securitate in sensul in care nu va permite stocarea parolelor mai mici de 5 caractere
(incearca sa introduci o parola de 3 caractere si observa rezultatul :D ).
Codul nostru pentru partea de securizarea a parolei va arata in felul urmator:
def securizareParola(parola):
parolaSecurizata = hash(parola)
return parolaSecurizata
def getDateUser(nume, user, parola):
"""Datele user-ului pot fi returnate ca un dictionar si folosite

ulterior, dar de dragul exemplului eu le voi afisa in consola"""
print("Datele de identificare ale user-ului sunt", nume, user, parola)
In functia de securizarea a parolei folosim o functie built-in in Python care se numeste

hash(). Aceasta genereaza o valoarea unica pentru orice sir sau numar pe care il
primeste ca argument si este o modalitate extrem de folosita pentru securizarea
parolelor stocate in bazele de date. Daca esti interesat de partea de Securitate si vrei sa
inveti mai multe iti recomand cartea mea de Introducere in Securitate Cibernetica. Mai
multe detalii poti afla aici. Dupa ce este apelata functia hash(), aceasta va genera un
rezultat sub forma unui sir de numere, ireversibil (din acest sir nu se poate regenera
parola) care va fi intors de catre functia principala. Urmatoarea functie va afisa datele
intr-un format simplu si usor de vizualizat. Iar in secventa de mai jos am pus lucrurile cap
la cap pentru a ne afisa un rezultat valid:
parolaSec = securizareParola(parola)
print("Parola", parola, "a fost securizata si este", parolaSec)
getDateUser(nume, user, parolaSec)
Si rezultatul afisat va fi:
Introdu numele tau: Adi
Introdu usernamul pe care il doresti: adiuser
Introdu parola pe care o doresti: python2019
_____________________________________________________________________
84
___________________________________________________________________
Parola python2019 a fost securizata si este 748367380273021697
Datele de identificare ale user-ului sunt: Adi adiuser 748367380273021697
3) Functii recursive
Functia recursiva este o functie care se apeleaza pe sine pentru a produce rezultatul
dorit. In aceasta sectiune iti voi da doua exemple despre cum poti sa folosesti functiile
recursive.
Exemplu #1 - Maximul dintre 3 numere
Avem problema cu urmatoarea cerinte care se doreste a fi rezolvata intr-un mod mai
eficient:
“Scrie un program care sa afiseze numarul maxim dintre trei numere aleatoare.”
Solutia este urmatoarea:
if x > y:
return x
else:
return y
def numarMax( x, y, z ):
return valoareaMaxima( x, valoareaMaxima( y, z ) )
print(numarMax(2, 7, -2))
Dupa cum poti sa vezi am definit doua functii: prima functie (valoareaMaxima)
determina valoarea maxima dintr-o doua numere, iar a doua functie (numarMax) se
foloseste de prima pentru a determina valoarea cea mai mare dintre cele 3 numere. Cum
face asta? Din secventa: valoareaMaxima(x, valoareaMaxima(y,z))mai intai se
va determina rezultatul functiei date ca parametru (adica se vor compara valorile lui y si z
si se va stabili cea mai mare valoarea - in cazul acesta 7), dupa aceea se va executa
_____________________________________________________________________
85
___________________________________________________________________
aceeasi functie, dar folosindu-se de valoarea lui x (in cazul acesta 2), respectiv cea a
rezultatului dintre y si z (adica 7 in acest exemplu). Rezultatul acestei secventa va fi: 7
Exemplu #2 - N! (n factorial)
Acest exemplu va fi unul putin mai complex dpvd al conotatiei matematice, dar invitatia
mea pentru tine este sa dai la o parte ideile si parerile (adesea) negative pe care le-ai
putea avea fata de matematica si sa urmezi cu mine exemplul. Iti mai aduci aminte cum
erau la matematica operatiile factoriale (studiate la liceu)? Daca nu, iti explic aici. Notatia
era aceasta: n! si se citea n factorial. Cat este 5! ? Conform formulei n! = n * (n - 1)!
rezultatul pentru 5! va fi:
5 * 4 * 3 * 2 * 1 = 120
Detaliez aici rezolvarea:

5! = 5 * (5 - 1)! = 5 * 4!
unde 4! = 4 * (4 - 1)! = 4 * 3!
unde 3! = 3 * (3 - 1)! = 3 * 2!
unde 2! = 2 * (2 - 1)! = 2 * 1!
unde 1! = 1
Acum daca inlocuim:

5! = 5 * (5 - 1) * (4 - 1) * (3 - 1) * (2 - 1) = 5 * 4 * 3 * 2 * 1
De aici ajungem la: 5! = 120
Cum poti face asta in programare?
Creand o metoda care este recursiva. O metoda recursiva este o functie care se
apeleaza pe ea insasi, adica se autoapeleaza. Atunci cand cream o astfel de metoda,
primul lucru de care trebuie sa tinem cont este ca aceasta metoda sa contina cel putin o
conditie de oprire. Odata ce se ajunge la indeplinirea conditiei de oprire, metoda nu se
va mai apela, astfel se va opri recursivitatea.
def fact(n):
if n == 1:
return 1
else:
return (n * fact(n - 1))
_____________________________________________________________________
86
___________________________________________________________________
print(fact(5))
Aici in cod am aplicat exact rezolvarea unui factorial. Daca am apela 1!, adica in loc de
fact(5) am scrie fact(1) functia recursiva nu ar avea sansa sa se autoapeleze. Daca in
schimb am apela 2!, functia s-ar autoapela singura o data (pentru ca prima apelare are
loc dupa functia de print). Astfel atunci cand se apeleaza functia pentru 5! pana cand se
ajunge la apelarea fact(1), iar aici functia va returna 1.
4) Functia main()
Exista mai multe moduri de a rula un program:
a) Sub forma unui script - parcurgand secvential: un script in Python este un fisier pe
care vrei sa il executi din linia de comanda pentru a realiza o sarcina.
Modul in care ii spui calculatorului sa execute cod din linia de comanda este usor diferit
in functie de sistemul de operare al fiecaruia. Pe Linux si macOS, linia de comanda arata
ca in exemplul de mai jos:
user@python:~/Documents$
Partea dinaintea semnului $ poate arata diferit, in functie de numele de utilizator.

Comenzile pe care le tastati vor fii dupa $.
Pe Windows, linia de comanda arata de obicei ca in exemplul de mai jos:
C:\Users\user\Documents>
Partea de dinainte de semnul > poate arata diferit, în functie de numele de utilizator.
Comenzile pe care le tastati vor fii după acest semn >.
b) Import din module si folosire functii: un modul in Python este un fisier pe care doresti
sa il importi intr-un alt modul sau intr-un script. De multe ori, este necesar sa importam
module construite deja pentru a ne face munca mai usoara, iar aceasta se face prin
cuvantul cheie: import. In timpul procesului de importare, Python executa instructiunile
definite in modulul specificat.
_____________________________________________________________________
87
___________________________________________________________________
c) Rularea programului printr-un fisier in care exista o ordine specifica a lucrurilor de

executie. Acest mod se face prin folosirea functiei main(). Este un fisier care contine cod
si are extensia: .py
def main():
print("main code")
def func():
print("func")
func()
if __name__ == "__main__":
main()
Python nu atribuie nicio semnificatie unei functii numite “main”, dar tinand cont ca alte
limbaje de programare folosesc functia main pentru a defini functia principala, cea mai
buna practica este de a defini functia principala din cod: main, iar functia main trebuie sa
contina orice cod pe care doresti sa il rulezi, atunci cand Python executa fisierul. Ca idee
principala, ar trebui denumita functia principala: “main” pentru a comunica intentia
functiei, chiar daca Python nu atribuie vreo semnificatie acestui nume, iar ca structura
pentru cod, daca doresti sa refolosesti o anumita functie din cod, ii poti defini logica in
afara functiei main, iar apoi sa o apelezi in interiorul functiei main ca in exemplul de mai
jos:
def produs():
print(2*3)
def func():
print("func1")
def main():
produs()
func()
main()
_____________________________________________________________________
88
___________________________________________________________________
Exercitii
Dupa cum te-ai obisnuit pana acum, la fiecare final de capitol iti pun la dispozitie un set
de exercitii pe care tu sa le practici.
1) Scrie un program ce foloseste o functie care gaseste cel mai mare numar dintre 3
numere date.
2) Scrie un program ce foloseste o functie cu ajutorul careia putem obtine inversul unui
String dat.
3) Scrie un program ce testeaza daca un numar este prim sau nu. Un numar prim este
acela care nu se poate imparti exact la niciun numar.
_____________________________________________________________________
89
___________________________________________________________________
Capitolul 5 - Structuri de Date in Python

In acest capitol si in urmatorul vom discuta despre elementele fundamentale din
programare care ne fac viata mai usoara atunci cand lucram cu date: structurile de date.
La sfarsitul acestui capitol iti va fi mult mai clar ce sunt acestea, unde si cand le poti folosi
si mai ales de ce sa le folosesti.
Ce sunt structurile de date?
Structurile de date sunt fix ceea ce sugereaza titlul: structuri de date. Sunt anumite tipuri
de date speciale care ne ajuta pe noi sa le structuram si sa le manipulam in functie de
obiectivul nostru. Mai exact, structurile de date reprezinta o grupare de date care sunt
organizate, stocate si manage-uite cu scopul de face accesul si modificarea (datelor) cat
mai eficienta si mai usoara. Fiecare structura de date (ex: stive, cozi, vectori etc.) are un
comportament, un mod de acces la date si functii specifice. Utilizarea acestora depinde
foarte mult de context si, bineinteles, de problema care se doreste a fi rezolvata. In cele
ce urmeaza vom discuta mai multe despre acestea, dar mai intai hai sa vedem de cate
tipuri pot fi aceste structuri de date.
Tipuri de structuri de date
Cand vine vorba de structuri de date, avem mai multe tipuri din care putem alege in
functie de nevoie. Iti voi enumera cateva dintre cele mai des folosite, dupa care vom
incepe sa discutam (si sa le folosim) pe fiecare in parte:
• Listele reprezinta un tip de structuri de date care permit ordonarea si

schimbarea elementelor din cadrul ei. In cadrul eipot exista elemente duplicate.
• Tuple (perechi) reprezinta un tip de structuri de date ordonata si neschimbabile.

In cadrul ei pot exista elemente duplicate.
• Dictionarul reprezinta un tip de structuri de date care nu este ordonata,

modificabila si indexata. In cadrul ei nu pot exista elemente duplicate.
• Set-ul (multimile) reprezinta un tip de structuri de date neordonata si

neindexata. In cadrul ei nu pot exista elemente duplicate.
_____________________________________________________________________
90
___________________________________________________________________
Acestea reprezinta structurile de date existente by default in Python. Pe langa acestea

mai exista multe altele care fie au fost implementate deja, fie necesita implementare
proprie (cum ar fi grafurile, arborii, cozile si altele). In general vei gasi module existente
prin care te poti folosi de implementari eficiente ale acestora. Un aspect important pe
care trebuie sa-l avem in considerare este faptul ca fiecare structura de date are rolul sau
si utilitatea potrivita in anumite contexte.
De exemplu, daca dorim sa stocam mai multe elemente si sa le accesam recurent (prin
cautare), ar fi mai util sa utilizam un anumite structuri (dictionare sau multimi), in schimbul
altora. De ce? Pentru ca timpii de accesare/cautare sunt mult redusi fata de alte structuri
(liste, dictionare, set-uri etc.). Acum haide sa le luam pe rand si sa vorbim despre fiecare
in parte.
_____________________________________________________________________
91
___________________________________________________________________
1) Liste
Lista este o structura de date care poate retine mai multe valori. Spre exemplu, intr-o
lista, variabila a poate sa fie un integer, un string, dar nu ambele in acelasi timp.
Declararea acestor siruri este foarte simpla, fiind asemanatoare cu declararea unei
simple variabile. Deosebirea dintre o variabila si o lista, este ca variabila poate sa aiba
alocata o singura valoare pe cand unei liste ii pot fi alocate mai multe valori. Intr-o lista,
variabila a poate avea valorile 1, 2, 3, 4 (aka. de tip numeric) si asa mai departe, dar si
valoarea “Salut”, “bun venit”, “next level”, (aka. de tip string) etc. Cel mai bun exemplu de
lista este feed-ul de Facebook si contactele din dreapta, ce sunt asezate intr-o ierarhie.
Mai poti identifica o lista si intr-o baza de date, unde un sir de intrari, fiecare cu
elementele lui, este de fapt, o lista. Elementele din cadrul unei liste sunt numerotate de
la 0 si pot fi accesta printr-un index (numarul pozitiei pe care acesta se afla). Daca lista
are 10 elemente in cadrul ei, atunci acestea vor fi numerotate de la 0 la 9 si vor putea fi
accesate in felul urmator:
Figura 5.1
arr = [1,2,3,4,5,6,7,8,9,10]
print(arr[0])
print(arr[5])
print(arr[9])
Rezultatul afisat va fi:

1
6
10
NOTA: termenul de arr vine de la array (aka. sir), un tip de structura de date, care in
Python este asociata cu listele (practic sunt acelasi lucru in acest limbaj de programare)
_____________________________________________________________________
92
___________________________________________________________________
Dupa cum am spus si mai devreme, in programare numaratoarea incepe de la 0, astfel

prima pozitie a variabilei noastre "arr", declarata cu 10 pozitii este 0, iar ultima este 9.
Atribuirea valorilor a unei anumite pozitii se face prin index (ex: [3], [5] ), care este
valoarea aflata in parantezele drepte si determina pozitia careia ii va fi atribuita valoarea
dorita.
Care sunt functiile unei Liste?
Valorile unei liste pot fi modificate (prin adaugarea, actualizarea sau stergerea elementor
din cadrul ei). Exista numeroase operatiuni care se pot face cu listele, atat prin operatori
cat si prin functii built-in. Iata mai jos o parte dintre ele:
• .append(value) – adauga un element la sfarsitul listei

• .insert(index, value) – adauga un element la indexul specificat
• .pop(value) – sterge elementul din lista si il returneaza
• .remove(value) – sterge element din lista
• .sort() – sorteaza lista crescator, by default
• .reverse() - inverseaza ordinea din lista
Pe langa aceastea mai putem include urmatoarele operatii:
• Accesarea valorilor
• Concatenarea
• Repetitia
• Iterarea
• Apartenenta
Cum folosim o lista in Python?
In continuare vom vedea cateva moduri de a pune in practica functiile acestei structuri de
date. Mai intai sa definim o lista:
#Definirea si accesarea valorilor dintr-o lista

listX = ['AI&ML', 'TensorFlow', 1991, 2022]
listZ = [1, 2, 3, 4, 5, 6, 7]
print("listX[0]: ", listX[0])
print("listZ[1:5]: ", listZ[1:5])
print("listX[-1]: ", listX[-1])
_____________________________________________________________________
93
___________________________________________________________________
Rezultatul va fi:
listX[0]: AI&ML
listZ[1:5]: [2, 3, 4, 5]
listX[-1]: 2022
In continuare vom aborada functiile discutate in sectiunea de mai devreme prin

urmatoarea secventa de cod:
#Concatenarea
listA = [1, 2, 3]
listB = [4, 5, 6]
print(listA + listB)
#Lungimea
print("Lungimea tuplului este:",len(listA))
#Repetitia
listR = ["RO"] * 3
print(listR)
#Iterarea
for x_list in [1, 2, 3]:
print(x_list)
#Apartinerea
print(3 in [1, 2, 3])
print(9 in listB)
#Folosirea functiilor specifice listelor
print("Old:",listX)
listX.append("Data Science")
print("New:",listX)
listX.insert(2, "Test value")

print("New 2.0:",listX)
ret = listX.pop(3)
print("New 3.0:",listX)
print("Valoarea returnata si eliminata din lista este", ret)
_____________________________________________________________________
94
___________________________________________________________________
newList = listA + listB

print("Lista generata ", newList)
newList.reverse()
print("Lista reversed ",newList)
newList.sort()
print("Lista sortata ", newList)
newList.remove(2)
print("New list: ", newList)
Rezultatul rularii secventei de cod de mai sus va fi:

[1, 2, 3, 4, 5, 6]
Lungimea tuplului este: 3
['RO', 'RO', 'RO']
1
2
3
True
False
Old: ['AI&ML', 'TensorFlow', 1991, 2022]
New: ['AI&ML', 'TensorFlow', 1991, 2022, 'Data Science']
New 2.0: ['AI&ML', 'TensorFlow', 'Test value', 1991, 2022, 'Data Science']
New 3.0: ['AI&ML', 'TensorFlow', 'Test value', 2022, 'Data Science']
Valoarea returnata si eliminata din lista este 1991
Lista generata [1, 2, 3, 4, 5, 6]
Lista reversed [6, 5, 4, 3, 2, 1]
Lista sortata [1, 2, 3, 4, 5, 6]
New list: [1, 3, 4, 5, 6]
_____________________________________________________________________
95
___________________________________________________________________
Exercitii
Si acum sa trecem la partea de exercitii in care ne vom "juca" cu listele in Python.
1) Sa spunem aceasta lista salvata intr-o variabila: a = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100].
Scrieti o linie de Python care ia aceasta lista a si face o lista noua care contine doar
elementele pare ale acestei liste.
Iar acum un exercitiu putin mai complex:
2.1) Creati o lista cu numele a 10 prieteni (numele nu trebuie sa fie distincte). Respectand
ordinea, rezolvati urmatoarele cerinte:
• Sortati lista de nume.

• Utilizand o lista auxiliara, determinati numarul de aparitii al fiecarui nume.
• Determinati numele care apare de cele mai multe ori in lista initiala.
• Determinati numele care apar cel mai putin ori in lista initiala.
• Revenind la lista initiala de nume, inversati ordinea elementelor.
2.2) Formati perechi de cate 2 persoane cu numele din lista initiala si impartiti aceste
perechi (in mod egal) in 2 liste. Asigurati-va ca acestor perechi nu li se poate modifica
valoarea (hint: tupluri). Avand aceste perechi, calculati numarul total de caractere pentru
fiecare pereche in parte si creati o lista noua in care sa le introduceti in ordine
descrescatoare.
Si putina matematica...
3) Scrieti un script care afiseaza in consola toate numerele pare divizibile cu 7 din
intervalul [0, 3463]. Sugestie: folositi functia range(). Ajustati codul astfel incat la aparitia
primului multiplu al lui 666, algoritmul sa se opreasca.
_____________________________________________________________________
96
___________________________________________________________________
2) Tupluri (Tuples)
Acest concept este similar cu cel de liste, dar contine cateva diferente. Din momentul ce
listele sunt structuri de date ce pot tine mai multe valori ale integer-urilor si string-urilor,
tuplurile fac acelasi lucru, doar ca acestea sunt imutabile. Asta inseamna ca datele din
ele nu pot fi modificate/actualizate, ci doar citite. Scopul lor este sa genereze o variabila
cu mai multe date care pot fi doar citite (read-only). In cazul tuplurilor, valorile si pozitiile
acestora sunt foarte clar definite si nu mai pot fi schimbate (adaugate, modificate sau
sterse).
Care sunt functiile unui tuplu in Python?
Pe scurt, tuplurile sunt un tip de structura de date care permit multimi de elemente
ordonate, care nu se pot modifica si in care pot exista elemente duplicate (spre
deosebire de set-uri despre care vom discuta in sectiunea urmatoare). Astfel, tuplurile au
cateva functii de baza care permit introducerea datelor, modificare sau stergerea datelor
intr-un mod indirect cu ajutorul listelor (vom vedea imediat cum) In continuare, hai sa
aruncam o privire peste o parte din functiile disponibile pentru tupluri:
• len() sau .count () – intoarce numarul de elemente existente in tuplu
• .index (valoare)– intoarce valoarea unui aflata la o pozitie specifica din tuplu
Pe langa aceastea mai putem include urmatoarele operatii:
• Accesarea valorilor
• Concatenarea
• Repetitia
• Iterarea
• Apartenenta
Cum folosim un tuplu in Python?

date. Mai intai sa definim un tuplu:
_____________________________________________________________________
97
___________________________________________________________________
#Definirea si accesarea valorilor unui tuplu

food_tuple = ("Paste", "Banane", "Lava Cake", "Smoothie")
print(food_tuple)
print("Vreau sa mananc", food_tuple[1])
Rezultatul va fi:
('Paste', 'Banane', 'Lava Cake', 'Smoothie')
Vreau sa mananc Banane
Pentru a folosi functiile discutate in sectiunea anterioara vom prelua exemplul de mai sus
si il vom rescrie (si dezvolta) astfel:
print("\n#Parcurgerea elementelor unui tuplu folosind o bucla for\n")
for food in food_tuple:
print("Astazi am pofta de:", food)
#De asemenea, in cazul tuplurilor exista mai multe operatii care pot avea loc:
#Secventierea
tupX = ('Python', 'Jupiter', 1999, 2025)
tupZ = (1, 2, 3, 4, 5, 6, 7 )
print("tupX[0]: ", tupX[0])
print("tupZ[1:5]: ", tupZ[1:5])
#Concatenarea
tupA = (1, 2, 3)
tupB = (4, 5, 6)
print(tupA + tupB)
#Lungimea
print("Lungimea tuplului este:",len(tupA))
#Repetitia
tupR = ("RO") * 3
print(tupR)
#Iterarea
for x_tuple in (1, 2, 3):
print(x_tuple)
#Apartenenta
_____________________________________________________________________
98
___________________________________________________________________
print(3 in (1, 2, 3))

print(9 in tupB)
#Stergerea
del tupR
Rezultatul rularii secventei de cod de mai sus va fi:

#Parcurgerea elementelor unui tuplu folosind o bucla for
Astazi am pofta de: Paste

Astazi am pofta de: Banane
Astazi am pofta de: Lava Cake
Astazi am pofta de: Smoothie
tupX[0]: Python
tupZ[1:5]: (2, 3, 4, 5)
(1, 2, 3, 4, 5, 6)
Lungimea tuplului este: 3
RORORO
1
2
3
True
False
File "main.py", line 386, in <module>
print (tupR)
NameError: name 'tupR' is not defined
_____________________________________________________________________
99
___________________________________________________________________
Exercitii
Iar acum sa ne reintoarcem la partea practica:
1) Scrie un program care verifica daca un element exista intr-un tuplu.

2) Scrie un program ce sorteaza un tuplu dupa numere reale(cu virgula).
3) Scrie un program ce calculeaza produsul elementelor unui tuplu.
_____________________________________________________________________
100
___________________________________________________________________
3) Multumi (Set) in Python
Multimile (Set) in Python reprezinta un tip de structura de date care permite organizarea
datelor (de orice tip) intr-un format neordonat, nemodificabil si care nu permite valori
duplicate. In momentul in care dorim ca fiecare valoarea introdusa in acesta structura de
date sa fie unica (si nemodificabila), atunci set-urile pot fi unul dintre instrumentele de
care avem nevoie pentru a ne face munca mai usoara. Modul prin care putem defini un
set (o multime) in Python este urmatorul:
vacation_set = {"Bora Bora", "Las Vegas", "Tenerife"}
print (vacation_set)
Cu urmatorul rezultat afisat pe ecran:

{'Tenerife', 'Bora Bora', 'Las Vegas'}
Care sunt functiile unei multimi (set) in Python?
Set-urile au cateva functii de baza care permit introducerea datelor in acestea, cautarea
acestora, stergerea lor etc. In continuare, hai sa aruncam o privire peste o parte din
functiile disponibile pentru set-uri:
• .add (valoare)– adauga un element in set
• .pop ()– sterge un element aleator din set
• remove (valoare)– sterge un element specific din set
• .update (set) - actualizeaza set-ul curent cu un alt set (sau cu o lista)
• .union (set1, set2, ...) - intoarce un set care reprezinta unirea a doua sau mai
multe seturi
• .clear () - sterge toate elementele din set
Pe langa aceste functii, exista multe altele, dar am considerat ca acestea sunt cele de
baza cu ajutorul carora vei putea profita de utilitatea acestei structuri de date.
_____________________________________________________________________
101
___________________________________________________________________
Cum folosim un set in Python?

date. Dupa cum am spus si mai devreme, set-urile nu permit stocarea de valori duplicate
(chiar daca acestea sunt definite):
vacation_set = {"Bora Bora", "Las Vegas", "Tenerife", "Las Vegas"}

print(vacation_set)
Ele vor fi eliminate din structura:

{'Tenerife', 'Bora Bora', 'Las Vegas'}
Pentru a folosi functiile discutate in sectiunea anterioara vom prelua exemplul de mai sus
si il vom rescrie (si dezvolta) astfel:
print("\n#Adaugarea unui element in set\n")
vacation_set.add("San Torini")
vacation_set.add("Las Vegas") #incercam sa adaugam un element care exista deja
print(vacation_set)
print("\n#Stergerea unui element din set\n")

vacation_set.remove("Bora Bora")
print(vacation_set)
print("\n#Actualizarea a unui set cu o lista (se poate aplica si intre doua

seturi)\n")
lista_vacante = ["Bali", "Monaco", "Fiji", "Australia", "Bali"]
print(lista_vacante)
vacation_set.update(lista_vacante)
print(vacation_set)
print("\n#Uniunea a doua set-uri\n")

ro_vacations = {"Brasov", "Maramures", "Constanta", "Hateg"}
wish_list_vacations = vacation_set.union(ro_vacations)
print(wish_list_vacations)
print("\n#Parcurgerea elementelor unui set folosind o bucla for\n")

current_year = 2021
for loc in wish_list_vacations:
print("Am in plan sa calatoresc in " + loc + " in anul " + str(current_year))
current_year = current_year + 1
print("\n#Stergerea valorilor dintr-un set\n")

_____________________________________________________________________
102
___________________________________________________________________
wish_list_vacations.clear()
print(wish_list_vacations)
Rezultatul afisat in urma rularii secventei de mai sus este urmatorul:
#Adaugarea unui element in set
{'San Torini', 'Bora Bora', 'Tenerife', 'Las Vegas'}
#Stergerea unui element din set
{'San Torini', 'Tenerife', 'Las Vegas'}
#Actualizarea a unui set cu o lista (se poate aplica si intre doua seturi)
['Bali', 'Monaco', 'Fiji', 'Australia', 'Bali']

{'Monaco', 'Tenerife', 'San Torini', 'Australia', 'Fiji', 'Bali', 'Las
Vegas'}
#Uniunea a doua set-uri
{'Monaco', 'Tenerife', 'Maramures', 'San Torini', 'Australia', 'Hateg',

'Constanta', 'Fiji', 'Brasov', 'Bali', 'Las Vegas'}
#Parcurgerea elementelor unui set folosind o bucla for
Am in plan sa calatoresc in Australia in anul 2021

Am in plan sa calatoresc in San Torini in anul 2022
Am in plan sa calatoresc in Constanta in anul 2023
Am in plan sa calatoresc in Tenerife in anul 2024
Am in plan sa calatoresc in Brasov in anul 2025
Am in plan sa calatoresc in Hateg in anul 2026
Am in plan sa calatoresc in Monaco in anul 2027
Am in plan sa calatoresc in Maramures in anul 2028
Am in plan sa calatoresc in Las Vegas in anul 2029
Am in plan sa calatoresc in Fiji in anul 2030
Am in plan sa calatoresc in Bali in anul 2031
#Stergerea valorilor dintr-un set
set()
_____________________________________________________________________
103
___________________________________________________________________
Exercitii
Si acum sa trecem la partea de exercitii in care ne vom "juca" cu set-urile in Python:
1) Scrie un program in care sa stergi toate elementele dintr-o structura de tip set.
2) Scrie un program care verifica daca 3 structuri de tip set nu au elemente in comun
luate fiecare cu fiecare. Daca nu au se afiseaza “TRUE”, altfel “FALSE”
3) Scrie un program ce gaseste elementele dintr-o structura de date de tip set ce nu se

gaseste in alta data.
_____________________________________________________________________
104
___________________________________________________________________
4) Dictionare
Ce este si cum functioneaza un dictionar?
In programare dictionarele reprezinta un sir de elemente care stocheaza o pereche de

“(cheie, valoare)”. Astfel pentru fiecare cheie (unica) in parte va fi alocata o anumita
valoare (care nu trebuie sa fie unica). Cheile trebuie sa fie unice pentru ca dictionarul
foloseste o tehnica numita hashing. Hashing-ul este o metoda (un algoritm) prin care se
genereaza o valoarea numerica (aka. hash), care identifica in mod unic acea cheie.
Aceasta tehnica permite ca accesarea elementelor dintr-un dictionar sa fie facuta extrem
de rapid in comparatie cu alte structuri de date. Motivul se datoreaza acestui hash, care
permite dictionarului sa acceseze direct (aproape instant) indexul unde se afla perechea
de (cheie, valoare) care doreste a fi accesata.
Figura 5.2
In figura 5.2 de mai sus poti sa vezi structura dictionarului (care contine mai multe casute
- noduri) si structura fiecarui nod in parte (care este alcatuit dintr-un hash, o cheie, o
valoarea si adresa - locul unde se afla in memorie - urmatorului nod). Gasesti in figura de
mai jos o ilustratie prin care vei putea intelege mai bine cum are loc maparea perechii
cheie - valoarea intr-un dictionar din Python.
_____________________________________________________________________
105
___________________________________________________________________
Figura 5.3
Care sunt functiile unei dictionar in Python?
Dictionarele au cateva functii de baza care permit introducerea perechilor de cheie -

valoare, cautarea acestora, stergerea lor etc. In Python nu exista o functie specifica
pentru adaugarea elementelor intr-un dictionar (vom vedea in detaliu cum putem face
asta in sectiunea urmatoare). In continuare, hai sa aruncam o privire peste o parte din
functiile disponibile pentru dictionare:
• .pop (cheie)– sterge elementul din dictionar care se afla la si il returneaza.
• .get (cheie) – intoarce elementul din dictionar care se afla la nodul <cheie> a
efectua nicio modificare asupra acesteia.
• .items () - intoarce o lista de tupluri (formate din perechea - cheie - valoare) cu
elementele din dictionar
• .len (dictionar) - intoarce dimensiunea dictionarului
• .clear () - sterge toate elementele din dictionar
Pe langa aceste functii, exista multe altele, dar am considerat ca acestea sunt cele de
baza cu ajutorul carora vei putea profita de utilitatea acestei structuri de date.
_____________________________________________________________________
106
___________________________________________________________________
Cum folosim un dictionar in Python?
Haide acum sa cream un dictionar si sa-l folosim intr-un exemplu practic. Sa presupunem
ca dictionarul nostru va fi alcatuit dintr-o pereche cheie-valoare de tip string (numele unei
persoane), respectiv integer (suma de bani disponibila in contul bancar):
dictionarul_meu = {
"cheie_1": "valoare_1",
"cheie_2": "valoare_2"
}
print(dictionarul_meu)
Rezultatul codului de mai sus va fi:

{cheie_1: valoare_1, cheie_2: valoare_2}
In continuare, vom folosi prin exemple practice functiile discutate in sectiunea de mai
devreme:
print("#Crearea dictionarului - reprezinta nume si contul bancar in EUR ale

unor persoane\n")
dictionarul_meu = {
"Marius": 4832,
"Ionel": 683
}
print(dictionarul_meu)
print("\n#1 - Adaugarea elementelor in dictionar\n")
dictionarul_meu["Adi"] = 2149
print("Dictionarul actualizat 1.0:\n", dictionarul_meu)
dictionarul_meu["Ana"] = 3434
dictionarul_meu["Alex"] = 1204
dictionarul_meu["Dan"] = 1378
dictionarul_meu["Ion"] = 932
print("Dictionarul actualizat 2.0:\n", dictionarul_meu)
_____________________________________________________________________
107
___________________________________________________________________
print("\n#2 - Obtinerea valorii pe baza unei chei date\n")

valoare_exA = dictionarul_meu["Adi"]
print("Valoarea din contul lui Adi:", valoare_exA)
#aici se foloseste metoda get()

valoare_exB = dictionarul_meu.get("Adi")
#se obtine acelasi rezultat ca in exemplul de mai sus

print("Valoarea din contul lui Adi:", valoare_exB)
print("\n#3 - Modificarea elementelor (existente)\n")

print("#Valoarea initiala din contul lui Adi: " + str(dictionarul_meu["Adi"])
+ " EUR")
dictionarul_meu["Adi"] = 7777 #valoarea initiala find 2149

print("#Valoarea din contul lui Adi: " + str(dictionarul_meu["Adi"]) + "
EUR")
print("##Valoarea initiala din contul lui Ion: " +

str(dictionarul_meu["Ion"]) + " EUR")
suma_initiala = dictionarul_meu["Ion"]
suma_noua = suma_initiala * 2
dictionarul_meu["Ion"] = suma_noua
print("##Valoarea actualizata din contul lui Ion: " +
str(dictionarul_meu["Ion"]) + " EUR")
print("\n#4 - Parcurgerea dictionarului prin folosirea buclei for\n")

key = dictionarul_meu.items()
for key in dictionarul_meu:

print("Suma de bani disponibila din contul lui " + key + " este "+
str(dictionarul_meu[key]) + " EUR")
print("\nAcordam un bonus pentru toata lumea...\n")
#Adaugam 150 EUR in contul fiecarei persoane

for key in dictionarul_meu:
dictionarul_meu[key] = dictionarul_meu[key] + 150
print("NOUA Suma de bani disponibila din contul lui " + key + " este "+
_____________________________________________________________________
108
___________________________________________________________________
str(dictionarul_meu[key]) + " EUR")
print("\n#5 - Eliminarea elementelor\n")

nr_elemente = len(dictionarul_meu)
print("Dictionarul contine " + str(nr_elemente) + " elemente")
dictionarul_meu.pop("Adi")
print("Dictionarul fara Adi:\n", dictionarul_meu)
#se mai poate folosi si del

del dictionarul_meu["Ion"]
print("Dictionarul fara Adi si Ion:\n", dictionarul_meu)
#va sterge toate elementele din dictionar, pastrand variabila dictionarul_meu

in memorie
dictionarul_meu.clear()
#va sterge intregul dictionar si variabila dictionarul_meu din memorie

del dictionarul_meu
Rezultatul codului de mai sus va fi:

#Crearea dictionarului - reprezinta nume si contul bancar in EUR ale unor
persoane
{'Marius': 4832, 'Ionel': 683}
#1 - Adaugarea elementelor in dictionar
Dictionarul actualizat 1.0:

{'Marius': 4832, 'Ionel': 683, 'Adi': 2149}
Dictionarul actualizat 2.0:
_____________________________________________________________________
109
___________________________________________________________________
{'Marius': 4832, 'Ionel': 683, 'Adi': 2149, 'Ana': 3434, 'Alex': 1204,
'Dan': 1378, 'Ion': 932}
#2 - Obtinerea valorii pe baza unei chei date
Valoarea din contul lui Adi: 2149

Valoarea din contul lui Adi: 2149
#3 - Modificarea elementelor (existente)
#Valoarea initiala din contul lui Adi: 2149 EUR

#Valoarea din contul lui Adi: 7777 EUR
##Valoarea initiala din contul lui Ion: 932 EUR
##Valoarea actualizata din contul lui Ion: 1864 EUR
#4 - Parcurgerea dictionarului prin folosirea buclei for
Suma de bani disponibila din contul lui Marius este 4832 EUR
Suma de bani disponibila din contul lui Ionel este 683 EUR
Suma de bani disponibila din contul lui Adi este 7777 EUR
Suma de bani disponibila din contul lui Ana este 3434 EUR
Suma de bani disponibila din contul lui Alex este 1204 EUR
Suma de bani disponibila din contul lui Dan este 1378 EUR
Suma de bani disponibila din contul lui Ion este 1864 EUR
Acordam un bonus pentru toata lumea...
NOUA Suma de bani disponibila din contul lui Marius este 4982 EUR
NOUA Suma de bani disponibila din contul lui Ionel este 833 EUR
NOUA Suma de bani disponibila din contul lui Adi este 7927 EUR
NOUA Suma de bani disponibila din contul lui Ana este 3584 EUR
NOUA Suma de bani disponibila din contul lui Alex este 1354 EUR
NOUA Suma de bani disponibila din contul lui Dan este 1528 EUR
NOUA Suma de bani disponibila din contul lui Ion este 2014 EUR
#5 - Eliminarea elementelor
Dictionarul contine 7 elemente

Dictionarul fara Adi:
{'Marius': 4982, 'Ionel': 833, 'Ana': 3584, 'Alex': 1354, 'Dan': 1528,
'Ion': 2014}
_____________________________________________________________________
110
___________________________________________________________________

Dictionarul fara Adi si Ion:
{'Marius': 4982, 'Ionel': 833, 'Ana': 3584, 'Alex': 1354, 'Dan': 1528}
Nested dictionary
Un dictionar poate avea ca elemente alte dictionare (situatie foarte des intalnita atunci
cand lucram cu date transmise in format JSON). Scopul acestora este de a organiza si
transmite datele de la un sistem catre altul astfel incat sa poata fi procesate rapid si usor
de catre acestea, fara un consum mare de resurse. Sintaxa de baza pentru definirea unui
astfel de dictionar este urmatoarea:
nested_dict = {
"d1": { 'cheie_1': 'valoare_1', 'cheie_2': 'valoare_2'},
"d2": { 'cheie_3': 'valoare_3', 'cheie_4': 'valoare_4'}
}
print(nested_dict)
print(nested_dict["d1"])
Si rezultatul in urma rularii acestei secvente de cod:

{'d1': {'cheie_1': 'valoare_1', 'cheie_2': 'valoare_2'}, 'd2': {'cheie_3':
'valoare_3', 'cheie_4': 'valoare_4'}}
{'cheie_1': 'valoare_1', 'cheie_2': 'valoare_2'}
{'cheie_3': 'valoare_3', 'cheie_4': 'valoare_4'}
Iata mai jos un exemplu:
nested_dict = {
"d1": { 'cheie_1': 'valoare_1', 'cheie_2': 'valoare_2'},
"d2": { 'cheie_3': 'valoare_3', 'cheie_4': 'valoare_4'}
}
print(nested_dict)
print("\nCrearea unui dictionar de tip nested\n")
_____________________________________________________________________
111
___________________________________________________________________
date_personal = {
"p1": { 'nume': 'Adi', 'venit': 1000, 'varsta': 28},
"p2": { 'nume': 'Emanuel', 'venit': 2750, 'varsta': 36},
"p3": { 'nume': 'George', 'venit': 1750, 'varsta': 31}
}
print(date_personal)
print(date_personal["p1"])
print("\n#Adaugarea unui element\n")

date_personal["p4"] = { 'nume': 'Gabi', 'venit': 0, 'varsta': 16, 'job':
'Internship'}
print("\n#Eliminarea unui element\n")

del date_personal["p2"]
Rezultatul secventei de cod de mai sus:

Crearea unui dictionar de tip nested
{'p1': {'nume': 'Adi', 'venit': 1000, 'varsta': 28}, 'p2': {'nume':

'Emanuel', 'venit': 2750, 'varsta': 36}, 'p3': {'nume': 'George', 'venit':
1750, 'varsta': 31}}
{'nume': 'Adi', 'venit': 1000, 'varsta': 28}
{'nume': 'Emanuel', 'venit': 2750, 'varsta': 36}
{'nume': 'George', 'venit': 1750, 'varsta': 31}
#Adaugarea unui element
{'p1': {'nume': 'Adi', 'venit': 1000, 'varsta': 28}, 'p2': {'nume':

'Emanuel', 'venit': 2750, 'varsta': 36}, 'p3': {'nume': 'George', 'venit':
1750, 'varsta': 31}, 'p4': {'nume': 'Gabi', 'venit': 0, 'varsta': 16, 'job':
'Internship'}}
#Eliminarea unui element
_____________________________________________________________________
112
___________________________________________________________________
{'p1': {'nume': 'Adi', 'venit': 1000, 'varsta': 28}, 'p3': {'nume': 'George',
'venit': 1750, 'varsta': 31}, 'p4': {'nume': 'Gabi', 'venit': 0, 'varsta':
16, 'job': 'Internship'}}
Cand folosim dictionarele si ce aplicabilitate practica au?
Dictionarele sunt folosite in tabelele de rutare pentru ca routerele trebuie sa decida unde
sa trimita traficul: catre retea sau catre portul spre care poate trimite. Dictionarele sunt
folosite:
• In retelistica, pe Routere, in crearea tabelelor de rutare.

• In cadrul API-urile pentru transmiterea informatiilor intre sisteme (de obicei in
format JSON)
• In stocarea parolelor in baza de date. Deoarece parolele sunt criptate, ele au un
hash stocat in baza de date. In momentul in care tu trimiti parola, serverele
lucreaza sa o puna intr-o functie si intr-un hash. Cheia este parola, hash-ul este
valoarea acelei chei, deci acesta este un alt exemplu de dictionar.
_____________________________________________________________________
113
___________________________________________________________________
Exercitii
Iar acum sa ne reintoarcem la partea practica:
1.1) Creati cu ajutorul unui dictionar o baza de date la care sa retineti numerele de telefon
a 10 prieteni.
1.2) Afisati intrarile din aceasta baze de date in ordine alfabetica, dupa nume.
2) Scrieti un program pentru a obtine (sortate dupa pret) primele 3 produse dintr-un
online magazin.
Produse magazin: {'Pantofi': 45.50, 'Geaca': 35, 'Pulover': 41.30, 'Sacou': 55, 'Tricou': 24}
Rezultatul dorit:
Sacou 55
Pantofi 45.5
Pulover 41.3
3) Scrieti un program prin care sa obțineți cheia, valoarea și pozitia unui element dintr-o
structura de date de tip dicționar.
_____________________________________________________________________
114
___________________________________________________________________
Capitolul 6 - Programare Orientata pe Obiecte in

Python
1) Concepte teoretice despre POO
POO (Programare Orientata pe Obiecte) sau OOP (Object Oriented Programming) este o
paradigma de programare care foloseste concepte abstracte (sub forma de clase si
obiecte) pentru a crea modele bazate pe elemente din lumea reala. O aplicatie construita
pe POO foloseste mai multe obiecte care comunica prin mesaje specifice pentru a
rezolva diverse servicii (ale aplicatiei) solicitate. Aceste obiecte sunt capabile sa trimita
mesaje (date), sa primeasca mesaje (date) si sa proceseze date. Scopul programarii
orientate pe obiecte este de a incerca sa creasca flexibilitatea si mentenabilitatea
programelor. Deoarece programele create folosind un limbaj orientat pe obiecte (cum
este Java, Python, C++, etc.) sunt modulare, ele pot fi mai usor de dezvoltat si mai usor de
inteles dupa dezvoltare.
POO vs. Programare Procedurala
Programele sunt alcatuite din module. Aceste module pot fi programe de sine statatoare
(independente) care pot fi dezvoltate (codate) si testate separat fata de programul initial
(ulterior acestea - mai multe module - putand fi asamblate pentru a forma un program
complet). In limbajele de programare procedurale (cum ar fi C si Pascal) aceste module
sunt de fapt proceduri, adica o secventa de instructiuni. In limbajul C, procedurile sunt
functii care au un set clar de instructiuni (de tipul if, for, while etc.) cu scopul de a
intoarce (sau nu) un rezultat (al acelei functii). In programarea procedurala se ia problema
(care se doreste a fi rezolvata) si se sparge in mai multe bucati (sub proceduri). Astfel
sub-procedurile rezolva bucati mai mici din problema initiala. Lucrurile continua asa pana
cand problemele secundare (bucatile mai mici) sunt suficient de simple pentru a fi
rezolvate de sub-procedura corespunzatoare ei.
Dificultatea cu acest tip de programare consta in faptul ca intretinerea software-ului
poate fi dificila si consumatoare de timp. Atunci cand se efectueaza modificari ale
procedurii principale, aceste modificari pot intra in cascada, iar schimbarea poate avea
un impact major asupra tuturor procedurilor din programul initial. O alternativa la
programarea procedurala este programarea orientata pe obiecte. Scopul POO este cel
de a rezolva dificultatile legate de programarea procedurala. In POO principalele module
_____________________________________________________________________
115
___________________________________________________________________
dintr-un program sunt clase, mai degraba decat proceduri. POO ne permite sa ne cream
clase si obiecte care modeleaza elementele din lumea reala.
Din ce este compusa programarea orientata pe obiecte?

Dupa cum poti vedea si in figura 6.1 de mai jos, programarea orientata pe obiecte este
alcatuita din urmatoarele elemente:
Figura 6.1
● Obiecte
● Clase
● Mostenirea (claselor)
● Polimorfism
● Abstractizarea (claselor)
● Incapsularea (claselor)
_____________________________________________________________________
116
___________________________________________________________________
a) Obiecte si Clase in POO
O clasa este o colectie de obiecte care au proprietati, operatii si comportamente

comune. O clasa este o combinatie de stari (date) si de comportamente (metode). In POO
o clasa este un tip de date, iar obiectele sunt instante ale acestui tip de date. In
urmatoarea sectiune vom discuta in detaliu despre acest subiect.
b) Mostenirea claselor in POO
Mostenirea (Inheritance) unei clase X de catre o clasa Y ii ofera acesteia posibilitatea de

a imprumuta metodele si atributele existenta in clasa (parinte) X. Putem lua exemplul unui
autoturism, marca BMW care are la baza foarte multe elemente comune cu alte
autoturisme (Mercedes, Audi, Porsche etc), dar in acelasi timp are si elemente unice,
specifice marcii BMW. Acesta este un exemplu cand un BMW mosteneste caracteristicile
unui autoturism (marca, caroserie, roti, culoare, viteza maxima, capacitate motor,
combustibil folosit etc.).
c) Polimorfismul in POO
Polimorfism-ul reprezinta "a avea mai multe forme" si apare in momentul in care folosim
mostenirea. Practic polimorfismul ne ofera posibilitatea de a folosi metodele mostenite
sub mai multe forme, in functie de rezultatul pe care il dorim (astfel codul nostru
devenind mai flexibil). Acest lucru ne ofera avantajul de a face un lucru in mai multe
moduri. In concluzie, mostenirea ne ofera posibilitatea de a folosi atributele si metodele
clasei parinte, in timp ce polimorfismul ne ofera posibilitatea de a folosi metodele
mostenite sub mai multe forme pentru a obtine rezultate diferite. Acest lucru se face prin
overloading (supraincarcare) si overriding (suprascriere).
d) Abstractizarea in programarea orientata pe obiecte
Procesul de abstractizare a datelor are legatura cu ascunderea anumitor elemente care

compun clase (care de obicei reprezinta aspecte de detaliu) si punerea in evidenta a
acelor informatii esentiale pentru un utilizator. Abstractizarea poate fi facuta fie prin clase
abstracte, fie prin interfete. Mai multe detalii in capitolul urmator.
_____________________________________________________________________
117
___________________________________________________________________
e) Incapsularea in programarea orientata pe obiecte
Incapsularea ne asigura cu faptul ca ascunde informatii sensibile de catre utilizatori. In

aceasta situatie ne referim in mod special la variabile, metode sau clase care pot avea
atributul private. Se ascund anumite stari interne a obiectelor, devenind necesar ca toate
interactiunile sa fie efectuate utilizand metodele obiectelor. Cu alte cuvinte, atributele
unei clase nu vor putea fi accesate (si modificate) in mod direct, ele nefiind vizibile
(pentru ca sunt private), dar modificarile vor putea fi facute prin intermediul metodelor.
Beneficiile POO
Iata beneficiile principale pe care ni le ofera POO in comparatie cu programare
procedurala:
1. Modularitatea: Codul sursa pentru o clasa poate fi scris si mentinut independent de

codul sursa pentru alte clase. Odata creat, un obiect poate fi usor transferat in interiorul
sistemului.
2. Securitatea ridicata la nivel de cod: Interactionand doar cu metodele obiectului,
detaliile implementarii interne raman ascunse de lumea exterioara.
3. Reutilizarea codului: Daca o clasa exista deja, puteti utiliza in programul dvs. obiecte
din acea clasa. Acest lucru permite programatorilor sa implementeze / testeze / sa faca
depanare pe obiecte complexe, specifice pentru sarcini, pe care apoi le puteti folosi in
propriul cod.
4. Debugging mai usor: Daca un anumit obiect se dovedeste a fi o problema, il puteti
elimina din program si puteti adauga/conecta, ca inlocuitor, un obiect diferit. Acest lucru
este similar cu rezolvarea problemelor mecanice in lumea reala. Daca un surub se rupe, il
inlocuiti pe el, nu intreaga masina.
Un scurt rezumat al celor discutate mai sus

1. In POO totul este un obiect.
2. Calculul se realizeaza prin obiecte care comunica intre ele, solicitand ca alte obiecte
sa efectueze actiuni. Obiectele comunica prin trimiterea si primirea de mesaje. Un mesaj
este o cerere de actiune, insotita de oricate argumente care ar putea fi necesare pentru
a finaliza sarcinile.
3. Fiecare obiect are propria sa memorie alocata de catre OS.
4. Fiecare obiect (odata initializat) devine o instanta a unei clase. O clasa reprezinta pur si
simplu o grupare de obiecte similare care are un set specific de caracteristici si functii.
_____________________________________________________________________
118
___________________________________________________________________
2) Clase in Python
O clasa este o colectie de obiecte care au proprietati, operatii si comportamente

comune. O clasa este o combinatie de stari (date) si comportament (metode). In POO o
clasa este un tip de date, iar obiectele sunt instante ale acestui tip de date. De
exemplu, putem crea o clasa Persoana() care reprezinta o colectie care poate descrie
(printr-un obiect) fiecare persoane in parte. Persoanele au un statut, cum ar fi inaltimea,
greutatea, genul, culoarea parului etc.. Ei au, de asemenea, un anumit comportament, o
anumita limba pe care o vorbesc, o mancare preferata. Toate aceste caracteristici despre
oameni sunt incapsulate (continute) in clasa Persoana(). Dupa cum am spus mai
devreme, un obiect (dupa ce a fost initializat) devine o instanta a unei clase. Obiectele
sunt unitati de abstractizare. Un obiect poate comunica cu alte obiecte folosind mesaje.
Un obiect transmite un mesaj unui alt obiect, ceea ce duce la invocarea unei metode.
Obiectele efectueaza apoi actiunile necesare pentru a obtine un raspuns de la sistem.
Obiectele din lumea reala au 2 caracteristici in comun: toate au o stare si un
comportament. O metoda de a gandi intr-un mod orientat pe obiecte este de a identifica
starea si comportamentul obiectelor din lumea reala. Complexitatea acestor obiecte
poate sa difere, unele obiecte au mai multe stari si comportamente considerabil mai
complexe decat alte obiecte. Compara starea si comportamentul unui TV cu starile si
comportamentele unei masini, sunt total diferite. Obiectele unei clase, dpvd conceptual,
sunt similare cu obiectele din lumea reala. Un obiect isi stocheaza starea in atribute (aka.
Variabile ale clasei) si isi expune comportamentele prin metodele sale (aka. Functiile
clasei). Vom vedea in cele ce urmeaza mai multe detalii (si exemple) despre acestea.
Odata ce ai inteles mai multe lucruri despre POO si care este rolul acestui mod de
structurare a datelor este timpul sa intram in partea concreta, practica, a lucrurilor. Pentru
inceput vom relua definitia unei clase in Python, dupa care iti voi arata un exemplu de
folosire a acestora.
_____________________________________________________________________
119
___________________________________________________________________
Cum definim o clasa in Python?

In sectiunea aceasta ne vom defini printr-o clasa, propriul tip de date (cum este de
exemplu: String, listele, etc.) care poate fi caracterizat asa cum vrem noi.
NOTA: In momentul in care incepi sa lucrezi cu POO in Python iti recomand ca pentru
fiecare clasa in parte pe care o definesti sa-ti creezi cate un fisier separat. Daca ai 3 clase
diferite (ClasaA, ClasaB, ClasaC) iti recomand sa creezi trei fisiere diferite fiecare cu
denumirea ClasaA.py, ClasaB.py, ClasaC.py astfel incat codul tau sa utilizeze principiile
de best-practice pentru utilitatea si modularitatea lui.
Iata mai jos cum definim o clasa in Python:
class PrimaClasa:
pass
Exemplul de mai sus defineste o clasa denumita PrimaClasa. In aceasta situatie, clasa
nu va face nimic, dar noi putem incepe sa adaugam variabile (atribute) astfel:
class PrimaClasa:
primulSir = "Salut!"
primulNr = 51
nrSecund = -21
Acum, odata ce am definit clsa si variabilele din ea, vom creea un obiect al acestei clase,
iar apoi cu ajutorul lui sa folosim variabilele din clasa:
obj = PrimaClasa()
Variabilele de clasa le vom apela pentru a le putea folosi astfel:
print(obj.primulSir)
print(obj.primulNr)
print(obj.nrSecund)
print(obj.primulNr - obj.nrSecund)
_____________________________________________________________________
120
___________________________________________________________________
In acest exemplu eu am printat atributele clasei PrimaClasa, folosindu-ma de obiectul

obj creat mai devreme si cu ajutorul notatiei cu . pentru a ma adresa direct fiecarui
atribut in parte.
Exemplul #2
In acest exemplu vom extinde ce am invatat pana acum despre programare cu conceptul
de clase pe care il studiem. Iata o clasa denumita ClasaPrincipala care contine un set de
variabile (atribute) si functii (metode):
class ClasaPrincipala:
"""Aceasta este o clasa cu scop introductiv"""
varA_clasa = 12345
varB_clasa = 54321
def doSomething(self):
print("Sunt aici sa-ti arat valoarea atributelor:", self.varA_clasa,
self.varB_clasa )
def changeVar(self,var):
var %= 10
return var
obj = ClasaPrincipala()
obj.doSomething()
print("Valoarea lui varA_clasa este:", obj.changeVar(obj.varA_clasa))
print("Valoarea lui varA_clasa este:", obj.changeVar(obj.varB_clasa))
Codul scris mai sus reprezinta o clasa in care am definit o variabila si doua functii care
realizeaza o anumite actiune. Lucrurile nu difera cu mult fata de cum faceam pana acum,
tot ce este diferi consta in faptul ca acestea sunt parte din clasa ClasaPrincipala (si au
indentarea corespunzatoare). Urmatorul pas, dupa crearea clasei are de a face cu
crearea si definirea obiectelor prin structura obj = ClasaPrincipala() care indica
faptul ca variabila obiect obj va insusi proprietatile clasei (asta inseamna ca va putea
folosi atributele si metodele din acea clasa, exact cum apare in exemplul generat de ea).
Rezultatul afisat este urmatorul:
Sunt aici sa-ti arat valoarea atributelor: 12345 54321
Valoarea lui varA_clasa este: 5
Valoarea lui varB_clasa este: 1
_____________________________________________________________________
121
___________________________________________________________________
NOTA: In Python (precum si in alte limbaje de programare de nivel inalt cum ar fi Java,
C++, JavaScript etc.) avem la dispozitie un set de clase predefinite pe care le putem
folosi. In toate aceste limbaje exista deja anumite functii, anumite grupari, anumite clase
care au scopul de a ne ajuta pe noi sa ne eficientizam munca. Ce rost ar avea un limbaj
de programare fara functiile definite de catre o comunitate, de catre persoanele care au
dezvoltat acel limbaj? Fiecare limbaj are specificul lui si ne ajuta sa ne facem munca mult
mai eficient in anumite arii. De exemplu, cand facem programare in Python, e mai usor sa
facem aplicatii pentru telefoane sau pentru servere. Cand facem programare in PHP, va fi
mult mai usor sa ne ocupam de partea de web pentru ca acest limbaj a fost optimizat si
gandit pentru asa ceva. Programarea in C ne ajuta sa facem lucruri care tin de sistemul
de operare sau de programarea placutelor hardware pentru ca acest limbaj este foarte
rapid si asa a fost conceput.
self: reprezinta instanta clasei. Folosind acest keyword putem accesa atributele si
metodele unei clase clasei in Python.
3) Constructori si Destructori
Acum ca ai inteles si ai vazut cum se folosesc clasele in Python, a venit momentul sa
mergem mai departe si sa vorbim despre Constructori (si Destructori) in POO (aceste
concepte se aplica la orice limbaj orientat pe obiecte si nu doar in Python).
Ce este un constructor in POO?
Constructorul unei clase este o functie interna, speciala a acelei clase care este apelata
in momentul in care se creeaza o instanta a acelei clase. De exemplu sa presupunem
clasa Proiect:
class Proiect:
pass
x = Proiect()
In momentul in care rulam programul, in background va fi apelat constructorul clasei

Proiect care poate sa faca urmatoarele operatiuni:
• Initializarea atributelor (variabilelor) clasei sau a celor date ca parametru

• Alocarea memorie pentru acestea sau alte atribute ale clasei
_____________________________________________________________________
122
___________________________________________________________________
In exemplele care urmeaza vei vedea cum declaram constructorii unei clase si cum ii
putem folosi pentru o alocare cat mai eficienta a resurselor.
Folosirea constructorilor in Python
Pentru a-ti putea demonstra folosirea constructorilor in Python, vom crea o clasa Person
prin care vom defini o persoana. Clasa Person va contine urmatoarele atribute principale
care definesc o persoana: nume, varsta, gen, si CNP. Aceasta clasa, impreuna cu
atributele care o compun, ne va ajuta sa colectam mai multe date despre persoanele
care folosesc aplicatia (gandeste-te la o aplicatie de gestiune a clientilor, de exemplu).
Iata un exemplu: in momentul in care vizitam un site web si introducem datele personale,
in spate sunt anumite structuri sau clase ce iti cer acele date si le structureaza intr-un
singur loc. Prin urmare, clasa Person ne va ajuta sa luam un cumul mare de date si sa le
aranjam intr-un mod mai ordonat is mai clar, ca apoi sa putem interpreta si folosi
informatia in diferite scopuri. Iar acum, sa definim variabilele impreuna cu constructorul
nostru:
class Person:
def __init__(self, nume, varsta, gen, cnp):
self.nume = nume
self.varsta = varsta
self.gen = gen
self.cnp = cnp
In Python constructorul se defineste prin def __init__() urmat de argumentele sale.

Te poti gandi la mai multe elemente care apartin unei persoane. Poti merge mult mai in
detaliu, prin adaugarea altor caracteristici precum CNP, inaltime, studii etc. Acum vom
creea un obiect ala acestei clase si il vom initializa cu valori astfel:
persA = Person("Ramon", 25, "M", 194)
print(persA.nume)
print(persA.varsta)
print(persA.gen)
print(persA.cnp)
_____________________________________________________________________
123
___________________________________________________________________
Si rezultatul afisat va fi urmatorul:

Ramon
25
M
194
De asemenea, in constructorul definit anterior putem trece o valoare default a atributelor

definite in acesta, iar in momentul in care o instanta noua va fi creata (vezi urmatoarea
secventa de cod), i se vor atribui aceste valori daca nu au fost definite altele:
class Person:
def __init__(self, nume = "Nimeni", varsta = 0, gen = "N/A", cnp = 0):
self.nume = nume
self.gen = gen
self.cnp = cnp
Daca rescriem obiectul fara a oferi valori specifice ca argumente:
persB = Person()
print(persB.nume)
print(persB.varsta)
print(persB.gen)
print(persB.cnp)
Rezultatul va fi:
Nimeni
0
N/A
0
Instanta persB este goala in momentul de fata (in sensul in care nu are atribuite valori
catre atributele definite in clasa). Pentru a afisa pe ecran acest rezultat am fost nevoiti sa
luam fiecare atribut in parte si sa-l printam pe ecran. Avem o metoda si mai eficienta de a
face acest lucru prin definirea unei functii __str__, care practic ne permite sa
_____________________________________________________________________
124
___________________________________________________________________
customizam modul in care vrem sa printam obiectul din clasa noastra. Daca vrem sa
printam datele persoanei A, vom creea in clasa Person urmatoarea functie:
class Person:
def __init__(self, nume = "Nimeni", varsta = 0, gen = "N/A", cnp = 0):
self.nume = nume
self.gen = gen
self.cnp = cnp
def __str__(self):
return 'Person(nume=' + self.nume + ', varsta=' + str(self.varsta) +
', gen=' + self.gen + ', cnp=' + str(self.cnp) + ')'
Prin return, am intors variabilele clasei Person ca fiind un String. Astfel, printand:
print(persA)
si pe ecran va aparea:
Person(nume=Ramon, varsta=25, gen=M, cnp=194)
Vom face acelasi lucru pentru persB, tot din:
print(persB)
Pe ecran va fi afisat urmatorul text:
Person(nume=Nimeni, varsta=0, gen=N/A, cnp=0)
In primul exemplu va aparea numele ca avand valoarea “Nimeni” pentru ca asa a fost
definit in primul constructor.
_____________________________________________________________________
125
___________________________________________________________________
Ce este un destructor in POO?
Daca un constructor este folosit pentru initializarea variabilelor si alocarea de memorie

pentru diferiti membri ai clasei, atunci destructorul este o componenta apelata in
momentul in care se termina executia codului pentru dealocarea obiectului din memorie.
Astfel gestiunea memorie va fi corect facuta (memoria alocata initial, fiind eliberata
pentru folosirea acesteia de catre alte programe). In Python nu este necesara crearea
unui destructor pentru ca acest proces are loc automat in momentul in care se termina
executia programului.
4) Encapsularea elementelor dintr-o clasa in Python

Intr-un limbaj de programare orientat pe obiecte (asa cum este si Python) poti restrictiona
accesul la variabilele si metodele unei clase. Cateva dintre motivele pentru care dorim sa
facem acest lucru sunt urmatoarele:
• Pentru a evita accesul direct sau modificarea variabilelor unei clase.

• Getters (returneaza valoarea unei variabile) si setters (seteaza valoarea unei
variabile) pot oferi diferite nivele de acces la date.
• Pentru setarea corecta a valorilor unor variabile, prin validarea valorilor.
Acest proces se numeste encapsulation (aka. incapsularea datelor). Pentru clarificarea

procesului de encapsulare avem nevoie sa discutam despre urmatoarele aspecte:
a) Metode de tip public, private si protected in Python

Limbajele clasice orientate obiect, cum ar fi Python, C ++ sau Java, controleaza accesul la
resursele clasei prin cuvinte cheie publice, private si protejate. Membrii privati ai clasei nu
au acces din mediul din afara clasei. Ele pot fi tratate numai din interiorul clasei. Iata care
este scopul fiecareia:
• Tipul public este pentru ca oricine sa ne poata folosi clasa, functia sau ce mai
avem creat.
• Tipul private este pentru a folosi atributele doar in aceeasi clasa sau metoda
• Tipul protected specifica faptul ca putem accesa si folosi elementele create
(clasa, variabila etc.) doar in aceeasi clasa sau in clase-copil (clase care mostenesc
clasa principala - vom vorbi despre acest subiect in sectiunea 5 a acestui capitol).
_____________________________________________________________________
126
___________________________________________________________________
Iata in secventa de cod de mai jos un exemplu de creare declarare a variabilelor unei
clase, folosind cele trei tipuri de specificatori de acces (public, private si protected):
class Student:
def __init__(self, nume="Nimeni", varsta=0, gen="N/A", cnp=0):
#variabila este publica
self.nume = nume
#variabila este protected, poate fi accesata din interiorul clasei sau
din clase care mostenesc (clase child) clasa Person
self._varsta = varsta
#variabila este privata (nu poate fi accesata din exteriorul clasei)
self.__gen = gen
#variabila este privata (nu poate fi accesata din exteriorul clasei)
self.__cnp = cnp
Prin crearea unui obiect, odata ce incercam sa modificam/apelam fiecare variabila in

parte, rezultatul va fi urmatorul:
stud = Student("Alex", 23, "M", 198)
print (stud.nume)
print (stud.gen)
print (stud.varsta)
Programul afiseaza “numele” studentului pentru ca variabila poate fi accesata datorita

faptului ca este de tip public), dar pentru variabila gen (care este de tip private) primim
urmatorul mesaj de eroare, dupa care programul se opreste din a rula:
Alex
print (stud.gen)
AttributeError: 'Student' object has no attribute 'gen'
Aceeasi situatie are loc si in cazul variabilei varsta (care este de tip protected).De
asemenea, pe langa variabile, metodele unei clase pot restrictiona accesul prin
specificatorii folositi anterior. Iata cum putem face asta, ddaugand la clasa Student,
urmatoarele metode studentRandom(), __getRandom() si randomFun():
_____________________________________________________________________
127
___________________________________________________________________
import random
class Student:
... #definirea valorilor din exemplul de mai sus
def studentRandom(self):
randNr = random.randint(1, 10)
return self.nume + str(randNr)
def __getRandom(self): #metoda definita private

return self.studentRandom()
def randomFun(self, value):

return "Random is: " + self.__getRandom() + " " + value
print (stud.nume)
print (stud.studentRandom())
print (stud.randomFun("Tadaa"))
print (stud.__getRandom())
Rezultatul rularii programului de mai sus va fi:

Alex
Alex1
Random is: Alex10 Tadaa
Traceback (most recent call last): File "main.py", line 70, in <module> print
(stud.__getRandom())
AttributeError: 'Student' object has no attribute '__getRandom'
Mesajul de eroare se datoreaza faptului ca metode __getRandom() este de tip private si

poate fi apelata doar in cadrul elementelor clasei Student si nu in afara ei prin accesare
directa.
_____________________________________________________________________
128
___________________________________________________________________
b) Getters si setters in Python

Pentru a rezolva problema accesarii si modificarii variabilelor de tip private sau protected
avem la dispozitie conceptul de metode de tip getter & setter. Un getter este o metoda
care obtine valoarea unei variabile. In POO, acest lucru ajuta la accesarea variabilelor
private dintr-o clasa. Un setter este o metoda care seteaza valoarea unei variabile. In
POO, acest lucru ajuta la setarea valorii unei variabile private dintr-o clasa. Practic,
utilizarea getters si setters asigura incapsularea datelor. In continuare vom lua un
exemplu de metoda de tip getter, prin completarea clasei Person, definita anterior:
def getNume(self):
return self.nume
Odata definita, putem afisa pe ecran valoarea dorita (in cazul acesta numele persoanei),
astfel:
print("Numele meu este " + persA.getNume())
In cazul metodelor de tip setter, lucrurile arata in felul urmator:

def setNume(self, value):
self.nume = value
Iar, modul in care utilizam aceasta metoda este urmatorul:

persA.setNume("Adi")
print( "Numele meu este " + persA.getNume() )
Metodele de tip getter si setter se definesc pentru fiecare variabila din cadrul clasei care
se doreste a fi accesata (prin getter) /modificata (prin setter). Astfel, in cazul exemplului
nostru, intregul cod va arata in felul urmator:
class Person:
self.nume = nume
self.gen = gen
self.cnp = cnp
#definim metode de tip getter
def getNume(self):
return self.nume
def getVarsta(self):
return self.varsta
def getGen(self):
return self.gen
def getCNP(self):
return self.cnp
_____________________________________________________________________
129
___________________________________________________________________
#definim metode de tip setter

self.nume = value
def setVarsta(self, value):
self.varsta = value
def setGen(self, value):
self.gen = value
def setCNP(self, value):
self.cnp = value
def __str__(self):
return 'Person(nume=' + self.nume + ', varsta=' + str(self.varsta) +
', gen=' + self.gen + ', cnp=' + str(self.cnp) + ')'
persA = Person()
persA.setNume("Adi")
persB = Person("Ramon", 27, "M", 1)

print(persB)
In continuare, te invit ca pentru obiectul persA, sa modifici prin setters, fiecare variabila,
dupa care sa le afisezi pe ecran, fiecare separat prin folosirea metodelor de tip getter.
_____________________________________________________________________
130
___________________________________________________________________
Exercitii
Iata mai jos un exercitiu care sa te ajute sa-ti dezvolti abilitatile practice de programare in
Python folosind conceptele de POO studiate pana acum:
Creati o clasa de nume "FamiliaMea", iar obiectele asociate acesteia corespund

membrilor familiei voastre. Clasa va contine variabilele "nume", "prenume", "vara", o lista
de pasiuni, denumire "pasiuni" si o functie denumita "motto", care afiseaza motto-ul
familiei voastre.
• Creati un constructor fara parametrii care initializeaza variabilele cu date default

• Creati un constructor cu parametrii care initializeaza variabilele cu cele setate
crearea instantei (obiectului)
• Creati metode de tipul Getter si Setter pentru modificarea apelarea/modificarea
atributelor din clase
• Afisati variabilele pe ecran folosind "Getters" si modificati valorile atributelor prin
apelarea "Setters"
_____________________________________________________________________
131
___________________________________________________________________
5) Mostenirea (Inheritance) unei clase in Python
Mostenirea unei clase (parent) A de catre o clasa (child) B ii ofera clasei B posibilitatea de
a imprumuta metodele si atributele existenta in clasa A. Ideea de baza este de a prelua
functionalitatea existenta intr-o clasa si de a o modela pe cea existenta fara a rescrie
codul. Relatia intre clase este de tipul “IS-A” (X este un Y) X face parte din multimea Y.
Putem lua exemplul unui autoturism, marca BMW care are la baza foarte multe elemente
comune cu alte autoturisme (Mercedes, Audi, Porsche etc), dar in acelasi timp are si
elemente unice, specifice marcii BMW. Acesta este un exemplu cand un BMW
mosteneste caracteristicile unui autoturism (marca, caroserie, roti, culoare, viteza
maxima, capacitate motor, combustibil folosit etc.) De exemplu:
• clasa Caine (child class) mosteneste clasa Animal (parent class)
• clasa Tesla mosteneste clasa Masina
• clasa Java si clasa Python mostenesc clasa LimbajProgramare
Sau:
• “Un caine este un animal”
• “O carte este un document”
• “Python este un limbaj de programare”
• “Tesla este o masina”
Iata mai jos o schema vizuala a acestui concept:
_____________________________________________________________________
132
___________________________________________________________________
Intr-o alta perspectiva, conceptul de "mostenire" in programare orientata pe obiecte se

refera la posibilitatea de a crea o clasa "child" (copil), care are la baza ei o clasa de tip
"parent" (parinte). Astfel, clasa de tip "child" va imprumuta atributele si metodele clasei
“parent”. Acest concept este folositor pentru stabilirea atributiilor comune a mai multe
clase particulare. Acesta poate fi dezvoltat la infinit clasele de tip "child" putand deveni
"parents" pentru alte clase pe care le au in subordine. Aceasta tehnica eficientizeaza
foarte mult programul si curata codul, nefiind nevoiti sa rescriem bucati importante de
cod de mai multe ori. Adesea clasei child (copil) i se mai spune si subclass, iar clasei
parent (parinte) i se spune superclass.
Exemplu #1
In continuare vom reorganiza codul folosit in exemplele anterioare, astfel incat sa utilizam
conceptul de mostenire. Dupa cum poti vedea in exemplul de mai jos, elementele noi
sunt:
1. In declararea clasei Student (class Student(Person):) prin care se specifica
faptul ca aceasta mosteneste elementele clasei Person
2. In folosirea metodei super() din cadrul constructorului clasei Student care spune
ca se doreste a fi reutilizat constructorul clasei parinte (Person in acest caz - clasa
in care se atribuie valorile).
3. In folosirea metodelor clasei Person de catre un obiect de tip Student
import random
class Person:
self.nume = nume
self.gen = gen
self.cnp = cnp
def __str__(self):
return 'Person(nume=' + self.nume + ', varsta=' + str(
self.varsta) + ', gen=' + self.gen + ', cnp=' + str(self.cnp) + ')'
def getNume(self):
return self.nume
def getVarsta(self):
return self.varsta
def getGen(self):
return self.gen
_____________________________________________________________________
133
___________________________________________________________________
def getCNP(self):
return self.cnp
self.nume = value
def setVarsta(self, value):
self.varsta = value
def setGen(self, value):
self.gen = value
def setCNP(self, value):
self.cnp = value
class Student(Person): #clasa Student mosteneste clasa Person

super().__init__(nume,varsta,gen,cnp) #preia modul de initializare a
valorilor din clasa parinte
def studentRandom(self):
randNr = random.randint(1, 10)
return self.nume + str(randNr)
def __getRandom(self):
return self.studentRandom()
def randomFun(self, value):
return "Random is: " + self.__getRandom() + " " + value
#exemple de folosire a metodelor definite in clasa parinte, de catre clasa copil

print (stud.getNume())
stud.setVarsta(29)
print (stud.getVarsta())
stud.setCNP(192)
print (stud.getCNP())
print (stud.studentRandom())
print (stud.randomFun("Tadaa"))
Rezultatul in urma rularii secventei de cod de mai sus va fi:

Alex
29
192
Alex8
Random is: Alex2 Tadaa
_____________________________________________________________________
134
___________________________________________________________________
Care este rolul metodei super?
Dupa cum poti sa vezi in declararea clasei Student, am specificat ca aceasta va mostenii
clasa Person (cu alte cuvinte Student devine o subclasa a clasei Person), iar in interiorul
constructorului (clasei Student) am folosit metoda super. In aceasta situatie prin super
refolosim constructorul clasei parinte pentru a initializa variabilele create.
Avem aceasta optiune in situatile in care dorim sa invocam constructorul clasei parinte
(dupa cum ai putut sa vezi in exemplul de mai devreme) si in situatile in care dorim sa
folosim o functie deja exista in clasa parinte (fara a fi nevoie sa redefinim noi codul).
Exemplu #2
In continuare vom lua un al doilea exemplu de cod (de data aceasta avand la baza
masinile) pentru a vedea si intelege dintr-o alta perspectiva cele discutate mai devreme
in acest capitol:
class Masina():
def __init__(self, marca, caroserie, combustibil, pret, pretNegociabil):
self.marca = marca
self.caroserie = caroserie
self.combustibil = combustibil
self.pret = pret
self.pretNegociabil = pretNegociabil
def getMarca(self):
return self.marca
def getCaroserie(self):
return self.caroserie
def setCaroserie(self, caroserie):

self.caroserie = caroserie
def getCombustibil(self):
return self.combustibil
def setCombustibil(self, combustibil):

self.combustibil = combustibil
def getPret(self):
return self.pret
_____________________________________________________________________
135
___________________________________________________________________
def setPret(self, pret):

self.pret = pret
def getPretNegociabil(self):
return self.pretNegociabil
def setPretNegociabil(self, pretNegociabil):

self.pretNegociabil = pretNegociabil
Dupa cum poti sa vezi clasa “Masina” contine o parte din caracteristiciile de baza care le
intalnim la marea majoritate a masinilor (marca, combustibil, culoare, cai putere, viteza
maxima). Aceasta clasa va fi clasa parinte pentru orice tip de masini dorim. In exemplul
de mai jos eu am ales marca BMW si am creat o clasa cu caracteristiciile specifice acestei
marci.
class BMW(Masina):
def __init__(self, caroserie, combustibil, model, culoare,
kmParcursi, cPutere, vitezaMax, pret, pretNegociabil):
super().__init__("BMW", caroserie, combustibil, pret, pretNegociabil)
self.model = model
self.culoare = culoare
self.kmParcursi = kmParcursi
self.cPutere = cPutere
self.vitezaMax = vitezaMax
print("Masina de marca " + super().getMarca() + " si modelul " +

self.model + " a fost creata.")
def getModel(self):
return self.model
def setModel(self, model):

self.model = model
def getCuloare(self):
return self.culoare
def setCuloare(self, culoare):

self.culoare = culoare
_____________________________________________________________________
136
___________________________________________________________________
def getcPutere(self):
return self.cPutere
def setcPutere(self, cPutere):

self.cPutere = cPutere
def getVitezaMax(self):
return self.vitezaMax
def setVitezaMax(self, vitezaMax):

self.vitezaMax = vitezaMax
def pornesteMotor(self):
print("Vmmmmm")
def opresteMotor(self):
print("Brrmmmm")
def tureazaMotor(self):
print("VMMMMMMMMMM")
def accelereaza(self):
print("PFIUUUHHH")
Acum, in momentul definirii clasei BMW, poti vedea ca intre paranteze am adaugat clasa
Masina (clasa parinte) care specifica faptul ca aceasta clasa mosteneste caracteristiciile
(atributele si metodele) clasei “Masina”. De asemenea folosesc si metoda super() al
carui rol este sa se foloseasca de constructorul definit initial in clasa parinte (Masina).
Dupa cum poti vedea in clasa BMW am definit atat functii de getter si setter pentru
variabilele clasei, cat si functii specifice clasei BMW (care nu exista in clasa parinte) pe
care le folosim in secventa urmatoare:
#vom creea o instanta a clasei BMW si initializam variabilele: caroserie,
combustibil, model, culoare, kmParcursi, cPutere, vitezaMax, pret si
pretNegociabil
bA = BMW("SUV", "Diesel", "X6", "Negru", 120000, 300, 260, 45000,'N')
bA.pornesteMotor()
bA.tureazaMotor()
_____________________________________________________________________
137
___________________________________________________________________
bA.accelereaza()
bB = BMW("Berlina", "Diesel", "530d", "Negru", 90000, 240, 230, 34000, 'Y')

bB.pornesteMotor()
bB.tureazaMotor()
bB.accelereaza()
Mai sus poti vedea intregul program pus “cap la cap” in prin obiectele create (care in
urma initializarii devin instante) ale clasei BMW. Mai jos poti vedea rezultatul rularii
programului nostru:
Masina de marca BMW si modelul X6 a fost creata.
Vmmmmm
VMMMMMMMMMM
PFIUUUHHH
Masina de marca BMW si modelul 530d a fost creata.
Vmmmmm
VMMMMMMMMMM
PFIUUUHHH
_____________________________________________________________________
138
___________________________________________________________________
Capitolul 7 - Exceptii si Operatii cu Fisiere in Python
I. Exceptii in Python
Ce sunt exceptiile?
O exceptie reprezinta un eveniment (neasteptat) care are loc in timpul executiei unui
program. Aceasta exceptie (daca nu este tratata) poate duce la intreruperea programului
si oprirea permanenta a acestuia. Exceptiile pot aparea in mai multe situatii, cum ar fi:
• Citirea sau lucru cu un fisier care nu exista (FileNotFoundError)

• Indentarea codului nu a fost facuta corect (IndentationError)
• Imposibilitatea utilizarii (sau inexistenta) unei clase (ClassNotFound)
• Depasirea lungimii maxime definite pentru o lista (IndexError)
• Imposibilitatea conectarii la un server
Toate aceste exceptii, precum si multe altele cu denumiri la fel de sugestive, pot aparea
(sub forma de eroare) atunci cand scriem programele noastre si facem greseli la nivel de
comportament al codului nostru, si nu la nivel de compilare (greseli de sintaxa in
programare).
Cum sunt generate exceptiile in Python?
O exceptie este generata prin “aruncarea” sa in momentul in care o anumita conditie nu

este respectata. Sa luam codul de mai jos sub forma de exemplu pentru a intelege mai
bine:
h = None
if h == None:
raise Exception("Valoarea variabilei este nedefinita")
_____________________________________________________________________
139
___________________________________________________________________
Iar rezultatul generat va fi aceasta eroare:

raise Exception("Valoarea variabilei este nedefinita")
Exception: Valoarea variabilei este nedefinita
In acest exemplu am creat o variabile care am initializat-o cu None - o valoare care indica
faptul ca variabila e complet goala, e nula, nu are atribuit nimic. Dupa aceea am testat
daca variabila este nula. In cazul in care if-ul este valid, atunci va fi aruncata o exceptie
(prin crearea unui instante de tipul Exception) care va anunta faptul ca variabila este
nula, iar programul nu poate merge mai departe datorita acestui fapt. Exceptiile pot fi de
doua tipuri:
1. Exceptii predefinite (built-in) - vezi figura 7.1
2. Exceptii definite de catre programator
Clasa BaseException este clasa parinte a majoritatii exceptiilor din Python. O parte
dintre exceptiile built-in le-am mentionat si la inceputul acestui capitol:
• FileNotFoundError
• ZeroDivisionError
• ValueError
• EOFError
• IndexError
• ImportError
• TypeError
• Si multe altele
_____________________________________________________________________
140
___________________________________________________________________
Figura 7.1
In aceasta sectiune ne vom concentra asupra exceptiilor built-in. In cele ce urmeaza iti
voi arata cateva exemple de programe care genereaza exceptii si modul in care le putem
trata. Iata mai jos un exemplu de cod care genereaza o exceptie:
o = 3
d = "Str"
g = o + d
print(g)
In exemplul de mai sus, secventa de cod declara 2 variabile de tipuri diferite (int si
String) si printr-o a treia variabila incearca sa adune valorile celor 2. Dupa cum poti
vedea in eroarea de mai jos exceptia de tipul TypeError, acest lucru nu este posibil
pentru ca cele doua valori nu sunt de acelasi tip, iar o operatie matematica in aceasta
situatie este imposibila.

g = o + d
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Aceasta eroare o putem rezolva in doua moduri. Primul mod este prin a trata exceptia cu
blocul de instructiuni try - except (asa cum vei vedea in sectiunea urmatoare),
_____________________________________________________________________
141
___________________________________________________________________
respectiv prin convertirea variabilei de tipul int la String pentru a putea face o
concatenare a doua siruri:
o = 3
d = "Str"
g = str(o) + d
print(g)
Cu rezultatul:
3Str
Cum tratam exceptiile in Python?
Pentru a rezolva aceasta problema (si pentru a permite codului nostru sa fie executat in
continuare fara intreruperi) trebuie sa prindem (captam) exceptiile care sunt aruncate,
dupa care sa le tratam. Putem face asta in formatul urmator:
l = [1, 2, 3, 4]
for r in range(6):
print(l[r])
Rezultatul in acesta situatie va fi urmatorul:
1
2
3
4
print (l[r])
IndexError: list index out of range
Practic prin folosirea blocului de instructiuni try - except putem sa ne protejam codul
(si programul) nostru de o eventuala intrerupere care poate avea loc. In blocul try -
except am introdus codul principal care va fi executat instructiune cu instructiune. In
_____________________________________________________________________
142
___________________________________________________________________
momentul in care este lansata o exceptie, blocul except o va prinde si o va trata (in
functie de codul scris acolo). In cazul acesta, codul nostru va arata astfel:
l = [1, 2, 3, 4]
try:
for r in range(6):
print(l[r])
except IndexError:
print("S-a depasit dimensiunea listei")
Si rezultatul:
1
2
3
4
S-a depasit dimensiunea listei
NOTA: Aici este recomandat sa modificam valoarea functiei range(), in loc sa tratam
exceptia.
Iata alte exemple de cod care genereaza o parte din exceptiile mentionate la inceputul
acestui capitol:
Exemplul #1 - Divide by 0
In acest exemplu poti sa vezi cum are loc o operatie de impartire a unui numar la 0 si
rezultatul generat de catre compilator:
x = 21
y = 0
z = x / y
print(z)
print("Programul a fost terminat cu succes")
Iar rezultatul il poti vedea mai jos:
_____________________________________________________________________
143
___________________________________________________________________

z = x / y
ZeroDivisionError: division by zero
Pentru a rezolva aceasta problema, vom folosi blocul try - except, care ne ve permite
sa prindem o eventuala exceptie care ar putea fi lansata de catre program. In secventa
except vom incerca sa prindem exceptia ZeroDivisionError.
try:
x = 21
y = 0
z = x / y
except ZeroDivisionError:
print("Operation Not allowed")
Si rezultatul in urma rularii codului:
Operation Not allowed

Programul a fost terminat cu succes
Exemplul #2 - File Not Found
In acest al doilea exemplu poti sa vezi cum are loc o operatie de citire a datelor (despre
care vom discuta in partea a doua a acestui capitol) dintr-un fisier si rezultatul generat:
f = open("test.txt", "r")
f.read()
Iata rezultatul acestei secvente de cod care are scopul de a deschide un fisier, denumit
test.txt, si de a citi datele din el:
_____________________________________________________________________
144
___________________________________________________________________

f = open("test.txt", "r")
FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'
Pentru a rezolva aceasta problema, vom folosi blocul try - except, care ne ve permite
sa prindem o eventuala exceptie care ar putea fi aruncata de catre program. In secventa
except vom incerca sa prindem exceptia FileNotFoundException, doar ca de data
aceasta am sa te las pe tine sa scrii codul pentru prinderea exceptiilor (vezi sectiunea de
exercitii de la sfarsitul acestei prime parti ale capitolului).
NOTA: Pentru ca acest program sa functioneze cum trebuie, este foarte important ca
fisierul test.txt sa existe. Mai multe detalii la sfarsitul acestui capitol.
Exemplul #3 - Indentation Error
In acest al treilea exemplu poti sa vezi cum are loc o operatie simpla, dar asupra careia
indentarea nu a fost facuta corect:
k = [9, 8, 7, 6, 5]
def listPrint(ls):
for x in range(len(ls)):
print (ls[x])
listPrint(k)
Iata si rezultatul:
File "main.py", line 168

print (ls[x])
^
IndentationError: expected an indented block
Iti poti da seama unde este eroarea? Pentru a rezolva aceasta problema, nu este nevoie
de blocul try - except (desi poate fi folosit ca o bariera de siguranta), ci e nevoie de a
_____________________________________________________________________
145
___________________________________________________________________
identifica elementul unde a fost facuta in mod eronat indentarea. Ce spui, reusesti sa
gasesti greseala? :)
Astfel de erori sunt des intalnite in programare in Python mai ales pentru ca nu exista
acolade sau alte tipuri de delimitari ale codului in afara de aceasta indentare. Asadar, iti
recomand sa fii foarte atent la modul in care este indentat codul tau (mai ales atunci cand
scrii programe mai lungi si mai complexe) pentru ca in anumite situatii s-ar putea ca
programul tau sa ruleze (eronat), chiar daca a fost gresita indentarea intr-un anumit loc.
Exemplul #4 - String index out of range
In acest al patrulea exemplu poti sa vezi cum are loc o operatie de parcurgere a
caracterelor dintr-un sir (ba, chiar depasirea numarului total de caractere) si rezultatul
generat:
e = "Big string"
print(e[20])
Iar eroarea generata este:

print(e[20])
IndexError: string index out of range
Pentru a rezolva aceasta problema, vom folosi blocul try - except, care ne ve permite sa
prindem o eventuala exceptie care ar putea fi lansata de catre program. In secventa
except vom incerca sa prindem exceptia IndexError, doar ca de data aceasta am sa te
las pe tine sa scrii codul pentru prinderea exceptiilor (vezi sectiunea de exercitii de la
sfarsitul acestei prime parti ale capitolului).
NOTA: Aceeasi eroare poate aparea atat in cazul string-urilor, cat si in cazul listelor sau a
oricaror alte structuri de date. Acest lucru se poate intampla doar in momentul in care
este depasit indexul alocat acelei structuri de date. Exemplu: exista 9 elemente intr-o lista
si este apelat elementul 11, atunci va fi aruncata aceasta exceptie de index.
ATENTIE: acestea au fost cateva exemple de erori pe care le poti avea atunci cand iti
scrii programele in Python. Cand vine vorba de exceptii precum IndexError te incurajez
sa rezolvi cauza acestei exceptii si NU sa pui codul intr-un bloc try - except, in acest caz
aceasta solutie nu este una eficienta.
_____________________________________________________________________
146
___________________________________________________________________
Exercitiu
1) Pentru fiecare exemplu (2 - 4) de mai sus care nu contine o solutie de tratare a
exceptiilor, te invit sa rescrii codul astfel incat programul sa nu fie intrerupt si sa-si poata
continua executia.
_____________________________________________________________________
147
___________________________________________________________________
II. Operatii cu Fisiere in Python
Cand vine vorba de programare, o buna parte din timp vei lucra cu operarea sau
manipularea de date, care sunt folosite de programul sau de aplicatia la care lucrezi. In
marea majoritate a cazurilor, aceste date se vor afla stocate pe disc (cel mai probabil sub
forma fisiere) sau intr-o baza de date. In aceasta sectiune vom invata cum sa gestionam
citirea dintr-un fisier, respectiv scrierea intr-un fisier prin Python.
Cand vine vorba de lucrul cu fisiere, in mare parte poti face 2 lucruri: citirea sau scrierea
in acele fisiere. Este important sa il ai in vedere pentru ca te vei intalni destul de des cu
astfel de operatii. Alte moduri prin care programul tau poate obtine date (pe care sa le
proceseze) sunt:
• De la alte programe prin fisierele locale (aflate pe acelasi PC/laptop, hard disk)
• De la alte programe prin retea (aflate pe anumite PC-uri/laptop-uri sau servere)
• Din program, datele fiind introduse de la tastatura (despre care am vorbit in
capitolul 2)
1) Citirea fisierelor in Python
Cand vine vorba de citirea dintr-un fisier, este extrem de important ca acel fisier sa existe
si sa-i fie precizata locatia exacta de pe disk, astfel incat sa fie citite datele din el. Pentru
asta putem folosi functia open() care ne va permitem sa accesam un fisier stocat pe
hard disk. Functia open() are urmatoarea structura si contine urmatoarele proprietati:
open (file, mode, buffering, encoding, errors)
"r" - Read - Deschide un fisier pentru a citi datele din el si intoarce o eroare daca acesta
nu exista. Este valoarea implicita.
"w" - Write - Deschide un fisier pentru a scrie in el. Daca fisierul exista deja si are
continut, va sterge acel continut si apoi scrie in el noile date. Altfel, creeaza fisierul daca
nu exista.
"a" - Append - Deschide un fisier pentru adaugare. Daca fisierul exista deja si are
continut, va adauga noile date dupa acel continut. Altfel, creeaza fisierul daca nu exista.
"x" - Create - Creeaza fisierul specificat si intoarece o eroare in care fisierul exista deja.
_____________________________________________________________________
148
___________________________________________________________________
Pe langa acestea, mai poti specifica si modul in care sa fie citite datele dintr-un fisier:
"t" - Text - Modul text, valoarea implicita.
"b" - Binary - Modul binar, folosit in cazul citirii unei imagini.
Acum, haide sa vedem cum putem “declara” un fisier pentru a face diferite operatiuni de
scriere sau de citire cu acesta. Inainte de asta, te invit sa creezi un fisier pe Desktop (sau
in folderul proiectului tau din IDE) si sa adaugi urmatorul text in el:
Salut!
Sunt un fisier care asteapta sa fie modificat.
NOTA: Acest exercitiu iti recomand sa-l faci intr-un IDE (cum ar fi PyCharm) pentru ca iti
va fi mai usor sa gestionezi fisierele. Implicit fisierele create (ex: “fisier.txt”) se vor afla in
folderul proiectului tau.
fileWindows = "C:\Users\Public\Desktop\fisierIntrare.txt"
fileMac = "/Users/ramon/Desktop/fisierIntrare.txt"
fileLinux = "/home/ramon/Desktop/fisierIntrare.txt"
fW = open(fileWindows, "r")
fM = open(fileMac, "r")
fL = open(fileLinux, "r")
Daca locatia oferita programului nu este exacta si programul esuaza sa citeasca datele
din fisier, atunci acesta (daca nu este scris corect) se poate opri din executie. In marea
majoritate a cazurilor o exceptie este lansata cand fisierul nu exista sub forma
FileNotFoundError. Daca ajungem in aceasta situatie, e important sa tratam aceasta
exceptie astfel incat programul nostru sa continue si sa nu-si inceteze executia. Asadar,
indiferent daca esti pe Windows, Linux sau macOS iti recomand sa folosesti calea
absoluta (adica locul exact de pe disc) pentru a arata unde se afla fisierul din care doresti
sa faci operatia de citire (asa cum ai putut sa vezi in exemplul de mai sus). De asemenea
putem creea un fisier care se va afla in folderul proiectului nostru din IDE, folosind
expresia de mai jos:
_____________________________________________________________________
149
___________________________________________________________________
fisier = "fisier.txt"
f = open(fisier, "r", "t")
Pentru a citi datele stocate intr-un fisier, vom folosi functia read() exemplificata in
urmatoarea structura de cod:
print(fW.read())
Iar rezultatul afisat in consola va fi:
Salut!
Sunt un fisier care asteapta sa fie modificat
Astfel, ai reusit sa citesti toata informatia din acel fisier si sa o afisezi in consola. Practic,
programul tau a accesat un fisier stocat pe hard disk-ul tau, a citit acele date si le-a afisat
in consola. Acum sper ca iti poti imagina cat de departe poti merge cu asta. Acest proces
este unul care sta la baza majoritatii programelor cu care noi lucram zi de zi. Odata ce am
terminat lucrul cu fisierul, e important sa il inchidem pentru a nu aparea erori sau alterari
ale acestuia. Modul prin care facem asta este cu functia de mai jos:
fW.close()
Alte moduri de a citi informatia dintr-un fisier

Functia read poate primi si un argument care reprezinta numarul de biti pe care sa-l
citeasca din fisier.
print(fW.read(10))
Iata in exemplul de mai jos rezultatul afisat:

Salut!
Su
_____________________________________________________________________
150
___________________________________________________________________
Asadar, doar o parte din continutul fisierului a fost citit (mai exact primii 10 biti). In cazul in
care ai un fisier si vrei sa citesti datele linie cu linie, atunci te poti folosi de secventa de
mai jos:
fW.readline()
In secventa urmatoarea poti vedea un mod mai rapid de a declara un fisier si de a

importa intr-o variabila datele existente in el pentru a putea fi procesate de catre
program:
with open('file.txt') as f:
read_f = f.read()
print(read_f)
Unul dintre avantajele acestei secvente de cod consta in faptul ca fisierul este inchis
automat la finalizarea sa (un aspect pe care marea majoritate a programatorilor il uita),
fapt care va duce la mai putine erori de program.
_____________________________________________________________________
151
___________________________________________________________________
2) Scrierea in fisiere cu Python
Procesul de scriere intr-un fisier este mai usor de facut pentru ca nu trebuie sa existe
fisierul in care vrem sa scriem. Daca fisierul destinatie (cel cu denumirea in care vrem sa
scriem) nu exista, atunci programul il va crea automat, deci nu trebuie sa-ti faci griji.
Important si aici este sa te asiguri ca oferi corect locatia destinatie a fisierului. Iata mai jos
un exemplu:
fileW = "fisierul_meu.txt"
fileA = "C:\Users\Public\Desktop\fisierul_meu_desktop.txt"
fW = open(fileW, "w")
fA = open(fileLoc, "a")
Mai sus, intentionat am ales 2 fisiere (unul care se va afla in folderul proiectului din IDE -
fileW) si al doilea care se afla pe Desktop. Primul fisier nu exista, deci va fi creat automat
de catre program in momentul in care va fi executata functia de deschidere si scriere, iar
al doilea fisier exista si continutul (1234, “Salut!”). Primul a fost deschis cu “w”, adica
cu scopul de a scrie in el, iar al doilea a fost deschis cu “a”, adica cu scopul de a face
append, de a adauga text in el (astfel pastrandu-si continutul).
ATENTIE: daca deschizi un fisier cu scopul de a scrie in el (“w”), e important ca acel fisier
sa fie gol pentru ca, altfel, functia de scriere iti va sterge intregul continut al acelui fisier.
Daca doresti doar sa adaugi, atunci declara-l cu append (“a”).
fW.write("Text pentru noul fisier fileW")

fA.write("Text pentru fisierul fileA")
fW.close()
fA.close()
Si acum, iata mai jos rezultatele pentru fisierul fW:

Text pentru noul fisier fileW
Respectiv fA:
_____________________________________________________________________
152
___________________________________________________________________
1234, “Salut!”
Text noul fisierul fileA
Dupa cum poti sa vezi, in primul fisier rezultatul este exact ceea ce am scris in el, iar in al
doilea fisier a fost adaugat textul pe langa cel existent initial.
Exemplul #2
Mergand mai departe, propun sa punem lucrurile cap la cap. In sectiunea de cod de mai
jos poti vedea un exemplu complet de citire, respectiv scriere a unui text intr-un fisier.
Programul citeste datele din fisierul input.txt (care poate contine orice valoare doresti tu -
in cazul meu am ales sa-l umplu cu dummy text - Lorem Ipsum) si le scrie in fisierul
output.txt. Daca nu introducem o locatie anume de unde dorim sa citim/scriem in fisier,
programul va folosi locatia default (cea in care se afla proiectul tau Python). Pentru a afla
aceasta locatie, avem la dispozitie functia:
import os
print(os.getcwd())
Aceasta functie o folosim pentru a afisa in consola locatia curenta, unde programul
nostru in Python cauta (by default) fisierul input.txt, respectiv unde va crea fisierul
output.txt. Nu iti fa griji, vom discuta in capitolul urmator mai multe despre module,
functia import si ce alte functii mai putem folosi pentru a ne face viata mai usoara in
timp ce scriem programe.
try:
fIn = open("input.txt", "r")
fOut = open("output.txt", "w")
dateFisier = fIn.read()
print("Fisierul citit este:")

print(dateFisier)
print("Fisierul scris este:")

dateFisier = dateFisier.upper()
fOut.write(dateFisier)
_____________________________________________________________________
153
___________________________________________________________________
print(dateFisier)
fOut.close()
fIn.close()
except IOError:
print("Fisierul de citire nu a fost gasit")
fOut.close()
Acest program citeste datele dintr-un fisier, le stocheaza intr-o variabila de tipul String
(dateFisier), dupa care le modifica formatul (toate caracterele devin uppercase) intr-un alt
fisier. Rezultatul il poti vedea mai jos:
Fisierul citit este:
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec hendrerit lorem
vel libero scelerisque, in faucibus lorem iaculis. Etiam vestibulum lacus sit
amet nisi pretium vehicula. Sed quam lacus, volutpat et magna a, consequat
sodales quam. Donec luctus sapien finibus, dapibus tellus nec, auctor turpis.
Nullam sit amet mauris ultrices, gravida metus rutrum, pulvinar orci. Integer
molestie scelerisque tellus, quis bibendum sem accumsan et. Vestibulum et ante
fermentum, condimentum nisl et, auctor neque. Vivamus in nibh nec enim
scelerisque dictum. Nullam accumsan turpis quis risus elementum sodales. Sed
blandit nec nulla ultricies euismod. Praesent eu euismod nibh. Curabitur eu erat
vitae diam ultricies volutpat nec sed velit.
Fisierul scris este:
LOREM IPSUM DOLOR SIT AMET, CONSECTETUR ADIPISCING ELIT. DONEC HENDRERIT LOREM
VEL LIBERO SCELERISQUE, IN FAUCIBUS LOREM IACULIS. ETIAM VESTIBULUM LACUS SIT
AMET NISI PRETIUM VEHICULA. SED QUAM LACUS, VOLUTPAT ET MAGNA A, CONSEQUAT
SODALES QUAM. DONEC LUCTUS SAPIEN FINIBUS, DAPIBUS TELLUS NEC, AUCTOR TURPIS.
NULLAM SIT AMET MAURIS ULTRICES, GRAVIDA METUS RUTRUM, PULVINAR ORCI. INTEGER
MOLESTIE SCELERISQUE TELLUS, QUIS BIBENDUM SEM ACCUMSAN ET. VESTIBULUM ET ANTE
FERMENTUM, CONDIMENTUM NISL ET, AUCTOR NEQUE. VIVAMUS IN NIBH NEC ENIM
SCELERISQUE DICTUM. NULLAM ACCUMSAN TURPIS QUIS RISUS ELEMENTUM SODALES. SED
BLANDIT NEC NULLA ULTRICIES EUISMOD. PRAESENT EU EUISMOD NIBH. CURABITUR EU ERAT
VITAE DIAM ULTRICIES VOLUTPAT NEC SED VELIT.
_____________________________________________________________________
154
___________________________________________________________________
Exercitii
Dupa cum te-ai obisnuit pana acum, la fiecare final de capitol iti pun la dispozitie un set
de cateva exercitii pe care tu sa le practici.
1) Creeaza un program care citeste numerele din cele 3 fisiere atasate AICI. Dupa citire,
aceste numere vor fi sortate in ordine crescatoare si vor fi scrise intr-un fisier nou
denumit "rezultat.txt". Pe prima linie se va scrie cel mai mare numar dintre cele citite,
urmat numarul total de elemente citite din cele 3 fisiere.
Exemplu fisiere "rezultat.txt":
8181 45
3
4
5
19
...
Unde 8181 reprezinta cel mai mare numar dintre cele citite, iar 45 reprezinta numarul total
de numere citite din cele 3 fisiere. Raspuns corect:
991 44
3
4
_____________________________________________________________________
155
___________________________________________________________________
Capitolul 8 - Module in Python
Ce sunt modulele si de ce le folosim

Rolul modulelor in Python (precum si in alte limbaje de programare) este de a ne face
viata mai simpla, mai usoara atunci cand vrem sa dezvoltam diverse aplicatii. Gandeste-te
la urmatorul lucru: atunci cand dorim sa batem un cui in perete, cel mai probabil vom
folosi un ciocan (sau un alt instrument - aka. modul) care sa ne faca viata mai usoara
pentru ca altfel, daca ar fi sa-l batem cu palma sau cu pumnul, s-ar putea sa dureze si cel
mai probabil sa doara. La fel si in programarea cu partea de module, le folosim pentru ca
ne faca viata mai usoara, acestea continand deja metode eficiente implementate de alte
persoane care devin “best-practice” in industrie.
Exemple de module folosite cu Python

In Python sunt numeroase module pentru diferite scopuri (in general gasesti pentru orice
arie de interes cel putin un modul pe care il poti folosi, tot ce ai nevoie este sa cauti pe
Google, acel modul de care ai nevoie). Iata o lista cu cele mai populare module din
Python, impreuna cu ariile de utilizare:
● NumPy - math & number processing

● Pandas - analiza de date
● TensorFlow - inteligenta artificiala si machine learning
● Pillow - procesare de imagini
● Tkinter - programare aplicatii grafice (GUI)
● Requests - HTTP requests & API development
a) Modulul “random” (have fun with random numbers)

Modulul random este folosit pentru a obtine valori noi, pentru a genera valori aleatoare.
Acesta poate fii utilizat pentru a efectua o actiune la intamplare, pentru a obtine un
numar aleator, amestecarea elementelor dintr-o structura de date sau pentru selectarea
aleatorie a unui element dintr-o lista. In exemplul de mai jos, vei vedea o problema care
se rezolva folosind acest modul. Probabil ca stii deja jocul “Piatra, hartie, foarfeca”. Am
incercat sa oferim o rezolvare a acestui joc, creand logica bazata pe modulul random
dupa urmatorul enunt:
_____________________________________________________________________
156
___________________________________________________________________
Creati un joc Piatra-Hartie-Foarfeca la care participa 2 persoane, folosindu-va de functia

input pentru a cere date de la jucatori. In momentul cand cineva castiga, printati un mesaj
de felicitare si intrebati utilizatorii daca doresc sa inceapa un joc nou.
import random
optiune = str(input("Alege o optiune dintre piatra, hartie si foarfeca. "))

optiuni = ["piatra", "hartie", "foarfeca"]
optiuneCalculator = random.choice(optiuni)
print(optiuneCalculator)
variantaCastigatoare = "Felicitari! A-ti castigat. Doriti sa incepeti inca un
joc?"
a = "Yes"
while a == "Yes":
if optiune == optiuneCalculator:
print("egalitate")
break
elif optiune = "piatra":
if optiuneCalculator == "hartie":
print("ai pierdut")
break
elif optiuneCalculator == "foarfeca":
print(variantaCastigatoare)
a = input("Introduceti Yes sau NO: ")
if a == "Yes":
optiune = str(input("Alege o optiune dintre piatra,
hartie si foarfeca: "))
elif optiune == "hartie":
if optiuneCalculator == "foarfeca":
print("ai pierdut")
break
elif optiuneCalculator == "piatra":
a = input("Introduceti Yes sau No: ")
if a == "Yes":
optiune = str(input("Alege o optiune dintre piatra,
hartie si foarfeca: "))
_____________________________________________________________________
157
___________________________________________________________________
` elif optiune == "foarfeca":
if optiuneCalculator == "hartie":
a = input("Introduceti Yes sau No: ")
if a == "Yes":
optiune = str(input("Alege o optiune dintre
piatra, hartie si foarfeca: "))
elif optiuneCalculator == "piatra":
print("ai pierdut")
break
Poti testa jocul si sa iti faci o idee despre logica din spate a unui program. Fiecare dintre
aceste module are propriile sale metode. Vom aminti doar o parte dintre ele in cele ce
urmeaza:
Metoda random.randint() ce returneaza un numar intreg aleator intre un interval
specificat.
>>>import random
>>>random.randint(5,10)
7
>>>random.randint(5,10)
9
Metoda random.random() ce returneaza un numar real (cu virgula) intre 0.0 si 1.0
>>>import random
>>>random.random()
0.458765675
Metoda random.shuffle() ce reordoneaza random elementele dintr-o lista:
>>>import random
>>>a = [30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]
>>>random.shuffle(a)
>>>a
[32, 37, 40, 31, 30, 38, 35, 39, 33, 36, 34]
>>>random.shuffle(a)
_____________________________________________________________________
158
___________________________________________________________________
>>>a
[37, 35, 36, 34, 30, 38, 31, 39, 33, 40, 32]
Metoda random.choice() ce returneaza un element selectat random dintr-o secventa

nevida, precum o lista:
>>>import random
>>>random.choice('computer')
'm'
>>>random.choice([11,14,17,19,20])
11
>>>random.choice([11,14,17,19,20])
19
Metoda random.randrange() ce selecteaza random un element dintr-un interval ales,

format din numarul de unde incepe intervalul, numarul la care se termina intervalul, iar
acestui interval ii poti adauga si un pas, un argument
>>>import random
>>>random.randrange(1, 10)
3
>>>random.randrange(1, 10, 2)
5
>>>random.randrange(0, 101, 10)
70
_____________________________________________________________________
159
___________________________________________________________________
b) Modulul “pillow” pentru procesarea de imagini

Multe aplicatii folosesc imagini digitale necesare pentru diferite scopuri, iar una dintre
lucrurile de baza ale aplicatiilor web sunt imaginile, in Python existand biblioteci pentru
procesarea acestora, precum: OpenCV, PIL sau Pillow despre care vom vorbi in cele ce
urmeaza. Modulul pillow accepta mai multe formate de imagine, iar printre tipuri de
procesare a imaginilor amintim: redimensionarea, rotirea, decuparea sau transformarea
imaginilor. Acest modul poate rula pe orice sistem de operare si suporta o varietate de
imagini: jpeg, png, ppm, etc. Pe langa procesarea imaginilor, cu ajutorul acestui modul
putem executa anumite operatii de filtrare a imaginilor. Permite, de asemenea,
extragerea unor date statistice din imagine prin folosirea Histogramei pentru o analiza
statistica si implicit, imbunatatirea contrastului. Utilizarea acestui capitol presupune
cateva etape:
a) Instalarea modulului pillow folosind pip
Iar pentru a face aceasta etapa, avem nevoie sa introducem in command prompt
urmatoarea comanda:
python -m pip install pip
python -m pip install pillow
Daca ai deja instalat acest modul, vei primi un mesaj in care vei fii anuntat despre acest
lucru sau poti sa ii faci un update folosind urmatoarele comenzi:
python3 -m pip install --upgrade pip
python3 -m pip install --upgrade Pillow
E posibil sa intampini totusi cateva erori provocate de IDE. Iti recomand ca in acest caz sa
urmaresti linkurile de mai jos:
How to import pil in pycharm or anaconda

How to use Conda env in pycharm
Python Tutorial: Image Manipulation with Pillow
_____________________________________________________________________
160
___________________________________________________________________
b) Folosirea modulului IMAGE
Acest modul contine cateva functii incorporate precum incarcarea imaginilor sau crearea
lor. Pentru incarcarea imaginilor, importam si apelam modulul IMAGE folosind comanda:
Image.open(“poza”), trecand intre paranteze numele pozei dorite. Apoi vom incarca
imaginea prin functia Image.open(), iar orice modificare ii aducem acestei imagini,
poate fii salvata prin comanda save() . Vom apela modulul PIL, in locul modulului Pillow
pentru a fii compatibil cu modulul Python Imaging Library (PIL), iar codul va incepe cu
secventa: “from PIL import Image”. Imaginea poate fii redimensionata, decupata,
putandu-se opera diferite functii sau metode. In exemplul de mai jos, poti observa rotatia
unei imagini. Functia show() este apelata pentru a afisa o imagine.
from PIL import Image
x = Image.open("image.jpg")
#comanda pentru a afisa imaginea actuala
x.show()
#imaginea rotita
x = x.rotate(90)
x.show()
Exemple de metode ale modulului Image( sa presupunem ca avem o poza cu numele

imagine):
● imagine.filename: functie folosita pentru a obtine numele imaginii

● imagine.format: folosita pentru a identifica formatul pozei, exemplu JPEG
● imagine.mode : determina formatul pixelilor folositi in imagine, exemplu RGB
● imagine.size : marimea imaginii
In exemplul urmator, poti observa diferite functii folosite in cadrul acestui modul. Iti
recomand sa testezi si sa vezi ce se intampla in propriul IDE.
_____________________________________________________________________
161
___________________________________________________________________
# Importam modulul Image

# Importam modulul os
import os
# Selectam imaginea
imageName = 'a.jpg'
if os.path.exists(imageName) :
# deschidem imaginea
imagine = Image.open('a.jpg')
# o afisam
imagine.show()
# printam latimea si inaltimea acesteia
print('Dimensiunea imaginii este : {}'.format(imagine.size))
# afisam formatul imaginii
print('Formatul imaginii este : {}'.format(imagine.format))
else:
# altfel afisam o eroare
print('Imaginea nu exista')
De asemenea, te poti juca si cu formatul acesteia:

print('The size of the original image is : {}'.format(imagine.size))
# schimbam dimensiunea imaginii
resized_imag = imagine.resize((200, 100))
# salvam noua imagine cu un nou nume
resized_imag.save('new.jpg')
# Print the width and height of the new image in pixels
print('Dimensiunea noii imagini este : {}'.format(resized_imag.size))
_____________________________________________________________________
162
___________________________________________________________________
Poti crea si o miniatura a pozei respective:

#deschidem imaginea
imag = Image.open('a.jpg')
# stabilim valorile miniaturii

imag.thumbnail((200, 200))
# salvam miniatura
imag.save('thumbnail.png')
# deschidem miniatura
thumbnail_imag = Image.open('thumbnail.png')
# o afisam
thumbnail_imag.show()
In concluzie, modulul IMAGE contine multiple functii pentru a putea efectua operatii
asupra unei imagini. Te invit sa le testezi si sa te joci cu acestea.
_____________________________________________________________________
163
___________________________________________________________________
c) Folosire modul sys & argumentele unui program in Python

In continuare iti voi arata cum putem sa luam argumente pentru scripturile noastre de
Python din linia de comanda. Asta ne va ajuta programul nostru prin interactiunea directa
cu utilizatorul. Daca ai mai folosit Linux (sau terminalul de pe replit.com), sigur ai rulat (din
linia de comanda) anumite programe care aveau nevoie si de argumente. Ai vazut deja
cum poate un utilizator sa interactioneze cu un program intre timp ce acesta ruleaza, el
poate introduce anumiti parametri sau raspunsuri. De data aceasta userul le va preciza
chiar inainte de rularea programului, prin argumente. In acest capitol o sa vezi cel mai
clar cum Python si Linux merg mana-n mana si avantajul oferit acestei posibilitati. Voi
crea un fisier denumit file.py, dupa care il deschid cu un editor text.
import sys
Modulul sys odata importat, ne simplifica accesarea anumitor variabile si functii. Acum,
pentru a accesa argumentele, ne vom folosi chiar de acest modul. Clasic, daca vrem sa
rulam un program, ne folosim de comanda: python file1.py
Daca in schimb vrem sa ii specificam si anumite argumente, il vom rula sub forma:
python file1.py {argv[1]} ... {argv[n]}
Observa cum simbolic, numerotarea argumentelor date de utilizator am inceput-o de la 1.
De ce? Pentru ca numele fisierul (numele script-ului) reprezinta de fapt {argv[0]}, iar
{argv[1]} este imediat urmatorul argument primit.
import sys
n = len(sys.argv)
if n < 2:
print("Usage: file.py nr1 nr2")
exit()
print("Number of arguments found: " + str(n))
Prin codul de mai sus atribuim intai variabile n numarul de argumente folosite in linia de
comanda, dupa care verificam ca acesta sa aibe minim 2 argumente (adica minim numele
fisierului, urmat de un numar). In continuare, pentru a afisa fiecare agument in parte gasit,
completam codul cu:
import sys
n = len(sys.argv)
if n < 2:
_____________________________________________________________________
164
___________________________________________________________________
exit()
print("Number of arguments found: " + str(n) + "\n1st: " + sys.argv[0] +
"\n2nd: " + sys.argv[1] + "\n3th: " + sys.argv[2])
Totusi, ca sa calculam suma acestor doua argumente date, mai avem nevoie de
urmatoarea completare:
import sys
n = len(sys.argv)
if n < 2:
exit()
a1 = sys.argv[1]
a2 = sys.argv[2]
suma = a1 + a2
print("The sum is: " + suma)
Apeleaza programul prin: python file1.py 2 si observa ce se afiseaza. Eroarea

IndexError: list index out of range iti spune de fapt ca programul nu a gasit al
doilea argument. E nevoie sa modific verificarea din if, pentru a fi sigur ca se executa
programul doar daca numarul de argumente nu este mai mic decat 3.
import sys
n = len(sys.argv)
if n < 3:
exit()
a1 = sys.argv[1]
a2 = sys.argv[2]
suma = a1 + a2
print("The sum is: " + suma)
Observam ca se afiseaza de data aceasta: 13. Asta deoarece sys.argv le-a preluat ca
String-uri, iar la adunare le-a concatenat. Mai jos poti vedea cum le modificam in numere
intregi.
_____________________________________________________________________
165
___________________________________________________________________
import sys
n = len(sys.argv)
if n < 3:
exit()
a1 = int(sys.argv[1])
a2 = int(sys.argv[2])
suma = a1 + a2
print("The sum is: " + str(suma))
_____________________________________________________________________
166
___________________________________________________________________
d) Alte exemple de folosire a modulelor in Python
1. Trimiterea unui mail cu Python
import smtplib
#pentru a putea trimite mesaje, mail-uri catre un anumit server
from email.mime.multipart import MIMEMultipart

from email.mime.text import MIMEText
#pentru a compune mail-ul, pentru a adauga text, formate, etc
fromADD="adresa1@gmail.com" #schimba cu adresa reala

toADD="adresa2@gmail.com" #schimba cu adresa reala
msg=MIMEMultipart() # pentru a crea un obiect in care noi vom putea sa
atasam informatiile legate de mailul acesta
subiect="Hello from Programming"
### PART 1 - Crearea mail-ului in formatul MIME

print("Creating the message.")
msg["From"]=fromADD
msg["To"]=toADD
msg["Subject"]=subiect
mesaj="Eu invat Python"
### PART 2 - Crearea mesajului

msg.attach(MIMEText(mesaj, 'plain')) #atasam acest mesaj in format text
catre obiectul msg
### PART 3 - Conectarea la server cu user-ul & parola de gmail

print("Connecting to server...")
server=smtplib.SMTP("smtp.gmail.com",587)
# pentru transferul mailului de la noi catre destinatie
server.starttls() # pentru partea de criptare a mesajului

server.login(fromADD, "parola ta")
_____________________________________________________________________
167
___________________________________________________________________
server.sendmail(fromADD, toADD, msg.as_string())

print("Done sending")
In functie de versiunea de Python pe care o ai, e posibil sa intampini ceva erori. Iti
recomand sa cauti pe Google aceste erori, iar mai jos iti las cateva linkuri pentru cateva
erori de securitate:
● https://stackoverflow.com/questions/16512592/login-credentials-not-working-with-
gmail-smtp
● https://stackoverflow.com/questions/10147455/how-to-send-an-email-with-gmail-as
-provider-using-python/27515833#27515833
● https://myaccount.google.com/u/1/lesssecureapps?pli=1&pageId=none&rapt=AEjH
L4MDS9PUmGwAGxJ99P_CQglLsYVSeKrvR80tWRcpweYUk6BCL1alBYhmAyGmlI
sP5z2mm5DWIVq3ter2zw6lhEAL-WGVxw
● https://myaccount.google.com/security?utm_source=OGB&utm_medium=act&origi
n=3
NOTA: codul a fost testat si validat pe versiunea de Python 3.9
_____________________________________________________________________
168
___________________________________________________________________
2. Descarcarea unei pagini web cu Python - urllib2
import urllib.request as urllib2
url = "http://www.google.com"
raspuns_server = urllib2.urlopen(url)
date = raspuns_server.read()
print("##### STARTING TO CRAWL THE SITE #####")

print(date)
try:
fisier_html = open("site_downloadat.html","w")
fisier_html.write(str(date))
except Exception:
print("Procesul nu s-a incheiat cu succes. ")
else:
fisier_html.close()
print("Job done")
NOTA: codul a fost testat si validat pe versiunea de Python 3.9
_____________________________________________________________________
169
___________________________________________________________________
3. Folosirea unor module precum turtle sau calendar
Te poti juca cu astfel de module pentru a vedea si o alta parte practica a acestora.
import turtle
def square():
a = turtle.Turtle()
a.forward(100)
a.right(90)
a.forward(100)
a.right(90)
a.forward(100)
a.right(90)
a.forward(100)
square()
turtle.done()
Rezultand o imagine precum cea de mai jos:
Figura 8.1
_____________________________________________________________________
170
___________________________________________________________________
Iti poti face propria imagine si chiar te invit sa te joci cu acest modul si sa desenezi un
trapez, paralelogram sau orice forma grafica doresti tu. De asemenea, te poti juca si cu
modulul calendar precum in exemplul de mai jos:
import calendar
print(calendar.weekheader(5))
print()
print(calendar.firstweekday())
print()
print(calendar.month(2021,4))
print(calendar.monthcalendar(2021,4))
print(calendar.calendar(2021))
Rezultand:
Mon Tue Wed Thu Fri Sat Sun
April 2021
Mo Tu We Th Fr Sa Su
1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30
[[0, 0, 0, 1, 2, 3, 4], [5, 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17, 18],
[19, 20, 21, 22, 23, 24, 25], [26, 27, 28, 29, 30, 0, 0]]
2021
January February March

Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 1 2 3 4 5 6 7 1 2 3 4 5 6 7
4 5 6 7 8 9 10 8 9 10 11 12 13 14 8 9 10 11 12 13 14
11 12 13 14 15 16 17 15 16 17 18 19 20 21 15 16 17 18 19 20 21
18 19 20 21 22 23 24 22 23 24 25 26 27 28 22 23 24 25 26 27 28
25 26 27 28 29 30 31 29 30 31
_____________________________________________________________________
171
___________________________________________________________________
April May June

1 2 3 4 1 2 1 2 3 4 5 6
5 6 7 8 9 10 11 3 4 5 6 7 8 9 7 8 9 10 11 12 13
12 13 14 15 16 17 18 10 11 12 13 14 15 16 14 15 16 17 18 19 20
19 20 21 22 23 24 25 17 18 19 20 21 22 23 21 22 23 24 25 26 27
26 27 28 29 30 24 25 26 27 28 29 30 28 29 30
31
July August September

1 2 3 4 1 1 2 3 4 5
5 6 7 8 9 10 11 2 3 4 5 6 7 8 6 7 8 9 10 11 12
12 13 14 15 16 17 18 9 10 11 12 13 14 15 13 14 15 16 17 18 19
19 20 21 22 23 24 25 16 17 18 19 20 21 22 20 21 22 23 24 25 26
26 27 28 29 30 31 23 24 25 26 27 28 29 27 28 29 30
30 31
October November December

1 2 3 1 2 3 4 5 6 7 1 2 3 4 5
4 5 6 7 8 9 10 8 9 10 11 12 13 14 6 7 8 9 10 11 12
11 12 13 14 15 16 17 15 16 17 18 19 20 21 13 14 15 16 17 18 19
18 19 20 21 22 23 24 22 23 24 25 26 27 28 20 21 22 23 24 25 26
25 26 27 28 29 30 31 29 30 27 28 29 30 31
_____________________________________________________________________
172
___________________________________________________________________
Capitolul 9 - Versionarea codului cu Git si GitHub
Ce este Git si GitHub?
O modalitate prin care iti poti salva si cum iti poti apoi accesa codul in orice moment. Git
si GitHub este din ce in ce mai utilizat si cerut de catre toti angajatorii. Reprezinta un
software ce te ajuta la versionarea codului tau si chiar in management-ul codului sursa
(SCM - Source Code Management). Git-ul te ajuta sa iti salvezi codul scris, online. Iar cel
mai mare avantaj este ca tu si ceilalti programatori dintr-un proiect puteti vedea
schimbarile pe care le faceti in cod. Pe langa asta, poti si gasi anumite solutii pe
problemele pe care le intampini in cod. Creatorul Linux, pe numele lui Linus Torvalds,
este cel care s-a gandit la o metoda de versionare a codului, in momentul in care a
considerat ca este nevoie ca mai multi programatori sa lucreze la versiunea sa de Linux.
Hai sa vedem in ce context ai putea folosi Git-ul. De exemplu, daca vrei sa construiesti pe
baza a ceea ce ai lucrat deja sau sa aduci si alte persoane care sa contribuie la munca ta,
nu poti tine codul pe calculatorul tau pentru ca va deveni dificil ca si altii sa acceseze si
sa lucreze cu ceea ce tu ai facut pana la momentul respectiv. Un alt exemplu ar fi ca,
dupa ce ai scris cod si ai adaugat ceva acum 3 zile, te anunta testerul de software ca
90% din codul scris in ultimele 3 zile trebuie rescris, conform modificarilor in cerinta
initiala (presupunand ca sunteti echipa mica). Prin GitHub te poti intoarce la versiunea de
acum 3 zile si poti incepe sa lucrezi la asta fara ca tu manual sa stergi fiecare linie de cod
adaugat in cele 3 zile. Bun, bun, dar este folositor Git-ul pentru proiecte mari cu o echipa
mai complexa? Raspunsul este da. Tocmai aici se vede cat de util poate fi. O echipa
complexa inseamna o echipa care are membrii cu diferite roluri si chiar diferite drepturi
pe proiect. Cei cu rol de tester pot colabora cu developerii, intre timp project managerul
poate monitoriza cine, unde si ce a adaugat.
Simplu spus, prin folosirea Git, altii vor putea adauga si isi pot pune amprenta pe codul
deja creat de tine. INTRA AICI pentru a afla mai multe despre Git si GitHub. Multi
programatori folosesc GitHub pentru a-si stoca ceea ce au codat si pentru a-si crea un
portofoliu pe care angajatorii il pot oricand vizualiza. Este extrem de important sa ai cont
pe GitHub daca iti doresti o cariera in IT. Sa nu mai vorbesc ca poti colabora cu alti
programatori ce vor aduce imbunatatiri codului tau. Pe langa GitHub, te mai poti folosi de
GitLab si Atlantis, care fac exact aceleasi lucruri, dar au doar cateva mici diferente de
design.
_____________________________________________________________________
173
___________________________________________________________________
Cum folosim Git pentru versionarea codului?
De ce este important sa iti faci back-up la cod in Git? Versionarea codului este necesara,
deoarece un program se scrie pe o perioada indelungata de timp, iar salvarile anumitor
etape sunt absolut necesare pentru a te intoarce la versiunea codului pe care o doresti
sau la versiunea care este corecta. Exemplele anterioare sunt doar cateva dintre cele
simple, un intreg flow de dezvoltare al unui produs final fiind mult mai complicat in
realitate, pentru echipele mari. Am amintit deja ca Git este foarte util atunci cand mai
multi programatori lucreaza la acelasi cod si aduc propriile lor versiuni de cod, ce pot fi
mai mult sau mai putin bune. Acum ca tot mai multi programatori aplica “laptop lifestyle”,
adica isi iau laptopul si lucreaza cand, cat si mai ales de unde doresc ei atata timp cat au
acces la Internet, este evident ca multi programatori care colaboreaza nu se afla in
aceeasi tara, deci au diferite zone de timp (fusuri orare). Git-ul are avantajul de a mentine
integritatea codului sursa. Asta datorita posibilitatii lucrului pe diferite “branch”-uri, adica
pe diferite ramuri (pe care se lucreaza) care nu intra in conflict in momentul in care, sa
zicem ca, mai multi programatori lucreaza pentru aceeasi aplicatie. Am putea sa ne uitam
la un “repository” ca la un depozit in care practic chiar depozitam un intreg proiect, cu
toate fisierele si folderele din care acesta este compus, dar care pe langa asta contine si
un istoric al modificarilor/revizuirilor care au avut loc in fiecare fisier in parte. In Git,
oricine care are o copie locala (pe propriul PC) al repository-ului are acces la intreaga
baza de date a schimbarilor care au avut loc asupra codului, cu istoricul lor cu tot. Acum,
daca tot avem o baza de date a intregului istoric al codului, cu toate fisierele si folderele
din el, ce putem face cu acesta si cum anume? Pentru a interactiona cu codul, putem
folosi linia de comanda sau un program cu interfata grafica. Mai concret:
• Putem clona istoricul sau putem interactiona cu el

• Putem crea branch-uri
• Putem da commit la ce am scris noi (acest commit se face local)
• Putem face merge
• Putem schimba si testa diferite versiuni ale codului, etc.
Hai sa vedem comenzile pe care sa le dam pentru a configura contul de GitHub si cum
se seteaza mai multi useri ce pot lucra la codul tau. Dupa asta vom adauga in Repository
si vom modifica codul astfel incat munca ta sa evolueze in directia cea buna. Bineinteles,
te poti oricand intoarce la anumite salvari ale codului tau, deci nu fi speriat daca ai gresit
ceva. Este posibil ca oricand sa reincepi de la un nivel in care erai multumit. INTRA AICI
pentru a vedea cum sa folosesti Git.
_____________________________________________________________________
174
___________________________________________________________________
Cum urcam codul pe GitHub?
Stocand munca ta intr-o baza de date (repository) din GitHub, vei avea posibilitatea sa
revii oricand la stadii din proiectele tale si sa inviti alte persoane sa contribuie la codul
tau. Poti avea repository-uri publice si private, acestea din urma trebuind sa fie platite.
Sunt multe alte platforme asemenatoare cu GitHub, dar aceasta este totusi cea mai
cunoscuta pentru cod open source. Sa nu mai vorbesc ca marea majoritate a
angajatorilor se ajuta foarte mult de ea si cer aplicantilor la job-urile lor sa-si prezinte
portofoliul aici. Acum vei afla cum sa accesezi codul tau in GitHub, cum sa-l downloadezi
si cum sa-l copiezi sau modifici. Bineinteles ca poti lua bucati de cod din anumite
repository-uri si sa lucrezi la ele, dupa care sa le urci inapoi in repository-ul de care
apartin si sa astepti sa vezi daca ai avut o contributie de succes, care multumeste pe
toata lumea. Vei invata cum sa-ti creezi repository-urile tale si cum sa urci munca ta pe
platforma. Poti vedea cine a adaugat ceva codul tau, urmarind commit-urile ce s-au facut.
Urmareste acest video BONUS pentru a vedea cum poti face asta: INTRA AICI.
_____________________________________________________________________
175
___________________________________________________________________
Care sunt urmatorii pasi?
Si iata-ne ajunsi la final! Da-mi voie sa te felicit pentru parcursul tau pentru ca ai ajuns
pana aici. Iti vine sa crezi sau nu dar nu foarte multi oameni reusesc sa parcurga o carte
sau un curs, asadar acesta este meritul tau si ma bucur foarte mult esti aici.
In continuare, pentru urmatoarea etapa, iti recomand sa incepi sa dezvolti proiecte,
aplicatii software, prin care sa rezolvi diverse situatii (probleme) din lumea reala
(indiferent de nivelul acestora). Poate te confrunti tu cu diverse probleme, in mod
constant, acasa, la scoala, la locul de munca actual pe care le-ai putea solutiona cu
ajutorul programarii.
Acum practica este cel mai important lucru de care ai nevoie pentru ca toate aceste
cunostinte pe care le dobandit sa devina abilitati care te vor servi pe mai departe in ceea
ce iti propui tu sa faci in domeniul IT. Iti recomand sa dezvolti mai multe proiecte, sa urci
codul pe GitHub (astfel dezvoltandu-ti un portofoliu) si sa te prezinti in fata angajatorului
(sau in fata unui potential client asta daca iti doresti partea de freelancing) pentru ca
sansele tale de reusita sa fie net superioare fata de media din piata. Construind acest
portofoliu pe GitHub (si de ce nu, chiar si unul de Linkedin) te vei diferentia fata de
restul persoanelor care incearca sa obtina un job in domeniu.
Totodata pentru a aprofunda studiile te invit sa programezi o discutie telefonica sau pe
Zoom cu un membru din echipa mea care te va ghida in urmatoarea etapa pentru a
ajunge acolo unde iti doresti. Tot ce ai de facut este sa apesi pe acest link sa
completez formularul, iar apoi colegii mei te vor contacta pentru a purta o discutie cu
tine. Acestia te vor ajuta sa-ti dezvolti un plan personalizat de invatare pentru a obtine
rezultate mai rapid si a ajunge sa faci printr-o cariera in IT, ceea ce iubesti cu adevarat. Iti
doresc mult succes in ceea ce ti-ai propus si drum bun in noua ta etapa. Ramon
_____________________________________________________________________
176

Introducere in Programare Cu Python

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Introducere in Programare Cu Python

Încărcat de

Drepturi de autor:

Formate disponibile

#InvataProgramare - Introducere in Programare cu Python

© Copyright 2021 Ramon Nastase – Toate drepturile rezervate.

Notificare privind renuntarea la raspundere

Retineti ca informatiile continute in acest document sunt numai pentru scopuri

Cateva cuvinte despre Ramon Nastase, autorul cartii 12

Capitolul 0 - Despre IT si Programare 17

Capitolul 1 - Introducere in Python 29

Cum incepi sa programezi in Python? 29

Capitolul 2 - Variabile in Python 55

Variabile de tip numere (intregi, reale) 55

Capitolul 3 - Instructiuni conditionale (if, for, while) 72

Capitolul 4 - Functii in Python 86

Capitolul 5 - Structuri de Date in Python 98

Ce sunt structurile de date? 98

Capitolul 6 - Programare Orientata pe Obiecte in Python 124

1) Concepte teoretice despre POO 124

Capitolul 7 - Exceptii si Operatii cu Fisiere in Python 149

I. Exceptii in Python 149

Chapter 8 - Module in Python 167

Ce sunt modulele si de ce le folosim 167

Capitolul 9 - Versionarea codului cu Git si GitHub 184

Ce este Git si GitHub? 184

Cateva cuvinte despre Ramon Nastase, autorul cartii

Ma consider a fi un IT-ist Optimist, pasionat de Educatie. Cred in tehnologie, cred in

Sunt trainer, autor si co-fondatorul platformei educationale TeachBit care se axeaza pe

Am fost trainer in corporatie si cunosc cat de important e sa se explice conceptele

Cateva cuvinte despre Gabriel Grecu, contribuitor al cartii

Ne propunem ca acest material sa te ajute in a dobandi cunostintele de start in lumea

Ce vei obtine de la aceasta carte

• Cum arata domeniul IT si care sunt trendurile

Cum sa parcurgi aceasta carte

Cum sa abordezi partea practica

Iti doresc mult succes si spor la treaba!

Ramon, cel care te sustine in procesul tau de crestere.

PS: Daca ai intrebari nu ezita sa ma contactezi pe email, Facebook sau YouTube.

Capitolul 0 - Despre IT si Programare

Ce oportunitati de angajare ai ca programator?

1. Adobe - Specializarea: Servicii Software, Web Development. Localitate: Bucuresti.

Daca privim din perspectiva start-up-urilor, in Romania, exista o multitudine de centre

Ce salarii sunt in IT?

1) Junior – salariu de 2500 – 4000 RON pe luna cu o experienta de 0 – 2 ani

Cine castiga cele mai mari salarii din IT?

“Ce limbaje de programare poti sa inveti pentru a deveni

● C / C++ – Limbaje perfecte pentru proiecte low-level, des intalnite in

● HTML + CSS + JavaScript – Un combo excelent pentru realizarea de pagini web

● PHP – Realizarea Backend-ului pentru o pagina web interactiva, limbaj intalnit si in

● Java / C# / Swift – Limbaje destinate aplicatiilor mobile pentru Android, Microsoft

De ce sa incepi cu programarea in Python?

Ce poti face cu limbajul Python?

● Automatizare - Aceasta este des intalnita in partea de retelistica prin scripturi

● Cyber-Security - Python ajuta la principiile de Pen-Testing prin realizarea

● Web Development - Aici Python poate fi utilizat cu ajutorul framework-urilor

● Quality Assurance (Controlul Calitatii) - Poate fi realizata testarea modulelor

● Embedded si Internet of Things - Un bun exemplu sunt placutele de tip Raspberry

Cum sa aprofundezi programarea folosindu-te de Google?

1. “Nu stiu ceva?”

Google constituie o librarie enorma de documentatie pentru limbajele de programare

• https://stackoverflow.com – un site pentru comunitatea de developeri, care

• https://www.tutorialspoint.com – e un site care iti arata cum sa programezi unele

Capitolul 1 - Introducere in Python

Cum incepi sa programezi in Python?

Presupun ca esti nerabdator sa incepi sa programezi. Pentru a incepe sa programam in

• Interpretor - aplicatie instalata pe laptop/PC si folosita printr-un terminal

I. Folosirea unui IDE Online - Repl.it