De Ce Sa Te Apuci de Programare

Cuprins
Cuprins .................................................................................................................................. 1
Argument De ce s te apuci de programare? ......................................................... 3
Cu ce limbaj ar trebui s ncep? ............................................................................................. 4
De ce Python? ............................................................................................................................... 6
Capitolul I Instalarea Python 3. Noiuni fundamentale ........................................ 8
Instalarea Python3 .................................................................................................................... 8
1.1. Primul program ................................................................................................................ 10
1.2. Noiuni fundamentale ..................................................................................................... 11
1.3. Variabile .............................................................................................................................. 14
1.4. Calcule .................................................................................................................................. 18
1.5. Formatarea numerelor (Important!!!!!) .................................................................. 21
Capitolul II FUNCII ..................................................................................................... 24
Indentarea (Important!!!!!) .................................................................................................. 26
2.1. Variabile locale ................................................................................................................. 27
2.2. Constante i variabile globale ...................................................................................... 30
Capitolul III STRUCTURI DE DECIZIE ....................................................................... 30
3.1. Declaratia if ........................................................................................................................ 30
3.2 Declaraia if-else ................................................................................................................ 31
3.3 Operatori logici .................................................................................................................. 33
3.4 Variabile booleene ............................................................................................................ 33
3.5.Structuri de repetiie ....................................................................................................... 34
3.6.Bucla for ................................................................................................................................ 35
Capitolul IV Funcii care returneaz valori ........................................................... 41
4.1.Generarea de numere aleatoare .................................................................................. 41
4.2.Biblioteci de funcii standard i declaraia import ............................................... 41
4.3.Generarea numerelor aleatoare .................................................................................. 42
4.4.Funciile randrange, random i uniform ................................................................... 44
4.5.Scrierea propriei funcii care returneaz o valoare ............................................. 44
4.6.Modulul matematic ........................................................................................................... 47
4.7.Stocarea funciilor n module ....................................................................................... 49
Capitolul V Fiiere i excepii ................................................................................ 52
5.1.Tipuri de fiiere ................................................................................................................. 52
5.2.Metode de acces a fiierelor .......................................................................................... 53
5.3.Deschiderea unui fiier n Python ............................................................................... 53
5.4.Scrierea datelor ntr-un fiier ....................................................................................... 54
5.5.Citirea datelor dintr-un fiier ....................................................................................... 56
5.6.Adugarea datelor ntr-un fiier existent ................................................................. 58
5.7.Scrierea i citirea datelor numerice ........................................................................... 59
5.8.Excepii ................................................................................................................................. 60
Capitolul VI Liste, tupluri, dicionare i seturi. Serializarea obiectelor
(pickling) ........................................................................................................................... 62
6.1. Liste ....................................................................................................................................... 62
6.2. Tupluri ................................................................................................................................. 76
6.3. Dicionare ........................................................................................................................... 78
6.4. Seturi .................................................................................................................................... 85
6.5. Serializarea obiectelor (pickling) ............................................................................... 87
Capitolul VII Clase i obiecte. Programarea orientat pe obiect .................... 89

Definiii ........................................................................................................................................ 89
7.1. Clase ...................................................................................................................................... 92
7.2.Crearea claselor n Python ............................................................................................. 93
7.3.Adugarea atributelor ..................................................................................................... 95
7.4.Sa punem clasa la treaba ................................................................................................ 96
7.5.Argumentul self ................................................................................................................. 97
7.6. Definirea unei clase o alt abordare ....................................................................... 98
7.7. Mostenirea (Inheritance) in Python ....................................................................... 105
7.8. Extensia unui obiect ..................................................................................................... 107
Milioane de posibiliti... ............................................................................................ 110
Bibliografie ..................................................................................................................... 111

Argument De ce s te apuci de programare?
Pentru c:
1. i ine mintea treaz
2. e fun
3. e o activitate care i aduce prestigiu
4. poi catiga bani (muli!)
Pn la 45 de ani nu m interesa mai deloc IT-ul. Mi se prea un univers
inaccesibil. Foloseam calculatorul ca orice user de rnd: scriam texte pe care abia
dac reueam s le tehnoredactez, citeam sau trimiteam mail-uri i uneori lecturam
ziare sau publicaii online. Dup aceea s-a produs declicul. Pcat c am descoperit
acest minunat domeniu cam trziu, cnd creierul nu mai funcioneaz ca odinioar.
Toat viaa am crezut c programarea nseamn inainte de toate s fii tob de
matematic. E o exagerare. Dup ce am studiat limbaje de programare vreme de trei
ani, am ajuns la concluzia c nu trebuie s tii mai mult de operaiile matematice
fundamentale la care se adaug i cunoaterea ordinii lor. Astea se nva din cte mi
amintesc prin clasa a asea sau a aptea, atunci cnd deslueti tainele algebrei 1.
Cel mai important lucru n asimilarea unui limbaj de programare este n opinia mea
sintaxa, adic regulile dup care sunt puse semnele, numerele sau declaraiile dintr-un
program. Din necunoaterea lor n profunzime vin i cele mai multe erori n scrierea
unui program. Cnd am nceput s nv PHP uitam mai mereu s nchei linia de
program cu punct i virgul aa cum e regula. Asta genera permanent erori pe care
apoi, cu ct programul devine mai lbrat, le dibuieti greu, cam ca pe acul din carul
cu fn.
Ce i este necesar ca s scrii un program (pe lng ceva cunotine de mate i
stpnirea sintaxei)? Druire, atenie iscrierea de programe. Fiecare carte care
afirma ca te nva un limbaj de programare are n general la sfritul capitolelor o
seciune de exerciii i probleme. E partea cea mai important (i captivant)! Citii
bine teoria, scriei programele date n carte n propriul editor de text (nu descrcai
codul aferent crii de pe site-ul editurilor), analizai-le i apoi procedai la rezolvarea
exerciiilor. Numai aa nvei!

1
Asta desigur e valabil pentru un anumit nivel (mai lipsit de pretentii) in programare.
Cu ce limbaj ar trebui s ncep?

Aici e ca n proverbul acela cu cte bordeie, attea obiceie. Am stat odat ore
ntregi pe forumuri pentru a afla un rspuns ct de ct adecvat la aceast intrebare.
Oricum ar fi, e bine s ncepi s studiezi un limbaj uor. Dar exist unul uor, att de
uor nct s fie asimilat ntr-o perioad ct mai scurt? Din experiena personal, nu.
Totui, un limbaj de programare foarte uor de implementat pe calculator i nu prea
greu de nvat este Python. Despre el am ales s discut n aceast carte.
Exist limbaje de programare complexe i altele mai puin complexe. Exist limbaje
cu ajutorul crora se pot construi doar aplicaii web i altele care pot aduce la via
idei mree care uureaz viaa de zi cu zi a celor care le folosesc. Acestea din urm
sunt cel mai greu de nvat dar odat asimilate i garanteaz satisfacii majore.
Limbaje de scriptare precum PHP sau Javascript sunt bune (doar) pentru a face siteuri, bloguri, aplicaii pentru Internet n general. Cnd ns vorbim spre exemplu de
programe de contabilitate, de proiectare n inginerie sau arhitectur, de aplicaii IT n
medicin sau tiine atunci intervin adevratele limbaje de programare: C, C++, Java,
Python, Lisp, Pascal 2 etc.
Sfatul meu este s ncepei, daca imi este permis, s studiai - dintre limbajele
grele - pe cele mai uoare! n niciun caz ns nu e indicat s v apucai de nvarea
C++. E adevrat, el este regele balului (alaturi de Java), e extrem de utilizat dar
foarte dificil de asimilat. i C-ul este asemenea lui innd cont c i este precursor.
Java pe de alt parte, seamn mult (ca sintax cel puin, cu toate c ceva
maiuuric) cu C++ dar pe deasupra are un mediu de dezvoltare greu de configurat.
Eu am pierdut zile ntregi pentru asta
n tot cazul, nu v apucai s deprindei un limbaj de programare din surs
nchis precum cele furnizate de Windows sau Apple. E drept C# sau Objective C se
folosesc (acum!) pe scar larg la construirea de aplicaii pentru dispozitivele mobile
aflate n mare vog. Dar inei minte c voga e mod i de obicei ea trece mai ncet
sau mai repede, dar tot trece. Sfatul meu e s nvai limbaje de programare portabile
pe orice sistem de operare i mai ales din surs deschis. Unele dintre ele n-au moarte.
C spre exemplu bate spre 50 de ani i nu d semne c va pieri n curnd. C++ are i el
peste trei decenii i la fel, e n plin putere.

2
Vezi site-ul Tiobe.com (http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html)
Atunci cnd cutai materiale tiprite sau online, tutoriale, cri, exemple etc pentru
nvat, evitai titluri de genul : nva Java n 24 de ore! Sunt minciuni ordinare!
Java, Python, C++ (chiar i Basic) nu se nva nici ntr-o luna, nici mcar ntr-un an,
daramite ntr-o zi! Opinia mea pe care o mprtesc cu sinceritate, e c un limbaj
de programare se asimileaza n ani de zile. i nici atunci, dup o perioad lung de
timp, nu cred c poi s pretinzi c eti masterDup unele voci autorizate3,
perioada optim de timp necesar deprinderii unui limbaj de programare este de zece
ani!
Alegei-v un limbaj de programare pe care-l putei iniia imediat i fr bti
de cap la compilare. Cel mai indicat e desigur Python. l descarci ntr-o clipa de pe
Internet, i configurezi variabilele de mediu (n Windows) i dai drumul la lucru. Alta
e treaba cu Java, C++ sau C. Ele necesit mai mult munc i pentru un nceptor
(care nu prea are pe cine s ntrebe n afar de Google) nu e chiar uor.
Marele noroc n desluirea unui limbaj de programare este c pe Internet se gsesc o
mulime de tutoriale i forumuri (locuri unde ntotdeauna afli rspunsuri la ntrebri
pentru c alii s-au lovit inaintea voastr de aceleai probleme.).
Uitasem un lucru esenial: limba englez. Din observaiile pe care le tot fac de
vreo civa ani, am observat c exist cteva naii care exceleaz n IT. Printre ele, la
loc de cinste, indienii, chinezii i nordicii. Am gsit i explicaii. La indieni e vorba
despre numrul uria al populaiei. V imaginai c din peste un milliard de oameni ai
de unde alege cteva sute sau mii de cpni luminate. Acetia au avut poate norocul
educaiei i pe cale de consecin, a ieirii din foame. ntr-o ar n care sperana de
via e de 40 de ani, a fi instruit e o ans uria! Programarea i-a scos pur i simplu
din srcie, i-a adus n America i i-a angajat la companii de vrf precum Windows,
Oracle, IBM, Apple. Cutai informaii despre diverse companii de top i nu se poate
s nu gsii n poziii de frunte indieni sau chinezi. Numrul foarte mare i srcia pe
msur este explicaia succesului (multora dintre ei) n IT.
Ceilali sunt nordicii. Cteva exemple edificatoare: cel care a proiectat Linuxul este finlandez cu rdcini suedeze; cel care a fcut iniial PHP-ul este danez, cel
care a fcut C++ este danez, cel care a proiectat Python-ul este olandez. i exemplele
pot continua. Ei, contrar indienilor ori chinezilor, provin din ri foarte dezvoltate
economic dar paradoxal, cu populaie deficitar. i atunci de unde formidabilul succes

3
http://norvig.com/romanian21-days.html
n IT? Am gsit i aici o explicaie: condiiile meteo. Cnd ai jumtate sau mai bine
din an temperaturi negative, cnd plou sau ninge nentrerupt zile intregi eti nevoit s
stai n cas, eventual n faa computerului. Cu el i omori timpul, cu el comunici cu
alii i tot el te poate aduce pe culmile gloriei.
i totui, cei care au inventat calculatorul, limbajele iniale de programare i
tot ce ine de IT au fost americanii, adic un popor care vorbete limba englez, limb
n care logic, au scris i limbajele de programare, apropiate ca vocabular limbii
engleze. De aici rezult importana fundamental a limbii engleze n nvarea
limbajelor de programare. Totusi, nu vreau sa va sperii. Nu trebuie sa stiti engleza la
nivel de excelenta insa un bagaj minim de cuvinte este strict necesar sa-l posedai.
Mai trebuie s tii fie doar pentru cultura general c la baza industriei IT de
astzi au stau odinioar proiecte militare americane (realizate in colaborare cu mediul
academic), care dateaz nc ht, din timpul Rzboiului Rece. Apoi a venit mediul de
afaceri ce a avut nevoie de aplicaii care s uureze munca, s mreasc
productivitatea i implicit profitul. Ca o concluzie, IT-ul are origini militare,
academice i financiare. Doar cei care puteau susine financiar cercetarea n domeniile
de vrf puteau obine rezultate, nu? Timpul a dovedit c au reuit dar mai ales,
aplicaiile bazate 100% pe limbaje de programare si care odat, de mult, erau
accesibile doar unei mini de oameni, au devenit astzi un lucru banal i ct se poate
de comun. Pentru asta trebuie doar s jonglai puin cu un telefon mobil inteligent care
este nesat cu ele.
De ce Python?
Pentru c n primul rnd este un limbaj curat ca sintax i foarte uor de
implementat pe orice calculator. Legenda spune c Guido van Rosssum creatorul
Python, a pus bazele limbajului ntr-un week-end de Crciun cnd se plictisea i nu
prea avea cu ce s-i omoare timpul. Cert este c olandezul, care a lucrat muli ani
dup aceea la Google, a reuit s ofere lumii un limbaj cu o sintax simpl i supl, cu
reguli clare i de netrecut i care se folosete astzi pe scar larg n mediul academic
(tocmai pentru nvarea limbajelor de programare), n afaceri dar i n proiectarea
unor aplicaii de mare succes. Youtube spre exemplu este scris n Python. i Google
folosete ca liant Python. Asemenea lui Yahoo!. Renumitul ziar Washington Post
folosete n varianta lui online limbajul Python. Cutai pe Internet i vei gsi alte
numeroase domenii n care Python are un cuvnt important de spus.
Un alt motiv pentru care este indicat s ncepei cu Python este dat de numrul de

entuziati aflat ntr-o cretere constant i care se ocup de Python. Internetul este plin
de informaii despre el, de tutoriale, de cri i forumuri. Este tiut c ntr-un fel,
Python nu poate s fac ceea ce face C++ spre exemplu. Totui, curba de nvare a
celor dou limbaje este radical diferit. Cred sincer c un programator Python valoros
se poate forma n circa doi ani. Nu acelai lucru se poate afirma despre C++
Altfel dect PHP un alt limbaj relativ uor de nvat, cu Python se pot realiza
proiecte web dar / sau mai ales, aplicaii desktop de sine stttoare.
Un alt motiv pentru care este bine s nvai Python e numrul relativ redus
(pe plan mondial, n Romnia ce s mai vorbim) de programatori n acest limbaj.
tiu, vei spune c site-urile de joburi sunt pline de oferte de munc pentru
programatori Java, C++, C# , PHP sau Objective C i mai puin Python. Aa este,
numai c numrul programatorilor Java sau PHP este covritor n vreme ce al celor
care se ocup de Python cu toata creterea lui - nu. De aici vine i confuzia care se
creeaz cu privire la gsirea unui job legat de Python. Dai un banal search pe Google
cu cuvintele cheie python jobs(s) i vei avea afiate istantaneu n faa ochilor un
noian de rezultate care mai de care mai interesante. Sunt oferte peste oferte, ce-i drept,
majoritatea de peste Ocean. Asta nu nseamn c nu avei anse. Nu trebuie neaprat
s lucrai full time la sediul din Chicago sau din Silicon Valey al unei firme, ci n
intimitatea propriului cmin. Restul l face Internetul, Skype, Messenger si/sau
PayPal. Internetul a anulat distanele, a fcut ca proiectele i ideile s circule
nestingherite cu viteze uluitoare iar banii s intre (sau s ias) din conturi la fel.
Ultimul motiv i poate cel mai important este prestigiul. Stpnirea Python
(sau a oricrui alt limbaj de programare) face diferena n ochii cunosctorilor, a
prietenilor sau rudelor dar mai ales n ochii votri. A ti s programezi i ine mintea
activ, te face s fii mandru de tine, s te simi tnr i cine tie, cu mult munc i
ceva ans, i poate aduce i venituri substaniale.
Succes!
Capitolul I Instalarea Python 3. Noiuni fundamentale

n aceast carte vom lucra cu Python 3 (sau variantele lui ulterioare). n
prezent exist variantele Python 2 (i cele din clasa lui: 2.6 i 2.7 care sunt cele mai
folosite) i Python 3 (de asemenea cu variantele lui). Din pcate, Python 3 nu a
devenit nc standardul dar, cel mai important, urmeaza sa devina! Tot din nefericre,
majoritatea framework-urile necesare aplicaiilor web sunt scrise n Python2. Ele nu
sunt compatibile cu Python 3, aa c dac vei ncerca s le instalai pe un computer
care ruleaz Python 3 nu vei reui. O excepie notabil este din cele observate de
mine, Pyramid. Oricum, pn la a proiecta aplicaii web scrise n Python e cale lung
de btut pe care o ncepem cu..
Instalarea Python3
Ca s programezi n Python trebuie mai nti s-l instalezi pe computer. i alegi
ultima distribuie de pe site-ul www.python.org. n Windows lucrurile sunt puin mai
complicate dar nu dezndjduii. Descarci de pe link-ul de mai sus (www.python.org)
executabilul (.exe) ultimei variante pe care-l rulezi (Run). Pachetul este instalat
automat pe partiia C (v sftuiesc s nu o schimbai). Dac ns vei deschide o
fereastr n linia de comand i vei scrie python, limbajul nu va funciona (nc)
pentru c nu ai schimbat calea de rulare n variabila de mediu i calculatorul nu tie
unde s-l gseasc.
Iat care sunt paii ca s faci asta:
1. Start -> Computer
2. Properties
3. Advanced Settings
4. Environment Variables
5. Path (Edit)
6. Aici adaugi la sfritul liniei urmtoarele: ; C:\Python32 (nu uita de semnul ;
scris naintea datelor!)
7. Ok
8. Restartezi computerul
Dupa repornire, deschizi o nou fereastr command prompt i scrii python. Abia
acuma vei avea posibilitatea s jonglezi cu limbajul de programare Python n modul
interactiv.
Ca s rulezi un program Python n modul script (vom vedea imediat ce nseamn

asta) n Windows 7 sunt necesari urmtorii pai:
1. Scrii programul n Notepad (sau orice alt editor, mai puin MS Word..)
2. l salvezi (pe Desktop) cu extensia .py din meniul derulant al Notepad
3. Porneti command prompt-ul cu comanda W+R , scrii n csu cmd i apei
Enter
4. Odat fereastra command promt deschis, schimbi aici directorul pe desktop
cu comanda: cd Desktop (adic acolo unde ai salvat fiierul Python, s-i zicem
test.py)
5. Scrii la prompter: python test.py
Dac totul este n regul i programul nu are erori de sintax, el va fi rulat fr
probleme.
n MacOS X
Spre deosebire de Windows, n Mac OS X Python este deja (pre)instalat. Tot ceea ce
trebuie s faci este s deschizi Terminal-ul (din Applications -> Utilities -> Terminal)
i s scrii la prompt: python. Imediat i va aprea promterul python care este >>> i
unde poi ncepe sprogramezi (asta n modul interactiv). Daca vei scrie ns
programe ntr-un editor de text gen Smultron (pn recent era gratis dar acuma
obeserv c dezvoltatorul i-a pus preul de 5$ pe Apple Store), atunci vei urma paii de
la rularea n Windows. n linii mari sunt aceiai. Scrii programul n editorul preferat,
l salvezi pe Desktop cu extensia .py, deschizi Terminalul, schimbi directorul (cd
Desktop) i rulezi programul (python test.py).
De obicei OS X Snow Leopard sau Lion au deja preinstalate versiunile 2.7. (sau
mai vechi) ale Python. Dac ns ai descrcat o variant 3.0 sau peste (de exemplu
3.2.), ea va fi instalat n Applications. Nu este nicio problem, cci ca s-o rulezi
trebuie doar ca n Terminal s scrii n linia de comanda: python3 i programul va
ncepe s funcioneze. Totui, dac vrei ca ultima versiune Python (din clasa 3) s-i
porneasc automat atunci cnd scrii doar python n Terminal (care i va deschide
invariabil varianta mai veche, cea preinstalat) trebuie s faci unele modificri.
Acestea sunt urmtoarele:
1. n Terminal scrii: open ~/.bash_profile . Aceast comand i va

deschide n editorul predefinit (TextEdit) fiierul pomenit.
2. Adaugi aici, n poziia cea mai de sus, urmtoarele:
3. alias python=python3
4. Salvezi
5. Redeschizi Terminalul i scriind python vei observa c versiunea
Python3 este cea care ruleaz.
1.1. Primul program
n Python exist dou moduri de a vizualiza programele:
-
n interpretorul Python
n modul script
S vedem mai nti, pentru a v convinge c Python este un limbaj grozav, care este
diferena ntre scrierea unui program n C++ i unul n Python. n C++:
// my first program in C++
#include <iostream>
using namespace std;
int main ()
{
cout << "Hello World!";
return 0;
}
i acuma n Python:
>>> print (Hello World!)
Fig.1.1. Hello World! n Python shell
Deci ceea ce n C++ se afieaz cu ajutorul a apte linii, n Python se face cu una
singur!
10
Pentru scrierea primului (i urmtoarelor) programe n Python trebuie s deschidei

interpretorul Python astfel:
Windows -> All Programs -> Python32 -> Python (command line) -> Enter
Odat ce ai scris o declaraie aici, automat dup apsarea tastei Enter desigur,
intrepretorul Python o (i) afieaz pe ecran:
Fig.2 Interpretorul Python
1.2. Noiuni fundamentale

Declaraiile (statements) sunt liniile (coninutul) unui program. Toate declaraiile
dintr-un program scrise n modul script i salvate pe hard-ul calculatorului cu extensia
.py se cheama cod surs sau pur i simplu cod.
Modul script
Spre deosebire de interpretorul Python, modul script salveaz declaraiile programului
pe calculator. Acestea sunt de fapt, adevratele programe.
S afim de exemplu cu ajutorul programului urmtor, datele unui personaj fictiv.
Mai nti scriem n editorul de text preferat (Notepad n Windows de exemplu sau
Smultron n Mac OS) urmtoarele linii de cod:
print(Vasile Popescu)
print(Adresa: Str.N.Iorga, Nr.46, Bucuresti)
print(Telefon: 0722 200406)
Fig.3 Programul scris n Notepad
Salvm programul sub numele popescu.py (eu l-am salvat pe desktop) i apoi l rulm
din linia de comand cu comanda python popescu.py:
11
Fig.4 Rularea programului popescu.py n linia de comand
Intrri, procesare, ieiri, funcia print

Intrrile (Input-ul) care se fac de obicei de la tastatur, sunt datele pe care programul
le primete. Urmeaz etapa procesrii lor. Rezultatul operaiei de procesare se
numete ieire (Output) i este afiat pe ecran.
Afiarea ieirii cu funcia print
O funcie este un cod prescris care realizeaz o operaie. Python are numeroase funcii
preconstruite. Totui, dintre toate, fundamental rmne funcia print, adic exact
aceea care afieaz ieirea pe ecran.
Cnd un program execut o funcie, spunem c el cheam (invoc) funcia. Cnd
invocm funcia print, scriem cuvntul print urmat de un set de paranteze ( ).
nuntrul parantezelor scriem argumentul care reprezint datele pe care le dorim
afiate pe ecran. Spre exemplu, la invocarea funciei print n declaraia print(Hello
World), argumentul este Hello World. Observm c ghilimelele nu sunt afiate la
ieirea programului. Ele doar arat nceputul i sfritul textului pe care vrem s-l
afim.
Prin urmare, putem afirma c print este cea mai important funcie. Cu ajutorul ei,
recapitulnd, afim ieirea unui program n Python.
>>> print(Hello world!)
Hello world!
12
iruri i iruri literale

Ex: Vasile Popescu
46, N.Iorga
Bucuresti, 0722200406
Acestea sunt iruri de date care se mai cheam i iruri de date literale. Ele sunt
incluse ntre ghilimele. Se pot folosi ghilimele simple ( ), duble ( ) sau chiar triple
( ).
S lum de exemplu urmtoarea linie de cod care folosete ghilimele simple i duble:
print(Vinoncoa!)
Ea va scoate la ieire irul literal:
Vinoncoa!
Ce s-ar ntmpla dac n expresia (irul) de mai sus am pune doar ghilimele simple (la
fel de bine duble sau triple)? Am primi din partea interpretorului (shell-ul) Python o
eroare de sintax ca mai jos:
Foto1.2. Eroare de sintax la ghilimele
Comentariile
Sunt folosite ntr-un program ca s ari ce ai vrut s faci acolo. Dac peste ctva timp
vei redeschide programul, comentariile i vor reaminti de ceea ce ai vrut s faci cu
linia de cod respectiv din program. Ele sunt ignorate de interpretorul Python dar nu
trebuiesc ignorate de tine!
n Python, comentariile ncep cu semnul diez #.
Ex:
#Acest program afiseaza

#numele unei persoane
print(Mircea Prodan)
13
1.3. Variabile
O variabil este un nume (cuvnt) care reprezint o valoare stocat n memoria
calculatorului. Numele (variabila) se scrie ntotdeauna n partea stng:
age = 49
i nu
49 age
Semnul = nu nseamna egal ca n matematic ci reprezint atribuirea.
n exemplul de mai sus :
(lui) age = (i-am atribuit valoarea) 49
Cnd treci o variabil ca argument al funciei print nu mai ai nevoie de ghilimele.
Ex:

print( )
argument
funcia print
>>>latime = 10 (Enter)
>>>print(latime)
latime
>>> print(latime) (Enter)
10
>>>
Exemplu de program care demonstreaz o variabil:
(variabila.py)
#Acest program demonstreaza o variabila
camera = 123
print(Stau in camera numarul: )
print(camera)
14
Ieirea (output-ul) acestui program este:

Stau in camera numarul
123
Ce s-ar fi ntmplat dac n ultima linie am fi cuprins ntre ghilimele parametrul
camera ca mai jos?
print(camera)
Pi n loc s ne afieze valoarea parametrului care este 123, ne-ar fi afiat cuvntul
(irul literal) camera:
Fig.1.3 Variabila ir
Ai sesizat diferena?
Exemplu de program cu dou variabile:
(variabila2.py)
#Creeaza doua variabile numite viteza si distanta
viteza = 160
distanta = 300
#Afiseaza valoarea referita de variabile
print (Viteza este: )
print (viteza)
print (Distanta parcursa este: )
print (distanta)
Este indicat ca numele variabilei s nceap cu liter mic. Variabilele sunt sensibile
la litere mici sau mari (case sensitive) aa c de exemplu python Python..
Numele variabilelor nu au voie s conin cuvintele cheie din Python (vezi Anexa 1).
Variabilele nu trebuie s conin spaii dar au voie s conin (i s nceap) cu
semnul underscore ( _ ). De asemenea, variabilele nu trebuie s nceap cu un numr

15
sau s conin caractere speciale precum $#%^&* .a.m.d.

Cu funcia print se pot afia mai muli itemi. Ex. (refacerea exemplului variabila.py):
#Acest program demonstreaza o variabila
camera = 123
print(Stau in camera numarul, camera)
Ieirea este: Stau in camera 123
Stocarea irurilor cu tipul de date str
#Creeaza o variabila care refera doua siruri
first_name = Vasile
last_name = Popescu
#Afiseaza valorile referite de variabile
print(first_name, last_name)
La ieire vom avea: Vasile Popescu
La fel de bine putem s inversm numele dac ultima declaraie ar arta astfel:
print(last_name, first_name)
iar la ieire ar rezulta Popescu Vasile.
Reatribuirea variabilelor diferitelor tipuri
n Python, o variabil poate s refere orice tip de date. Dup ce o variabil a fost
atribuit unui anumit tip, ea poate fi reatribuit altui tip de date.
Ex:
>>> x = 99
(enter)
>>> print(x)
(enter)
#aici avem o variabila int (ntreg)
99
dar i :
>>> x = Sa mergem la masa (enter) #aici avem o variabile str (ir)
>>> print(x) [enter]
Sa mergem la masa
>>>
n Python exist trei tipuri de variabile:
16
int (ntregi)
float (reale sau n virgul mobil) (numere zecimale)
str (iruri)
Citirea intrrilor de la tastatur

Prompterul de pe ecran este un ir care invit userul s introduc date de la tastatur.
Ex.:
name = input (Care este numele tau? )
aici este un spaiu!!
variabil
tastatur
datele ir
Spaiul dintre semnul ntrebrii din irul Care este numele tu? i ultima ghilimea
este necesar pentru ca dup rspuns, ntrebarea i rspunsul s nu fie lipite (de ex:
Care este numele tu?Vasile Popescu n loc de Care este numele tau? Vasile
Popescu).
Exemplu de program cu dou iruri la introducerea de la tastatur:
#Ia prenumele userului
first_name = input(Introdu prenumele: )
#Ia numele de familie
last_name = input(Introdu numele de familie: )
#Afiseaza numele userului
print (Salut, first_name, last_name)
Citirea numerelor cu funcia input

Funcia input returneaz ntotdeauna input-ul (intrarea) userului ca pe un ir, chiar
dac userul introduce date numerice.
De exemplu, dac in fereastra interactiv tastezi numrul 65 i apei Enter, valoarea
returnat de funcia input este irul 65. Aceasta poate fi o problem dac vrei s
foloseti operaii matematice.
Aadar:
Operaiile matematice pot fi fcute doar cu valori numerice i NU cu iruri.
Exemplul urmtor folosete funcia input ca s citeasc un ir (str), un numar ntreg
17
(int) i unul n virgul mobil (float):

(input.py)
#Ia numele, varsta si venitul financiar al userului
nume = input(Care e numele tau? )
varsta = int(input(Cati ani ai? ))
venit = float(input(Care e venitul tau? ))
#Afiseaza datele
print(Iata datele pe care le-ai introdus: )
print(Nume, nume)
print(Varsta, varsta)
print(Venit, venit)
Concluzia este urmtoarea: atunci cnd introduci nume sau alte date literale scrii
simplu input (..). Cnd ns introduci numere (ntregi sau n virgul
mobil) e musai s ari de ce tip sunt (int sau float).
Int i float funcioneaz doar dac itemul ce urmeaz s fie introdus conine o
valoarea numeric. Altfel, va aparea o eroare numit excepie.
1.4. Calcule
Python are numeroi operatori cu care se pot face calcule matematice. Operatorii sunt
aceiai ca n matematica: + / * - dar i:
// mprirea cu ntreg (rezultatul e totdeauna un ntreg, de ex. 10/3 = 3)
% rest mparte un numr la altul i atribuie variabilei restul
** ridicarea la putere a unui numr
(i celalalte simboluri matematice).
Ex. salariu.py
#Atribuie o valoare variabilei salariu
salariu = 2500.0
#Atribuie o valoarea bonusului
18
bonus = 1200.0
#Calculeaza venitul total si
#atribuie valoarea variabilei plata
plata = salariu + bonus
#Afiseaza plata
print(Plata ta este: , plata)
Calcularea unui procent
Algoritmul este urmtorul:
-
ia preul original al unui item
calculeaz 20% din preul original; acesta este discountul
scade discountul din preul original; acesta e preul de vnzare
afieaz preul
i acuma s vedem programul (sale_price.py):

#Acest program ia pretul original si
#calculeaza un discount de 20%.
#Ia pretul original
original_price = float(input(Introdu pretul original: ))
#Calculeaza valoarea discountului
discount = original_price * 0.2
#Calculeaza pretul de vanzare
sale_price = original_price discount
#Afiseaza pretul de vanzare
print(Pretul de vanzare este: , sale_price)
Precedena operatorilor matematici
1. Ridicarea la putere se execut prima (**)
2. nmulirea, mpartirea i restul (* / // %) al doilea
3. Adunarea i scderea ultimele
19
Ridicarea la putere a unei valori se scrie aa:

Ex: suprafata = lungimea**2
n care **2 este ridicarea la puterea a doua
sau
volum = lungimea**3 (ridicarea la puterea a treia)
Operatorul rest (remainder) %
Ex. rest = 17 % 3
Variabilei rest i atribuim valoarea 2 pentru ca 17/3 = 5 rest 2.
Spargerea declaraiilor lungi n linii multiple
Python permite s spargi o declaraie n linii multiple folosind backslah-ul ( \ ).
Ex:
print(Am vandut, bucati_vandute, pentru un total de, vanzare_totala)
devine
print (Am vandut, bucati_vandute, \
pentru un total de, vanzare_totala)
Specificarea unui item separator
Cnd argumentele sunt trecute funciei print, ele sunt automat separate de un spaiu
care este afiat pe ecran.
Ex
>>> print(Unu, Doi, Trei)
Unu Doi Trei
>>>
Dac le vrei mpreunate, treci argumentul sep= funciei print la sfarsitul declaratiei:
>>> print(Unu, Doi, Trei, sep=)
#(enter)
UnuDoiTrei
>>>
Caracterul escape
Caracterul escape este unul special care e precedat de un backslash \ ce apare
20
nuntrul unui ir literal.

Ex.
print(Unu\nDoi\nTrei)
afieaz:
Unu
Doi
Trei
ceea ce nseamn c \n reprezint o linie nou (n vine de la new).
Afiarea mai multor itemi cu operatorul +
(concatenarea)
Cnd operatorul + se folosete la adunarea irurilor se cheam concatenare (legare).
Ex.
print (Acesta este + un sir.)
care afieaz:
Acesta este un sir.
1.5. Formatarea numerelor (Important!!!!!)
Cnd un numr n virgul mobil e afiat pe ecran, el poate avea i 12 zecimale.
Ex:
#Acest program demonstreaza cum un numar
#in virgula mobila este afisat fara formatare
suma_datorata = 5000.0
plata_lunara = suma_datorata / 12.0
print (Plata lunara este , plata_lunara)
iar ieirea programului este:
Plata lunara este 416.666666667
Fig.1.4. Valoare neformatat
Cum facem totui ca rezultatul s nu mai apar ca un ir urt de numere? Simplu!
21
Invocm funcia format. Cnd invoci funcia format, i treci dou argumente:
-
o valoare numeric
un specificator de format
Specificatorul de format (format specifier) este un ir care conine caractere speciale

ce arat cum valorile numerice trebuiesc formatate.
Ex: format (12345.6789, .2f)
Primul argument, care este un numr n virgul mobil (12345.6789), este numrul
pe care vrem s-l formatm.
Al doilea argument este un ir .2f i reprezint specificatorul de format.
Iat ce nseamn el luat pe buci :
.2 specific precizia; el arat c vrem s rotunjim numrul la dou zecimale
f vine de la float i specific faptul c numrul pe care-l formatm este n virgul
mobil (pentru formatarea ntregilor, cum vom vedea, nu se folosete litera f).
n aceste condiii, funcia format returneaz un ir care conine numrul formatat:
>>> print(format(12345.6789, .2f)) #(Enter)
12345.68
S notm c numrul este rotunjit la dou zecimale.
Acuma, s lum acelai exemplu, dar rotunjit la o singur zecimal:
>>> print(format(12345.6789, .1f)) (Enter)
12345.7
Sa lum exemplul anterior n fereastra interactiv:
Fig.1.5. Valoare formatat cu specificatorul de format
Formatarea n mod tiinific

Se utilizeaz literele e sau E n loc de f.
Ex:
>>> print(format(12345.6789, e))
1.2345678e +04
>>> print(format(12345.6789, .2e))

22
1.23e + 04
>>>
Inserarea separatorului virgul
>>> print(format(123456789.456, ,.2f))
123,456,789.46
separatorul virgul
>>>
Programul urmtor demonstreaz cum separatorul virgul i o precizie de dou
zecimale pot fi folosite la formatarea unui numr mare:
#Acest program demonstreaza formatarea
#numerelor mari
monthly_pay = 5000.0
annual_pay = monthly_pay * 12
print(Plata ta anuala este $,\
format(annual_pay, ,.2f), \
sep=)
Ieirea programului este:
Plata ta anuala este $60,000.00
S notm c n ultima linie a codului am trecut sep= ca argument al funciei print.
Acesta specific faptul c nu trebuie afiat niciun spaiu ntre itemii care urmeaz s
fie afiai. Dac nu facem acest lucru, va aprea un spaiu ntre $ i sum.
Specificarea unei limi minime de spaiu
Urmtorul exemplu afieaz un numr n cmpul care este de laime 12:
>>> print(Numarul este, format(12345.6789, 12,.2f))
Numarul este 12,345.68
>>>
Fig.1.6. Specificare limii de spaiu
23
Formatarea unui numr n virgul mobil ca procent

Aici n loc s folosim litera f folosim simbolul procentului % ca s formatm un
numr ca procent:
>>> print(format(0.5, %))
50.000%
>>>
i nc un exemplu care are 0 ca precizie:
>>> print(format(0.5, .0%))
50%
>>>
Formatarea ntregilor
Diferenele la formatarea ntregilor fa de numerele reale (n virgul mobil) sunt:
-
foloseti d n loc de f
NU poi specifica precizia
Ex:
>>> print(format(123456, d))
123456
Acuma, acelai exemplu dar cu separatorul virgul:
>>> print(format(123456, ,d))
123,456
Capitolul II FUNCII
O funcie reprezint un grup de declaraii care exist ntr-un program pentru a
realiza o anumit sarcin. Am vazut in primul capitol comportamentul functiei
prestabilite print.
Majoritatea programelor realizeaz sarcini care sunt ndeajuns de mari ca s poat fi
sparte n cteva subsarcini. Din acest motiv programatorii sparg programele n
buci mai mici cunoscute sub numele de funcii.
Astfel, n loc s scriem largi secvene de declaratii, scriem cteva funcii mai mici,
fiecare realiznd o parte specific din sarcin.

24
Aceste mici funcii pot fi executate n ordinea dorit pentru ca n final s realizeze
soluia la ntreaga problem.
Definirea i invocarea unei funcii
Codul unei funcii este (i) definiia unei funcii. Ca s execui o funcie scrii pur si
simplu declaraia care o invoc (numele funciei).
Numele funciilor
Numele unei funcii trebuie s fie apropiat de ceea ce ea face. n Python, cnd
denumim o funcie urmm aceleai reguli ca la botezarea variabilelor adic:
-
Nu poi folosi cuvintele cheie din Python
Nu pot exista spaii ntre cuvintele care alctuiesc numele funciei
Primul caracter trebuie s fie o liter de la a la z, de la A la Z sau underscore ( _ )
Literele mici sunt tratate diferit de cele mari
Pentru c funciile realizeaz aciuni, e indicat s folosim verbe atunci cnd le alegem
numele.
De exemplu, o funcie care calculeaz venitul (gross_pay) poate fi denumit
calculate_gross_pay.
Definirea i invocarea unei funcii
Formatul general este:
def nume_functie() :
declaratie
declaratie
Ex:
def mesaj ():
print(Sunt Gigel,)
print(cel fara de creier!)
Codul de mai sus definete o funcie numit mesaj. Functia mesaj conine un bloc cu
dou declaraii.
Invocarea unei funcii
Definiia unei funcii specific ce face funcia dar nu o execut. Ca s execui o
funcie trebuie s o invoci (s o chemi).
25
Iat cum invocm funcia mesaj:

mesaj()
Cnd funcia e chemat, interpretorul sare la acea funcie i execut declaraiile din
blocul ei. Apoi, cnd blocul s-a terminat, interpretorul sare napoi la partea de
program care a chemat funcia i programul rezum execuia n acel punct. Cnd se
ntmpl asta, spunem c funcia returneaz.
Ex:
(function_demo.py)
#Acest program defineste o functie
#Prima data definim o functie numita mesaj
def mesaj():
print(Sunt Mircea,)
print(si incerc sa invat Python.)
#Chemam functia mesaj
mesaj()
Cum funcioneaz? Interpretorul ignor comentariile. Apoi citete declaraia def n

linia 3. Aceasta creeaz o funcie numit mesaj n memorie. Ea conine declaraiile
din liniile 4 i 5. Apoi interpretorul citete comentariul din linia 6 care este ignorat.
La sfrit citete linia 7 care invoc funcia mesaj. Aceasta face ca funcia mesaj s
fie executat i s fie afiat ieirea.
Fig. 2.1 Ilustrarea unei funcii n Python shell
Indentarea (Important!!!!!)
ntr-un bloc indentarea se face cu acelai numr de linii. De obicei se folosete
tab-ul sau patru spaii. Dac n acelai program folosim odat patru spaii ,
altdat tabul sau trei, cinci ori n spaii, programul va da eroare de
26
indentare:
Fig.2.2 Eroare de indentare
Indentarea n Python este obligatorie i se face pentru ca blocurile de cod din

program s fie perfect stabilite, ceea ce duce la lizibilitatea mai bun programului.
Indentarea ine de fapt locul acoladelor din celelalte limbaje de programare din
familia limbajului C.
2.1. Variabile locale
O variabil local este creat n interiorul unei funcii i nu poate fi accesat din afara
ei. Funcii diferite pot avea variabile locale cu acelai nume pentru c ele nu se pot
vedea una pe ceallalt. De fiecare dat cnd atribui o valoare unei variabile n
interiorul unei funcii, creezi o variabil local.
S luam un exemplu de program care are dou funcii i care fiecare conine o
variabil cu acelai nume:
#Acest program demonstreaza doua functii
#care au variabile locale cu acelasi nume.
def main():
#Cheama functia dolj
dolj()
#Cheama functia gorj
gorj()
#Defineste functia dolj. Ea creeaza
#o variabila locala numita pasari
def dolj():
pasari = 5000
print(Doljul are, pasari, de pasari)
27
#Defineste functia gorj. Ea creeaza

#o variabila locala numita pasari
def gorj():
pasari = 8000
print(Gorjul are, pasari, de pasari)
#Cheama functia principala
main()
Trecerea argumentelor la funcii
Un argument este o poriune de date care este trecut ntr-o funcie atunci cnd funcia
este invocat.
Un parametru este o variabil care primete un argument ce este trecut ntr-o funcie.
Exemplu:
def show_double(number):
result = number*2
print(result)
Funcia se cheama show_double. Ea accept un numr (number) ca parametru i
afieaz valoarea dublat a acelui numr.
Exemplu de program:
#Acest program demonstreaza cum un
#argument este trecut unei functii
def main():
value=5
show_double(value)
#Functia show_double accepta un argument
#si afiseaza valoarea lui dubla
def show_double(number):
result = number*2
print(result)
28
main()
Fig. 2.3 Trecerea unui argument la funcie
Trecerea ntr-o funcie a mai multor argumente

Exist situaii cnd trebuie s treci dou sau mai multe argument unei funcii.
def main():
print(Suma lui 12 cu 45 este)
show_summ(12, 45)
def show_summ(num1, num2):
result = num1 + num2
print(result)
main()
S facem schimbri n parametri
def main():
value = 99
print(Valoarea este, value)
def change_me(arg):
print(Voi schimba valoarea.)
arg = 0
print(Acuma valoarea este, arg)
29

main()
2.2. Constante i variabile globale
O variabil global este accesibil tuturor funciilor dintr-un program. Ea se creeaz
n afara oricrei funcii.
Ex:
#Creeaza o variabila globala
number = 0
def main():
global number
number = int(input(Introdu un numar ))
show_number()
def show_number():
print(Numarul introdus este: , number)
main()
Este totui indicat s nu foloseti variabile globale. n schimb poi s foloseti
constante globale. O constant global refer o valoare care NU POATE FI
SCHIMBAT.
Capitolul III STRUCTURI DE DECIZIE

3.1. Declaratia if
Forma general:
if conditie:
declaratie
declaratie
etc
Ex: if sales > 5000:
bonus = 500.0
Blocuri de declaraii imbricate: cnd ai un bloc nuntrul altui bloc, blocul interior
30
trebuie indentat mai departe. Dac clauza if a fost indentat ( fa de main() ) cu un

tab (sau patru spaii), atunci declaraiile ei vor fi indentate cu dou taburi sau opt
spaii i tot aa.
Exemplu:
Fig.3.1 Blocuri de declaraii indentate
3.2 Declaraia if-else

O declaraie if-else execut un bloc de declaraii dac (if) condiia e adevarat sau
alt bloc (else) dac condiia e fals.
Forma general:
if conditie:
declaratie
declaratie
etc
else:
declaratie
declaratie
etc
Ex:
if temperatura < 15:

31
print(E cam frig!)

else:
print(E binisor!)
Reguli de indentare a clauzei if-else
-
fii sigur c if i else sunt aliniate
fii sigur c declaraiile care urmeaz dupa if i else sunt indentate.
Compararea irurilor
Python permite s compari iruri. Acest lucru i d voie s creezi structuri de decizie
care testeaz valoarea unui ir.
Ex:
nume1 = Marcel
nume2 = Marius
if nume1 = nume2:
print(Numele sunt la fel)
else:
print(Numele sunt diferite)
Structuri de decizie imbricate i declaraia if-elif-else
Ca s testeze mai mult de o condiie, o structur de decizie poate fi imbricat nuntrul
altei structuri de decizie.
Ex (fragment de program):
if salariu > = MIN_SALARIU:
if ani_la_serviciu >= MIN_ANI:
print(Te califici pentru imprumut)
else:
print(Nu te califici)
else:
print(Trebuie sa ai minim..)
Forma general a declaraiei if-elif-else:
if conditie_1 :
32
declaratie
declaratie
etc
elif conditie_2:
declaratie
declaratie
etc
(Introduci oricate clause elif vrei)
else:
declaratie
declaratie
etc
3.3 Operatori logici
Sunt: and, or, not.
Exemplu and:
if temperatura < 20 and minute > 12:
print(Temperatura e periculoasa)
Exemplu or:
if temperatura < 20 or temperatura > 100:
print(Temperatura este extrema)
Exemplu not:
if not(temperatura > 100):
print(Aceasta e aproape temperatura maxima)
3.4 Variabile booleene

O variabil boolean poate referi dou valori: TRUE sau FALSE. Ele arat dac o
condiie exist. Variabilele booleene sunt folosite ca indicatori. Un indicator este o
variabil care semnalizeaza cnd o condiie exist n program.
Ex:
33
if sales_quota >=5000.0:
sales_quota_met = True
else:
sales_quota_met = False
3.5.Structuri de repetiie
O structur de repetiie face ca o declaraie sau un set de declaraii s se repete.
Bucla while o bucl controlat
O condiie controlat face ca o declaraie sau un bloc de declaraii s se repete atta
timp ct o condiie e adevrat. Python folosete declaraia (bucla) while ca s scrie o
astfel de condiie.
Formatul general al buclei while este:
while conditie:
declaratie
declaratie
etc
Ex:
while valoare == y:
Exemplu:
Fig. 3.2 Bucla while
34
Bucla while nu se execut niciodat dac condiia de nceput e fals.
3.6.Bucla for
Bucla for itereaz de un numr specific de ori.
Format general:
for variable in [value1, value2, etc] :
declaratie
declaratie
etc
Ex:
#Acest program demonstreaza o bucla for
#care utilizeaza o lista de numere
def main():
print(Voi afisa numerele de la 1 la 5)
for num in [1, 2, 3, 4, 5]:
print(num)
main()
Fig.3.3 Bucla for
Folosirea funciei range cu bucla for

Funcia range creeaz un tip de obiect numit iterabil. Un iterabil este similar unei
liste (vom vorbi ceva mai trziu despre liste):

35
for num in range(5):

print (num)
Fig.3.4. Bucla forin range
Ex:
#Acest program demonstreaza cum functia range
#poate fi folosita cu bucla for
def main():
#Afiseaza un mesaj de 5 ori
for x in range(5):
print(Salut, sa te fut!)
main()
Fig.3.5. Exemplu de mai sus n interpretor
Funcia for in range produce o secven de numere care crete cu valoarea 1

fiecare numr succesiv din list. S vedem ce se ntmpl cu urmtoarea declaraie:
36
for numar in range(1, 10, 2):

print(numar)
Primul argument este 1 iar ultimul argument este 10. Dar ce reprezint numrul 2 ?
Acesta este folosit ca valoarea de pas (step valor sau pas). Astfel, fiecare numr
succesiv din secven n loc s creasc cu 1, va crete cu valoarea pasului, n cazul
nostru 2. Deci 2 va fi adugat fiecrui numr succesiv din secven:
Fig.3.. Demonstrarea valorii de pas
S vedem ce se ntampl dac o lum de la sfrit spre nceput iar valoarea pasului
devine negativ:
Fig.3Inversarea secvenei
Acumulatori
Un total de funcionare (running total) este o sum de numere care acumuleaz
fiecare iterare (trecere, execuie) a unei bucle. Variabila folosit ca s nmagazineze
totalul se cheam acumulator.
Multe programe cer s calculezi totalul unei serii de numere. De exemplu, se
presupune c scrii un program care calculeaz totalul vnzrilor pentru o sptmn.
Programul citete vnzrile din fiecare zi i calculeaz totalul acelor numere.
Acest tip de programe folosete de obicei dou elemente:
1. o bucl care citete fiecare numr al seriei
2. o variabil care acumuleaz totalul numerelor citite

37
S lum un program care demonstreaz un acumulator:

#Acest program calculeaza suma unei serii
#de numere introduse de user
#Ia constanta pentru numarul maxim
MAX = 5
(Reine! Constanta se pune la nceput)
Def main():
#Initializeaza variabila acumulator
total = 0.0
(acumulatorul se inializeaz ntotdeauna cu 0.0)
#Explica ceea ce faci

print(Acest program calculeaza suma)
print(MAX, numerelor introduse.)
#Ia numerele si acumuleaza-le
for counter in range(MAX):
number = int(input(Introdu un numar: ))
total = total+number
#Afiseaza totalul numerelor
print(Totalul este, total)
main()
Operatori de atribuire augmentat
Acetia ajut la prescurtarea i deci simplificarea codului.
Exemple:
x= x + 1 se mai poate scrie x+=1
sau:
y= y - 2 se mai poate scrie y-=2
sau:
z= z * 5 se mai poate scrie z*=5
sau
total = total + number devine total += number
38
Bucle de validare a intrrilor

Validarea intrrilor (input-ului) este procesul de verificare a datelor care sunt
introduse ntr-un program ca s fii sigur c sunt corecte nainte de a fi folosite n
calcule. Dac un user introduce date greite, programul va scoate rspunsuri eronate
(sau erori logice care sunt cel mai greu de depanat). Calculatorul orict de detept
l-am crede (i nu este) proceseaz datele pe care omul i le furnizeaz. El nu tie s
fac diferena ntre datele bune i cele proaste.
De exemplu, urmtorul program va afia un rezultat eronat pentru c datele introduse
sunt ilogice (salariat.py):
#Acest program afiseaza salariul unui angajat
def main():
#Ia numarul orelor lucrate intr-o saptamana
ore = int(input(Introdu numarul orelor lucrate intr-o saptamana: ))
#Ia salariul orar
sal_orar=float(input(Introdu salariul orar: ))
#Calculeaza salariul
salariu = ore * sal_orar
#Afiseaza salariul
print(Salariul este: lei , format(salariu, ,.2f))
#Cheama functia main
main()
Fig. 3.6. Date aberante i rspunsuri pe msur!
Ce s-ar intmpla dac la orele lucrate pe sptmn, un angajat ar introduce n loc de

40 de ore (adic opt ore pe zi nmulite cu 5 zile pe sptmn) 400 de ore? Rezultatul
ar fi aberant, n primul rnd pentru c o sptmn fie ea de lucru sau nu nu poate
s aib 400 de ore!
39
Cum corectam o asemenea nzbtie? Simplu! Adugm o bucl while:

#Acest program afiseaza salariul unui angajat
def main():
#Ia numarul orelor lucrate intr-o saptamana
ore = int(input(Introdu numarul orelor lucrate intr-o saptamana: ))
#Asigura-te ca userul nu introduce o valoare absurda
while ore > 40:
print(Eroare! Nu poti lucra mai mult de 40 de ore!)
ore=int(input(Introdu orele corecte: ))
#Ia salariul orar
sal_orar=float(input(Introdu salariul orar: ))
#Calculeaza salariul
salariu = ore * sal_orar
#Afiseaza salariul
print(Salariul este: , format(salariu, ,.2f))
main()
Bucle imbricate
O bucl aflat nuntrul altei bucle se cheam imbricat.
Ceasul este cel mai bun exemplu de bucle imbricate. Secundele, minutele i orele se
rotesc pe un ecran de ceas. O or se rotete complet n 12 ore ale ecranului. Unui
minut i trebuiesc 60 de rotiri. Pentru a demonstra funcionarea ceasului folosim o
bucl for:
for seconds in range(60):
print (seconds)
sau
for minutes in range(60):
40
print(minutes, :, seconds)
Buclele complete ale ceasului arat aa:
for hours in range(24):
for minutes in range(60):
print(hours, :, minutes, :, seconds)
Bucla cea mai din interior itereaz de 60 de ori pentru fiecare iteraie a buclei din
mijloc. Bucla din mijloc itereaza de 60 de ori la fiecare iteraie a buclei din exterior.
Cnd bucla din exterior itereaz de 24 de ori, bucla din mijloc itereaz de 1440 de ori
iar cea din interior de 86.400 de ori.
Capitolul IV Funcii care returneaz valori

4.1.Generarea de numere aleatoare
O funcie care returneaz valori este o funcie care trimite napoi o valoare prii din
program care a chemat-o. Python ofer o bibliotec (pre) scris de funcii care face
asta. Aceast bibliotec conine o funcie care genereaz numere aleatoare
(ntmpltoare).
4.2.Biblioteci de funcii standard i declaraia import

Am folosit deja cteva funcii standard pre-scrise n biblioteci: print, input, range.
Cteva dintre funciile Python sunt construite n interpretorul lui. Dac vrei s le
foloseti, pur i simplu le invoci. Aa este cazul cu input, print, range. Multe alte
funcii sunt ns stocate n biblioteci numite module. Aceste module - care sunt
copiate n computer n momentul instalrii Python, ajut la organizarea bibliotecilor
standard.
Cnd invoci o funcie stocat ntr-un modul, trebuie s scrii o declaraie de import n
partea cea mai de sus a programului. Spre exemplu, s lum modulul numit math. El
conine funcii matematice care lucrez cu numere reale (n virgul mobil). Dac vrei
s foloseti modulul math trebuie s scrii n vrful programului o declaraie ca

41
aceasta:
import math
Aceast declaraie face ca interpretorul s ncarce coninutul modulului math n
memorie i s-l fac disponibil.
4.3.Generarea numerelor aleatoare
Python ofer cteva biblioteci de funcii care lucreaz cu numere aleatoare
(ntmpltoare). Acestea sunt stocate ntr-un modul numit random. Ca s generm
numere aleatoare vom importa modulul random prin declaraia:
import random
Prima funcie aleatoare generat se numeste randint.
Pentru c funcia randint se gsete n modulul random, avem nevoie s folosim
notaia cu punct ca s ne referim la ea. n notaia cu punct numele funciei este

modul
random.randint
funcie
n partea stng a punctului este numele modulului iar dup el numele funciei.
Deci:
Punctul leag modulul de funcie.
random este modulul.
randint este funcia.
Ex:
number = random.randint(1, 100)
Argumentul (1, 100) spune funciei randint s afieze un ntreg aleator situat ntre 1
i 100.
Exemplu de program:
#Acest program afiseaza un numar aleator
#situat in marja 1 pana la 100
import random
def main():

42
#Ia un numar aleator

numar = random.randint(1, 100)
#Afiseaza numarul
print(Numarul este, numar)
main()
Acuma s lum un alt exemplu n care iterm cu o bucl for de 5 ori:

#Acest program afiseaza 5 numere aleatoare
#situate intre 1 si 100
import random
def main():
for count in range(5):
#Ia un numar aleator
numar = random.randint(1, 100)
#Afiseaza numarul
print(numar)
#Cheama main
main()
Sa simplificm programul anterior astfel:
import random
def main():
for count in range(5):
print(random.randint(1, 100))
main()

43
Fig.4.1. Ilustrarea exemplului de mai sus
4.4.Funciile randrange, random i uniform

Funcia randrange ia acelai argument ca funcia range. Diferena este c randrange
nu returneaz o list de valori. n loc de asta, ea returneaz o valoare aleatoare dintr-o
secven de valori.
De exemplu, urmtoarea declaraie atribuie un numr aleator situat ntre 0 i 9
variabilei numar:
numar = random.randrange(10)
Argumentul n cazul nostru 10 specific limita unei secvene de valori. Funcia va
returna un numr aleator selectat din secvena de la 0 n sus dar nu include limita
sfritului, adic numrul 10.
Urmtoarea declaraie specific i valoarea de nceput dar i de sfrit a secvenei:
numar = random.randrange(5, 10)
Cnd aceast declaraie e executat, un numr ntmpltor cuprins ntre 5 i 9 va fi
atribuit variabilei numr.
Urmtorul exemplu specific o valoare de start, una de sfrit i o alt valoare:
numar = random.randrange (0, 101, 10)
Funcia uniform returneaz un numr aleator n virgul mobil, dar i permite s
specifici media valorilor pe care le-ai selectat:
numar = random.uniform (1.0, 10.0)
Declaraia de mai sus face ca funcia uniform s returneze o valoarea aleatoare n
virgul mobil situat n gama 1.0 pn la 10.0 i s-o atribuie variabilei numar.
4.5.Scrierea propriei funcii care returneaz o valoare

O funcie care returneaz o valoare conine o declaraie return care napoiaz o
valoare prii de program care a invocat-o.
Scrierea unei funcii care returneaz o valoare se face la fel ca scrierea unei funcii
44
simple cu o excepie: o funcie care returneaz o valoare trebuie s aib o declaraie

return.
Forma general a funciei este:
def function_name():
declaratie
declaratie
etc
return expression
Ex:
def sum(num1, num2):
result = num1 + num2
return result
i acuma un exemplu practic (total_bani.py):
#Acest program foloseste valoarea returnata a unei functii
def main():
#Ia valoarea banilor unui cetatean
bani_primul=float(input(Introdu valoarea banilor: ))
#Ia valoarea banilor celui de-al doilea cetatean
bani_al_doilea=float(input(Introdu valoarea banilor: ))
#Afla valoarea totala
total=sum(bani_primul, bani_al_doilea)
#Afiseaza totalul
print(Impreuna cei doi au: total)
#Functia sum accepta doua argumente numerice si
#returneaza suma celor doua argumente
def sum(num1, num2):
rezultat=num1 + num2
return rezultat
#Cheama main

45
main()
Modularea cu funcii
(exemplu de aplicaie)
Andrei are o afacere numit F-i propria muzic prin intermediul creia vinde
instrumente muzicale. Andrei i pltete angajaii cu comision. Comisionul este n
funcie de vnzri astfel:
-
mai puin de 10000 lei - 10%
10000 14999 12%
15.000 17.999 14%
18.000 21.999 16%
22.000 i mai mult 18%
Pentru c agenii de vnzri sunt pltii lunar, Andrei permite fiecruia dintre ei s ia
n avans cte 2000 de lei. Cnd comisionul este calculat, suma pe care fiecare angajat
a luat-o n avans este sczut din comision. Dac comisionul este mai mic dect suma
luat n avans, ei trebuie s-i ramburseze lui Andrei diferena. Ca s calculeze plata
lunar a fiecrui angajat, Andrei folosete urmtoarea formul:
plata = vanzari * comision avans
Andrei te roag s-i scrii o aplicaie care s fac toate calculele pentru el.
Algoritmul aplicaiei este urmtorul:
1. Ia vnzrile lunare ale fiecrui agent de vnzri
2. Ia suma de bani luat n avans de fiecare dintre ei
3. Folosete valoarea vnzrilor lunare ca s afli comisionul
4. Calculeaz plata fiecrui angajat folosind formula de mai sus. Dac valoarea e
negativ, angajatul trebuie s restituie banii.
Programul:
#Acest program calculeaza salariul
#unei persoane de vanzari
def main():
#Ia suma vanzarilor
vanzari = ia_vanzarile()
#Ia valoarea luata in avans

46
avans = ia_avansul()
#Determina comisionul
comision = determina_comision(vanzari)
#Calculeaza plata
plata = vanzari*comision avans
#Afiseaza valoarea platii
print (Plata este lei, format(plata, .2f))
#Afla daca plata e negativa
if plata < 0:
print(Plata trebuie rambursata)
else:
print(Plata nu trebuie rambursata)
main()
4.6.Modulul matematic
Modulul math conine numeroase funcii care pot fi folosite n calcule matematice
Ex:
result = math.sqrt(16)
Funcia sqrt accept un argument 16 i returneaz rdcina ptrat a
argumentului (care e 4).
Mai nti trebuie s importam modulul math pentru a scrie un program care l
folosete.
Ex de program:
#Acest program demonstreaza functia sqrt
import math
def main():
#Ia un numar
numar = float(input(Introdu un numar: ))
47
#Ia radacina patrata a numarului

square_root = math.sqrt(numar)
#Afiseaza radacina patrata a numarului
print(Radacina patrata este, square_root)
main()
Urmtorul program folosete funcia hypot ca s calculeze ipotenuza unui triunghi
dreptunghic:
#Acest program calculeaza lungimea ipotenuzei
#unui triunghi dreptunghic
import math
def main():
#Ia lungimea a doua laturi ale triunghiului
a=float(input(Introdu lungimea laturii A: ))
b=float(input(Introdu lungimea laturii B: ))
#Calculeaza lungimea ipotenuzei
c=math.hypot(a, b)
#Afiseaza lungimea ipotenuzei
print(Lungimea ipotenuzei este: , c)
main()
Valorile math.pi i math.e
Suprafaa cercului (ex.)
area = math.pi*radius**2
Ce se ntmpl? Suprafaa cercului (aria) este S=pi **r (unde r este raza cercului) la
ptrat. Dar cum pi este o constant universal care aparine modulului matematic,
trebuie s scriem math.pi.
48
4.7.Stocarea funciilor n module

Un modul este un fiier care conine cod Python. Programele mari sunt (mai) uor de
reparat i ntreinut atunci cnd sunt mprite n module.
S presupunem c ai de calculat urmtoarele:
-
Suprafaa unui cerc
Circumferina unui cerc
Suprafaa unui dreptunghi
Perimetrul unui dreptunghi
Exist dou categorii de calcule necesare n program: una legat de cercuri i alta de
dreptunghiuri. Poi s scrii funciile legate de cerc ntr-un modul i pe cele de
dreptunghi n altul.
Modulul cerc (circle.py)
#Modulul cerc are functii care calculeaza
#suprafata si circumferinta cercului
import math
#Functia area accepta raza cercului ca
#argument si returneaza suprafata cercului
def area(radius):
return math.pi*radius**2
#Functia circumference accepta raza cercului
#ca parametru si returneaza circumferinta lui
def circumference(radius):
return 2*math.pi*radius
Modulul dreptunghi (rectangle.py)

Acest modul conine dou funcii: area (suprafaa) care returneaz aria dreptungiului
i perimeter (perimetrul) care returneaz perimetrul.
#Modulul dreptunghi are functii care fac calcule
#legate de dreptunghiuri
49
#Functia area accepta lungimea si latimea

#ca argument si returneaza suprafata dreptunghiului
def area(width, length):
return width*length
#Functia perimetru accepta latimea si lungimea
#ca argument si returneaza perimetrul dreptunghiului
def perimeter(width, length)
return 2 *(width, length)
Fiierul unui modul trebuie s aib neaprat extensia py. Ca s foloseti modulele
ntr-un program trebuie s le impori cu declaraia:
import circle (sau import rectangle)
Cnd interpretorul Python citete aceast declaraie se uit dup modulul circle.py n
acelai folder cu programul pe care ncearc s-l proceseze. Din acest motiv,
programul trebuie salvat n acelai folder n care se afl modulul. Dac gsete
modulul, l ncarc n memorie. Dac nu-l gsete, apare o eroare. Odat ce modulul
este importat, programul poate s-i acceseze funciile. S spunem c radius (raza)
este o variabil creia i atribuim valoarea razei unui cerc.
Iat cum invocm funciile area i circumference:
my_area = circle.area(radius)
my_circum = circle.circumference(radius)
S scriem acuma un program complet ce implic aceste funcii.
(geometry.py) :
#Acest program permite userului sa aleaga diverse calcule
#geometrice dintr-un meniu. Programul importa
#modulele cerc si dreptunghi
import circle
import rectangle
#Constantele pentru alegerile din meniu
AREA_CIRCLE_CHOICE=1
CIRCUMFERENCE_CHOICE=2
AREA_RECTANGLE_CHOICE=3
PERIMETER_RECTANGLE_CHOICE=4
50
QUIT_CHOICE=5
#Functia principala
def main():
#Variabila choice controleaza bucla
#si ofera userului alegerea din meniu
choice = 0
while choice !4=QUIT_CHOICE:
#afiseaza meniul
display_menu()
#Preia alegerea utilizatorului
choice = int(input(Alege: ))
#Realizeaza alegerea selectata
if choice == AREA_CIRCLE_CHOICE:
radius=float(input(Introdu raza cercului: ))
print(Suprafata este, circle.area(radius))
elif choice == CIRCUMFERENCE_CHOICE:
radius = float(input(Introdu raza cercului: ))
print(Circumferinta este, \
circle.circumference(radius))
elif choice == AREA_RECTANGLE_CHOICE:
width = float(input(Introdu latimea dreptunghiului: ))
length = float(input(Introdu lungimea dreptunghiului:
))
print(Suprafata este, rectangle.area(width, length))
elif choice == PERIMETER_RECTANGLE_CHOICE:
width = float(input(Introdu latimea dreptunghiului: ))
length = float(input(Introdu lungimea dreptunghiului:
))
print(Perimetrul este, \
rectangle.perimeter(width, length))
elif choice == QUIT_CHOICE:
print(Iesirea din program)
else:
print(Eroare: selectare invalida.)
#Functia display_menu afiseaza meniul
def display_menu():
print(
MENU)
print(1) Suprafata unui cerc)
print(2) Circumferinta unui cerc)
print(3) Suprafata unui dreptunghi)

4
semnul != nseamn diferit de...
51
print(4) Perimetrul unui dreptunghi)

print(5) Quit)
main()
Capitolul V Fiiere i excepii

Cnd un program are nevoie s salveze date pentru a le folosi mai trziu, el le
scrie ntr-un fiier. Datele pot fi extrase i citite din fiier n orice moment.
Programele pe care le scrii sunt refolosite pentru c datele lui sunt stocate n
memoria RAM (Random Acces Memory). Datele sunt salvate ntr-un fiier care este
stocat pe disc. Odat ce datele sunt salvate n fiier, ele rmn i dup ce fiierul este
nchis. Datele pot fi retrimise i refolosite de utilizator oricnd dorete.
Exemple:
-
procesoare word
editoare de imagine
tabele de date
jocuri de calculator
browsere web (prin cookie)
Cnd o bucic de date este scris ntr-un fiier, ea e copiat dintr-o variabil din
RAM n fiierul de pe disc.
Procesul de retrimitere a datelor dintr-un fiier este cunoscut ca citirea din
fiiere. Procesul acesta este invers scrierii n fiiere: cnd o poriune de date este citit
din fiierul de pe HDD, este copiat n RAM i referit de o variabil.
Procesul implic trei pai:
1. Deschiderea fiierului creeaz o conexiune ntre fiier i program.
Deschiderea unui fiier din input permite programului s citeasc date din el.
2. Procesarea fiierului datele sunt scrise n fiier (fiier output) sau citite (fiier
input)
3. nchiderea fiierului cnd programul termin cu fiierul, el trebuie nchis.
4.
5.1.Tipuri de fiiere
Sunt dou tipuri de fiiere: text i binare.
Un fiier text conine date care au fost codificate n text folosind scheme ca ASCII sau
52
Unicode. Chiar dac fiierele conin numere, ele sunt stocate ca o serie de caractere.
Drept rezultat, fiierul poate fi deschis i vzut ntr-un editor de text precum Notepad.
Un fiier binar conine date care sunt convertite n text. Ca urmare, nu le poi citi cu
un editor de text.
5.2.Metode de acces a fiierelor
Majoritatea limbajelor de programare ofer dou ci de acces la datele stocate n
fiiere:
a) acces secvenial
b) acces direct
Cnd lucrezi cu accesul secvenial, accesezi date de la nceput spre sfrit. Deci dac
vrei s citeti date situate spre sfritul fiierului eti nevoit s parcurgi tot fiierul
nu poi sri la ceea ce te intereseaz. Este ca la casetofon: nu poi pune direct
cntecul dorit.
Cnd ns foloseti accesul direct (random access file), poi sri direct la orice date
din fiier. Este ca la CD sau ca la pick-up: poi pune direct orice cntec vrei.
Noi vom lucra cu accesul secvenial.
Numele fiierului i obiectele fiier (Filenames and File Objects)
Fiierele sunt identificate printr-un nume. Asta se ntmpl cnd le salvm. De
exemplu: cat.jpg ; nota.txt ; scrisoare.doc etc.
n msura n care un program lucreaz cu un fiier de pe computer, programul trebuie
s creeze un fiier obiect n memorie ca s-l poat accesa. Un fiier obiect (file
object) este un obiect asociat cu un fiier specific i ofer o cale programului de a
lucra cu acel fiier.
n program, o variabil refer obiectul fiier. Acea variabil se ngrijete de toate
operaiile fcute n fiier.
5.3.Deschiderea unui fiier n Python
Ca s deschidem un fiier folosim funcia open. Funcia open creeaz un fiier obiect
pe care l asociaz cu fiierul dorit de pe discul computerului:
Formatul general al funciei open este:
file_variable = open(filename, mode)
unde:
53
file_variable este numele variabilei care refer obiectul fiier
filename este un ir care arat numele fiierului
mode este un ir care specific modul (scris, citit, etc) n care fiierul va fi
deschis.
Exemple de moduri (mode) n Python:

r = deschide un fiier doar pentru citit (read); fiierul de acest tip nu poate fi scris
w = deschide un fiier pentru scris (write). El poate fi interpretat cam aa: dac
fiierul exist, terge-i coninutul; dac nu exist, creeaz-l.
a = deschide un fiier pentru a fi scris. Toate datele fiierului vor fi anexate pn la
sfrit. Dac nu exist (fiierul) creeaz-l.
De exemplu, s presupunem c fiierul client.txt conine datele unui client i vrem s-l
deschidem pentru a-l citi. Iat un exemplu de cum invocm funcia open:
fisier_client = open(client.txt, r)
Dup ce declaraia este executat, fiierul client.txt este deschis i variabila
fisier_client va referi un fiier obiect pe care-l putem folosi ca s citim date din fiier.
Acuma, vrem s crem un fiier numit vanzari.txt i s scriem n el. Iat cum facem:
fisier_vanzari = open(vanzari.txt, w)
5.4.Scrierea datelor ntr-un fiier
Este timpul s introducem un alt tip de funcii care se cheam metode.
O metod este o funcie care aparine unui obiect i care face unele operaii folosind
acel obiect. Odat ce ai deschis un fiier, foloseti metoda fiierului obiect ca s poi
face operaii pe fiier.
De exemplu, obiectul fiier are o metod numit write care poate fi folosit ca s scrii
date ntr-un fiier.
Iat formatul general i cum s invoci metoda write:
file_variable.write(string)
n aceast declaraie, file_variable este o variabil care refer un fiier obiect i
string este un ir care va fi scris n fiier. Fiierul trebuie s fie deschis pentru scris
(w sau a) altfel va aprea o eroare.
S spunem c customer_file refer un fiier obiect i fiierul va fi deschis pentru

54
scris cu modul w. Iat cum vom scrie de exemplu irul Traian Basescu ntr-un
fiier:
customer_file.write(Traian Basescu)
Urmtorul fragment de cod arat un alt exemplu:
nume = Traian Basescu
customer_file.write(nume)
Odat ce am terminat cu un fiier, el trebuie nchis cu cuvntul close. Ex.:
customer_file.close()
Exemplu complet de program (scriere_fisier.py)
#Acest program scrie trei linii de date
#intr-un fisier
def main():
#Deschide un fisier numit tenori.txt
outfile = open(tenori.txt, w)
#Scrie numele a trei tenori
#in fisier
outfile.write(Luciano Pavarotti\n)
outfile.write(Placido Domingo\n)
outfile.write(Jose Carreras\n)
10
#Inchide fisierul
outfile.close()
12

main()
Rezultatul programului este redat mai jos:
Fig.5.1 tenori.txt
55
(Nota: Numerele din partea dreapt reprezint rndurile programului). Cum lucreaz
nsa acest program? Linia 5 deschide fiierul tenori.txt folosind modul w. Acesta face
ca fiierul s fie creat i bun pentru scris n el. De asemenea, aceeai declaraie
creeaz un obiect n memorie pe care il atribuie variabilei outfile. Declaraiile din
liniile 8, 9 i 10 scriu pur i simplu irurile din fisier. Linia 12 nchide fiierul. Dup
ce programul este rulat, numele celor trei personaje este scris n fiierul tenori.txt. S
mai observm c fiecare ir se termin cu \n adic urmtorul este aezat pe o linie
nou.
5.5.Citirea datelor dintr-un fiier
Dac un fiier este deschis pentru citire (folosind modul r), putem folosi metoda
obiect read ca s-i citim ntregul coninut. Cnd este invocat metoda read, ea
returneaz coninutul fiierului ca pe un ir. S vedem n exemplul urmtor cum
folosim metoda read ca s citim coninutul textului tenori.txt pe care l-am creat
anterior:
(citire_fisier.py)
#Acest program citeste si afiseaza continutul
#fisierului tenori.txt
def main():
#deschidem fisierul numit tenori.txt
infile = open(tenori.txt, r)
#Ii citim continutul

file_contents = infile.read()
#Inchidem continutul
infile.close()
#Afisam datele citite
print(file_content)

56
#Invocam functia principala

main()
Declaraia din linia 5 deschide fiierul pentru citit folosind modul r. De asemenea
creeaz un fiier obiect pe care l atribuie variabilei infile. Linia 8 invoc metoda
infile.read ca s i citeasc coninutul. Coninutul este citit n memorie ca un ir i
atribuit variabilei file_contents. Putem de asemenea folosi metoda readline ca s
citim doar o linie dintr-un fiier. Metoda returneaz o linie ca pe un ir.
Concatenarea unei linii noi la un ir
n cele mai multe cazuri, datele care sunt scrise ntr-un fiier nu sunt iruri literare dar
sunt referite n memorie de variabile. Este cazul n care un program invit userul s
introduc date i apoi s le scrie ntr-un fiier. Cnd un program scrie date introduse
de user, este de obicei necesar s le legm (concatenm) cu un caracter \n. Acest
lucru ne va asigura c fiecare dat este scris ntr-o linie nou n fiier. Programul
urmtor ne arat cum se face acest lucru (concat.py).
#Acest program ia trei nume de la user
#Si le scrie intr-un fisier
def main():
#Ia trei nume
print(Introdu numele a trei barbati.)
nume1=input(Barbatul #1: )
nume2 = input(Barbatul #2: )
nume3 = input(Barbatul #: )
#Deschide un fisier numit barbati.txt
myfile = open(barbati.txt, w)
57
#Scrie numele in fisiere

myfile.write(nume1 + \n)
#Inchide fisierul
myfile.close()
print(Numele au fost scrise in barbati.txt)
main()

5.6.Adugarea datelor ntr-un fiier existent
Cnd folosim metoda w ca s deschidem un fiier dar fiierul cu nume specificat
exist deja pe disc, fiierul existent va fi ters i unul gol dar cu acelai nume va fi
creat.
Uneori dorim s pstrm fiierul vechi i s-i adugm date noi. Acestea se adaug la
sfritul celor existente. n Python folosim modul a ca s deschidem un fiier cruia
vrem s-i adugm date. Asta nseamn c:
-
dac fiierul exist deja, el nu va fi ters. Dac nu exist, va fi creat.
cnd datele sunt scrise n fiier, ele vor fi adugate la sfritul datelor existente.
De exemplu, s spunem c fiierul barbati.txt conine deja urmtoarele nume scrise

fiecare pe o linie separat:
Costel
Mirel
Florel
Codul de mai jos deschide fiierul i adaug urmtoarele date la coninutul existent:
myfile=open(barbati.txt, a)
myfile.write(Gigel\n)
myfile.write(Fanel\n)
58
myfile.write(Stanel\n)
myfile.close()
Dup aceasta vom avea numele anterior scrise (Costel, Mirel, Florel) la care se
adaug cele de mai sus. Fiierul va arta n final aa:
Costel
Mirel
Florel
Gigel
Fanel
Stanel
5.7.Scrierea i citirea datelor numerice
irurile pot fi scrise direct cu metoda write dar numerele trebuiesc convertite n iruri
nainte de a fi scrise.
Python are o funcie preconstruit numit str care convertete o valoare ntr-un ir.
S spunem de pild c variabilei num i este atribuit valoarea 99. Expresia str(num)
va returna irul 99.
Ex: scrie_numere2.py
#Programul demonstreaza cum numerele
#trebuiesc convertite in siruri inainte de a fi
#scrise in fisiere text
def main():
#Deschide un fisier pentru scris
outfile=open(numere.txt, w)
#Ia trei numere de la user
num1=int(input(Introdu un numar: ))
num2=int(input(Introdu alt numar: ))
num3=int(input(Mai baga unul: ))
#Scrie cele trei numere in fisier
59
outfile.write(str(num1) + \n)
#Inchide fisierul
outfile.close()
print(Date scrise in numere.txt)
main()
La ieire, programul va afia cele trei numere introduse de utilizator i mesajul Date
scrise in numere.txt.
Expresia str(num1) + \n convertete valoarea referit de variabila num1 ntr-un ir
i o concateneaz cu \n irului. Cnd userul introduce s zicem valoare 50, expresia
va produce irul 50\n. Drept rezultat, irul 50\n este scris n fiier.
5.8.Excepii
O excepie este o eroare care apare atunci cnd un program ruleaz i care are drept
consecin oprirea lui brutal. Pentru mnuirea excepiilor se folosete declaraia
try/except .
Programul de mai jos (imparte.py) ofer un exemplu.
#Programul imparte un numar la altul
def main():
#Ia doua numere
num1=int(input(ia un numar: ))
num2=int(input(ia al doilea numar: ))
#Imparte-le unul la celalalt si afiseaza rezultatul
result=num1 / num2
print(num1, impartit la, num2, este, result)
#Cheama main
main()
60
Fig.5.1 Excepie Traceback
El mparte dou numere. Atunci cnd userul vrea s mpart un numr la zero, apare o
excepie sau o eroare numit traceback. Ea d informaii cu privire la numrul liniei
(liniilor) care cauzeaz excepia. Cnd se ntmpl s avem de a face cu o excepie,
spunem c programul a ridicat o excepie. Ele pot fi prevenite scriind codul cu
atenie.
S rescriem codul de mai sus (impartire2.py) astfel nct excepia s nu mai apar:
#Programul imparte un numar al altul
def main():
#Ia doua numere
num1=int(input(ia un numar: ))
num2=int(input(ia al doilea numar: ))
#Daca num2 nu este 0, imparte num1 la num2
#si afiseaza rezultatul
If num2 != 0:
result=num1 / num2
print(num1, impartit la, num2, este, result)
else:
print(Impartirea la zero este imposibila.)
#Cheama main
main()

61
Fig.5.3 Imparirea la zero cu eroarea corectat
Dup cum poate v-ai dat seama, excepiile trebuiesc pur i simplu ghicite atunci cnd
programatorul scrie programul. El trebuie s-i puna mereu ntrebarea Ce s-ar
ntmpla dac? (n cazul de mai sus, Ce s-ar ntampla dac userul introduce valoarea
celui de-al doilea numr ca fiind zero?).
Capitolul VI Liste, tupluri, dicionare i seturi. Serializarea

obiectelor (pickling)

6.1. Liste
O list este un obiect care conine itemi multipli. Este similar matricei din
alte limbaje de programare. Listele sunt mutabile ceea ce nseamn c coninutul lor
poate fi schimbat pe timpul execuiei programului. Listele sunt structuri dinamice de
date adic itemii lor pot fi adugai sau teri. Pentru aceasta se poate folosi
indexarea, felierea (slicing) dar i alte metode de lucru cu liste.
Fiecare item dintr-o list se cheam element al listei.
Iat cum arat o declaraie de creare a unei liste de ntregi (ex):
numere_impare=[1, 3, 5, 7, 9]
Elementele listei sunt incluse ntre paranteze drepte i sunt desprite ntre ele prin
virgul.
S luam un exemplu de list cu iruri:
nume= [Mircea, Dana, Marcel, Stanel]
O list poate s conin tipuri diferite de valori:
lista = [Stanel, 51, 4.157]
62
Lista lista conine un ir (Stanel), un ntreg (51) i o valoare n virgul mobil

(4.157).
Pentru afiarea coninutului listei folosim funcia print( ) ca mai jos:
print (lista)
ceea ce va da la ieire:
Fig.6.1. List de itemi cu valori diferite
Python are de asemenea o funcie preconstruit care convertete anumite tipuri de

obiecte n liste. Aa cum am vazut ntr-un capitol anterior, funcia range returneaz
un iterabil ce este un obiect care ine o serie de valori ce itereaz peste ea.
Mai jos este un exemplu de folosire a declaraiei funciei range:
numere = [5, 10, 15, 20]
numere = list(range(5))
Cnd executm declaraia se ntmpl urmtoarele:
-
funcia range este invocat cu 5 drept argument; funcia returneaz un iterabil

care conine valorile 0, 1, 2, 3, 4.
iterabilul este trecut ca argument funciei list( ); funcia list( ) returneaz lista
[0, 1, 2, 3, 4].
lista [0, 1, 2, 3, 4] este atribuit variabilei numere.
Operatorul de repetiie
Operatorul de repetiie face copii multiple unei liste i le pune laolalt. Forma
general este:
lista * n
Un exemplu n care este multiplicat o list de ntregi dar i una cu valoare ir:
63
Fig. 6.2. Multiplicarea listelor
Iterarea peste o list cu bucla for

numere = [45, 67, 90, 3.45]
for n in numere:
print(n)
Ceea ce la ieire va da:
45
67
90
3.45
Indexarea
O metod de accesare a elementelor individuale dintr-o list este cu ajutorul unui
index. Fiecare element al listei are un index specific care-l poziioneaz n list.
Numrarea elementelor dintr-o list ncepe de la zero (0) , aa c primul element are
indexul 0, al doilea are indexul 1, al treilea are indexul 2 s.a.m.d.
S spunem c avem lista urmtoare:
lista = [12, 56, 6.345, Stanel]
Ca s accesm elementul listei care are valoarea Stanel, utilizm declaraia:
print(lista[3]) .
Sau elementul cu indexul 1 al listei (care este 56).
Fig. 6.3. Acces index list
64
Dac folosim indeci negativi, vom identifica poziia elementelor relative la sfritul
listei. Aa se face c indexul -1 identific ultimul element al listei, -2 pe penultimul i
tot aa. Indexul 0 este acelai cu indexul -4. Ce se ntmpl ns dac vrem s aflm
elementul care numrat de la coada listei, are indexul -5 ?
Va aprea o eroare Traceback pentru c lista nu are cinci indecsi:
Fig.6.4. Afiarea elementelor cu ajutorul indecsilor negativi
Funcia len
Cu ajutorul funciei len putem afla lungimea unei liste.
S lum urmtorul cod:
lista = [1, 2, 3, 4, 5]
lungime = len(lista)
Fig.6.5. Funcia len( )
Funcia len poate fi folosit ca s previn o excepie IndexError atunci cnd iterm
peste o list cu o bucl:
lista = [1, 2, 3, 4, 5]
index = 0
while index < len(lista):
print(lista[index])

65
index +=1
Listele sunt mutabile
Aa cum scriam la nceputul capitolului, listele n Python sunt mutabile ceea ce
nseamn c elementele ei pot fi schimbate.
S vedem un exemplu:
lista = [1, 2, 3,4, 5]
print(lista)
lista[0] = 50
print(lista)
Cum funcioneaz:
Pe rndul 1 crem lista lista iar apoi o afim pe rndul 2. Pe rndul 3, elementului
0 din list care este 1 i reatribuim valoarea 50. Cu linia 4 afim noua
componen modificat a listei:
Fig.6.6. Listele pot fi modificate
Ce se ntmpl dac nu folosim un index valid, ci unul care depete numrul

elementelor listei? Va aprea o excepie:
Fig.6.7. Excepie de ieire din marj
Lista de mai sus are cinci elemente dar care au indecii de la 0 la 4. Cum nu exist
index-ul 7, ncercarea de modificare va eua aprnd o eroare Traceback.
S luam un exemplu cu bucla while:
66
Fig. 6.8. Program list vnzri
i acuma ieirea programului de mai sus:
Fig.6.9. Ieirea programului anterior
Concatenarea (legarea) listelor

Pentru concatenarea listelor n Python se folosete semnul + .
Cel mai bun mod de a nelege cum funcioneaz este un exemplu:
lista1 = [8,9,10,11]
lista2 = [12,13,14,15]
lista3 = lista1 + lista 2

67
care va afia la ieire:
Fig.6.10. Concatenarea listelor
La fel de bine putem folosi i concatenarea listelor cu valoare ir:

fete = [Dana, Roxana, Ileana, Maria]
baieti = [Costel, Gigel, Ion, Popica]
nume = fete + baieti
care va avea output-ul:
Fig.6.11 Concatenare iruri
dar i tipuri diferite de valori (ntregi, float, ir):
Fig. 6.12. Tipuri diferite combinate ntr-o list
S reinem c putem combina doar liste cu liste. Dac ncercm s combinm o list
cu o alt entitate va aprea o excepie.
Felierea (slicing) listelor
Uneori ai nevoie s selectezi mai multe elemente dintr-o secven dar nu pe toate.
Atunci foloseti felierea (slice). Ca s iei o poriune dintr-o list trebuie s scrii o
expresie de forma:
lista[start : end]
unde start este indexul primului element din poriune i end este indexul ultimului
element din poriune.
S presupunem c avem urmtoarea list:

68
zile_saptamana = [Luni, Marti, Miercuri, Joi, Vineri, Sambata,

Duminica]
Urmtoarea expresie folosete o porionare care preia elementele din lista de mai sus
care au indexul 2 pn la 5 (dar neincluzndu-l pe cel din urm):
zile_mijloc = zile_saptamana[2:5]
Cnd este executat declaraia va rezulta:
[Marti, Miercuri, Joi]
sau un exemplu numeric:
Fig.6.13 Slicing
Dac lsm gol locul unuia dintre indeci, Python va folosi automat 0 ca index de
nceput.
Fig. 6.14. Lipsa unui index
sau invers:
Fig. 6.15. Lipsa celuilalt index
Ce se ntmpl dac lai goale spaiile indecilor? Python va face o copie a ntregii
69
liste:
Fig. 6.16. Lipsa ambilor indeci
Expresiile partajate pot avea i un pas (step value) ca n exemplul de mai jos:
Fig.6.17. Feliere cu pas
Pasul partajarii este 2 ceea ce face ca poriunea afiat s cuprind fiecare al doilea
numr din list.
Gsirea itemilor dintr-o list cu operatorul in
Forma general este:
item in lista
S lum un exemplu (in_lista.py)
#demonstrarea operatorului in
def main():
#creeaza o lista a numerelor produselor
prod_num = ['V476', 'F890', 'Q143', 'R688']
#Ia numarul unui produs pe care-l cauti
search = input('Introdu numarul produsului: ')
#afla daca numarul se gaseste in lista
if search in prod_num:
print(search, 'a fost gasit in lista.')
else:
print(search, 'nu a fost gasit in lista.')
#cheama functia principala
main()
70
Metode i funcii preconstruite pentru liste

Metoda append
Metoda append este folosit pentru adugarea unui nou item listei. Itemul este trecut
drept argument i este adugat la sfritul listei.
Ex. program (append.py)
#acest program demonstreaza metoda append
#de adaugare a unui nou item intr-o lista
def main():
#cream o lista goala
name_list = [ ]
#cream o variabila de control a buclei
again = 'y'
#adaugam cateva nume listei
while again == 'y':
#luam un nume de la utilizator
name = input('Introdu un nume: ')
#adauga numele introdus in lista
name_list.append(name)
#mai adauga inca un nume
print('Mai adaugi un nume? ')
again = input('y = yes, anything else = no ')
print()
#afiseaza numele introduse
print('Iata numele pe care le-ai introdus.')
for name in name_list:
print(name)
#cheama functia principala
main()

71
Metoda index
Uneori dorim s tim unde se afl un item dintr-o list. Pentru aceasta folosim metoda
index. Trecem un argument metodei index i ea returneaz index-ul primului element
din list care conine acel item. Dac itemul nu este gsit, programul va ridica o
excepie ValueError.
Ex. index_list_py
#programul demonstreaza cum luam un index al unui item
#dintr-o lista si apoi il inlocuim cu un alt item
def main():
#cream o lista
food = ['Pizza', 'Hamburg', 'Cipsuri']
#afisam lista
print(food)
#luam itemul pe care il vrem inlocuit
item = input('Ce item vrei sa schimbi? ')
try:
#ia indexul itemului din lista
item_index = food.index(item)
#ia valoarea de inlocuire
new_item = input('Introdu noua valoare: ')
#inlocuieste vechiul item cu noul item
food[item_index] = new_item
#afiseaza lista
print('Aici este noua lista.')
print(food)
except ValueVallor:
print('Itemul nu a fost gasit in lista.')
#cheama main
72
main()
Metoda insert
Aceast metod permite s adaugi un item ntr-o list pe o poziie specific. Ca s faci
asta trebuie s treci dou argumente metodei insert: un index care specific locul unde
itemul ar trebui s fie inserat i itemul pe care doreti s-l inserezi.
Ex.(insert_list.py)
def main():
#creeaza o lista cu cativa itemi
nume = ['Mircea', 'Dana', 'Auras']
#afiseaza lista
print('Lista inainte de inserare: ')
print(nume)
#insereaza un nume nou ca element 0 al listei
nume.insert(0, 'Gigel')
#afiseaza din nou lista
print('Noua lista arata asa: ')
print(nume)
#cheama functia main
main()
Metoda sort
Metoda sort rearanjeaz elementele unei liste aa nct ele s apar n ordine
ascendent.
Ex:
lista = [1,2 ,8,9,4,6,0]
print('Ordinea originala este:', lista)
lista.sort()
print('Lista sortata:', lista )
Metoda remove
Ex in IDLE:
73

Metoda reverse
Dup cum i spune numele, metoda reverse inverseaz ordinea itemilor din list.
Ex:
lista = [1,2,3,4,5]
lista.reverse()
print(lista)
Fig. 6.19. Metoda reverse
Declaratia del
Cu aceast declaraie tergem un element din list:
Fig.6.20. Declaraia del
Funciile min i max

Ex:
Fig.6.21. Funcia min
74
La fel se ntmpl i cu max, nlocuind min cu max.

Totalul valorilor dintr-o list
Pentru acest calcul trebuie s folosim o bucl for dar si un acumulator iniiat cu
valoarea zero. Iat un exemplu:
#Acest program calculeaz totalul valorilor dintr-o list
def main():
#Crem lista
numere = [2,3,6,8,10]
#crem o variabil pe care o folosim drept acumulator
total = 0
#Calculm totalul elementelor listei
for value in numere:
total += value
#Afim totalul elementelor listei
print(Totalul elementelor este, total)
#Invocm funcia main
main()
Iar output-ul este: Totalul elementelor este 30.
Media valorilor dintr-o list
Dup ce calculm totalul (ca mai sus) unei liste ca s aflm media valorilor din list
trebuie s mprim totalul la lungimea listei. Ex. (media.py)
#Acest program calculeaz media valorilor dintr-o list
def main():
#creem lista
scoruri = [2.5, 8.3, 6.5, 4.0, 5.2]
#creem o variabil ca s-o folosim ca acumlator
total = 0.0
75
#Calculam totalul valorilor din list

for value in scoruri:
total +=value
#Calculam media elementelor
media = total / len(scoruri)
#Afim totalul elementelor listei
print(Media elementelor este, media)
#Invocm funcia main
main()
Ieirea programului este: Media elementelor este 5.3.
6.2. Tupluri
Un tuplu este o secven imutabil, ceea ce nseamn c coninutul ei nu se poate
schimba. Un tuplu seaman foarte mult cu o list cu diferena c odat creat,
elementele lui nu se pot schimba. Elementele unui tuplu se nchid ntre o pereche de
paranteze, ca mai jos:
Fig.6.22. Elementele unui tuplu
Prima declaraie creeaz un tuplu numit tuplu care conine elementele 1,2,3,4,5. A
doua declaraie afieaz elementele tuplului.
S vedem acuma cum o bucla for itereaz peste elementele unui tuplu:
76
Fig. 6.23. Bucla for n tupluri
De fapt, tuplurile suport aceleai operaii ca listele cu excepia celor care schimb
coninutul. Tuplurile suport urmtoarele operaii:
-
Subscrierea indecsilor
Metode ca index
Functii preconstruite: len, min i max
Operaii de feliere (slicing)
Operatorul in
Operatorii + si *
Tuplurile nu suport metode ca append, remove, insert, reverse sau sort.

Cnd vrei s creezi un tuplu cu un singur element, acel element trebuie urmat neaprat
de virgul:
Fig. 6.24. Tuplu cu un singur element
Motivul pentru care tuplurile exist este acela c tuplurile sunt mai rapide ca listele.
Aceasta nseamn c tuplurile sunt o bun alegere atunci cnd se proceseaz date
foarte multe care nu urmeaz a fi modificate. Un alt motiv este acela c tuplurile sunt
sigure. Pentru c nu li se pot modifica elementele, nimeni nu poate s le manipuleze
accidental.
Exist dou functii care pot converti tuplurile n liste i invers. Acestea sunt: list( ) i
tuple( ) :
77
Fig. 6.25. Lista tuplu
6.3. Dicionare
Un dicionar e un obiect care stocheaz o colecie de date. Fiecare element
dintr-un dicionar are dou pri: o cheie i o valoare. Folosim cheia ca s localizm
valoarea.
ntr-un dicionar clasic ca de exemplu DEX, cheia este cuvntul pe care-l
cutm n dicionar ca s aflm ce semnificaie are. Spre exemplu, s lum cuvntul
enoria . Conform DEX el nseamn (are valoarea) persoan credincioas care
ine de o parohie.
Deci cheia este enoria iar valoarea este persoan credincioas care ine de o
parohie.
sau:
enoria = persoan credincioas care ine de o parohie
Un alt exemplu este cartea de telefon n care cheia este numele persoanei pe al crui
numr de telefon dorim s-l aflam iar numrul de telefon este valoarea.
Perechea cheie-valoare mai este referit i de expresia cartografiere.
S crem un dicionar:
carte_telefon = {Mircea : 072256666, Gigel : 0766666111, Minel :
0744234567}
Observm c la crearea dicionarului carte_telefon folosim o pereche de acolade n
interiorul crora introducem cheia care este numele persoanei i numrul de
telefon care este valoarea. Elementele dicionarului sunt fiecare cuprinse ntre
ghilimele iar perechile sunt desprite de virgule. Mai observm c fiecare pereche i
refer elementele prin semnul dou puncte (:).
Primul element al dicionarului este Mircea : 072256666;
Al doilea element este: Gigel : 0766666111;
Al treilea element este: Minel : 0744234567.

78
n acest exemplu cheile i valorile sunt iruri. Totui, elementele unui dicionar pot fi
de orice tip numai c spre deosebire de liste, cheile sunt imutabile. Cheile pot fi
iruri, ntregi, n virgul mobila sau tupluri. Cheile nu pot fi nsa liste (am nvat deja
c listele au elemente mutabile).
Extragerea unei valori din dicionar
Trebuie s reinem amnuntul c elementele dintr-un dicionar nu sunt stocate
ntr-o ordine anume. Aceasta nseamn c dicionarele nu sunt secvene ordonate de
date precum listele, tuplurile sau irurile. Prin urmare nu putem folosi indexuri
numerice ca s extragem valori. n loc de asta putem folosi cheile valorilor, nu ns
nainte de a pune naintea lor numele dicionarului (n cazul de fa carte_telefon):
Fig. 6.26. Extragerea unei valori
n momentul n care solicitm o cheie care nu exist n cartea de telefon, va aprea o

eroare Traceback (KeyError):
Fig. 6.27. KeyError
Folosirea operatorilor in i not in pentru testarea unei valori dintr-un

dicionar
Ca s prevenim eroarea de mai sus putem folosi operatorul in dintr-o declaratie if ca
s vedem dac o cheie exist n dicionar:
Fig. 6.28. Prevenirea apariiei KeyError
Declaraia if determin dac cheia Costel este n dicionarul carte_telefon. Dac

79
este, i va afia valoarea (numrul de telefon).

Putem de asemenea s folosim operatorul not in ca s determinm dac o cheie exist
ntr-un dicionar:
Fig. 6.29. Folosirea operatorului not in
S reinem c irurile care se compar cu ajutorul lui in i not in sunt case sensitive.
Adugarea unor elemente dicionarului
Dicionarele sunt obiecte mutabile. Putem s le adugam noi perechi de elemente cu o
declaraie de urmtoarea form:
nume_dictionar[cheie] = valoare
Fig. 6.30. Adugarea elementelor dicionarului
Dup cum se observ, n cartea noastr de telefon l-am adaugat pe Dorel.

Trebuie s mai reinem c ntr-un dicionar nu putem avea valori duplicat. Cnd
atribuim o valoarea unei chei existente, aceasta i va lua locul celei vechi.
tergerea elementelor dintr-un dicionar
Forma generala este:
del nume_dictionar[cheie]
Ex:
Fig. 6.31. tergerea elementelor unui dicionar
80
Dac privim atent exemplul de mai sus observm c atunci cnd cheia pe care dorim
s-o excludem nu exist n dicionar apare o eroare numit KeyError. In cazul de mai
sus e vorba de cheia Cornelia care nu exist n dicionar.
Aflarea numerelor de elemente dintr-un dicionar
Pentru aceasta folosim funcia len:
Fig. 6.32. Folosirea funciei len()
Amestecarea tipurilor de date ntr-un dicionar

Cheile unui dicionar sunt imutabile nsa ele pot fi de orice tip: liste, ntregi, numere
n virgula mobil, tupluri.
Exemplele urmtoare ilustreaz toate acestea:
Fig. 6.33. Date de tipuri diferite intr-un dicionar
sau:
Fig. 6.34. Ibidem
Dicionar gol
Un dicionar gol se creeaz printr-o simpl declaraie de forma general:
>>>dictionar = { }
sau n cazul nostru
>>>carte_telefon = { }
Dup aceea putem s-i adugm elemente:

81
>>>carte_telefon[Ion] = 0245345789
>>>carte_telefon[Costel] = 0743123098
>>>carte_telefon[Florina] = 0250445566
Pentru crearea unui dicionar gol se mai poate folosi i funcia preconstruit dict( ).
Ex:
carte_telefon = dict( )
Folosirea buclei for pentru iterarea peste elementele unui dicionar
Fig.6.35. Folosirea buclei for pentru afiarea elementelor dicionarului
Metode ale dicionarelor

Obiectele unui dicionar au cteva metode cu care se pot manipula datele:
clear cur coninutul unui dictionar
get ia valoarea asociat unei chei specifice. Dac cheia nu este gsit, metoda nu
ridic o excepie. n loc de asta, returneaz valoarea implicit.
items - returneaz toate cheile dintr-un dicionar i valorile lor asociate ca pe o
secven de tupluri
keys returneaz toate cheile ca pe o secven de tupluri
pop returneaz valorile asociate cu o cheie specific i le terge (perechile
cheie/valoare) din dicionar. Dac cheia nu e gsit returneaz valoarea implicit.
popitem returneaz o pereche ntmpltoare de cheie/valorare ca pe un tuplu i o
terge din dicionar
values returneaz toate valorile din dicionar ca pe o secven de tupluri.
S le lum pe rnd.
Metoda clear
Metoda clear terge toate elementele unui dicionar, lsndu-l gol.
Formatul general al acestei metode este:
82
dictionary.clear( )
Ex:
Fig. 6.36. Metoda clear
Metoda get
Forma general este:
dictionar.get(cheie, default)
n care dictionar e numele dicionarului, cheie este cheia pe care o cutm n dicionar
iar default este valoarea default pe care o returneaz declaraia n cazul n care cheia
nu e gsit (n cazul de mai jos Valoarea n-a fost gasita).
Ex.:
Fig. 6.37. Metoda get
Metoda items
Aceast metod returneaz toate cheile dicionarului i valorile asociate lor. Ea
returneaz valorile ntr-un tip special de secven numit vedere. Fiecare element din
dicionar este un tuplu i fiecare tuplu conine o cheie cu valoarea ei asociat.
Ex:
Fig. 6.38. Metoda items
Metoda keys
Aceast metod retuneaz toate cheile dicionarului.
Ex:
83
Fig. 6.39. Metoda keys
Metoda pop
Metoda pop returneaz valorile asociate cu o cheie specific i terge acele valori. n
cazul n care nu gsete perechea solicitat cheie/valoare, afieaz valoarea default.
Ex.:
Fig. 6.40. Metoda pop
Metoda popitem
Metoda popitem returneaz o pereche ntmpltoare de chei/valori i terge acea
pereche din dicionar.
Ex.:
Fig. 6.41. Metoda popitem
Metoda values
Aceast metod returneaz toate valorile dicionarului (fr cheiele lor) ca pe un
dicionar.
Ex.:
Fig. 6.42. Metoda values
84
6.4. Seturi
Un set este un obiect care stocheaz o colecie de date. Un set are cteva
caracteristici:
-
Toate elementele setului sunt unice, adic doua elemente nu pot avea aceeai
valoare
Seturile sunt structuri neordonate, ceea ce nseamn c elementele lui pot sta n
orice ordine
Elementele setului pot fi de diferite tipuri.
Pentru a crea un set, invocm functia preconstruita set:

setul_meu = set()
Aici aveam de-a face cu un set gol de elemente. Ca s-i adugm elemente, i le trecem
drept argumente ale functiei set():
setul_meu = set([a, b, c])
sau
setul_meu = set(abc)
Fig. 6.43. Crearea unui set
Dac scriem ns
setul_meu = set(a, b, c)
vom avea o eroare:
Fig. 6.44. Eroare
Aflarea numrului elementelor unui set se face prin intermediul funciei len:
setul_meu = set([1,2,3,4,5])
len(setul_meu)
85
Fig.6.45. Aflarea numrului elementelor unui set
Pentru adugarea de elemente setului se utilizeaz metoda add (legat cu punct,

desigur):
Fig. 6.46. Metoda add
Se poate folosi i metoda update:
Fig. 6.47. Metoda update
Tipurile de date introduse pot fi diferite ca mai jos:
Fig. 6.48. Date diferite
Pentru tergerea elementelor unui set se pot folosi metodele remove sau discard.
Itemul pe care-l vrem ters din set l trecem drept argument al uneia dintre aceste
metode. Spre exemplu, mai jos renunm la elementul 2 al setului
Fig.6.49. Metoda remove
Sau discard:
Fig. 6.50. Metoda discard (am renunat la litera a)
Ca sa iterm peste elementele unui set putem s folosim bucla for:
86
Fig. 6.51. Bucla for utilizat n seturi
Uniunea doua seturi contine elementele celor doua seturi si se realizeaza cu metoda
union:
Fig.. 6.52. Uniunea a dou seturi
6.5. Serializarea obiectelor (pickling)

Serializarea unui obiect este procesul de convertire a obiectului ntr-un numr
de bii care pot fi salvai ntr-un fiier ce poate fi accesat oricnd dup aceea. n
Python, serializarea obiectelor se numete pickling5.
Librria standard a limbajului Python pune la dispoziie un modul numit pickle care
este ntrebuinat la serializarea obiectelor.
Dup ce este importat modului pickle, facem urmtorii pai
-
Deschidem un fiier pentru scrierea binar
Invocm metoda dump a modulul pickle cu care scriem n fiierul dat
nchidem fisierul
Acuma, ca s scriem n modul binar un fiier trebuie s folosim modul wb (write

binary) atunci cnd chemm funcia open:
outputfile = open(datele_mele.dat, wb)
Odat ce am deschis fiierul pentru scrierea binar, invocm funcia dump a
modulului pickle:
pickle.dump(obiect, fiier)
unde obiect este o variabil care refer obiectul pe care vrem s-l serializm i

5 to pickle = a mura, a biui, a decapa, a afuma
87
fiier este o variabil care face referin la obiectul fiier. Dup ce funcia este
executat obiectul referit de obiectul fiier este serializat i scris n fiier. Trebuie spus
c se poate folosi modulul pickle pentru orice fel de obiecte: liste, tupluri, dicionare,
seturi, iruri, ntregi i numere n virgul mobil.
ntr-un fiier putem salva oricte obiecte serializate dorim. Cnd am terminat invocm
metoda close pentru nchiderea fiierului.
S lum exemplul urmtor dintr-o sesiune interactiv:
Fig. 6.53. Modulul Pickle si serializarea unui obiect
Ce se ntmpl mai sus?

Prima dat importm modulul pickle. Apoi, crem dicionarul carte_telefon cu
numele drept chei i numerele de telefon ca valori. Mai departe, deschidem fiierul
carte_telefon.dat pentru scriere binar. Urmtoarea linie de program invoc
funcia dump a modulului pickle care serializeaz dicionarul carte_telefon i l scrie
n fiierul carte_telefon.dat. Ultima linie nchide fiierul carte_telefon.dat.
Poate c la un moment dat avem nevoie s desfacem (unpickle) acel obiect. Pentru
aceasta trebuie s facem urmtorii pai:
-
Deschidem fiierul pentru citire binar
Invocm funcia load din modulul pickle ca s recuperm un obiect din fiier
Dup aceasta nchidem fisierul
Ca s citim fiierul utilizm modul rb:
Fig. 6.54. Citirea binar a fiierului
Ce se ntmpl? n prima linie importm modulul pickle. n linia a doua deschidem

fiierul carte_telefon.dat pentru citire binar. Apoi invocm funcia load din
modulul pickle ca s desfacem (unpickle) un obiect din fiierul carte_telefon.dat.
88
Rezultatul l atribuim variabilei ct (de la carte de telefon, voi putei s-i spunei cum
vrei).
Apoi afim cu comanda ct coninutul crii de telefon. Ultima linie de cod nchide
fiierul carte_telefon.dat.
Capitolul VII Clase i obiecte. Programarea orientat pe obiect

Dup cum i spune i numele, programarea orientat pe obiect este centrat pe
obiect. Obiectele sunt create din date abstracte ncapsulate i care funcioneaz
mpreun.
ntr-un program procedural, itemii de date sunt trecui de la o procedur la alta.
Separarea datelor i codului care opereaz datele poate rezolva problemele dar astfel
un program devine din ce n ce mai mare i mai complex.
S presupunem c faci parte dintr-o echip de programatori care scrie un program
ntins de baze de date. Programul este iniial proiectat astfel nct numele, adresa i
numrul de telefon sunt referite de trei variabile. Sarcina ta este s proiectezi cteva
funcii care accept cele trei variabile ca argument i s realizezi operaii cu ele.
Software-ul funcioneaz cu succes o perioad, dar echipa ta este rugat la un moment
dat s updateze soft-ul adugndu-i cteva noi componente. n timpul procesului de
revizuire, programatorul ef i spune c numele, adresa i numrul de telefon nu mai
sunt stocate n variabilele tiute. n loc de asta, ele urmeaz s fie stocate n liste. Asta
nseamn c trebuie s modifici toate funciile pe care le-ai scris, astfel nct s
funcioneze cu liste n locul celor trei variabile. Fcnd aceast modificare major, nu
numai c vei avea enorm de munc, ci deschizi oportunitatea ideal pentru apariia
erorilor.
n timp ce programarea procedural este centrat pe crearea de proceduri (funcii),
programarea orientat pe obiect (OOP) este centrat pe crearea de obiecte.
Definiii
Un obiect este o entitate software care conine date i proceduri. Datele
coninute ntr-un obiect sunt cunoscute drept atributele datelor obiectului. Atributele
datelor obiect sunt variabile simple care refer date.
89
Procedurile prin care un obiect performeaz sunt cunoscute ca metode. Metoda unui
obiect este funcia care realizeaz operaii prin intermediul datelor obiectului.
Conceptual, obiectul este o unitate autoconinut care const n atributele datelor i
metodele ce le opereaz. OOP realizeaz separarea codului i datelor cu ajutorul
encapsulrii i ascunderii datelor.
ncapsularea se refer la combinarea datelor i codului ntr-un singur obiect.
Ascunderea datelor se refer la abilitatea unui obiect de a ascunde atributele datelor
de codul aflat n afara obiectului. Doar metodele obiectului pot accesa direct i pot
face schimbri asupra atributelor datelor obiectului.
De obicei, un obiect ascunde datele dar permite codului exterior s-i acceseze
metodele. Cum vom vedea mai trziu, metodele obiectului ofer declaraii din afara
obiectului cu acces indirect asupra atributelor datelor.
OBIECT
Date
--//- --//-- --//-- --//-- --//--

METODE
Cod din
afara
obiectului
Fig. 7.1. Modelarea obiectelor
Cnd atributele datelor obiectului sunt ascunse codului extern i accesul atributelor
datelor este restricionat de metodele obiectului, atributele sunt protejate de ntreruperi
sau defeciuni accidentale. n plus, codul din afara obiectului nu trebuie s tie nimic
despre structura i formatul intern al datelor obiectului. Codul are nevoie s
interacioneze doar cu metodele obiectului. Acesta este motivul pentru care datele din
obiect rmn neschimbate.
Un exemplu din viaa de zi cu zi de obiect este ceasul cu alarm pe care ns s ni-l
imaginm ca pe un obiect software. El are urmtoarele atribute:
secunda_curenta (o valoare cuprins ntre 0 i 59)
minut_curent ( -- // --)
ora_curenta (o valoare cuprins ntre 0 i 12)

90
timp_alarma (o or i un minut valide)
setare_alarma (True sau False)
Dup cum se poate vedea, atributele datelor sunt valori care definesc starea atunci
cnd alarma ceasului e fixat. Tu, utilizatorul obiectului ceas cu alarm nu poi
manipula direct aceste date pentru c ele sunt private. Ca s schimbi valoarea datelor
atribut trebuie s foloseti una din metodele obiectului.
Iat mai jos cteva din metodele obiectului ceas cu alarm:
-
setare_timp
setare_timp_alarma
setare_alarma_on
setare_alarma_off
Fiecare metod manipulez unul sau mai multe atribute ale datelor. De exemplu,
setare_timp i permite s fixezi timpul alarmei ceasului. Activezi metoda prin
apsarea butonului din capul ceasului. Folosind alt buton (cheia) poi activa metoda
setare_timp_alarma. n plus, un alt buton i permite s execui metodele
setare_alarma_on i setare_alarma_off.
Trebuie s ii minte c aceste metode sunt activate de tine din afara ceasului cu
alarm. Metodele care pot fi accesate de entiti din afara obiectului sunt cunoscute ca
metode publice.
Ceasul cu alarm are de asemenea metode private care sunt pri private ale
obiectului i care funcioneaz intern. Entitile exterioare (ca tine, de exemplu), nu au
acces direct la metodele interne ale ceasului cu alarm. Obiectul este proiectat s
execute aceste metode automat i s ascund detaliile de tine.
Metodele private ale obiectului ceas cu alarm sunt:
-
incrementare_secunda_curenta
incrementare_minut_curent
incrementare_ora_curenta
sunet_alarma
Metoda incrementare_secunda_curenta este executat n fiecare secund. Aceasta

schimb valoarea atributului datei secunda_curenta. Daca atributul datei
secunda_curenta este setat la 59 cnd metoda este executat, metoda este programat
s reseteze valoarea secunda_curenta la 0 i face ca valoarea lui
incrementare_minut_curent s creasc, adic aceast metod este executat.
91
Metoda incrementare_minunt_curent adaug 1 la atributul minunt_curent, mai

putin cnd e setat la 59. n acest caz el reseteaz minunt_curent la 0 i duce la
execuia metodei incrementare_ora_curenta. Metoda incrementare_minut_curent
compar noul timp cu setare_alarma. Dac cele doua coincid i alarma este pornit,
metoda sunet_alarma este executat.
7.1. Clase
O clas este un cod care specific atributele datelor i metodele pentru un tip
particular de obiect.
nainte ca un obiect s fie creat, el trebuie s fie proiectat de un programator.
Programatorul determin atributele i metodele necesare i apoi creaz o clas. S ne
gndim la o clasa ca la un ablon dup care obiectele sunt creeate. ablonul servete
acelai scop ca acela folosit la proiectarea unei case. ablonul n sine nu este o cas
dar el descrie n detaliu o cas. Cnd folosim un ablon ca s construim o cas putem
spune c construim o instan a casei descrise de ablon. Dac vrem, putem s
construim oricte case (identice) dorim dup ablon. Fiecare cas este o instan
separat a casei descrise de ablon.
Programatorii au mai imaginat i o alt asemnare pentru a descrie mai bine
diferenele dintre clase i obiect. Spre exemplu o form de prajitur i prjitura n
sine. Sau, daca m gndesc la gogoile pe care le fcea bunica mea cu paharul, atunci
gura paharului descria o gogoa dar nu era o gogoa la rndul ei. Forma de prajitur
este deci folosit s faci prjituri. S ne gndim la o clas ca la un ablon, o form de
prjituri sau gura unui pahar iar la obiectele create cu ele ca la case, prjituri sau
gogoi.
Deci o clas descrie caracteristicile unui obiect. Cnd un program ruleaz el poate
folosi o clas ca s creeze n memorie oricte obiecte dorete. Fiecare obiect care este
creat de o clas se cheam instana clasei.
De exemplu, Anda este entomolog dar se ocup i cu scrierea de programe de
calculator. Ea proiecteaz un program care s catalogheze diversele tipuri de insecte.
Ca parte a programului, Anda creeaz o clas numit Insecte care are caracteristicile
comune oricror insecte.
Clasa Insecte specific obiectele ce pot fi create din ea. Apoi, Anda scrie declaraiile
de program care creeaz un obiect numit musca care este o instan a clasei Insecte.
92
Obiectul musca este o enitate care ocup un loc n memoria computerului i

stocheaz date despre musc. El are atributele i metodele specific clasei Insecte.
Apoi ea scrie o declaraie care creeaz un obiect numit tantar. Obiectul nar este de
asemenea o instan a clasei Insecte. El are propriul loc n memorie i stocheaz
date despre nar. Altfel, obiectele musca i tantar sunt dou entiti separate n
memoria computerului, ambele create din clasa Insecte. Asta nseamn c fiecare
dintre cele doua obiecte are atributele i metodele descrise de clasa Insecte.
Clasa
Insecte
Obiectul
musc
Obiectul
nar
7.2.Crearea claselor n Python

Nu trebuie s scriem prea mult cod ca s ne dm seama c Python este un limbaj
foarte curat. Cnd vrem s facem ceva, facem pur i simplu, fr a urma prea muli
pai. Omniprezentul hello world n Python, este dup cum tim, afiat cu o singur
linie de cod.
n mod similar, cea mai simpl clas n Python 3 arat cam aa:
class MyFirstClass:
pass
Acesta este primul nostru program obiect orientat! Definiia clasei ncepe cu cuvntul
cheie class. El este urmat de un nume (la alegerea noastr) care identific clasa
(numele clasei) i apoi de semnul dou puncte. Numele clasei trebuie s urmeze
regulile standard de denumire a variabilelor. De asemenea este recomandat ca numele
s fie scris n stilul cocoas de cmil (CamelCase): s nceap cu o liter mare iar
apoi fiecare cuvnt subsecvent la fel (ex: MyFirstClass).
93
Linia de definiie a clasei este urmat de coninutul indentat al clasei. Ca i ali

constructori din Python, indentarea este folosit ca s delimiteze clasele n locul
acoladelor din alte limbaje de programare bazate pe C.
Pentru c prima noastr clas nu face practic nimic, folosim cuvntul cheie pass ca s
artm c nu urmeaz nicio aciune (ca la poker). Ne putem gndi c nu sunt prea
multe de fcut cu o clas de baz, dar ea permite s instaniezi obiecte dup acea
clas. Putem s ncrcm clasa n interpretorul Python 3 ca s ne jucm cu ea
interactiv. Ca s facem asta, salvam definiia clasei de mai devreme ntr-un fiier
numit first_class.py i apoi rulm comanda:
$ python i first_class.py.
Argumentul i i spune lui Python s ruleze codul i apoi s-l arunce interpretorului
interactiv. Urmtoarea sesiune n interpretor demonstreaz interaciunea de baz cu o
clas:
>>> a = MyFirstClass()
>>> b = MyFirstClass()
>>> print(a)
< __main__.MyFirstClass object at 0xb7b7faec>
>>> print(b)
< __main__.MyFirstClass object at 0xb7b7fbac>
>>>
Explicaii
Codul de mai sus instaniaz dou obiecte ale clasei MyFirstClass, obiecte numite a i
b. Crearea instanei unei clase nseamn de fapt scrierea numelui clasei urmat de o
pereche de paranteze. Ea arat aproape la fel ca invocarea unei funcii normale, numai
c Python tie c invoc o clas i nu o funcie, deci nelege c sarcina lui e s creeze
un obiect nou. Cnd sunt afiate, cele dou obiecte ne spun despre ce clas e vorba i
care e adresa de memorie unde ele slluiesc. Adresele de memorie nu sunt prea mult
folosite n Python, dar n exemplul anterior ele demonstreaz c sunt implicate dou
obiecte distincte.
94
7.3.Adugarea atributelor
n exemplul nostru avem deci o clas de baz dar total inutil. Ea nu conine nicio
dat i mai ales, nu face nimic. Ce se ntmpl daca dm un atribut unui obiect dat?
Putem s setm un atribut arbitrar unui obiect instaniat folosind notaia cu punct (dot
notation):
class Point:
pass
p1 = Point()
p2 = Point()
p1.x = 5
p1.y = 4
p2.x = 3
p2.y = 6
print(p1.x, p1.y)
print(p2.x, p2.y)
Dac rulm acest cod, cele dou declaraii de afiare de la sfrit, ne dau noile valori
ale atributelor celor doua obiecte:
54
36
Ce face totui acest cod? El creeaz o clas goal numit Point care nu are date i nici
comportamente. Apoi, el creeaz dou instane ale clasei i atribuie fiecreia
coordonatele x i y care identific un punct bidimensional. Tot ceea ce avem de
fcut este s atribuim o valoare atributului obiectului folosind sintaxa general:
<obiect>.<atribut> = <valoare>
Aceasta este uneori denumit notaia cu punct (dot notation). Valoarea poate fi orice:
o primitiv Python, a data preconstruit etc. Poate fi chiar o funcie sau un alt obiect!

95
7.4.Sa punem clasa la treaba

Acuma, s avem obiecte cu atribute este un lucru mare, dar OOP este chiar despre
interaciunea obiectelor ntre ele. Suntem interesai aadar s invocm aciuni care fac
ca lucrul acesta s se ntmple. Este timpul deci s adugm comportamente claselor
noastre.
S concepem modelul unor aciuni ale clasei Point. Putem ncepe cu o metod numit
reset care mut punctul la origine (originea este punctul unde valoarea lui x i y este
egal cu zero). Aceasta este o bun introducere pentru c ea necesit orice parametru:
class Point:
def reset(self):
self.x = 0
self.y = 0
p = Point()
p.reset()
print(p.x, p.y)
Declaraia print ne afieaz cele dou zerouri ale atributelor (0 0) ca n sesiunea
interactiv de mai jos:
Fig.7.2. Iesire program
O metod n Python este identic cu definirea unei funcii. Ea ncepe cu cuvntul

cheie def urmat de un spaiu i de numele metodei. Aceasta e urmat de o pereche de
paranteze care conin parametrul self (vorbim imediat despre el) i se termin cu
dou puncte. Urmtoarea linie este indentat i conine declaraiile din interiorul
metodei. Aceste declaraii pot fi cod Python arbitrar care opereaz asupra obiectelor
nsi precum i orice parametru trecut metodei.
96
7.5.Argumentul self
Singura diferen dintre metode i funciile normale este aceea c fiecare metod
necesit un argument. Acest argument este convenional numit self.
Argumentul self dintr-o metod este o simpla referin la un obiect a crui metoda a
fost invocat. Putem accesa atribute i metode ale acelui obiect. Aceasta este exact
ceea ce facem nuntrul metodei reset atunci cnd setm atributele x i y obiectului
self.
S notm c atunci cnd invocm metoda p.reset(), nu trebuie s trecem argumentul
self n ea. Python are automat grij s fac acest lucru pentru noi. El tie cnd
invocm o metod a obiectului p, deci el trece automat acel obiect metodei.
Oricum, o metod chiar este cu adevrat doar o funcie care se ntmpl s fie ntr-o
clas.
n loc s invocm metoda pe un obiect, putem invoca funcia clasei, trecnd explicit
obiectul ca argumentul self:
p = Point()
Point.reset(p)
print(p.x, p.y)
Ieirea este aceeai ca la exemplul anterior, pentru c se petrece acelai proces.
Sa adaugam o noua metoda care permite sa muti un punct intr-o pozitie arbitrara , nu
doar la origine. Putem sa includem un alt obiect Point ca input si apoi sa returnam
distanta dintre ele:
import math
class Point:
def move(self, x, y):
self.x=x
self.y=y
def reset(self):
self.move(0, 0)
def calculeaza_distanta(self, other_point):
return math.sqrt(
97
(self.x alt_punct.x)**2 +
(self.y alt_punct.y)**2)
#cum folosim programul:
point1 = Point()
point2 = Point()
point1.reset()
point2.move(5, 0)
print(point2.calculeaza_distanta(point1))
assert (point2.calculeaza_distanta(point1) ==
point1.calculeaza_distanta(point2))
point1.move(3, 4)
7.6. Definirea unei clase o alt abordare
Ca s creezi o clas trebuie s scrii definiia ei. Definiia clasei este un set de
declaraii care definete metodele i atributele datelor obiectului.
S luam un exemplu simplu. S presupunem c scriem un program care simuleaz
ntoarcerea unei monede. Avem nevoie s repetm ntoarcerea monedei ca s
determinm de fiecare dat dac e cap sau pajur.
Folosind OOP vom scrie o clas numita Coin (moned) care descrie comportamentul
unei monede.
Iat mai jos programul (incomplet) moneda.py:
import random
#Clasa Coin simuleaza o moneda

#care poate fi intoarsa
class Coin:
#Metoda __init__ initializeaza atributele
98
# partii de sus a monedei (sideup) cu Heads
def __init__(self):
self.sideup = Heads
#Metoda toss genereaza un numar aleator

# in gama 0 si 1. Daca numarul este 0 atunci
# sideup (partea de sus) este setata pe Heads
# altfel, sideup este setata pe Tails
12
def toss(self):
13
if random.randint(0, 1) = = 0:
self.sideup = Heads
else:
14
15
16
self.sideup = Tails
17
#Metoda get_sideup returneaza o valoare

#referita de sideup
19
def get_sideup(self):
20
return self.sideup
Ce se ntmpl? n linia 1 importm modulul random, cci nu-i aa, dm cu banul,
adic urmeaz o valoarea ntmpltoare. El este necesar pentru c folosim funcia
randint inclus n modulul random ca s generm un numr aleator.
Linia 4 reprezint nceputul definiiei clasei. Ea ncepe cu cuvntul cheie class urmat
de numele clasei (care este Coin), urmat la rndul lui de dou puncte. Aceleai reguli
care se aplic la numele unei variabile, sunt valabile i aici. S notm totui c numele
clasei ncepe cu majuscul: Coin. Nu este obligatoriu dar este o convenie general
utilizat de programatori. Ea ajut s facem distincia ntre numele claselor i numele
variabilelor atunci cnd citim codul.
Clasa Coin conine trei metode:
1. metoda __init__ care apare n liniile 6 i 7
2. metoda toss care ocup liniile 12-16
99
3. metoda get_sideup din liniile 19 i 20

S privim mai atent nceputul fiecrei metode i s observm c fiecare dintre ele are
un parametru numit self:
Linia 6
def __init__ (self):
Linia 12
def __toss__ (self):
Linia 20
Parametrul self este obligatoriu n fiecare metod a unei clase. Cnd o metod este
executat ea trebuie s aib o cale ca s tie asupra crui atribut al datelor obiectului
trebuie s opereze. Aici este momentul n care parametrul self intr n rol. Cnd o
metod este invocat, Python face ca parametrul self s refere un obiect specific
asupra cruia se presupune c metoda opereaz.
S privim mai atent fiecare dintre metode. Prima metod numit __init__ este
definit n liniile 6 i 7:
def __init__ (self):
self.sideup = Heads
Majoritatea claselor n Python au o metod special numit __init__ care este
executat automat atunci cnd o instan a clasei este creat n memorie. Metoda
__init__ este mai cunoscut sub numele de metoda de inializare pentru c
iniializeaz atributele datelor obiectului. Numele metodei ncepe cu dou liniue
joase urmate de cuvntul init i apoi de nc dou liniue joase.
Imediat dup ce un obiect este creat n memorie, metoda __init__ este executat i
parametrul self este automat atribuit obiectului ce tocmai a fost creat.
Avem apoi declaraia din linia 14 care este executat:
self.sideup = Heads
Aceast declaraie atribuie irul Heads atributului sideup care aparine obiectului ce
tocmai a fost creat. Drept rezultat al metodei __init__ fiecare obiect pe care-l crem
din clasa Coin va avea un atribut sideup care e setat pe Heads.
Nota: Metoda __init__ este de obicei prima metoda nuntrul definiiei clasei.
Metoda toss apare n liniile 12 16:
100
def toss(self):
if random.randint(0, 1) = = 0:
self.sideup = Heads
else:
self.sideup = Tails
i aceast metod necesit variabila parametru self. Cnd metoda toss este invocat,
self refer automat obiectul asupra cruia metoda opereaz. Metoda toss simuleaz
ntoarcerea unei monede. Cnd metoda este invocat, declaraia if cheam funcia
random.randint ca s dea un ntreg situat ntre 0 i 1. Dac numrul este 0 atunci
declaraia urmtoare atribuie Heads lui self.sideup. Altfel, declaraia atribuie
Tails lui self.sideup.
Metoda get_sideup apare n liniile 19 i 20:
return self.sideup
nc odat, metoda necesit parametrul self. Aceast metod returneaz valoarea lui
self.sideup. Chemm aceast metod ori de cte ori vrem s tim care fa a
monedei este n sus.
Programul ntreg moneda.py n IDLE:
101
i rezultatul:
Fig. 7.3. Rezultatul programului moneda.py
Clasa BankAccount
Programul urmtor ne arat clasa BankAccount stocat ntr-un modul numit
bankaccount. Obiectele create de aceast clas simuleaz un cont bancar, permind
s faci o balan, depozite, extrageri de bani pentru ca mai apoi s returneze balana
curent.
Fig. 7.4. bankaccount.py
S observm c metoda __init__ are doi parametric: self i bal. Parametrul bal
accept nceperea unei balane ca argument. n linia 6 parametrul bal este atribuit lui
__balance.
Metoda deposit se afl n liniile 10 i 11. Ea are doi parametri: self i amount.
Cnd metoda este invocat, suma (amount) depozitat n account (cont) este trecut n
parametrul amount. Valoarea parametrului este apoi adaugat atributului __balance

102
n linia 11.
Metoda withdraw se gsete n liniile 15 19. Aceasta are doi parametri: self i
amount. Cnd metoda este invocat, suma (amount) care este scoas din cont este
trecut n parametrul amount. Declaraia if determin dac sunt destui bani n cont ca
s poat fi fcut o extragere de bani. Daca e aa, suma este scoas din __balance n
linia 17. Altfel, dac nu sunt bani suficieni, programul afieaza un mesaj de eroare:
Eroare: fonduri insuficiente.
Ultima metod get_balance returneaz valoarea atributului __balance.
Dac rulm acest program n linia de comand, observm c nu se ntmpl nimic:
Fig.7.5. Ieire program
El este doar un modul care ns va funciona n momentul n care va fi importat n

programul care urmeaz s-l foloseasc. Acesta (account_test.py) demonstreaz cum
funcioneaza clasa BankAccount.
Foarte important! Clasa BankAccount (bankaccount.py) se import fr

terminaia .py. Ea se salveaz n acelai director/folder (n cazul meu pe Desktop) n
care salvm i programul care o folosete. Altfel, programul nu va funciona.
103
Fig. 7.6. Programul account_test.py
Ieirea programului este urmtoarea:
Fig.7.7. Ieire program account_test.py
Linia 10 creeaz o instan a clasei BankAccount i o atribuie variabilei savings. S

observm c variabila start_bal se afl nuntrul parantezelor. Aceast nseamn c
ea e trecut ca argument al metodei __init__ i va fi trecut n parametrul bal. Linia
13 ia suma pe care userul o depune i o atribuie variabilei pay. n linia 15 metoda
104
savings.deposit este invocat, trecnd variabila pay ca argument. n metoda deposit

variabila pay va fi trecut n parametrul amount.
Declaraiile din liniile 18 i 19 afieaz balana contului. Ele afieaz valoarea
returnat de metoda savings.get_balance.
Declaraia din linia 22 ia suma pe care userul vrea s-o extrag din cont i o atribuie
variabilei cash. n linia 24 este invocat metoda withdraw creia i este trecut
variabila cash drept argument. n metoda withdraw ea va fi trecut n parametrul
amount. Ultimele declaraii (liniile 27, 28) afieaz balana final.
7.7. Mostenirea (Inheritance) in Python
Daca ai avut rbdarea s parcurgei aceast carte pn aici, sunt sigur c v-ai
ntrebat la ce folosete totui cunoaterea unui limbaj de programare. Ai ntlnit doar
programe scrise ntr-un editor de text sau n IDLE, rulate n interpretorul Python sau
n command promt (Windows) ori Terminal (MacOS sau Linux). Pn acuma nu ai
ntlnit un ecran prietenos cu o interfa grafic deosebit care s aib n spate noianul
de linii de cod scrise in Python. i totui (i) acest limbaj de programare are
posibilitatea s creeze interfee grafice interesante (Graphical User Interface sau
GUI). M-am gandit totui s nu abordez aici acest subiect complex.
Scriu cu sinceritatea c am stat mult s m gndesc dac s ptrund i n
complicata lume a programrii orientat pe obiect din programarea n Python. Nu tiu
dac din acest ultim capitol ai neles foarte multe, prin urmare m-am gndit ca n
rndurile urmtoare s ncerc s dau un exemplu de aplicaie foarte interesant scris
n Python, care are o excelent parte grafic (realizat ce-i drept cu ajutorul
Javascript) dar care evideniaz n opinia mea noiunea de motenire n Python. Este
vorba despre OpenERP, o aplicaie modular din surs deschis de management al
unei afaceri ce implic extrem de multe posibiliti i utilizat din ce n ce mai mult de
companiile interesate.
OpenERP se poate descrca de pe site-ul www.openerp.com i instala n mediile
Windows (uor) i Linux (Debian-Ubuntu, ceva mai greu dar nu foarte). Eu am
ncercat s-o instalez i pe Macintosh, ns dup lupte seculare care au durat vreo
dou zile, m-am dat btut
105
OpenERP vine cu o serie de module standard preinstalate dar neactivate. Printr-un

singur click ns ele se pot activa i apoi utiliza. Ceea ce ns este interesant e faptul
c modulele se pot ajusta, se pot customiza, dup dorina clientului. Poate c de
exemplu unul dintre beneficiarii OpenERP vrea ca modulul CRM s conin mai
multe (sau mai puine) informaii despre clienii lui din baza de date. Poate c ei vor
ca partenerii de afaceri s nu aib adresa sau numarul de telefon fix care s apar n
rapoartele (chitane, facuri, etc) pe care programul le tiprete. Sunt o mulime de
posibiliti sosite standard odat cu instalarea programului, dar care se pot ajusta pe
gustul utilizatorului aplicaiei. Pentru a customiza ns aplicaia vei fi nevoii s
ptrundei n miezul (core-ul) ei i aceasta reprezint deja un nivel de programare ct
de ct ridicat.
Motenirea obiectelor nseamn n esen mai puin munc pentru c vei prelua (prin
inheritance6) ceea ce alii au creat nainte i vei adapta prin mici sau mai mari
modificri la nevoile dumneavoastr.
M-am gndit n consecin c unele linii de cod din OpenERP pot fi un exemplu
excelent de cum funcioneaz motenirea obiectelor n Python.
S lum ca exemplu fiierul care creeaz o factur (fiierul printe) din aplicaia
OpenERP:
Fig.7.8. Fiier printe
Fiierul are peste 1800 de linii de cod. Acuma s lum fiierul (copil) care motenete

6
motenire
106
comportamentul clasei printe de mai sus:
Fig. 7.9. Fiier copil
Acest cod are doar ceva mai mult de 200 de linii de cod. Am reuit astfel s scpm
de scrierea a peste 1500 de linii de cod printr-o singur declaraie pe care o vedei
marcat n fotografia de mai sus!
De altfel, dac suntei interesat de aplicaia OpenERP, putei gsi pe Internet destul
(nu ndeajuns totui...) material bibliografic.
Motenirea obiectelor n OpenERP funcioneaz astfel:
Obiectele pot fi motenite n module specifice customizate. Este mai bine s
moteneti un obiect adugnd/modificnd unele campuri.
Aceasta se face astfel:
inherit=object.name
7.8. Extensia unui obiect
Exist dou posibiliti ca s faci o astfel de motenire. Ambele au ca rezultat o nou
clas de date, care pstreaz cmpurile i comportamentul clasei printe la fel de bine
ca i cmpurile adiionale, dar ele difer dramatic din punct de vedere al programrii.
n vreme ce Exemplul 1 creeaz o nou subclas custom_material care poate fi
vzut sau folosit de oricine, nu la fel se ntmpl cu Exemplul 2.
107
Exemplul 1 (motenirea clasei)

class custom_material(osv.osv):
_name = network.material
_inherit = network.material
_columns = {
manuf_waranty : fields.boolean(Manufacturer warranty?),
}
_defaults = {
manuf_warranty : lambda *a: False,
}
custom_material()
S notm c _name i _inherit sunt unul i acelai lucru, adic network.material.
n exemplul de mai sus custom.material adaug un nou cmp numit
manuf_waranty obiectului network.material. Noua instan a clasei va fi
vizibil de view i tree care opereaz asupra tabelului superclasei
network.material.
Aceast motenire este numit deobicei motenirea clasei (class inheritance) n
OOP. Copilul motenete datele (fields) i comportamentul (functions) printelui.
Exemplul 2 (motenirea prin prototip)
class other_material(osv.osv):
_name = other.material
_inherit = network.material
_columns = {
manuf_warranty : fields.boolean(Manufacturer warranty?),
}
_defaults = {
manuf_warranty : lambda *a : False,
}
other_material()
S notam c de acest dat, _name i _inherit sunt diferite.
n Exemplul 2 other_material ine toate cmpurile specificate de

108
network.material i mai ine n plus un nou cmp numit manuf_warranty.

Toate aceste cmpuri vor fi parte ale tabelului other.material. Noua instan a
acestei clase nu va fi vzut niciodat de views sau trees care opereaz asupra
superclasei network.material.
Acest tip de motenire este cunoscut sub numele de motenire prin prototip pentru
c nou creata subclas copiaz toate cmpurile unei superclase (prototip) specificate.
Copilul motenete datele (fields) i comportamentul (functions) printelui.
Exemplul 3 Motenirea prin delegaie - _inherits
Sintaxa este:
class tiny_object(osv.osv)
_name = tiny.object
_table = tiny.object
_inherits = {
tiny.object_a : object_a_id,
tiny.object_b : object_b_id,
,
tiny.object_n : object_n_id
}
()
Obiectul tiny.object motenete toate coloanele i toate metodele de la
tiny_object_a i pn la tiny_object_n.
Ca s moteneti de la tabele multiple, tehnica const n adugarea unei coloane n
tabelul tiny_object pe obiectul motenit. Aceast coloan va stoca o cheie strin
(un ID de la un alt tabel). Valorile object_a_id ---- object_n_id sunt de tipul
ir i determin titlul coloanelor n care cheile strine din tiny.object_a
tiny.object_n sunt stocate.
Acest mecanism este de obicei numit motenirea instanei (instance inheritance)
sau motenirea valorii (values inheritance). O resurs (instan) are valoarea
printelui ei.

109
Milioane de posibiliti...
Cum bine spunea unul dintre Prinii Fondatori ai Statelor Unite, cea mai bun
metod ca s nvei un lucru este s scrii o carte despre el. Pot spune c i eu am
procedat la fel n cazul de fa. Putei afirma c nu e prea bine ca un individ care abia
desluete tainele unui limbaj de programare s se apuce s i scrie despre el. Munca
mea la acest mic manual mi-a dovedit c nu este aa, pentru c mereu eti nevoit s
caui i s aduni informaii de prin tot felul de cri n limba engleza descrcate de pe
Internet.
Din cri se nasc alte cri i aceast maxim e valabila i n privina paginilor
de fa. Mi-au fost de un real ajutor astfel, volumele scrise de Tony Gaddis (din care
m-am inspirat foarte mult) i Paul Barry & David Griffiths. Nu-i pot lsa deoparte pe
Dusty Phillips, pe Al Sweigart, ori pe Fabien Pinkaert, creatorul OpenERP.
Motivul pentru care m-am aplecat asupra acestui subiect este plcerea de a
scrie i rula programe in Python. Motivul cu adevrat important este c n limba
romn nu exist pn acuma dup tiina mea - o carte ct de nensemnat despre
acest din ce n ce mai important limbaj modern de programare. Nu am pretenia ca
paginile mele s umple acest gol. Sunt convins c n Romnia exist destui oameni
extrem de talentai n mnuirea liniilor de cod Python cu siguran autodidaci care ar putea s-o fac mult mai bine i cu mai mult talent ca mine. Sunt ns sigur c
paginile pe care le-ai avut n fa au reuit ct de ct s v dumireasc asupra unui
minunat dar puin cunoscut pe aceste meleaguri limbaj de programare.
Daca v-am trezit curiozitatea, v stau la dispoziie pe Internet o droaie de cri,
forumuri de discuii sau tutoriale dintre cele mai simple ori mai complexe. Dai doar
un search pe motorul de cautare preferat i n fa vi se vor deschide milioane de
posibiliti...
110
Bibliografie
1. Barry, Paul, Griffiths, David, Head First Programming,
OReilly Media, Sebastopol, CA, 2009
2. Barry, Paul, Head First Python, OReilly Media,
Sebastopol, CA, 2011
3. Gaddis, Tony, Starting out with Python (second
edition), Pearson Education, Boston,2012
4. Harrington, Andrew, Hands-On Python. A tutorial
introduction for beginners (Python 3.1. version),
creativecommons.org
5. Phillips, David, Python3 Object Oriented
Programming, Packt Publishing, London, 2010
6. Pinckaers Fabien, Van Vossel, Els, Streamline your
Menufacturing Processes with OpenERP, Open Object
Press, 2012
7. Swaroop, CH, A byte of Python (second edition)
8. Sweigart, Al, Invent Your Own Computer Games With
Python (second edition), Creative Commons Licence
111

De Ce Sa Te Apuci de Programare

Î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

De Ce Sa Te Apuci de Programare

Încărcat de

Drepturi de autor:

Formate disponibile

Cuprins

Capitolul VII Clase i obiecte. Programarea orientat pe obiect .................... 89

Cu ce limbaj ar trebui s ncep?

Vezi site-ul Tiobe.com (http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html)

Capitolul I Instalarea Python 3. Noiuni fundamentale

Ca s rulezi un program Python n modul script (vom vedea imediat ce nseamn

1. n Terminal scrii: open ~/.bash_profile . Aceast comand i va

Fig.1.1. Hello World! n Python shell

Pentru scrierea primului (i urmtoarelor) programe n Python trebuie s deschidei

Fig.2 Interpretorul Python

1.2. Noiuni fundamentale

Fig.3 Programul scris n Notepad

Fig.4 Rularea programului popescu.py n linia de comand

Intrri, procesare, ieiri, funcia print

iruri i iruri literale

Foto1.2. Eroare de sintax la ghilimele

#Acest program afiseaza

Ieirea (output-ul) acestui program este:

sau s conin caractere speciale precum $#%^&* .a.m.d.

#aici avem o variabila int (ntreg)

float (reale sau n virgul mobil) (numere zecimale)

Citirea intrrilor de la tastatur

Citirea numerelor cu funcia input

(int) i unul n virgul mobil (float):

ia preul original al unui item

calculeaz 20% din preul original; acesta este discountul

scade discountul din preul original; acesta e preul de vnzare

i acuma s vedem programul (sale_price.py):

Ridicarea la putere a unei valori se scrie aa:

nuntrul unui ir literal.

Fig.1.4. Valoare neformatat

Cum facem totui ca rezultatul s nu mai apar ca un ir urt de numere? Simplu!

Specificatorul de format (format specifier) este un ir care conine caractere speciale

Fig.1.5. Valoare formatat cu specificatorul de format

Formatarea n mod tiinific

Fig.1.6. Specificare limii de spaiu

Formatarea unui numr n virgul mobil ca procent

NU poi specifica precizia

Nu poi folosi cuvintele cheie din Python

Nu pot exista spaii ntre cuvintele care alctuiesc numele funciei

Primul caracter trebuie s fie o liter de la a la z, de la A la Z sau underscore ( _ )

Literele mici sunt tratate diferit de cele mari

Iat cum invocm funcia mesaj:

#Prima data definim o functie numita mesaj

print(si incerc sa invat Python.)

#Chemam functia mesaj

Cum funcioneaz? Interpretorul ignor comentariile. Apoi citete declaraia def n

Fig. 2.1 Ilustrarea unei funcii n Python shell

Fig.2.2 Eroare de indentare

Indentarea n Python este obligatorie i se face pentru ca blocurile de cod din

#Defineste functia gorj. Ea creeaza

Fig. 2.3 Trecerea unui argument la funcie

Trecerea ntr-o funcie a mai multor argumente

#Cheama functia principala

Capitolul III STRUCTURI DE DECIZIE

trebuie indentat mai departe. Dac clauza if a fost indentat ( fa de main() ) cu un

Fig.3.1 Blocuri de declaraii indentate

3.2 Declaraia if-else

print(E cam frig!)

fii sigur c if i else sunt aliniate

fii sigur c declaraiile care urmeaz dupa if i else sunt indentate.

3.4 Variabile booleene

Fig. 3.2 Bucla while

Bucla while nu se execut niciodat dac condiia de nceput e fals.