You are on page 1of 134

Cum s programezi n Python

(Manual n limba romn)

Mircea Prodan
- 2014 -

Cuprins
Cuprins ........................................................................................................................................................... 2
De ce s te apuci de programare? ......................................................................................................... 4
Cu ce limbaj ar trebui s ncep? ......................................................................................................................... 5
De ce Python? .......................................................................................................................................................... 8
Capitolul I Instalarea Python 3. Noiuni fundamentale .............................................................. 10
Instalarea Python3 n Windows ..................................................................................................................... 10
1.1. Primul program ............................................................................................................................................................ 12
1.2. Noiuni fundamentale ............................................................................................................................................... 14
1.3. Variabile .......................................................................................................................................................................... 18
1.4. Puin matematic ...................................................................................................................................................... 26
1.5. Spargerea declaraiilor lungi n linii multiple ............................................................................................. 28
1.6. Specificarea unui item separator .......................................................................................................................... 28
1.7. Concatenarea - afiarea mai multor itemi cu operatorul + ....................................................................... 29
1.8. Formatarea numerelor (Important!!!) ............................................................................................................... 29
1.9. Formatarea ntregilor ................................................................................................................................................ 33
1.10. Formatarea irurilor ............................................................................................................................................... 33
Capitolul II FUNCII .............................................................................................................................. 35
2.1. Definirea i invocarea unei funcii ....................................................................................................................... 35
2.2. Invocarea unei funcii ................................................................................................................................................ 36
2.3. Indentarea (Important!!!) ........................................................................................................................................ 37
2.4. Variabile locale ............................................................................................................................................................. 37
2.5. Constante i variabile globale ................................................................................................................................ 40
2.6. Funcia lambda ............................................................................................................................................................. 41
Capitolul III STRUCTURI DE DECIZIE ................................................................................................ 43
3.1. Declaraia if ................................................................................................................................................................. 43
3.2. Operatori de comparatie .......................................................................................................................................... 44
3.3. Declaraia if-else .......................................................................................................................................................... 44
3.4. Operatori logici ............................................................................................................................................................. 46
3.5. Variabile booleene ...................................................................................................................................................... 47
3.6.Bucle ................................................................................................................................................................................... 47
3.7. Bucla while o bucl controlat ........................................................................................................................... 47
3.8. Bucla infinit ................................................................................................................................................................. 49
3.9. Bucla for .......................................................................................................................................................................... 49
3.10. Acumulatori ................................................................................................................................................................ 52
3.11. Operatori de atribuire augmentat ................................................................................................................... 53
3.12. Bucle de validare a intrrilor ............................................................................................................................... 53
3.13. Bucle imbricate .......................................................................................................................................................... 55
Capitolul IV Module ................................................................................................................................ 56
4.1.Biblioteci de funcii standard i declaraia import ........................................................................................ 56
4.2. Generarea numerelor aleatoare ............................................................................................................................ 56
4.3. Funciile randrange, random i uniform ........................................................................................................... 58
4.4. Scrierea propriei funcii care returneaz o valoare ..................................................................................... 59
4.5. Modularea cu funcii .................................................................................................................................................. 60
4.6. Modulul matematic ..................................................................................................................................................... 61
Capitolul V Fiiere i excepii ........................................................................................................ 64
5.1.Tipuri de fiiere ............................................................................................................................................................. 64
5.2. Metode de acces a fiierelor ................................................................................................................................... 65
5.3. Deschiderea unui fiier n Python ........................................................................................................................ 65

5.4. Scrierea datelor ntr-un fiier ................................................................................................................................ 66


5.5. Citirea datelor dintr-un fiier ................................................................................................................................. 68
5.6. Adugarea datelor ntr-un fiier existent ......................................................................................................... 70
5.7. Scrierea i citirea datelor numerice .................................................................................................................... 70
5.8. Copierea unui fisier .................................................................................................................................................... 71
5.9. Fiiere binare ................................................................................................................................................................ 72
5.10. Excepii .......................................................................................................................................................................... 73

Capitolul VI Liste, tupluri, dicionare i seturi. Serializarea obiectelor (pickling) ......... 76


6.1. Liste ................................................................................................................................................................................... 76
6.2. Metode i funcii preconstruite pentru liste .................................................................................................... 84
Metoda append ..................................................................................................................................................................... 84
6.3. Tupluri ............................................................................................................................................................................. 89
6.4. Dicionare ....................................................................................................................................................................... 90
6.5. Metode ale dicionarelor .......................................................................................................................................... 95
6.6. Seturi ................................................................................................................................................................................. 98
6.7. Serializarea obiectelor (pickling) ...................................................................................................................... 100
Capitolul VII Clase i obiecte. Programarea orientat pe obiect ........................................... 103
7.1. Definiii ......................................................................................................................................................................... 103
7.2. Clase ............................................................................................................................................................................... 106
7.3. Crearea claselor n Python ................................................................................................................................... 108
7.4. Adugarea atributelor ............................................................................................................................................ 109
7.5. S punem clasa la treab ........................................................................................................................................ 110
7.6. Argumentul self ......................................................................................................................................................... 111
7.7. Definirea unei clase o alt abordare ............................................................................................................. 112
7.8. Motenirea (Inheritance) n Python ................................................................................................................. 117
Cap. VIII Crearea si manipularea formularelor web ................................................................ 123
8.1. Drepturi de acces la fiiere ................................................................................................................................... 131
Milioane de posibiliti... ..................................................................................................................... 133
Bibliografie .............................................................................................................................................. 134

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 email-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 desluesc tainele 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

1

Asta desigur e valabil pentru un anumit nivel (mai lipsit de pretenii) n programare.

programele date n carte n propriul editor de text (nu descrcai codul aferent crii de pe
site-ul editurilor pentru ca v va fi lene sa-l rescriei), analizai-le i apoi procedai la
rezolvarea exerciiilor. Numai aa nvei!
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 scriu 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 site-uri, 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 pentru un incepator.
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

2

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

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 se
ndreapt spre 50 de ani3 i nu d semne c va pieri n curnd. C++ are i el peste trei
decenii4 i la fel, e n plin putere, chiar dac a mai sczut n preferinele
programatorilor.
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 geekDup unele voci de mare ncredere5, 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 Google6) nu e chiar uor.
Marele noroc (astzi!) 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, desigur dac ti s ntrebi.
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

3 1972
4 1980
5

http://norvig.com/romanian21-days.html
Din pcate, literatura IT n Romnia e sublim dar (aproape) lipsete cu desvrire. Se mai gsesc rtcite
prin librarii vestigii din anii 90 sau nceputul ori mijlocul anilor 2000, total depite astzi.
6

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 adesea
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 Linux-ul 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 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 acesteia. De aici rezult
importana fundamental a limbii engleze n nvarea limbajelor de programare. Totui,
nu vreau s v sperii. Nu trebuie s stpnii engleza la nivel oxbridge, ns un bagaj minim
de cuvinte este absolut necesar s-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 n colaborare cu mediul academic), care dateaz nc ht, din timpul celui De-al
Doilea Rzboi Mondial. 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 Google7, 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 american (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 trei ani, bine-neles dac st cu brnca pe carte. Nu acelai lucru se poate afirma
despre C++
Altfel dect PHP un alt limbaj relativ uor de asimilat, 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,

Van Rossum a plecat ntre timp la Dropbox, dup apte ani petrecui n ograda Google.

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 i/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
mndru 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 rspndite) 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 nefericire, 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 notabil8 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 n Windows
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:\Python329 (nu uita de semnul
punct i virgul (;) scris naintea datelor!)

ntre timp i Django cel mai folosit i cunoscut web framework Python, a migrat complet spre Python3 ori
Mezzanine
9 python32 e varianta mea. La voi ar putea fi python33 sau python34 (varianta din momentul scrierii crii)
8

10


7. Ok
8. Restartezi computerul

Dupa repornire, deschizi o nou fereastr Command Prompt (DOS) 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 tastnd cheile Windows+R i scriind n csu cmd,
dup care 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).

11

De obicei OS X Snow Leopard, Lion, Mountain Lion i Maverick au deja


preinstalate versiunile 2.6. sau 2.7. (ori mai vechi) ale Python. Dac ns ai descrcat o
variant 3.0 sau peste (de exemplu 3.2. , 3.3. sau 3.4.), 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 urmtoarele10:
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 celui mai simplu program n Java i unul n Python. n Java:
// my first program in Java


n versiunea Mac OS Maverick, acest truc nu funcioneaz, astfel c n linia de comand scriei python3 i
dai enter. Dac nu adaugai numrul 3 dupa comanda python, computerul afieaz n Terminal shell-ul
versiunii 2.7. care este preinstalat. Daca lucrati in Ubuntu Linux, in versiunea 14 Python 3 este deja
preinstalat. Scrieti in Terminal (shortcut Ctr+Alt+T) python3 si este deschis shell-ul Python.


10

12

public class HelloWorld {


public static void main(String[] args) {
System.out.println("Hello, World");
}
}

i acuma n Python:
>>> print(Hello World!)


Fig.1.1. Hello World! n Python shell

Deci ceea ce n Java se afieaz cu ajutorul a ase linii, n Python se face cu una singur!
Pentru scrierea primului (i urmtoarelor) programe n Python trebuie s deschidei
interpretorul Python astfel:
Windows -> All Programs -> Python32 -> Python (Command Line) [Enter]
Acelai lucru se face i fr invocarea interpretorului, direct din Command Prompt /
fereastra DOS (Windows) sau Terminal (Mac OS, Linux). n fapt, sfatul meu este s lucrai
doar cu acest instrument.11
Exist de asemenea i mediumuri profesionale de dezvoltare a programelor Python, cum
ar fi Eclipse, Netbeans sau Pycharm (exclusiv pentru Python). Cu toate c primele dou
sunt dedicate programrii n Java, ele admit instalarea de add-on-uri suplimentare pentru
crearea si testarea programelor scrise in Python. Totui, nu v sftuiesc s utilizai aceste
mediumuri complexe (cel puin nu la nceput de drum) care sunt ndeajuns de intimidante
pentru un nceptor. n plus, nici configurarea lor iniial nu e prea lesne de realizat.
S revenim ns la lucruri uoare. Astfel, o dat ce ai scris o declaraie aici (n Windows
Command Prompt sau MacOS/Linux Terminal), automat dup apsarea tastei Enter,

Totul este ns ca n Enviromnent Variables (Windows) calea de rulare ctre executabilul Python s fie
configurat corect (vezi p.11-12 instalarea Python).
11

13

intrepretorul Python o (i) afieaz pe ecran:


Fig.1.2. Interpretorul Python n MacOS Terminal

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 din program pe
calculator. Acestea sunt de fapt, n opinia mea, adevratele programe.
S afim de exemplu cu ajutorul programului urmtor, cteva informaii despre un
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, Bucuresti12)
print(Telefon: 0722 200406)


Fig.1.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, nu nainte ns de a muta calea de
rulare a programului pe desktop cu comanda cd desktop13. Altfel, interpretorul Python
nu gsete fisierul (n cazul meu popescu.py) i va genera o eroare ct se poate de enervant.

Putei la fel de bine s scriei Bucureti (cu diacritice). Nu va rezulta nicio eroare pentru c Python foloseste
pentru decodificare standardul UTF-8 i nu ASCII.
13 Comanda cd desktop nu este case sensitive (nu ine cont dac scriei desktop sau Desktop) n Windows i
MacOS dar e case sensitive n Linux. Astfel, dac lucrai pe un computer cu sistemul de operare Ubuntu
instalat (nu tiu la celelalte distribuii Linux), comanda este neaprat cd Desktop, cu majuscul.
12

14

Poate v ntrebai de ce insist pe aceste aspecte care aparent nu par importante.


Dimpotriv, ele sunt foarte importante, mai ales la nceput, cnd tii doar s deschizi
calculatorul dar esti plin de dorina de a nva programare! Atunci cnd m-am apucat s
deprind tainele programrii, m loveam mereu i mi venea s arunc computerul pe
fereastr de aceste amnunte care apar exact la nceput de drum!


Fig.1.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 computerul le
primete de la utilizator. 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 argumentul14 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.

Parametrul este definit de numele care apare n definiia funciei, n vreme ce argumentul reprezint
variabila trecut unei funcii atunci cnd este invocat. Parametrul definete tipul de argument(e) pe care o
funcie l poate accepta.
14

15

Prin urmare, putem afirma c print este cea mai important funcie. Recapitulnd, cu
ajutorul ei afim ieirea unui program n Python. ncercai n shell-ul Python urmtoarea
linie de cod:

>>> print(Hello world!)


Hello world!
>>>


iruri i iruri literale
Ex: Vasile Popescu
46, N.Iorga
Bucuresti, 0722200406
Acestea sunt iruri de date care se mai cheam 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:


Fig.1.5. Eroare de sintax la punerea ghilimelor

Cteva cuvinte n plus trebuiesc adugate despre ghilimelele triple (pe care nu le vei gsi
n Java, C++, C ori PHP) dar care au o semnificaie aparte n Python. Muli folosesc
ghilimelele triple pe post de comentarii, ceea ce este eronat. n Python comentariile sunt
(doar liniile de cod marcate) cu semnul diez (#) la nceput (citii paragraful urmtor).
De exemplu #acesta este un comentariu.

16

Ghilimelele triple sunt tratate ca iruri regulate15 cu excepia cazului n care este vorba de
mai multe linii. Totui, ele nu sunt ignorate de interpretorul Python aa cum se ntmpl cu
comentariile care ncep cu semnul diez (#). Ele sunt aezate imediat dup definiia unei
funcii sau clase, ori n vrful codului unui modul, caz n care se numesc docstrings.
Docstring-urile pot include n interiorul lor ghilimele simple, duble sau de ambele feluri
ca-n exemplul de mai jos:


Fig.1.6. Utilizare ghilimele triple

S vedem acuma ce se ntmpl daca scriem doar ghilimele_triple (fr funcia print) i
dm enter:


Fig.1.7. Un ir ciudat de caractere apare la finalul procesrii programului

Rspunsul este uor nefiresc pentru c el ne arat codificarea intim n Python folosind
caracterul escape (\).

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 #.

irurile regulate sunt irurile care nu sunt atribuite unei variabile.

15

17



Ex:


#Acest program afiseaza
#numele unei persoane
print(Mircea Prodan)

1.3. Variabile
Programarea nseamn nainte de toate a jongla cu abstraciuni. A lucra cu astfel de entiti
ce nu sunt palpabile cel puin nu n faza lor de dezvoltare, este n opinia mea cel mai
dificil lucru pentru c n general, marea noastr majoritate avem o putere destul de limitat
de a imagina obiecte pipibile dar care au drept fundament idei incolore, inodore i
mai cu seam fr o form anume. Din acest motiv ni se pare grea matematica...
Variabilele sunt printre cele mai importante elemente din programare i nu m feresc s
afirm c dac ele i manipularea lor este bine neleas, ai fcut un mare pas nainte n
dobndirea unui limbaj de programare.
Totui, spre deosebire de lumea programrii orientat pe obiect (OOP), nelegerea
variabilelor este mulumitor de uoar. Tot ceea ce trebuie s facei este s v gndii la o
variabil ca la o cutie n care depozitai ceva.
Permitei-mi s-o lum altfel. S presupunem c ai terminat recent facultatea, ai redactat
licena care v-a fost aprobat de profesorul ndrumtor i apoi, aa cum cere
regulamentul, trebuie s-o punei (s-o depozitai) pe un CD ce urmeaz s stea la arhiva
universitii multe decenii de atunci ncolo, dar i s predai un exemplar tiprit. Lucrarea
dumneavoastr de licen nu import domeniul este pe calculatorul personal sub forma
unui fiier Microsoft Word16 i deci ea este abstracta. Putei s-o inei n mna? Nu, eventual
putei s-o artai cu degetul pe monitorul computerului! n momentul n care o printai i
legai, ea i pierde aceast calitate i devine un obiect n sine, ct se poate de palpabil, cu
care eventual v putei luda la familie i prieteni. Mergei apoi la facultate i depunei un
exemplar printat. Ea este nregistrat i depozitat ntr-o ncpere a facultii. Hopa! Iat c
dintr-o dat avem variabila care este ncperea i valoarea ei care este lucrarea de licen. Pe

Ar putea la fel de bine s fie o aplicatie de redactare din surs deschis n genul OpenOffice ori LibreOffice,
numai c universitile romneti accept doar fiiere Microsoft Word.
16

18

msur ce ali i ali (poteniali) absolveni i depun lucrrile, numrul (valoarea) lor crete
dar ncperea (variabila17) rmne aceeai.
Mutndu-ne oarecum n lumea computerelor, avei acuma nevoie i de CD-ul care s
conin lucrarea n format digital. Prin urmare ardei un CD nou nou, depozitnd pe/n
el lucrarea n format digital. Aici variabila este CD-ul cruia i-am atribuit valoarea lucrare
de licen. Exemplul meu poate nu este cel mai fericit pentru c un CD obinuit se poate
inscripiona doar o singur data, ceea ce ar nsemna c o dat atribuit o valoare variabilei,
aceasta nu se mai poate modifica. n programare acest fapt nu este adevrat (din acest
motiv se numete variabil). Totui, exist CD-uri care se pot inscripiona de mai multe
ori, radiind informaiile (valorile) de la un moment dat i nlocuindu-le cu altele. Numele
variabilei (n cazul nostru CD) rmne acelai, doar valoarea pe care i-o atribuim (licena) se
schimb.
O variabil este un nume (cuvnt) care reprezint o valoare stocat n memoria
calculatorului. Numele (variabila) se scrie ntotdeauna n partea stng:
age = 49

#Corect! Vrsta mea la data scrierii #primei

variante a lucrrii

i nu

49 = age

#Gresit!!

age = 52

#Corect!Vrsta mea la data scrierii #variantei

actuale

i nu

52 = age

#Gresit!!

Semnul = nu nseamna egal ca n matematic ci reprezint atribuirea.


n exemplul de mai sus :
(lui) age = (i-am atribuit valoarea) 49 respectiv 52.
Cnd treci o variabil ca argument al funciei print nu mai ai nevoie de ghilimele.

Ex:


De fapt numele ei...

17

19


print( )

argument




>>>latime = 10

funcia print

(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: )
print(camera)
Ieirea (output-ul) acestui program este:
Stau in camera:
123
Sa vedem in linia de comanda (Terminal) cum putem face economie de spaiu i efort prin
renunarea la ultima declaraie print:


Fig.1.8. Variabila ir


Ce s-ar fi ntmplat dac n prima varianta a exemplului anterior, n ultima declaraie
print am fi cuprins ntre ghilimele parametrul camera ca mai jos? Pi n loc s ne afieze
valoarea parametrului care este 123, ne-ar fi printat cuvntul (irul literal) camera:

20


Fig. 1.9. Importana ghilimelelor18 la afiarea rezultatelor

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)19

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 nu este totuna cu Python..
Numele variabilelor nu au voie s conin cuvintele cheie din Python20. 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 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

Se pot folosi ghilimele simple sau duble, rezultatul este acelai.
ncercai acest exemplu pe calculatorul dumneavoastr, dar s cuprind dou declaraii print i nu patru.
20 ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while',
'with', 'yield']
18
19

21

camera = 123
print(Stau in camera numarul , camera)
Ieirea este: Stau in camera 123
Dac privii cu atenie, vei observa ca propoziiei i lipsete ceva esenial (ca s
ndeplineasc normele gramaticale de definire a propoziiei) i anume punctul de la sfrit.
Haidei s vedem cum l afim. (ncercai s figurai rspunsul fr s citii paragraful de
mai jos).
Dac l punem imediat dup ultimul parametru al funciei print (camera) va rezulta o
eroare de sintax. Pentru a nu primi o eroare, punctul trebuie la rndul lui cuprins ntre
ghilimele ca n exemplul de mai jos:


Fig1.10. Afiarea corect a unei declaraii

S mai observm (n linia 4) c dac nu adugm un item separator21 (ca-n finalul liniei 5),
punctul este aezat uor anormal, la o distan destul de mare de locul n care ar trebui s
fie. n output-ul din linia 6 aceast mic inadverten (corect totui din punct de vedere al
programrii, nu ns i estetic) este eliminat.

Stocarea irurilor cu tipul de date str
#Creeaza o variabila care refera doua siruri
prenume = Vasile
nume = Popescu
#Afiseaza valorile referite de variabile
print(prenume, nume)
La ieire vom avea: Vasile Popescu

Am luat-o puin nainte, dar vei vedea foarte curnd ce reprezint un item separator.

21

22

La fel de bine putem s inversm numele dac ultima declaraie ar arta astfel:
print(nume, prenume)
iar la ieire ar rezulta Popescu Vasile.

Tipuri de date. Reatribuirea variabilelor diferitelor tipuri
n Python exist cteva tipuri principale de date:
1. int - ntregi
2. float - n virgul mobil22
3. string (str) - iruri
4. boolean True, False
Ca s aflm cu ce fel de date lucrm utilizm funcia type() ca n exemplele de mai jos:


Fig.1.11. Folosirea funciei type() pentru aflarea tipurilor de date

Ce se ntmpl ns dac unui intreg i adugm zero la sfrit? Pentru noi el rmne un
ntreg, nu ns i pentru calculator. Astfel, el devine un numr n virgul mobil (float):


Fig.1.12. Transformarea int n float


n Python, o variabil poate s refere orice tip de date: ntreg, ir, n virgul mobil (float),
boolean. Dup ce o variabil a fost atribuit unui anumit tip, ea poate fi reatribuit altui tip
de date.

Acestea nu sunt totuna cu numerele zecimale

22

23

Ex:
>>> x = 99

[enter] #aici avem o variabila int (ntreg)

>>> print(x) [enter]


99
dar i :
>>> x = Sa mergem la masa (enter) #aici avem o variabil #str (ir)
>>> print(x) [enter]
Sa mergem la masa
>>>
sau float:
x = 0.15
print(x) [enter]
0.15
Putem de fapt s renunm la 0 i s lsm doar punctul urmat de valorile semnificative:


Fig.1.13. Am renunat la 0 n declararea variabilei subunitare

Se observ c rezultatul este afiat ns normal cu 0 nainte.



Obinerea inputului de la user
In programare, obtinerea informatiilor de la user este extrem de importanta. Altfel ca n
Java de exemplu, n Python acest lucru se face foarte uor cu ajutorul funciei input().
Prompterul care clipete n fereastra DOS sau n Terminal este de fapt un ir care invit
userul s introduc date de la tastatur.
Ex.:
name = input (Care este numele tau? )

variabil

aici este un spaiu!!


tastatur

datele ir

24

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
prenume = input(Introdu prenumele: )
#Ia numele de familie
nume = input(Introdu numele de familie: )
#Afiseaza numele userului
print (Salut, prenume, nume)23

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 (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)

Reproducei toate aceste exemple ncet i atent pe computerul dumneavostr. Nu le copiai ca s vedei
cum i dac funcioneaz!! Programarea nseamn dou lucruri eseniale: pasiune i rbdare...
23

25

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)24.
int i float funcioneaz doar dac itemul ce urmeaz s fie introdus conine o valoarea
numeric. Altfel, va aprea o eroare numit excepie.

1.4. Puin matematic


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.


Fig.1.14. mprirea cu ntreg, restul i ridicarea la putere

S notm c la ridicarea la putere, primul numar (n exemplul de mai sus 10) este cel
multiplicat la puterea dat de cel de-al doilea numr (3 n cazul nostru).

Ex. salariu.py
#Atribuie o valoare variabilei salariu
salariu = 2500.0

Cei care au programat n Java sau C tiu c acolo e obligatoriu s declari tipul variabilei. De fapt, acelai
lucru se petrece i n Python, dar doar n cazul datelor cu valoare numeric.
24

26

#Atribuie o valoarea bonusului


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 (pret_vanzare.py):
#Acest program ia pretul original si
#calculeaza un discount de 20%.
#Ia pretul original
pret_original = float(input(Introdu pretul original: ))
#Calculeaza valoarea discountului
discount = pret_original * 0.2
#Calculeaza pretul de vanzare
pret_vanzare = pret_original discount
#Afiseaza pretul de vanzare
print(Pretul de vanzare este: , pret_vanzare)

Precedena operatorilor matematici
1. Ridicarea la putere se execut prima (**)
2. nmulirea, mpartirea i restul (* / // %) al doilea
3. Adunarea i scderea ultimele

27

Ridicarea la putere a unei valori se scrie aa:


Ex: suprafata_patrat = lungimea**2
n care **2 este ridicarea la puterea a doua
sau
volum_cub = 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.

1.5. 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)
Atunci cnd se sparge o declaraie considerat prea lung, indentarea (vom vedea puin
mai trziu ce nseamn acest lucru) este obligatorie.

1.6. 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)

[enter]

Unu Doi Trei


>>>
Dac le vrei mpreunate, treci argumentul sep= funciei print la sfarsitul declaratiei:
>>> print(Unu, Doi, Trei, sep= ) #[enter]
UnuDoiTrei

28

>>>


Fig.1.15. Inserarea itemului separator

Caracterul escape
Caracterul escape este unul special care e ilustrat de un backslash (\) ce apare 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 line)25.

1.7. Concatenarea - afiarea mai multor itemi cu operatorul +


Cnd operatorul + se folosete la adunarea irurilor se cheam concatenare (legare).
Ex.
print (Acesta este26 + un sir.)
care afieaz:
Acesta este un sir.

1.8. 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

ncercai pe calculatorul personal s nlocuii \n cu \t i vedei ce rezult. (Indiciu: litera t vine de la tab)
Nu uitai c ntre ultimul cuvnt din primul enun i ultima ghilimea care ncadreaz acelai enun este un
spaiu. Daca nu e marcat corespunzator, ultimul cuvnt din primul enun i primul din cel de-al doilea vor fi
afiate lipite.
25
26

29

#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.16. Valoare neformatat

Cum facem totui ca rezultatul s nu mai apar ca o iniruire grosiera de numere? Simplu:
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 ci d).
n aceste condiii, funcia format returneaz un ir care conine numrul formatat:

>>> print(format(12345.6789, .2f)) #[Enter]
12345.68

30

S notm c numrul este rotunjit la dou zecimale, in sus27.


Acuma, s lum acelai exemplu, dar rotunjit la o singur zecimal:
>>> print(format(12345.6789, .1f)) [Enter]
12345.7
Sa lum un alt exemplu n fereastra interactiv:


Fig.1.17. 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))
1.23e + 04
>>>

Inserarea separatorului virgul
>>> print(format(123456789.456, ,.2f)
123,456,789.46

separatorul virgul28


Programul urmtor demonstreaz cum separatorul virgul i o precizie de dou zecimale
pot fi folosite la formatarea unui numr mare:
(plata_anuala.py)

Pentru c a doua valoare din irul de numere de dup punct - n spe 7 (.6789) este mai aproape de 10

27

dect de 0, computerul rotunjete valoarea n sus, ea devenind .68. Dac ar fi fost n schimb .64..., .63..., .62...,
.61... atunci era rotunjit n jos, ea devenind 0.60.
28 ntre separatorul virgul i punctul situat naintea lui (.2f) nu exista spaiu. Dac este introdus din greeal
va rezulta o eroare (Invalid format specifier).

31

#Acest program demonstreaza formatarea


#numerelor mari
plata_lunara = 5000.0
plata_anuala = plata_lunara * 12
print(Plata ta anuala este $,\
format(plata_anuala, ,.2f), \
sep=)
Ieirea programului este:
Plata ta anuala este $60,000.00
Sa vedem cum funcioneaz programul n Terminal:


Fig.1.18. Rularea programul plata_anuala.py n shell-ul Python

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.19. Specificare limii de spaiu


Formatarea unui numr n virgul mobil ca procent
Aici n loc s folosim litera f folosim simbolul procentului ( %) ca s formatm un numr ca

32

procent:
>>> print(format(0.5, %))
50.000%
i nc un exemplu care are 0 ca precizie:
>>> print(format(0.5, .0%))
50%

1.9. 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

1.10. Formatarea irurilor


Formatarea sirurilor e puin mai complicat i se face cu ajutorul acoladelor ca n exemplul
urmtor:


Fig.1.20. Exemplu de formatare a irurilor

irurile i alte obiecte au o sintax special pentru funcii numit metod, asociat unui tip
particular de obiect. Obiectele de tipul ir (str) au o metod numita format. Sintaxa pentru
aceast metod conine obiectul urmat de punct urmat de numele metodei i urmtorii
parametri dintre paranteze:

33

obiect.nume_metoda(parametri)
n exemplul de mai sus obiectul este irul Salut {} iar metoda este format.
Parametrul este nume.
Dup cum se observ la ieire, acoladele sunt nlocuite de valoarea preluat din lista
parametrilor metodei format. Deoarece acoladele au un neles special n formatarea
irurilor, este nevoie de o regul special dac vrem ca ele s fie incluse n formatarea
final a irurilor. Regula este dublarea acoladelor: {{ i }}

De exemplu29:


Fig. 1.21. Formatarea irurilor


Vom vedea mai trziu ce reprezint un set in Python.

29

34

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
divizate 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 declaraii, scriem cteva funcii mai mici, fiecare
realiznd o parte specific din sarcin.
Aceste mici funcii pot fi executate n ordinea dorit pentru ca n final s realizeze soluia
la ntreaga problem.

2.1. Definirea i invocarea unei funcii


Definirea unei functii se face cu ajutorul cuvantului def (define). Codul unei funcii este
(i) definiia unei funcii. Ca s execui o funcie, scrii pur si simplu declaraia care o
invoc (numele funciei) urmat de paranteze ().
Numele funciilor
Numele unei funcii e bine 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 (case sensitive).

Pentru c funciile realizeaz aciuni, e indicat s folosim verbe atunci cnd le alegem
numele.
De exemplu, o funcie care calculeaz venitul poate fi denumit pur i simplu
calculeaza_venitul. Unii programatori folosesc pentru notarea funciilor metoda
numit cocoa de camil (camelCase). Dac am folosi-o n exemplul nostru, atunci ea ar

35

arta aa: calculeazaVenitul.


Formatul general este:
def nume_functie() :
declaratie
declaratie

Ex:
def mesaj():
print(Sunt Gigel,)
print(si incerc sa invat Python!)
Codul de mai sus definete o funcie numit mesaj. Functia mesaj conine un bloc cu dou
declaraii.

2.2. 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).
Iat cum invocm funcia mesaj din exemplul anterior:
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:
(functie_demo.py)
#Acest program defineste o functie

#Prima data definim o functie numita mesaj

def mesaj():

print(Sunt Mircea,)
print(si incerc sa invat

4
Python.)

#Apoi invocam functia mesaj

mesaj()

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

36

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 s fie executat i s fie afiat ieirea.

Fig. 2.1. Ilustrarea unei funcii n Python shell

2.3. 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 o dat patru spaii , altdat tabul sau
trei, cinci ori n spaii, programul va da eroare de 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 a programului. Indentarea ine de
fapt locul acoladelor din celelalte limbaje de programare din familia limbajului C. Ea ne
arata unde ncepe i se termin un bloc de declaraii. Totodat ine loc si de semnul punct
i virgula cu care se sfresc obligatoriu declaraiile din limbajele de programare din
familia C.

2.4. 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,

37


creezi o variabil local.
S luam un exemplu de program (pasari.py)30 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)
#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:

Scriei exemplele n editorul de text caracter cu caracter i nu le copiai (copy/paste) de pe formatul PDF n
care se gsete cartea pentru c exist mari anse s primii o eroare de tipul: SyntaxError: invalid character
in identifier. Aceasta se ntmpl pentru c formatele PDF, Word, ODT etc au caracteristici intime diferite,
care cel mai adesea, nu se potrivesc interpretorului Python ce pur i simplu nu distinge ceea ce scrie n
declaraii.
30

38

def dublul(numar):
rezultat = numar*2
print(rezultat)
Funcia se cheama dublul. Ea accept un numr (numar) ca parametru i afieaz
valoarea dublat a acelui numr. Sa vedem cum functioneaza in interpretorul Python:


Fig.2.3. Exemplul anterior complet

Exemplu de program (show_double.py):


#Acest program demonstreaza cum un
#argument este trecut unei functii
def main():
valoare=5
arata_dublul(valoare)
#Functia arata_dublul accepta un argument
#si afiseaza valoarea lui dubla
def arata_dublul(numar):
rezultat = numar*2
print(rezultat)
#Cheama functia principala
main()


Fig. 2.4. Trecerea unui argument la funcie

39


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)
arata_suma(12, 45)
def arata_suma(num1, num2):
rezultat = num1 + num2
print(rezultat)
#Cheama functia principala
main()
S vedem exemplul n interpretor:

Fig.2.5. Exemplul de mai sus n Python shell

Schimbarea parametrilor
def main():
valoare = 99
print(Valoarea este, valoare)
def schimba_valoarea(arg):
print(Voi schimba valoarea.)
arg = 0
print(Acuma valoarea este, arg)
#Cheama functia principala
main()

2.5. Constante i variabile globale


O variabil global este accesibil tuturor funciilor dintr-un program. Ea se creeaz n
afara oricrei funcii.

40

Ex:
#Creeaza o variabila globala
numar = 0
def main():
global numar
numar = int(input(Introdu un numar ))
arata_numar()
def arata_numar():
print(Numarul introdus este: , numar)
main()
Este totui indicat s nu folosii variabile globale. n schimb putei s utilizai constante globale.
O constant global refer o valoare care NU POATE FI SCHIMBAT.
Prin convenie, constantele globale se scriu cu majuscule i sunt aezate la nceputul
programului, naintea oricror alte declaraii, ca n exemplul urmtor:


Fig.2.6. Ilustrarea unei constate globale

2.6. Funcia lambda


Python permite crearea unei funcii anonime folosind cuvntul cheie lambda. O funcie
anonim poate s conin doar o singur expresie care neaprat trebuie s returneze o
valoare. Altfel ca la crearea unei funcii comune care folosete def, o funcie creat cu
lambda returneaz un obiect funcie. Acesta poate fi atribuit unei variabile care poate fi
folosit n orice moment ca s execute expresia coninut. S vedem cum arat n Terminal
o funcie normal, aceeai funcie creat cu ajutorul cuvntului cheie lambda i o funcie
lambda cruia nu-i atribuim nicio variabil (da, permite i acest lucru!).

41


Fig.2.7. Funcia lambda

42

Capitolul III STRUCTURI DE DECIZIE


Una dintre cele mai importante, interesante i frumoase pri ale programrii este oferit
de structurile de decizie. Toi cei care au fcut programare n coal sau facultate chiar
dac nu au fost deloc interesai de domeniu, le-a ajuns la ureche fie i total pasager cuvinte
precum if, while, else, continue. Dac ai terminat un liceu cu profil real, nu se
poate s nu v fi lovit de ele. Oricum ar fi, chiar dac pn acuma nu tiai de existena lor,
a venit momentul s ne ocupm de ele.

3.1. Declaraia if
De cele mai multe ori ntr-un program ajungi la o rspntie, mai corect spus, n faa unei
alegeri. S ne imaginm c mergem pe o osea cu autoturismul personal i la un moment
dat ajungem la o bifurcaie. S zicem de exemplu c ne deplasm de la Craiova ctre
Bucureti i am ajuns la Gneasa, Olt. Aici drumul se bifurc: drumul spre dreapta duce la
Bucureti via Piteti, drumul la stnga duce ctre Rmnicu Vlcea, via Drgani.
S vedem cum arat drumul direct spre Bucureti transpus n Python cu ajutorul
condiiei if (daca):
if (daca) laDreapta:

#o iau la dreapta

print(Ajung la Bucuresti prin Pitesti)


Dar poate c vrem s mergem la Rmnicu Vlcea. Programul nostru ar arta astfel n
aceast variant:
if(daca) laStanga:

#o iau la stanga

print(Ajung la Ramnicu Valcea prin Dragasani)


Forma general:
if conditie:

declaratie

declaratie

etc

43

Ex:
vanzari = float(input(Introdu vanzarile tale: ))
if vanzari > 5000:
print(Ai un bonus de 500 de lei)


3.2. Operatori de comparatie
Nu putem sa mergem mai departe inainte de a vedea care sunt operatorii de comparatie in
Python. Ei sunt prezentati mai jos:
Operator

Semnificaie

<

Mai mic ca

>

Mai mare ca

<=

Mai mic sau egal cu

>=

Mai mare sau egal cu

==

Egal cu

!=

Diferit de (nu este egal cu)


Tabel 3.1. Operatori de comparaie n Python

3.3. 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

44

etc

Ex:

Fig.3.1. Ilustrarea clauzei if-else

Reguli de indentare a clauzei if-else


-

fiti sigur c if i else sunt aliniate

fiti sigur c declaraiile care urmeaz dupa if i else sunt indentate la rndul lor.

Compararea irurilor
Python permite s compari iruri cu ajutorul declaraiei if-else. Acest lucru i d voie s
creezi structuri de decizie care testeaz valoarea unui ir.
Ex (testare_nume.py):
nume1 = Marcel
nume2 = Marius
if nume1 == nume2:
print(Numele sunt la fel)
else:
print(Numele sunt diferite)

Structuri de decizie imbricate31 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 (imprumut.py):
MIN_SALARIU = 2000
MIN_ANI = 3
salariu = eval32(input(Introdu salariul tau: ))
ani_la_serviciu = eval(input(Introdu ani de serviciu:))


Imbricat = mbucat(e), suprapus(e) ca indrilele de pe casa (cf.dexonline.ro)

31

32 Atunci cnd introducem date numerice putem utiliza eval fr sa ne mai gndim dac e vorba de o valoare n

virgul mobil sau de un ntreg. eval ine loc de float sau input.

45

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.., MIN_ANI)


Fig.3.2. Declaraia if-elif-else

Pentru a uura i a face economie de efort i de spaiu se poate utiliza declaraia (clauza) if-
elif-else. Mai sus este un exemplu de program ce include declaraia if-elif-else; n
momentul n care userul introduce diverse valori cuprinse ntre 500 i 1000, programul va
afia bonificaia corespunztoare. Dac ns introduce o valoare mai mic de 500,
programul afieaza irul Eti concediat!.


3.4. 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):

46


print(Aceasta e aproape temperatura maxima)

3.5. 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:
if cota_vanzari >=5000.0:
cota_vanzari_ok = True
else:
cota_vanzari_not_ok = False

3.6.Bucle
Buclele sunt acele pri dintr-un program care sunt folosite ca s execute o declaraie atta
timp ct o expresie este adevrat.

3.7. 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:

47


Fig. 3.3. Bucla while


Bucla while nu se execut niciodat dac condiia de nceput e fals.
S mai lum un exemplu de bucl while. Vom scrie un program care transform gradele
Fahrenheit n Celsius.
Formula de transformare este:
C = 5/9 * (F-32)
(temp.py)


Fig.3.4. Bucla while

Este nevoie ca la nceputul programului s setm temp = 0 pentru c altfel primim o


eroare. Programul pornete, iar bucla while caut s vad dac variabila temp nu cumva
este egala cu -100. Dac temp nu a fost setat iniial cu 0, se creeaz o problem pentru c
temp nu exist i bucla while nu tie ce s fac! n locul valorii 0 putem pune oricare alt
cifr dar nu -100. Dac facem asta, bucla while devine fals dintr-un nceput i nu ruleaz
niciodat.
O bucl while e asemntoare condiionalei if cu diferena c cea din urm funcioneaz

48

doar o singur dat iar while pn cnd condiia ei este atins (n cazul nostru temp = 100).
S lefuim puin exemplul de mai sus, astfel nct atunci cnd utilizatorul introduce
valoarea -100, computerul s-i spun La revedere!:
temp = 0
while temp != -100:
temp=eval(input(Introdu temp. in F(-100 ca sa iesi): ))
if temp != -100:
print(Temp in C este: , format(5/9*(temp-32),

,.2f))

else:
print(La revedere!)

3.8. Bucla infinit


S spunem c avem urmtorul exemplu de bucl while:
numar = 0
while numar < 10:
print(numar)
n acest program valoarea variabilei numar nu se schimb niciodat i deci declaraia
numar < 10 este ntotdeauna adevrat. Python va afia la infinit numrul 0. Ca s oprim
bucla infinit trebuie pur i simplu s ntrerupem brutal shell-ul Python. Exist ns o
posibilitate de a ntrerupe o bucl infinit atunci cnd scriem programul. Pentru aceasta
folosim declaraia break:
x = 0
numar = 1
while x < 10 and numar > 0:
numar = int(input(Introdu un numar: ))
break

3.9. Bucla for


Bucla for itereaz de un numr specific de ori.
Format general:
for variable in [value1, value2, etc] :

declaratie
49

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)
#Cheama functia principala
main()

Fig.3..5. 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):
for num in range(5):
print (num)


Fig.3.6. Bucla forin range


Ex:
#Acest program demonstreaza cum functia range
#poate fi folosita cu bucla for

50

def main():
#Afiseaza un mesaj de 5 ori
for x in range(5):
print(Ce faci Caine?!)
#Cheama functia principala
main()

Fig.3.7. 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 pn cnd este atins valoarea 5 inclusiv. S vedem ce se ntmpl
cu urmtoarea declaraie:
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.8. Demonstrarea valorii de pas

S vedem ce se ntampl dac o lum de la sfrit spre nceput iar valoarea pasului devine
negativ:

51

Fig.3.9. Inversarea secvenei

3.10. 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
S lum un program care demonstreaz un acumulator:
#Acest program calculeaza suma unei serii
#de numere introduse de user
#Ia constanta pentru numarul maxim
(Reine! Constanta se pune la nceput)

MAX = 5
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: ))

52

total = total+number
#Afiseaza totalul numerelor
print(Totalul este, total)
#Cheama functia principala
main()

3.11. 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

3.12. 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

53

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.10. 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!
Cum corectm 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 nr 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))
#Cheama functia main
main()

54

3.13. 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 secunde in range(60):
print (secunde)
sau
for minute in range(60):
for secunde in range(60):
print(minute, :, secunde)

Buclele complete ale ceasului arat aa:

for ore in range(24):
for minute in range(60):
for secunde in range(60):
print(ore, :, minute, :, secunde)

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.

55

Capitolul IV Module

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.1.Biblioteci de funcii standard i declaraia import
Am folosit deja cteva funcii standard pre-scrise n biblioteci: print, input, range,
type.
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 aceasta:
import math
Aceast declaraie face ca interpretorul s ncarce coninutul modulului math n memorie i
s-l fac disponibil.

4.2. 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. De fapt exist forme mai explicite
de a importa modulele i funciile din el:
from random import randint

56

from random import *


Pentru c funcia randint se gsete n modulul random, avem nevoie s folosim notaia cu
punct ca s ne referim la ea.
Iat mai jos cum se scrie o astfel de declaraie:

modul

random.randint

funcie

n partea stng a punctului este numele modulului (random) iar dup el numele funciei
(randint).
Deci, reine c:
1. Punctul leag modulul de funcie.
2. random este modulul.
3. randint este funcia.
Ex:
number = random.randint(1, 100)
Argumentul (1, 100) spune funciei randint s afieze un numar 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():
#Ia un numar aleator
numar = random.randint(1, 100)
#Afiseaza numarul
print(Numarul este, numar)
#Cheama functia principala
main()


Fig.4 .1. Numere aleatoare

57

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()


Fig.4.2. Ilustrarea exemplului de mai sus

4.3. 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

58

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.4. 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 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

59


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
main()

4.5. 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.

60

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 (comision.py):
#Acest program calculeaza salariul
#unei persoane de vanzari
def main():
#Ia suma vanzarilor
vanzari = ia_vanzarile()
#Ia valoarea luata in avans
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)
#Cheama functia principala
main()

4.6. Modulul matematic


Modulul math conine numeroase funcii care pot fi folosite n calcule matematice
Ex:
rezultat = math.sqrt(16)
Funcia sqrt accept argumentul 16 i i returneaz rdcina ptrat (care e 4).
Mai nti trebuie s importam modulul math pentru a scrie un program care l folosete.

61

Ex de program (radacina.py):
#Acest program demonstreaza functia sqrt
import math
def main():
#Ia un numar
numar = float(input(Introdu un numar: ))
#Ia radacina patrata a numarului
radacina_patrata = math.sqrt(numar)
#Afiseaza radacina patrata a numarului
print(Radacina patrata este, radacina_patrata)
#Cheama functia principala
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)
#Cheama functia main
main()

Valorarea math.pi
Suprafaa cercului este constanta pi nmulit cu raza cercului la ptrat, dup cum bine
tim din clasa a VII-a, de la studiul geometriei plane:
suprafata = math.pi*radius**2
Ce se ntmpl? Suprafaa cercului 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.

62

Un modul este doar un fiier care conine cod Python. Programele mari sunt (mai) uor de
reparat i ntreinut atunci cnd sunt mprite n module dar mai ales pot fi refolosite33
intr-un alt program. Un modul poart ntotdeauna extensia .py.
Modulul calendar
Sa luam de exmplu modulul implicit Python calendar. El se importa ca oricare alt modul,
asa cum am aratat mai devreme, cu declaratia import:
import calendar
Ca s afim de exemplu cum arta anul Revoluiei 1989 trebuie s ne referim la funcia
inclus n modulul calendar, prcal (printeaz calendar) folosind notaia cu punct:
calendar.prcal()
Programul urmtor afieaza anul amintit:
import calendar
an = int(input(Introdu anul dorit: ))
prcal(an)
S vedem cum funcioneaz n Python shell:


Fig.4.3. Modulul calendar


Reuse n lib.englez

33

63

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.

64

Un fiier text conine date care au fost codificate n text folosind scheme ca ASCII sau
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 sau Word.
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:

65

file_variable = open(filename, mode)

unde:
-

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

66

aprea o eroare.
S spunem c customer_file refer un fiier obiect i fiierul va fi deschis pentru 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 (presedinti.py)


#Acest program scrie trei linii de date
#intr-un fisier
def main():
#Deschide un fisier numit presedinti.txt
outfile = open(presedinti.txt, w)

#Scrie numele presedintilor Romaniei

#in fisier
outfile.write(Ion Iliescu\n)

outfile.write(Emil Constantinescu\n)

outfile.write(Traian Basescu\n)

10

#Inchide fisierul
outfile.close()

12

#Cheama functia principala


main()

Rezultatul programului este redat mai jos:


Fig.5.1 presedinti.txt

(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

67

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 numele urmtorului tenor 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 presedinti.txt
def main():
#deschidem fisierul numit presedinti.txt
infile = open(presedinti.txt, r)

#Ii citim continutul


file_contents = infile.read()

#Inchidem continutul
infile.close()
#Afisam datele citite
print(file_content)
#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 7 invoc metoda infile.read ca

68

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 (barbati.py).
#Acest program ia trei nume de la user
#Si le scrie intr-un fisier
def main():
print('Introdu numele a trei barbati.')
nume1 = input('Barbatul #1 ')
nume2 = input('Barbatul #2 ')
nume3 = input('Barbatul #3 ')
#deschide un fisier numit barbati.txt
fisier = open('barbati.txt', 'w')
#Scrie numele in fisier
fisier.write(nume1 + '\n')
fisier.write(nume2 + '\n')
fisier.write(nume3 + '\n')
#inchide fisierul
fisier.close()
print('Numele au fost scrise in barbati.txt')
main()

Sa verificam exitenta fisierului si functionalitatea lui:


Fig.5.2. Deschidere fisier

Ca sa rulam programul barbati.py trebuie neaparat sa fim in acest director. Tot aici va fi
creat si salvat fisierul barbati.txt.

69

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)
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, n schimb numerele trebuiesc convertite n
iruri nainte de a fi scrise.

70

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
outfile.write(str(num1) + \n)
outfile.write(str(num2) + \n)
outfile.write(str(num3) + \n)
#Inchide fisierul
outfile.close()
print(Date scrise in numere.txt)
#Cheama functia principala
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. Copierea unui fisier


Sa presupunem ca dorim sa facem o copie a fisierului barbati.txt care se va chema
copybarbati.txt. Pentru aceasta scriem urmatorul program (copybarbati.py):

71


Fig. 5.3. Copierea fisierului barbati.txt

Sa vedem si functionarea lui in Terminal:


Fig. 5.4. Functionare in Terminal

5.9. Fiiere binare


Urmtorul exemplu creeaz un fiier binar. Pentru aceasta folosim modul wb (binar.py):
str = 'Salutare si voiosie!'
fisier = open('fisier_binar.bin', 'wb')
fisier.write(str.encode('utf-8'))
fisier.close()
fisier = open('fisier_binar.bin', 'rb')
fisiercontinut = fisier.read()
fisier.close()
print('Continutul fisierului este:')
print(fisiercontinut.decode('utf-8'))

Programul binar.py creeaz un fiier numit fisier_binar.bin n modul write i


stocheaz n el irul Salutare si voiosie!. irul este codificat n sistemul UTF-8 nainte de
fi scris n fiier. Fiierul este apoi nchis. Ca sa confirmm c irul este stocat corect n fiier,
l deschidem cu modul read.
S vedem cum funcioneaz:

72


Fig. 5.5. Crearea unui fiier binar

5.10. 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 blocul de declaraii
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()


Fig.5.6. Eroare impartire la zero

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

73

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()


Fig.5.7. mparirea 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?).
Tabelul de mai jos arata exceptiile care pot aparea atunci cand un program este evaluat de
interpretor:
Exceptie

Descriere

AssertionError

Apare atunci cand declaratia esueaza

AttributeError

Atributul nu este gasit in obiect

EOFError

Cand se incearca citirea dincolo de sfarsitul unui


fisier

FloatingPointError

Apare cand operatia cu un numar in virgula mobila


esueaza

IOError

Cand o operatie I/O esueaza

74



IndexError


Cand se foloseste un index aflat in afara gamei
(range)

KeyError

Cand o cheie nu este gasita

OSError

Cand invocarea unui sistem de operare esueaza

OverflowError

Cand o valoarea este prea mare ca sa poata fi


reprezentata

TypeError

Cand un argument de un tip nepotrivit este furnizat

ValueError

Cand valoarea unui argument nu este potrivita

ZeroDivisionError

Cand un numar se imparte la zero ori cand al doilea


argument intr-o operatie modulo este zero
Tabel 5.1.

75

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]
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

76

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 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:


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

77

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]
0

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

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 contine cinci indecsi:


Fig.6.4. Afiarea elementelor cu ajutorul indecsilor negativi

78


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])
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

79

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:


Fig. 6.8. Program list vnzri

i acuma ieirea programului de mai sus:

80


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
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

81

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 unele elemente dintr-o secven dar nu pe toate. Atunci
foloseti felierea (slice). Ca s iei o poriune dintr-o list trebuie s scrii o declaratie 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:
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

82

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 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)

83

#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
cauta = input('Introdu numarul produsului: ')
#afla daca numarul se gaseste in lista
if cauta in prod_num:
print(cauta, 'a fost gasit in lista.')
else:
print(cauta, 'nu a fost gasit in lista.')
#cheama functia principala
main()

6.2. 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
nume_lista = [ ]
#cream o variabila de control a buclei
again = 'y'
#adaugam cateva nume listei
while again == 'y':
#luam un nume de la utilizator
nume = input('Introdu un nume: ')
#adauga numele introdus in lista
nume_list.append(nume)
#mai adauga inca un nume
print('Mai adaugi un nume? ')
again = input('y = yes, anything else = no ')

84


print()
#afiseaza numele introduse
print('Iata numele pe care le-ai introdus.')
for nume in nume_lista:
print(nume)

#cheama functia principala


main()


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. mancare.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
mancare = ['Pizza', 'Hamburg', 'Cipsuri']
#afisam lista
print(mancare)
#luam itemul pe care il vrem inlocuit
item = input('Ce item vrei sa schimbi? ')
try:
#ia indexul itemului din lista
item_index = mancare.index(item)
#ia valoarea de inlocuire
noul_item = input('Introdu noua valoare: ')
#inlocuieste vechiul item cu noul item
mancare[item_index] = noul_item
#afiseaza lista
print('Aici este noua lista.')
print(mancare)
except ValueVallor:
print('Itemul nu a fost gasit in lista.')

85

#cheama main
main()

Sa vedem cum functioneaza in Terminal:


Fig. 6.18. Functionarea in Terminal

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 )

86

Metoda remove







Fig. 6.19. Metoda remove

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.20. Metoda reverse

Declaratia del
Cu aceast declaraie tergem un element din list:


Fig. 6.21. Declaraia del

Funciile min i max


Ex:

87


Fig. 6.22. Funcia min

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():
#Cream lista
numere = [2,3,6,8,10]
#cream o variabila pe care o folosim drept acumulator
total = 0
#Calculam totalul elementelor listei
for value in numere:
total += value
#Afisam totalul elementelor listei
print(Totalul elementelor este, total)
#Invocam functia 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 variabila ca s-o folosim ca acumlator
total = 0.0

88

#Calculam totalul valorilor din lista


for value in scoruri:
total +=value
#Calculam media elementelor
media = total / len(scoruri)
#Afisam totalul elementelor listei
print(Media elementelor este, media)
#Invocam functia main
main()

Ieirea programului este: Media elementelor este 5.3.


6.3. 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 o dat creat, elementele lui nu se
pot schimba. Elementele unui tuplu se nchid ntre o pereche de paranteze, ca mai jos:


Fig. 6.23. 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:


Fig. 6.24. Bucla for n tupluri

De fapt, tuplurile suport aceleai operaii ca listele cu excepia celor care schimb
coninutul. Tuplurile suport urmtoarele operaii:

89

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.25. 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( ) :


Fig. 6.26. Conversia tuplu-lista


6.4. 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.

90

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: 07225666, Gigel : 076666111, 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.
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

91

naintea lor numele dicionarului (n cazul de fa carte_telefon):



Fig. 6.27. Extragerea unei valori dintr-un dictionar

n momentul n care solicitm o cheie care nu exist n cartea de telefon, va aprea o eroare
Traceback (KeyError):


Fig. 6.28. 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.29. Prevenirea apariiei KeyError

Declaraia if determin dac cheia Costel este n dicionarul carte_telefon. Dac 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.30. Folosirea operatorului not in

S reinem c irurile care se compar cu ajutorul lui in i not in sunt case sensitive.

92


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.31. Adugarea de elemente 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.32. tergerea elementelor dintr-un dicionar

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 numrului elementelor dintr-un dicionar
Pentru aceasta folosim funcia len:

93


Fig. 6.33. 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.34. Date de tipuri diferite intr-un dicionar


sau:


Fig. 6.35. 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:
>>>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:

94

carte_telefon = dict( )
Folosirea buclei for pentru iterarea peste elementele unui dicionar


Fig.6.36. Folosirea buclei for pentru afiarea elementelor dicionarului

6.5. 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:
dictionary.clear( )
Ex:

95


Fig. 6.37. 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 implicit 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.38. 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.39. Metoda items

Metoda keys
Aceast metod retuneaz toate cheile dicionarului.
Ex:

96


Fig. 6.40. 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.41. Metoda pop

Metoda popitem
Metoda popitem returneaz o pereche ntmpltoare de chei/valori i terge acea pereche
din dicionar.
Ex.:


Fig. 6.42. Metoda popitem

Metoda values
Aceast metod returneaz toate valorile dicionarului (fr cheiele lor) ca pe un dicionar.
Ex.:


Fig. 6.43. Metoda values

97

6.6. 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.44. Crearea unui set in Python shell

Dac scriem ns
setul_meu = set(a, b, c)
vom primi o eroare:


Fig. 6.45. Eroare

Aflarea numrului elementelor unui set se face prin intermediul funciei len:
setul_meu = set([1,2,3,4,5])
len(setul_meu)


Fig.6.46. Aflarea numrului elementelor unui set

98

Pentru adugarea de elemente setului se utilizeaz metoda add (legat cu punct, desigur):


Fig. 6.47. Metoda add

Se poate folosi i metoda update:


Fig. 6.48. Metoda update


Tipurile de date introduse pot fi diferite ca mai jos:


Fig. 6.49. 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.50. Metoda remove (am renuntat la numarul 2)

Sau discard:


Fig. 6.51. Metoda discard (am renunat la litera a)

Ca sa iterm peste elementele unui set putem s folosim bucla for:

99


Fig. 6.52. Bucla for utilizat n seturi

Uniunea a doua seturi contine elementele celor doua seturi si se realizeaza cu metoda
union:


Fig. 6.53. Uniunea a dou seturi

6.7. 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 pickling34.
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, asa cum am vazut in capitolul anterior, ca s scriem n modul binar un fiier
trebuie s folosim modul wb (write binary) atunci cnd invocam funcia open:
outputfile = open(datele_mele.dat, wb)
Odat ce am deschis fiierul pentru scrierea binar, invocm funcia dump a modulului
pickle:

34 to pickle = a mura, a biui, a decapa, a afuma

100

pickle.dump(obiect, fiier)
unde obiect este o variabil care refer obiectul pe care vrem s-l serializm i 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.54. 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.55. Citirea binar a fiierului

101

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.
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.








102

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.

7.1. 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.
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

103

incapsulrii 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 incercam sa
ni-l imaginm ca pe un obiect software. El are urmtoarele atribute:

104

secunda_curenta (o valoare cuprins ntre 0 i 59)

minut_curent ( o valoare cuprinsa intre 0 si 59)

ora_curenta (o valoare cuprins ntre 0 i 12)

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
105

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.
Metoda incrementare_minunt_curent adaug 1 la atributul minunt_curent, mai putin
cnd e setat la 59. n acest caz el reseteaz minut_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.2. 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 prjituri, gogoi sau case.

106

Un alt exemplu foarte nimerit de clas este formularul de la ghieul primriei prin care
solicii ceva. Formularul este proiectat o singur dat iar apoi este multiplicat n mii de
exemplare. Solicitantul (ceteanul) vine la primrie cu o problem i i se nmneaz sau i
ia singur un formular pe care l completeaz. Fiecare cetean are datele lui personale pe
care le introduce. O dat formularul completat avem deja de a face cu o instan a clasei
formular.
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, Andrei se ocup cu scrierea de programe de calculator. El proiecteaz un
program care s catalogheze diversele tipuri de automobile. Ca parte a programului,
Andrei creeaz o clas numit Vehicul care are caracteristicile comune oricror vehicule
(tip, productor, pre etc).
Clasa Vehicul specific obiectele ce pot fi create din ea. Apoi, Andrei scrie declaraiile de
program care creeaz un obiect numit automobil care este o instan a clasei Vehicul.
Obiectul automobil este o enitate care ocup un loc n memoria computerului i stocheaz
date despre automobil. El are atributele i metodele specific clasei Vehicul. Apoi Andrei
scrie o declaraie care creeaz un obiect numit bicicleta. Obiectul bicicleta este de asemenea
o instan a clasei Vehicul. El are propriul loc n memorie i stocheaz date despre bicicleta.
Altfel, obiectele automobil i bicicleta sunt dou entiti separate n memoria
computerului, ambele create din clasa Vehicul. Asta nseamn c fiecare dintre cele doua
obiecte are atributele i metodele descrise de clasa Vehicul.

Clasa
Vehicul

Obiectul
automobil

Obiectul
bicicleta

107

7.3. 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 PrimaMeaClasa:
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: PrimaMeaClasa).
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.35
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 = PrimaMeaClasa()

Cu aceast ocazie nvm i cum s trecem din modul script n modul interactiv din linia de comand

35

108

>>> b = PrimaMeaClasa()
>>> 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.

7.4. Adugarea atributelor


n programarea OOP exist dou denumiri frecvent ntlnite: metode i atribute.
Atributele sunt de fapt variabilele din programarea procedural iar metodele sunt funciile.
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 oferim un atribut unui obiect dat?
Putem s setm un atribut arbitrar unui obiect instaniat folosind notaia cu punct (dot
notation):
class Punct:
pass
p1 = Punct()
p2 = Punct()
p1.x = 5
p1.y = 4
p2.x = 3
p2.y = 6
print(p1.x, p1.y)
print(p2.x, p2.y)

109

Dac rulm acest cod, cele dou declaraii de afiare de la sfrit, ne dau noile valori ale
atributelor celor doua obiecte:
5 4
3 6
Ce face totui acest cod? El creeaz o clas goal numit Punct 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.

7.5. S punem clasa la treab


Programarea Orientata pe Obiect (OOP) este 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 Punct. 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, v-amintii probabil de la algebr de ordonata si abscisa). Aceasta este o bun
introducere pentru c ea necesit orice parametru:
(punct.py)
class Punct:
def reset(self):
self.x = 0
self.y = 0
p = Punct()
p.reset()
print(p.x, p.y)

Declaraia print afieaz cele dou zerouri ale atributelor (0 0) ca n sesiunea interactiv
de mai jos:

110


Fig.7.2. Ieire program punct.py

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.

7.6. 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. Prin el 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. 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 = Punct()
Punct.reset(p)
print(p.x, p.y)
Ieirea este aceeai ca la exemplul anterior, pentru c se desfaoar acelai proces.

111

Sa adugm o nou metod care permite s mui un punct ntr-o poziie arbitrar , nu doar
la origine. Putem s includem un alt obiect Punct ca input i apoi s returnm distana
dintre ele:
import math
class Punct:
def move(self, x, y):
self.x = x
self.y = y
def reset(self):
self.move(0, 0)
def calculeaza_distanta(self, alt_punct):
return math.sqrt(
(self.x alt_punct.x)**2 +
(self.y alt_punct.y)**2)
#cum folosim programul:
punct1 = Punct()
punct2 = Punct()
punct1.reset()
punct2.move(5, 0)
print(punct2.calculeaza_distanta(punct1))
assert (punct2.calculeaza_distanta(punct1) = =
punct1.calculeaza_distanta(punct2))
punct1.move(3, 4)
print(punct1.calculeaza_distanta(punct2))
print(punct1.calculeaza_distanta(punct1))

7.7. Definirea unei clase o alt abordare


Ca s creezi o clas trebuie s scrii definiia ei. Definiia clasei este un set de declaraii care
stipuleaza 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 Moneda care descrie comportamentul aruncrii
unei monede.

112

Iat mai jos programul moneda.py:


import random

#Clasa Moneda simuleaza o moneda


#care poate fi intoarsa
class Moneda:

#Metoda __init__ initializeaza atributele


# partii de sus a monedei (in_sus) cu Cap
def

__init__(self):
self.in_sus = Cap

#Metoda intoarce genereaza un numar aleator


# in gama 0 si 1. Daca numarul este 0 atunci
# in_sus (partea de sus) este setata pe Cap
# altfel, in_sus este setata pe Pajura

12

def intoarce(self):

13

if random.randint(0, 1) = = 0:

14

self.in_sus = Cap

15

else:

16
self.in_sus = Pajura

17

#Metoda ia_in_sus returneaza o valoare


#referita de in_sus

19

def ia_in_sus(self):

20

return self.in_sus
def main():
#cream un obiect (o instanta) din clasa Moneda
moneda_mea = Moneda()
#afisam partea monedei care este in sus
print(Aceasta parte este in sus: , moneda_mea.ia_in_sus())
#intoarcem moneda
print(Intorc moneda)
moneda_mea.intoarce()
#afisam fata monedei aflata in sus
print(Aceasta e in sus:, moneda_mea.ia_in_sus())
main()

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.

113

Linia 4 reprezint nceputul definiiei clasei. Ea ncepe cu cuvntul cheie class urmat de
numele clasei (care este Moneda), 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: Moneda. 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 Moneda conine trei metode:
metoda __init__ care apare n liniile 6 i 7
metoda intoarce care ocup liniile 12-16
metoda ia_in_sus 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 __intoarce__ (self):

Linia 20

def ia_in_sus(self):

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.in_sus = Cap

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.

114

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.in_sus = Cap

Aceast declaraie atribuie irul Cap atributului in_sus care aparine obiectului ce
tocmai a fost creat. Drept rezultat al metodei __init__ fiecare obiect pe care-l crem din
clasa Moneda va avea un atribut in_sus care e setat pe Cap.
Nota: Metoda __init__ este de obicei prima metoda nuntrul definiiei clasei.
Metoda intoarce apare n liniile 12 16:

def intoarce(self):
if random.randint(0, 1) = = 0:
self.in_sus = Cap
else:
self.in_sus = Pajura

i aceast metod necesit variabila parametru self. Cnd metoda intoarce este invocat,
self refer automat obiectul asupra cruia metoda opereaz. Metoda intoarce
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 Cap lui self.in_sus. Altfel, declaraia atribuie
Pajura lui self.in_sus.
Metoda ia_in_sus apare n liniile 19 i 20:

def ia_in_sus(self):
return self.in_sus

nc o dat, metoda necesit parametrul self. Aceast metod returneaz valoarea lui
self.in_sus. Chemm aceast metod ori de cte ori vrem s tim care fa a monedei
este n sus.
n imaginea urmtoare avem ieirea programului moneda.py rulat n Command Prompt:

115


Fig. 7.3. Ieire program moneda.py


S vedem n continuare i cum funcioneaz o clas. Astfel, vom scrie clasa Asigurari
care ine cteva informaii despre firme de asigurri (asigurari.py):
#Clasa Asigurari tine informatii despre
#firme de asigurari
class Asigurari:
#Metoda __init__ initializeaza atributele
def __init__(self, firma, pret):
self.__firma = firma
self.__pret = pret
#Metoda set_firma accepta un argument
#pentru firma de asigurari
def set_firma(self, firma):
self.__firma = firma
#Metoda set_pret accepta un argument
#pentru pretul asigurarii
def set_pret(self, pret):
self.__pret = pret
#Metoda ia_firma returneaza numele firmei
#de asigurari
def ia_firma(self):
return self.__firma
#Metoda ia_pret returneaza
#pretul politei de asigurare
def ia_pret(self):
return self.__pret

Si acuma programul care o testeaza (polita.py):


import asigurari
def main():
firma = input('Introdu firma de asigurari')
pret = float(input('Introdu pretul asigurarii'))
#Creeaza o instanta a clasei Asigurari
asigurare = asigurari.Asigurari(firma, pret)
#Afiseaza datele introduse

116

print('Iata datele pe care le-ai introdus: ')


print('Firma de asigurari: ', asigurare.ia_firma())
print('Pretul asigurarii este: ron',\
format(asigurare.ia_pret(), ',.2f'), sep='' )
main()

n final, s testm funcionarea n linia de comand a programului polita.py:


Fig. 7.4. Ieirea programului polita.py

Foarte important! Clasa Asigurari (asigurari.py) se import fr terminaia (extensia)


.py. Clasa (asigurari.py) se salveaz ntotdeauna n acelai director/folder (n cazul meu pe
Desktop) n care salvm i programul care o folosete (polita.py). Altfel, programul nu va
funciona.

7.8. Motenirea (Inheritance) n Python



Motenirea reprezint o tehnic de copiere a datelor i funciilor unei clase existente ntr-o
alt clas. n loc s pornim de la zero, o clas existent poate fi motenit de o alta creia i
adugm date noi. Clasa motenit se cheam clas de baz sau superclas iar clasa
motenitoare se cheam clas derivat sau subclas. Trebuie menionat c clasa care
motenete preia toate proprietile clasei de baz.
Exist trei tipuri de motenire. Acestea sunt:
1. motenirea simpl
2. motenirea pe mai multe niveluri
3. motenirea multipl
Noi vom vorbi n continuare despre motenirea simpl.
Toate clasele din limbajul Python sunt derivate dintr-o clas special (printe) numit
Object. Chiar dac nu este explicitatat scris, ea oricum este implicit. S zicem de exemplu
c vrem s crem o clas Animal pe care o derivm din clasa Object (animal.py):

117

class Animal(Object):
S lum n continuare un exemplu.
#Aici avem superclasa
class Animal(object36):
vorbesteStr = Salut de la Animal!
pass
#Aici avem clasa derivata
class Caine(Animal):
pass
latra = Caine.vorbesteStr
print(latra)
La ieire vom avea Salut de la Animal!.


Fig. 7.5. Ieire program animal.py

Clasa Caine motenete atributele clasei Animal i afieaz irul pe care clasa Animal l-a
avut ca atribut. Dac ns vrem s suprascriem valoarea unui atribut din clasa derivat
Caine, facem astfel (caine.py):
class Animal(object):
vorbesteStr = Salut de la Animal!
pass
class Caine(Animal):
vorbesteStr = Salut de la caine!
pass
latra = Caine.vorbesteStr
print(latra)
care va avea ieirea Salut de la caine aa cum se poate vedea n figura de mai jos:


Putem s adugm sau nu object, functionarea programului nu va fi afectata.

36

118


Fig. 7.6. Ieirea programului caine.py

Putem de asemenea s executm o metod din clasa printe (superclas) nauntrul unei
subclase aa cum se poate vedea n urmtorul program rulat n interpretorul Python:


Fig. 7.7. Metoda inauntrul subclasei


S mai lum un exemplu - de aceast dat din geometrie. S spunem c dorim s aflm
suprafaa unui dreptunghi i a unui triunghi care sunt la origine poligoane.

Poligon

Dreptunghi

Triunghi


Prin urmare trebuie s crem superclasa Poligon i apoi subclasele Dreptunghi i
Triunghi care s o moteneasc.
Prima dat crem superclasa Poligon (poligon.py):
class Poligon:
lungime = 0
latime = 0
def set_valori(self, lungime, latime):

119


Poligon.lungime = lungime
Poligon.latime = latime

Apoi subclasa Dreptungi care motenete caracteristicile superclasei Poligon


(Dreptunghi.py):

from poligon import*
class Dreptunghi(Poligon):
def suprafata(self):
return self.lungime * self.latime

n continuare crem clasa Triunghi (Triunghi.py):
from poligon import*
class Triunghi(Poligon):
def suprafata(self):
return(self.lungime * self.latime) / 2
n final, scriem programul necesar calculrii celor dou suprafee (mostenire.py):
from Dreptunghi import*
from Triunghi import*
#cream o instanta pentru fiecare subclasa
drept = Dreptunghi()
tri = Triunghi()
#invocam metoda mostenita de la superclasa, trecandu-i
#argumentele care sunt atribuite variabilelor clasei
drept.set_valori(35, 25)
tri.set_valori(16, 20)
#afisam rezultatele manipuland variabilele
#clasei mostenite din clasa de baza
print('Aria dreptunghiului este: ', drept.suprafata())
print('Aria triunghiului este: ', tri.suprafata())

La ieire vom avea:

120


Fig. 7.8. Output program mostenire.py


Nu tiu dac acest capitol a fost indeajuns de explicit, prin urmare m-am gndit s dau un
exemplu de aplicaie foarte interesant scris n Python, care are o excelent parte grafic
(realizat ce-i drept cu ajutorul xml si 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
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 complex sau foarte complex.
Motenirea obiectelor nseamn n esen mai puin munc pentru c vei prelua ceea ce
alii au creat nainte i vei adapta prin mici sau mai mari modificri, la nevoile
dumneavoastr. Daca aveti curiozitatea, puteti instala OpenERP (mai nou cunoscut ca
Odoo) si apoi sa-i deschideti fisierele diverselor module intr-un editor de text. Veti putea
analiza cum functioneaza mostenirea in Python intr-un program cladit pe o arhitectura

121

excelenta.

122

Cap. VIII Crearea si manipularea formularelor web



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 vazut doar
programe scrise ntr-un editor de text, rulate n interpretorul Python din Command
Prompt (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 n general, n afar de nerds, nimeni nu utilizeaz calculatorul din linia de
comand.. Totui Python deine capacitatea crerii de interfee grafice interesante
(Graphical User Interface sau GUI). M-am gandit totui s nu abordez (nc) acest subiect
complex.
Python este ns un puternic limbaj de programare utilizat (i) pentru crearea aplicaiilor
web. La fel ca formularele scrise n limbajul PHP, cele realizate n Python sunt gzduite pe
un webserver, loc din care sunt servite utilizatorului interesat. Exist ns o deosebire
fundamental ntre PHP i Python: n vreme ce scripturile PHP slluiesc numai i numai
pe server pentru ca s poat fi procesate, scripturile Python pot s stea pe calculator atunci
cnd avem de-a face cu o aplicaie desktop de sine stttoare i/sau pe web server atunci
cnd e vorba de o aplicaie pentru Internet. Cu PHP nu se pot face aplicaii desktop37.
Simplist explicat, procesul cerere procesare server - rspuns se desfoar conform
desenului de mai jos:


Browser
utilizator

Cerere

Web
Server
(raspuns
HTML)

Inter-
pretor
Python



Exist totui i posibilitatea rulrii scripturilor PHP din Terminal cu comanda php a, desigur dac PHP este
instalat pe calculatorul dumneavoastr.
37

123

Serverul web trebuie mai nti configurat ca s recunoasc scripturile (fiierele) Python
care au aa cum am nvat, extensia .py. Interpretorul Python proceseaz scriptul nainte
de a-l trimite ca un rspuns HTML serverului, care la rndul lui l returneaz browser-ului
utilizatorului. Un script Python cerut de browser poate s genereze un rspuns complet
HTML descriind tipul coninutului n prima linie a fiierului astfel:
Content-type:text/html\r\n\r\n
Ce facem totui cu scriptul (pe care nc nu l-am creat, linia de cod de mai sus arat doar
declaraia iniial din fiier), pentru c, altfel ca fiierele Python pe care le-am dezvoltat
pn acuma i care rulau din linia de comand a calculatorului, avem nevoie de un web
server ?
Exist aici dou posibiliti de luat n calcul:
a. S instalm serverul arhicunoscut i arhifolosit38 pe plan mondial Apache pe
propriul computer i apoi s-l configurm astfel nct s tie s proceseze scripturi
Python.
Aceasta este o operaie destul de dificil, care necesit timp, aflat nu la ndemna
nceptorilor. Totui, n Anexe gsii modul de configurare a fiierului httpd.conf (care
este creierul i inima serverului Apache) pentru a prelucra fiiere Ruby, CGI, Perl i
Python.
b. Cea mai la ndemn metod este s scriem propriul server n Python, operaie ce
necesit cteva linii de cod.
Vom apela la aceast a doua metod pentru c este mult mai puin complicat. Trebuie
reinut c fiierele vor fi afiate n regim local (localhost) n browser-ul calculatorului
dumneavoastr. Dac avei propriul website i vrei s exersai n lumea real putei
ntreba administratorul de sistem al serviciului de gzduire (hosting) dac exist
posibilitatea (n general, ea nu este setat implicit) de a v configura serverul pentru
scripturi Python. Oricum, dac atunci cnd ai nchiriat spaiu pe server n ofert nu era
trecut i opiunea scripturi CGI, sigur nu avei aceast posibilitate. Ca o parantez
vreau s mai adaug c gzduirea de scripturi sofisticate precum CGI, Perl, Python sau

Peste 60% din website-uri utilizeaz serverul Apache

38

124

Ruby cost enorm cel puin la anumite firme i mai ales pentru buzunarele noastre.
Serviciul meu de hosting de care de altfel nu m pot plnge, mi oferea pentru scripturi
Python un server dedicat la preul minim de 29 euro/lun! Normal c am zis pass ca-
ntr-o clas Python! Exist ansa s gsii i oferte ce includ scripturi CGI la preuri de bun
sim, dar dac spre exemplu, v bate gndul s v portai / alctuii un website n
framework-ul Django (scris n Python) ori n Mezzanine, vei primi rspunsul c nu e
posibil sau eventual, v vor pretinde o cru de bani.
Din acest motiv exemplele pe care le voi arta n continuare sunt pur i simplu oferite n
scop didactic, pentru a vedea cum poate fi utilizat Python n aplicaii de Internet.
Dar vorba mult srcia programatorului, aa c s dm drumul la treab i s scriem
codul serverului Python necesar aplicaiilor noastre, nu nainte de a crea pe desktopul
computerului un folder numit webdir iar nuntrul acestuia nc unul numit cgi-bin.
Scriptul webserver.py arat astfel:

Fig. 8 1. Fiierul webserver.py

Urmrii cu atenie liniile 1, 4 i 6. Ele sunt cele mai importante din ntreg fiierul Python.
Cu toate c prima linie este caracteristic computerelor UNIX (eu rulez serverul pe un
computer Macintosh bazat pe UNIX) trebuie musai s-o adugai n fiier chiar dac rulai
serverul pe Windows. Linia ar putea s difere, astfel nct s nu conin local ci pur i
simplu
#!/usr/bin/python3
Mai departe, scriei cu atenie maxim linia 4, ea fiind cea mai important din ntreg
scriptul:
from http.server import HTTPServer, CGIHTTPRequestHandler

125

Apoi este linia 6 care arat locul exact unde se afl fiierele Python ce urmeaz s fie servite
n browser. Desigur c la dumneavoastr difera, mai cu seam dac lucrai n Windows.
Important este s scriei cu exactitate unde se gsete folderul webdir:
webdir = '/Users/mirceaprodan/Desktop/webdir'
Linia 7 seteaz portul serverului. n mod normal, serverul web Apache ascult la portul
80 i n cazul meu, acest lucru e valabil pentru c aici l am i eu configurat pentru scripturi
PHP . Atunci cnd scriu localhost:8039 (sau 127.0.0.1:80) mi apare pagina principal a
serverului (It works!) sau eventual (depinde cum e configurat) indexul serverului.
Aa cum vedei n script, am setat serverul Python la valoarea 8080. Dac avei ceva
mpotriva numrului opt, putei s-i dai oricare alt valoare n linia 7, dar neaparat mai
mare ca 1024:
port = 8080
La sfrit, dup ce ai scris cu atenie toate liniile de cod exact aa cum sunt date n
imaginea de mai sus, salvai scriptul webserver.py n directorul (folderul) webdir.
Nu tiu dac suntei ct de ct familiarizai cu limbajul de marcare HTML, dar scriptul pe
care l vom rula iniial n browser este pur i simplu un document HTML (cruia mai trziu
i adugm funcia Python print() pentru a-l putea extrage de pe server). S vedem mai
nti cum arat documentul HTML:
<!DOCTYPE HTML>
<html lang="en">'
<head>
<meta charset="UTF-8">
<title>Raspuns Python</title>
</head>
<body>
<h1>Salutari de la Python online!</h1>
</body>
</html>
Salavai-l ca salutari.html pe desktop i apoi dai dublu click pe el ca s-l rulai n

39 80 e implicit i de regul nu se mai scrie

126

browser. Acesta este cum spuneam, doar un banal fiier HTML pe care l putem rula direct
de pe desktop, fr a fi necesar ca s fie ncrcat n server, aa cum putei vedea privind
URL-ul evideniat n browser:


Fig. 8.2. salutari.html rulat n browser

Ca s avem un script Python adevrat trebuie doar s-i facem cteva retuuri, s-l ncrcm
n server i apoi s-l afim n browser-ul web. Pentru asta trebuie mai nti s adugm
neaprat linia de cod care arat unde este interpretorul Python, inclusiv pentru fiierele pe
care le rulai sub Windows:
#!/usr/local/bin/python3.3
Apoi dai un Enter ca s avei o linie goal (linia 2) i dup aceea scriei linia de cod despre
care am amintit la nceputul acestui capitol:
print('Content-type:text/html\r\n\r\n')
n final, fiecare linie de program din fiierul salutari.html trecei-o drept argument al
funcie print() din Python.
n consecin, prima noastr pagin web scris n Python (raspuns.py) va arta aa:


Fig.8.3. Scriptul raspuns.py

Salvai fiierul raspuns.py n subfolderul cgi-bin aflat n folderul webdir situat pe desktop.
Acuma urmeaz lucrul cel mai interesant, anume vizualizarea primei dumneavoastr
pagini web scris n Python. Pentru aceasta mai nti trebui s pornim serverul despre care

127

am scris c lucreaz la portul 8080.


Schimbm directorul n folderul webdir cu comanda (aceeai pentru Mac, Windows sau
Linux) dat n Command Prompt sau Terminal :
cd Desktop/webdir
Urmtoarea comand este:
python3 webserver.py
care pornete serverul la portul 8080 dup cum se poate vedea n imaginea urmtoare:


Fig.8.4. Pornire server

Deschidem browser-ul (daca nu este deja n aceast poziie) i scriem n bara URL:
http://localhost:8080
Dac ai fcut corect toi paii necesari, pagina web care apare va arta indexul serverului
ce include fiierele aflate n el. n cazul meu sunt mai multe, dup cum se poate vedea mai
jos:


Fig.8.5. Directorul indexului fiierelor serverului

Cum scriam, fiierul care ne intereseaz si anume raspuns.py se afl n folderul cgi-bin. Ca

128

s-l afim scriem n browser n niciun caz nu dm click n index pe subfolderul cgi-bin
pentru ca va aprea o eroare de autorizare 403, urmtoarea adres:
http://localhost:8080/raspuns.py :


Fig.8.6. Scriptul web raspuns.py trimis din server

Se observ - privind URL-ul paginii, c de aceast dat fiierul este trimis din webserver i
cu toate c pagina pare identic cu cea afiat de fiierul rspuns.html, de fapt nu este
nici pe departe acelai lucru.
Urmtorul fiier pe care vi-l propun este mai complex i l-am preluat din cartea lui Mark
Lutz, Learning Python. Este vorba despre un program foarte simpatic care afieaz o pagin
web ce conine codul salutului nceptorilor n programare Hello World! afiat pentru
cele mai cunoscute limbaje de programare. Fiierul Python este urmtorul (limbaje.py):
#!/usr/local/bin/python3.3
"""
show hello world syntax for input language name;
any languages name can arrive at this script since explicit
"""
debugme = False
inputkey = 'language'
hellos = {
'Python': r" print('Hello World')
'Python2': r" print 'Hello Wordl'
'Perl': r' print "Hello World\n"
'Tcl': r' puts "Hello World"
'Scheme': r' (display "Hello World") (newline)
'SmallTalk': r" 'Hello World' print.
'Java': r' System.out.println("Hello World");
'C': r' printf("Hello World\n");
'C++': r' cout << "Hello World" << endl;
'Fortran': r" print *, 'Hello World'
'Pascal': r" Writeln('Hello World';)

129

",
",
',
',
',
",
',
',
',
",
"

}
class dummy:
def __init__(self, str): self.value = str
import cgi, sys
if debugme:
form = {inputkey: dummy(sys.argv[1])}
else:
form = cgi.FieldStorage()
print('Contet-type: text/html\n')
print('<title>Languages</title>')
print('<h1>Sytnax</h1><hr>')
def showHello(form):
choice = form[inputkey].value
print('<h3>%s</h3><p><pre>' %choice)
try:
print(cgi.escape(hellos[choice]))
except KeyError:
print("Sorry-- I don'y know that language")
print('</pre></p><br>')
if not inputkey in form or form[inputkey].value == 'All':
for lang in hellos.keys():
mock = {inputkey: dummy(lang)}
showHello(mock)
else:
showHello(mock)
print('</hr>')


Ieirea lui este urmtoarea (partea superioar a paginii):


Fig.8.7. Ieire program limbaje.py

130

8.1. Drepturi de acces la fiiere


Rmne totui de lmurit un lucru esenial n programarea Python pentru web, de care cu
siguran v vei lovi i anume dreptul de acces la fiiere. Spre deosebire de scripturile
PHP, fiierele Python sunt mult mai dificil de manipulat din server. Ce vreau s spun cu
aceasta este c atunci cnd vei ncerca s le afiai n browser, cu siguran vei ntlni
adesea refuzul serverului de a v permite accesul la fiier sau, n cel mai bun caz, n loc s
v afieze pagina web revendicat, v va fi oferit fiierul n sine pe care s-l vizualizai sau
descrcai ca n figura de mai jos (pentru MacOS dar e valabil i pentru Windows) unde eu
am solicitat pagina web link.py:


Fig.8.8. Setare incorect a privilegiilor de acces

Pentru a evita o astfel de situaie trebuie s configurai dreptul de acces la fiier astfel nct
doar dumneavoastr ca administrator s fii proprietarul lui i s avei dreptul s scriei n
el i s-l citii. Ceilali, trebuie s aib doar dreptul de a-l citi. Nu v garantez ca aceast
configurare funcioneaz fr probleme pentru c nu este aa. Dup ce am ncercat de
nenumrate ori diverse scripturi Python pentru web cu combinaii diferite de privilegii, am

131

ajuns la concluzia c exist o mare doz de impredictibilitate n a funciona sau nu. Poate vi
se pare o abordare neprofesional a problemei, dar dup ce v vei lovi de vreo 50 de ori de
refuzul de a deschide pagina web cerut tiind c ai scris/reprodus perfect un fiier, s-ar
putea s mi dai dreptate. tiu, n sistemele UNIX / Linux drepturile de acces la fiiere sunt
mult mai restrictive, acesta fiind unul dintre motivele pentru care n general, utilizatorii
comuni ai calculatoarelor evit folosirea lor. Nu tiu cum este n Windows, nu am ncercat,
dar dup tiina mea, setarea privilegiilor asupra unui fiier nu este att de spectaculoas
ca n Unix.



132

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...

133

Bibliografie
4. Barry, Paul, Griffiths, David, Head First Programming, OReilly
Media, Sebastopol, CA, 2009
5. Barry, Paul, Head First Python, OReilly Media, Sebastopol, CA,
2011
6. Gaddis, Tony, Starting out with Python (second edition), Pearson
Education, Boston,2012
7. Harrington, Andrew, Hands-On Python. A tutorial introduction
for beginners (Python 3.1. version), creativecommons.org
8. Phillips, David, Python3 Object Oriented Programming, Packt
Publishing, London, 2010
9. Pinckaers Fabien, Van Vossel, Els, Streamline your Menufacturing
Processes with OpenERP, Open Object Press, 2012
10. Swaroop, CH, A byte of Python (second edition)
11. Sweigart, Al, Invent Your Own Computer Games With Python
(second edition), Creative Commons Licence




134