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

2


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.

4


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)

5


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
6

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

7


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,

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

8


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

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

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

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

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
11

configurat corect (vezi p.11-12 instalarea Python).

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.

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

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
14

variabila trecut unei funcii atunci cnd este invocat. Parametrul definete tipul de argument(e) pe care o
funcie l poate accepta.

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

15 irurile regulate sunt irurile care nu sunt atribuite unei variabile.

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

numai c universitile romneti accept doar fiiere Microsoft Word.

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:

17 De fapt numele ei...

19


print( ) argument

funcia print
>>>latime = 10 (Enter)
>>>print(latime)
latime
>>> print(latime) (Enter)
10
>>>
Exemplu de program care demonstreaz o variabil:

(variabila.py)
#Acest program demonstreaza o variabila
camera = 123
print(Stau in camera: )
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

18 Se pot folosi ghilimele simple sau duble, rezultatul este acelai.
19 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']

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

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

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.

22 Acestea nu sunt totuna cu numerele zecimale

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

aici este un spaiu!!

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

cum i dac funcioneaz!! Programarea nseamn dou lucruri eseniale: pasiune i rbdare...

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

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

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

Nu uitai c ntre ultimul cuvnt din primul enun i ultima ghilimea care ncadreaz acelai enun este un
26

spaiu. Daca nu e marcat corespunzator, ultimul cuvnt din primul enun i primul din cel de-al doilea vor fi
afiate lipite.

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)

27 Pentru c a doua valoare din irul de numere de dup punct - n spe 7 (.6789) este mai aproape de 10
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

29 Vom vedea mai trziu ce reprezint un set in Python.

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 1
#Prima data definim o functie numita mesaj 2
def mesaj(): 3
print(Sunt Mircea,) 4
print(si incerc sa invat Python.) 5
#Apoi invocam functia mesaj 6
mesaj() 7
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:

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

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

31 Imbricat = mbucat(e), suprapus(e) ca indrilele de pe casa (cf.dexonline.ro)
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
MAX = 5 (Reine! Constanta se pune la nceput)
Def main():
#Initializeaza variabila acumulator
total = 0.0 (acumulatorul se inializeaz ntotdeauna cu 0.0)
#Explica ceea ce faci
print(Acest program calculeaza suma)
print(MAX, numerelor introduse.)
#Ia numerele si acumuleaza-le
for counter in range(MAX):
number = int(input(Introdu un numar: ))

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

33 Reuse n lib.englez

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) 5
#Scrie numele presedintilor Romaniei 6
#in fisier
outfile.write(Ion Iliescu\n) 8
outfile.write(Emil Constantinescu\n) 9
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) 5

#Ii citim continutul

file_contents = infile.read() 7

#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 1 2 3
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] 1
print(lista) 2
lista[0] = 50 3
print(lista) 4
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.

Date
--//- --//-- --//-- --//-- --//--


OBIECT


D



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

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

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 1
#Clasa Moneda simuleaza o moneda
#care poate fi intoarsa
class Moneda: 4
#Metoda __init__ initializeaza atributele
# partii de sus a monedei (in_sus) cu Cap 6
def __init__(self):
self.in_sus = Cap 8
#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:

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

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 Inter-
(raspuns pretor

HTML) Python

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

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

38 Peste 60% din website-uri utilizeaz serverul Apache

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