Documente Academic
Documente Profesional
Documente Cultură
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
De ce s te apuci de programare?
Pentru c:
1. i ine mintea treaz
2. e fun
3. e o activitate care i aduce prestigiu
4. poi catiga bani (muli!)
Pn la 45 de ani nu m interesa mai deloc IT-ul. Mi se prea un univers inaccesibil.
Foloseam calculatorul ca orice user de rnd: scriam texte pe care abia dac reueam s le
tehnoredactez, citeam sau trimiteam email-uri i uneori lecturam ziare sau publicaii
online. Dup aceea s-a produs declicul. Pcat c am descoperit acest minunat domeniu
cam trziu, cnd creierul nu mai funcioneaz ca odinioar.
Toat viaa am crezut c programarea nseamn inainte de toate s fii tob de matematic.
E o exagerare. Dup ce am studiat limbaje de programare vreme de trei ani, am ajuns la
concluzia c nu trebuie s tii mai mult de operaiile matematice fundamentale la care se
adaug i cunoaterea ordinii lor. Astea se nva din cte mi amintesc prin clasa a asea
sau a aptea, atunci cnd deslueti tainele algebrei 1.
Cel mai important lucru n asimilarea unui limbaj de programare este n opinia mea
sintaxa, adic regulile dup care sunt puse semnele, numerele sau declaraiile dintr-un
program. Din necunoaterea lor n profunzime vin i cele mai multe erori n scrierea unui
program. Cnd am nceput s desluesc tainele PHP uitam mai mereu s nchei linia de
program cu punct i virgul aa cum e regula. Asta genera permanent erori pe care apoi, cu
ct programul devine mai lbrat, le dibuieti greu, cam ca pe acul din carul cu fn.
Ce i este necesar ca s scrii un program (pe lng ceva cunotine de mate i
stpnirea sintaxei)? Druire, atenie iscrierea de programe. Fiecare carte care afirma ca
te nva un limbaj de programare are n general la sfritul capitolelor o seciune de
exerciii i probleme. E partea cea mai important (i captivant)! Citii bine teoria, scriei
1
Asta desigur e valabil pentru un anumit nivel (mai lipsit de pretenii) n programare.
programele date n carte n propriul editor de text (nu descrcai codul aferent crii de pe
site-ul editurilor pentru ca v va fi lene sa-l rescriei), analizai-le i apoi procedai la
rezolvarea exerciiilor. Numai aa nvei!
Cu ce limbaj ar trebui s ncep?
Aici e ca n proverbul acela cu cte bordeie, attea obiceie. Am stat odat ore ntregi
pe forumuri pentru a afla un rspuns ct de ct adecvat la aceast intrebare. Oricum ar fi, e
bine s ncepi s studiezi un limbaj uor. Dar exist unul uor, att de uor nct s fie
asimilat ntr-o perioad ct mai scurt? Din experiena personal, nu. Totui, un limbaj de
programare foarte uor de implementat pe calculator i nu prea greu de nvat este
Python. Despre el am ales s scriu n aceast carte.
Exist limbaje de programare complexe i altele mai puin complexe. Exist limbaje cu
ajutorul crora se pot construi doar aplicaii web i altele care pot aduce la via idei
mree care uureaz viaa de zi cu zi a celor care le folosesc. Acestea din urm sunt cel mai
greu de nvat dar odat asimilate i garanteaz satisfacii majore. Limbaje de scriptare
precum PHP sau Javascript sunt bune (doar) pentru a face site-uri, bloguri, aplicaii pentru
Internet n general. Cnd ns vorbim spre exemplu de programe de contabilitate, de
proiectare n inginerie sau arhitectur, de aplicaii IT n medicin sau tiine atunci intervin
adevratele limbaje de programare: C, C++, Java, Python, Lisp, Pascal 2 etc.
Sfatul meu este s ncepei, daca imi este permis, s studiai - dintre limbajele grele -
pe cele mai uoare! n niciun caz ns nu e indicat s v apucai de nvarea C++. E
adevrat, el este regele balului (alaturi de Java), e extrem de utilizat dar foarte dificil de
asimilat. i C-ul este asemenea lui innd cont c i este precursor. Java pe de alt parte,
seamn mult (ca sintax cel puin, cu toate c ceva maiuuric) cu C++ dar pe deasupra
are un mediu de dezvoltare greu de configurat pentru un incepator.
n tot cazul, nu v apucai s deprindei un limbaj de programare din surs nchis
precum cele furnizate de Windows sau Apple. E drept C# sau Objective C se folosesc
(acum!) pe scar larg la construirea de aplicaii pentru dispozitivele mobile aflate n mare
2
vog. Dar inei minte c voga e mod i de obicei ea trece mai ncet sau mai repede, dar
tot trece. Sfatul meu e s nvai limbaje de programare portabile pe orice sistem de
operare i mai ales din surs deschis. Unele dintre ele n-au moarte. C spre exemplu se
ndreapt spre 50 de ani3 i nu d semne c va pieri n curnd. C++ are i el peste trei
decenii4 i la fel, e n plin putere, chiar dac a mai sczut n preferinele
programatorilor.
Atunci cnd cutai materiale tiprite sau online, tutoriale, cri, exemple etc pentru
nvat, evitai titluri de genul : nva Java n 24 de ore! Sunt minciuni ordinare! Java,
Python, C++ (chiar i Basic) nu se nva nici ntr-o luna, nici mcar ntr-un an, daramite
ntr-o zi! Opinia mea pe care o mprtesc cu sinceritate, e c un limbaj de programare se
asimileaza n ani de zile. i nici atunci, dup o perioad lung de timp, nu cred c poi s
pretinzi c eti geekDup unele voci de mare ncredere5, perioada optim de timp
necesar deprinderii unui limbaj de programare este de zece ani!
Alegei-v un limbaj de programare pe care-l putei iniia imediat i fr bti de
cap la compilare. Cel mai indicat e desigur Python. l descarci ntr-o clipa de pe Internet, i
configurezi variabilele de mediu (n Windows) i dai drumul la lucru. Alta e treaba cu Java,
C++ sau C. Ele necesit mai mult munc i pentru un nceptor (care nu prea are pe cine
s ntrebe n afar de Google6) nu e chiar uor.
Marele noroc (astzi!) n desluirea unui limbaj de programare este c pe Internet se gsesc
o mulime de tutoriale i forumuri, locuri unde ntotdeauna afli rspunsuri la ntrebri
pentru c alii s-au lovit inaintea voastr de aceleai probleme, desigur dac ti s ntrebi.
Uitasem un lucru esenial: limba englez. Din observaiile pe care le tot fac de vreo
civa ani, am observat c exist cteva naii care exceleaz n IT. Printre ele, la loc de
cinste, indienii, chinezii i nordicii. Am gsit i explicaii. La indieni e vorba despre
numrul uria al populaiei. V imaginai c din peste un milliard de oameni ai de unde
3
1972
4
1980
5
http://norvig.com/romanian21-days.html
Din pcate, literatura IT n Romnia e sublim dar (aproape) lipsete cu desvrire. Se mai gsesc rtcite
prin librarii vestigii din anii 90 sau nceputul ori mijlocul anilor 2000, total depite astzi.
6
alege cteva sute sau mii de cpni luminate. Acetia au avut poate norocul educaiei i
pe cale de consecin, a ieirii din foame. ntr-o ar n care sperana de via e de 40 de ani,
a fi instruit e o ans uria! Programarea i-a scos pur i simplu din srcie, i-a adus adesea
n America i i-a angajat la companii de vrf precum Windows, Oracle, IBM, Apple.
Cutai informaii despre diverse companii de top i nu se poate s nu gsii n poziii de
frunte indieni sau chinezi. Numrul foarte mare i srcia pe msur este explicaia
succesului (multora dintre ei) n IT.
Ceilali sunt nordicii. Cteva exemple edificatoare: cel care a proiectat Linux-ul este
finlandez cu rdcini suedeze; cel care a fcut iniial PHP-ul este danez, cel care a fcut C++
este danez, cel care a proiectat Python-ul este olandez. i exemplele pot continua. Ei,
contrar indienilor ori chinezilor, provin din ri foarte dezvoltate economic dar paradoxal,
cu populaie deficitar. i atunci de unde formidabilul succes n IT? Am gsit i aici o
explicaie: condiiile meteo. Cnd ai jumtate sau mai bine din an temperaturi negative,
cnd plou sau ninge nentrerupt zile intregi eti nevoit s stai n cas, eventual n faa
computerului. Cu el i omori timpul, cu el comunici cu alii i tot el te poate aduce pe
culmile gloriei.
i totui, cei care au inventat calculatorul, limbajele iniale de programare i tot ce
ine de IT au fost americanii, adic un popor care vorbete limba englez, limb n care
logic, au scris i limbajele de programare, apropiate ca vocabular acesteia. De aici rezult
importana fundamental a limbii engleze n nvarea limbajelor de programare. Totui,
nu vreau s v sperii. Nu trebuie s stpnii engleza la nivel oxbridge, ns un bagaj minim
de cuvinte este absolut necesar s-l posedai. Mai trebuie s tii fie doar pentru cultura
general c la baza industriei IT de astzi au stau odinioar proiecte militare americane
(realizate n colaborare cu mediul academic), care dateaz nc ht, din timpul celui De-al
Doilea Rzboi Mondial. Apoi a venit mediul de afaceri ce a avut nevoie de aplicaii care s
uureze munca, s mreasc productivitatea i implicit profitul. Ca o concluzie, IT-ul are
origini militare, academice i financiare. Doar cei care puteau susine financiar cercetarea n
domeniile de vrf puteau obine rezultate, nu? Timpul a dovedit c au reuit dar mai ales,
aplicaiile bazate 100% pe limbaje de programare si care odat, de mult, erau accesibile
doar unei mini de oameni, au devenit astzi un lucru banal i ct se poate de comun.
Pentru asta trebuie doar s jonglai puin cu un telefon mobil inteligent care este nesat
cu ele.
De ce Python?
Pentru c n primul rnd este un limbaj curat ca sintax i foarte uor de
implementat pe orice calculator. Legenda spune c Guido van Rosssum creatorul Python,
a pus bazele limbajului ntr-un week-end de Crciun cnd se plictisea i nu prea avea cu ce
s-i omoare timpul. Cert este c olandezul, care a lucrat muli ani dup aceea la Google7, a
reuit s ofere lumii un limbaj cu o sintax simpl i supl, cu reguli clare i de netrecut i
care se folosete astzi pe scar larg n mediul academic american (tocmai pentru
nvarea limbajelor de programare), n afaceri dar i n proiectarea unor aplicaii de mare
succes. Youtube spre exemplu este scris n Python. i Google folosete ca liant Python.
Asemenea lui Yahoo!. Renumitul ziar Washington Post folosete n varianta lui online
limbajul Python. Cutai pe Internet i vei gsi alte numeroase domenii n care Python are
un cuvnt important de spus.
Un alt motiv pentru care este indicat s ncepei cu Python este dat de numrul de
entuziati aflat ntr-o cretere constant i care se ocup de Python. Internetul este plin de
informaii despre el, de tutoriale, de cri i forumuri. Este tiut c ntr-un fel, Python nu
poate s fac ceea ce face C++ spre exemplu. Totui, curba de nvare a celor dou limbaje
este radical diferit. Cred sincer c un programator Python valoros se poate forma n circa
doi trei ani, bine-neles dac st cu brnca pe carte. Nu acelai lucru se poate afirma
despre C++
Altfel dect PHP un alt limbaj relativ uor de asimilat, cu Python se pot realiza proiecte
web dar / sau mai ales, aplicaii desktop de sine stttoare.
Un alt motiv pentru care este bine s nvai Python e numrul relativ redus (pe
plan mondial, n Romnia ce s mai vorbim) de programatori n acest limbaj. tiu, vei
spune c site-urile de joburi sunt pline de oferte de munc pentru programatori Java, C,
Van Rossum a plecat ntre timp la Dropbox, dup apte ani petrecui n ograda Google.
C++, C# , PHP sau Objective C i mai puin Python. Aa este, numai c numrul
programatorilor Java sau PHP este covritor n vreme ce al celor care se ocup de Python
cu toata creterea lui - nu. De aici vine i confuzia care se creeaz cu privire la gsirea
unui job legat de Python. Dai un banal search pe Google cu cuvintele cheie python
jobs(s) i vei avea afiate istantaneu n faa ochilor un noian de rezultate care mai de care
mai interesante. Sunt oferte peste oferte, ce-i drept, majoritatea de peste Ocean. Asta nu
nseamn c nu avei anse. Nu trebuie neaprat s lucrai full time la sediul din Chicago
sau din Silicon Valey al unei firme, ci n intimitatea propriului cmin. Restul l face
Internetul, Skype, Messenger i/sau PayPal. Internetul a anulat distanele, a fcut ca
proiectele i ideile s circule nestingherite cu viteze uluitoare iar banii s intre (sau s
ias) din conturi la fel.
Ultimul motiv i poate cel mai important este prestigiul. Stpnirea Python (sau a
oricrui alt limbaj de programare) face diferena n ochii cunosctorilor, a prietenilor sau
rudelor dar mai ales n ochii votri. A ti s programezi i ine mintea activ, te face s fii
mndru de tine, s te simi tnr i cine tie, cu mult munc i ceva ans, i poate aduce
i venituri substaniale.
Succes!
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
n interpretorul Python
n modul script
S vedem mai nti, pentru a v convinge c Python este un limbaj grozav, care este
diferena ntre scrierea celui mai simplu program n Java i unul n Python. n Java:
// my first program in Java
n versiunea Mac OS Maverick, acest truc nu funcioneaz, astfel c n linia de comand scriei python3 i
dai enter. Dac nu adaugai numrul 3 dupa comanda python, computerul afieaz n Terminal shell-ul
versiunii 2.7. care este preinstalat. Daca lucrati in Ubuntu Linux, in versiunea 14 Python 3 este deja
preinstalat. Scrieti in Terminal (shortcut Ctr+Alt+T) python3 si este deschis shell-ul Python.
10
12
i acuma n Python:
>>> print(Hello World!)
Fig.1.1. Hello World! n Python shell
Deci ceea ce n Java se afieaz cu ajutorul a ase linii, n Python se face cu una singur!
Pentru scrierea primului (i urmtoarelor) programe n Python trebuie s deschidei
interpretorul Python astfel:
Windows -> All Programs -> Python32 -> Python (Command Line) [Enter]
Acelai lucru se face i fr invocarea interpretorului, direct din Command Prompt /
fereastra DOS (Windows) sau Terminal (Mac OS, Linux). n fapt, sfatul meu este s lucrai
doar cu acest instrument.11
Exist de asemenea i mediumuri profesionale de dezvoltare a programelor Python, cum
ar fi Eclipse, Netbeans sau Pycharm (exclusiv pentru Python). Cu toate c primele dou
sunt dedicate programrii n Java, ele admit instalarea de add-on-uri suplimentare pentru
crearea si testarea programelor scrise in Python. Totui, nu v sftuiesc s utilizai aceste
mediumuri complexe (cel puin nu la nceput de drum) care sunt ndeajuns de intimidante
pentru un nceptor. n plus, nici configurarea lor iniial nu e prea lesne de realizat.
S revenim ns la lucruri uoare. Astfel, o dat ce ai scris o declaraie aici (n Windows
Command Prompt sau MacOS/Linux Terminal), automat dup apsarea tastei Enter,
Totul este ns ca n Enviromnent Variables (Windows) calea de rulare ctre executabilul Python s fie
configurat corect (vezi p.11-12 instalarea Python).
11
13
Fig.1.2. Interpretorul Python n MacOS Terminal
Fig.1.3. Programul scris n Notepad
Salvm programul sub numele popescu.py (eu l-am salvat pe desktop) i apoi l rulm din
linia de comand cu comanda python popescu.py, nu nainte ns de a muta calea de
rulare a programului pe desktop cu comanda cd desktop13. Altfel, interpretorul Python
nu gsete fisierul (n cazul meu popescu.py) i va genera o eroare ct se poate de enervant.
Putei la fel de bine s scriei Bucureti (cu diacritice). Nu va rezulta nicio eroare pentru c Python foloseste
pentru decodificare standardul UTF-8 i nu ASCII.
13 Comanda cd desktop nu este case sensitive (nu ine cont dac scriei desktop sau Desktop) n Windows i
MacOS dar e case sensitive n Linux. Astfel, dac lucrai pe un computer cu sistemul de operare Ubuntu
instalat (nu tiu la celelalte distribuii Linux), comanda este neaprat cd Desktop, cu majuscul.
12
14
Fig.1.4. Rularea programului popescu.py n linia de comand
Intrri, procesare, ieiri, funcia print
Intrrile (Input-ul) care se fac de obicei de la tastatur, sunt datele pe care computerul le
primete de la utilizator. Urmeaz etapa procesrii lor. Rezultatul operaiei de procesare se
numete ieire (Output) i este afiat pe ecran.
Afiarea ieirii cu funcia print
O funcie este un cod prescris care realizeaz o operaie. Python are numeroase funcii
preconstruite. Totui, dintre toate, fundamental rmne funcia print, adic exact aceea
care afieaz ieirea pe ecran.
Cnd un program execut o funcie, spunem c el cheam (invoc) funcia. Cnd invocm
funcia print, scriem cuvntul print urmat de un set de paranteze ( ). nuntrul
parantezelor scriem argumentul14 care reprezint datele pe care le dorim afiate pe ecran.
Spre exemplu, la invocarea funciei print n declaraia print(Hello World),
argumentul este Hello World. Observm c ghilimelele nu sunt afiate la ieirea
programului. Ele doar arat nceputul i sfritul textului pe care vrem s-l afim.
Parametrul este definit de numele care apare n definiia funciei, n vreme ce argumentul reprezint
variabila trecut unei funcii atunci cnd este invocat. Parametrul definete tipul de argument(e) pe care o
funcie l poate accepta.
14
15
Prin urmare, putem afirma c print este cea mai important funcie. Recapitulnd, cu
ajutorul ei afim ieirea unui program n Python. ncercai n shell-ul Python urmtoarea
linie de cod:
iruri i iruri literale
Ex: Vasile Popescu
46, N.Iorga
Bucuresti, 0722200406
Acestea sunt iruri de date care se mai cheam iruri de date literale. Ele sunt incluse ntre
ghilimele. Se pot folosi ghilimele simple ( ), duble ( ) sau chiar triple ( ).
S lum de exemplu urmtoarea linie de cod care folosete ghilimele simple i duble:
print(Vinoncoa!)
Ea va scoate la ieire irul literal:
Vinoncoa!
Ce s-ar ntmpla dac n expresia (irul) de mai sus am pune doar ghilimele simple (la fel
de bine duble sau triple)? Am primi din partea interpretorului (shell-ul) Python o eroare de
sintax ca mai jos:
Fig.1.5. Eroare de sintax la punerea ghilimelor
Cteva cuvinte n plus trebuiesc adugate despre ghilimelele triple (pe care nu le vei gsi
n Java, C++, C ori PHP) dar care au o semnificaie aparte n Python. Muli folosesc
ghilimelele triple pe post de comentarii, ceea ce este eronat. n Python comentariile sunt
(doar liniile de cod marcate) cu semnul diez (#) la nceput (citii paragraful urmtor).
De exemplu #acesta este un comentariu.
16
Ghilimelele triple sunt tratate ca iruri regulate15 cu excepia cazului n care este vorba de
mai multe linii. Totui, ele nu sunt ignorate de interpretorul Python aa cum se ntmpl cu
comentariile care ncep cu semnul diez (#). Ele sunt aezate imediat dup definiia unei
funcii sau clase, ori n vrful codului unui modul, caz n care se numesc docstrings.
Docstring-urile pot include n interiorul lor ghilimele simple, duble sau de ambele feluri
ca-n exemplul de mai jos:
Fig.1.6. Utilizare ghilimele triple
S vedem acuma ce se ntmpl daca scriem doar ghilimele_triple (fr funcia print) i
dm enter:
Fig.1.7. Un ir ciudat de caractere apare la finalul procesrii programului
Rspunsul este uor nefiresc pentru c el ne arat codificarea intim n Python folosind
caracterul escape (\).
Comentariile
Sunt folosite ntr-un program ca s ari ce ai vrut s faci acolo. Dac peste ctva timp vei
redeschide programul, comentariile i vor reaminti de ceea ce ai vrut s faci cu linia de cod
respectiv din program. Ele sunt ignorate de interpretorul Python dar nu trebuiesc
ignorate de tine!
n Python, comentariile ncep cu semnul diez #.
irurile regulate sunt irurile care nu sunt atribuite unei variabile.
15
17
Ex:
#Acest program afiseaza
#numele unei persoane
print(Mircea Prodan)
1.3. Variabile
Programarea nseamn nainte de toate a jongla cu abstraciuni. A lucra cu astfel de entiti
ce nu sunt palpabile cel puin nu n faza lor de dezvoltare, este n opinia mea cel mai
dificil lucru pentru c n general, marea noastr majoritate avem o putere destul de limitat
de a imagina obiecte pipibile dar care au drept fundament idei incolore, inodore i
mai cu seam fr o form anume. Din acest motiv ni se pare grea matematica...
Variabilele sunt printre cele mai importante elemente din programare i nu m feresc s
afirm c dac ele i manipularea lor este bine neleas, ai fcut un mare pas nainte n
dobndirea unui limbaj de programare.
Totui, spre deosebire de lumea programrii orientat pe obiect (OOP), nelegerea
variabilelor este mulumitor de uoar. Tot ceea ce trebuie s facei este s v gndii la o
variabil ca la o cutie n care depozitai ceva.
Permitei-mi s-o lum altfel. S presupunem c ai terminat recent facultatea, ai redactat
licena care v-a fost aprobat de profesorul ndrumtor i apoi, aa cum cere
regulamentul, trebuie s-o punei (s-o depozitai) pe un CD ce urmeaz s stea la arhiva
universitii multe decenii de atunci ncolo, dar i s predai un exemplar tiprit. Lucrarea
dumneavoastr de licen nu import domeniul este pe calculatorul personal sub forma
unui fiier Microsoft Word16 i deci ea este abstracta. Putei s-o inei n mna? Nu, eventual
putei s-o artai cu degetul pe monitorul computerului! n momentul n care o printai i
legai, ea i pierde aceast calitate i devine un obiect n sine, ct se poate de palpabil, cu
care eventual v putei luda la familie i prieteni. Mergei apoi la facultate i depunei un
exemplar printat. Ea este nregistrat i depozitat ntr-o ncpere a facultii. Hopa! Iat c
dintr-o dat avem variabila care este ncperea i valoarea ei care este lucrarea de licen. Pe
Ar putea la fel de bine s fie o aplicatie de redactare din surs deschis n genul OpenOffice ori LibreOffice,
numai c universitile romneti accept doar fiiere Microsoft Word.
16
18
msur ce ali i ali (poteniali) absolveni i depun lucrrile, numrul (valoarea) lor crete
dar ncperea (variabila17) rmne aceeai.
Mutndu-ne oarecum n lumea computerelor, avei acuma nevoie i de CD-ul care s
conin lucrarea n format digital. Prin urmare ardei un CD nou nou, depozitnd pe/n
el lucrarea n format digital. Aici variabila este CD-ul cruia i-am atribuit valoarea lucrare
de licen. Exemplul meu poate nu este cel mai fericit pentru c un CD obinuit se poate
inscripiona doar o singur data, ceea ce ar nsemna c o dat atribuit o valoare variabilei,
aceasta nu se mai poate modifica. n programare acest fapt nu este adevrat (din acest
motiv se numete variabil). Totui, exist CD-uri care se pot inscripiona de mai multe
ori, radiind informaiile (valorile) de la un moment dat i nlocuindu-le cu altele. Numele
variabilei (n cazul nostru CD) rmne acelai, doar valoarea pe care i-o atribuim (licena) se
schimb.
O variabil este un nume (cuvnt) care reprezint o valoare stocat n memoria
calculatorului. Numele (variabila) se scrie ntotdeauna n partea stng:
age = 49
variante a lucrrii
i nu
49 = age
#Gresit!!
age = 52
actuale
i nu
52 = age
#Gresit!!
De fapt numele ei...
17
19
print( )
argument
>>>latime = 10
funcia print
(Enter)
>>>print(latime)
latime
>>> print(latime) (Enter)
10
>>>
Exemplu de program care demonstreaz o variabil:
(variabila.py)
#Acest program demonstreaza o variabila
camera = 123
print(Stau in camera: )
print(camera)
Ieirea (output-ul) acestui program este:
Stau in camera:
123
Sa vedem in linia de comanda (Terminal) cum putem face economie de spaiu i efort prin
renunarea la ultima declaraie print:
Fig.1.8. Variabila ir
Ce s-ar fi ntmplat dac n prima varianta a exemplului anterior, n ultima declaraie
print am fi cuprins ntre ghilimele parametrul camera ca mai jos? Pi n loc s ne afieze
valoarea parametrului care este 123, ne-ar fi printat cuvntul (irul literal) camera:
20
Fig. 1.9. Importana ghilimelelor18 la afiarea rezultatelor
Ai sesizat diferena?
Exemplu de program cu dou variabile:
(variabila2.py)
#Creeaza doua variabile numite viteza
si distanta
viteza = 160
distanta = 300
#Afiseaza valoarea referita de variabile
print (Viteza este: )
print (viteza)
print (Distanta parcursa este: )
print (distanta)19
Este indicat ca numele variabilei s nceap cu liter mic. Variabilele sunt sensibile la
litere mici sau mari (case sensitive) aa c de exemplu python nu este totuna cu Python..
Numele variabilelor nu au voie s conin cuvintele cheie din Python20. Variabilele nu
trebuie s conin spaii dar au voie s conin (i s nceap) cu semnul underscore ( _ ).
De asemenea, variabilele nu trebuie s nceap cu un numr sau s conin caractere
speciale precum $#%^&* .a.m.d.
Cu funcia print se pot afia mai muli itemi. Ex. (refacerea exemplului variabila.py):
#Acest program demonstreaza o variabila
Se pot folosi ghilimele simple sau duble, rezultatul este acelai.
ncercai acest exemplu pe calculatorul dumneavoastr, dar s cuprind dou declaraii print i nu patru.
20 ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while',
'with', 'yield']
18
19
21
camera = 123
print(Stau in camera numarul , camera)
Ieirea este: Stau in camera 123
Dac privii cu atenie, vei observa ca propoziiei i lipsete ceva esenial (ca s
ndeplineasc normele gramaticale de definire a propoziiei) i anume punctul de la sfrit.
Haidei s vedem cum l afim. (ncercai s figurai rspunsul fr s citii paragraful de
mai jos).
Dac l punem imediat dup ultimul parametru al funciei print (camera) va rezulta o
eroare de sintax. Pentru a nu primi o eroare, punctul trebuie la rndul lui cuprins ntre
ghilimele ca n exemplul de mai jos:
Fig1.10. Afiarea corect a unei declaraii
S mai observm (n linia 4) c dac nu adugm un item separator21 (ca-n finalul liniei 5),
punctul este aezat uor anormal, la o distan destul de mare de locul n care ar trebui s
fie. n output-ul din linia 6 aceast mic inadverten (corect totui din punct de vedere al
programrii, nu ns i estetic) este eliminat.
Stocarea irurilor cu tipul de date str
#Creeaza o variabila care refera doua siruri
prenume = Vasile
nume = Popescu
#Afiseaza valorile referite de variabile
print(prenume, nume)
La ieire vom avea: Vasile Popescu
Am luat-o puin nainte, dar vei vedea foarte curnd ce reprezint un item separator.
21
22
La fel de bine putem s inversm numele dac ultima declaraie ar arta astfel:
print(nume, prenume)
iar la ieire ar rezulta Popescu Vasile.
Tipuri de date. Reatribuirea variabilelor diferitelor tipuri
n Python exist cteva tipuri principale de date:
1. int - ntregi
2. float - n virgul mobil22
3. string (str) - iruri
4. boolean True, False
Ca s aflm cu ce fel de date lucrm utilizm funcia type() ca n exemplele de mai jos:
Fig.1.11. Folosirea funciei type() pentru aflarea tipurilor de date
Ce se ntmpl ns dac unui intreg i adugm zero la sfrit? Pentru noi el rmne un
ntreg, nu ns i pentru calculator. Astfel, el devine un numr n virgul mobil (float):
Fig.1.12. Transformarea int n float
n Python, o variabil poate s refere orice tip de date: ntreg, ir, n virgul mobil (float),
boolean. Dup ce o variabil a fost atribuit unui anumit tip, ea poate fi reatribuit altui tip
de date.
Acestea nu sunt totuna cu numerele zecimale
22
23
Ex:
>>> x = 99
Fig.1.13. Am renunat la 0 n declararea variabilei subunitare
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).
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.
- dar i:
Fig.1.14. mprirea cu ntreg, restul i ridicarea la putere
S notm c la ridicarea la putere, primul numar (n exemplul de mai sus 10) este cel
multiplicat la puterea dat de cel de-al doilea numr (3 n cazul nostru).
Ex. salariu.py
#Atribuie o valoare variabilei salariu
salariu = 2500.0
Cei care au programat n Java sau C tiu c acolo e obligatoriu s declari tipul variabilei. De fapt, acelai
lucru se petrece i n Python, dar doar n cazul datelor cu valoare numeric.
24
26
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
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.
[enter]
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.
29
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
Fig.1.17. Valoare formatat cu specificatorul de format
Formatarea n mod tiinific
Se utilizeaz literele e sau E n loc de f.
Ex:
>>> print(format(12345.6789, e))
1.2345678e +04
>>> print(format(12345.6789, .2e))
1.23e + 04
>>>
Inserarea separatorului virgul
>>> print(format(123456789.456, ,.2f)
123,456,789.46
separatorul virgul28
Programul urmtor demonstreaz cum separatorul virgul i o precizie de dou zecimale
pot fi folosite la formatarea unui numr mare:
(plata_anuala.py)
Pentru c a doua valoare din irul de numere de dup punct - n spe 7 (.6789) este mai aproape de 10
27
dect de 0, computerul rotunjete valoarea n sus, ea devenind .68. Dac ar fi fost n schimb .64..., .63..., .62...,
.61... atunci era rotunjit n jos, ea devenind 0.60.
28 ntre separatorul virgul i punctul situat naintea lui (.2f) nu exista spaiu. Dac este introdus din greeal
va rezulta o eroare (Invalid format specifier).
31
Fig.1.18. Rularea programul plata_anuala.py n shell-ul Python
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%
foloseti d n loc de f
Ex:
>>> print(format(123456, d))
123456
Acuma, acelai exemplu dar cu separatorul virgul:
>>> print(format(123456, ,d))
123,456
Fig.1.20. Exemplu de formatare a irurilor
irurile i alte obiecte au o sintax special pentru funcii numit metod, asociat unui tip
particular de obiect. Obiectele de tipul ir (str) au o metod numita format. Sintaxa pentru
aceast metod conine obiectul urmat de punct urmat de numele metodei i urmtorii
parametri dintre paranteze:
33
obiect.nume_metoda(parametri)
n exemplul de mai sus obiectul este irul Salut {} iar metoda este format.
Parametrul este nume.
Dup cum se observ la ieire, acoladele sunt nlocuite de valoarea preluat din lista
parametrilor metodei format. Deoarece acoladele au un neles special n formatarea
irurilor, este nevoie de o regul special dac vrem ca ele s fie incluse n formatarea
final a irurilor. Regula este dublarea acoladelor: {{ i }}
De exemplu29:
Fig. 1.21. Formatarea irurilor
Vom vedea mai trziu ce reprezint un set in Python.
29
34
Capitolul II FUNCII
O funcie reprezint un grup de declaraii care exist ntr-un program pentru a
realiza o anumit sarcin. Am vazut in primul capitol comportamentul functiei prestabilite
print.
Majoritatea programelor realizeaz sarcini care sunt ndeajuns de mari ca s poat fi
divizate n cteva subsarcini. Din acest motiv programatorii sparg programele n buci
mai mici cunoscute sub numele de funcii.
Astfel, n loc s scriem largi secvene de declaraii, scriem cteva funcii mai mici, fiecare
realiznd o parte specific din sarcin.
Aceste mici funcii pot fi executate n ordinea dorit pentru ca n final s realizeze soluia
la ntreaga problem.
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
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.
def mesaj():
print(Sunt Mircea,)
print(si incerc sa invat
4
Python.)
mesaj()
Cum funcioneaz? Interpretorul ignor comentariile. Apoi citete declaraia def n linia 3.
36
Aceasta creeaz o funcie numit mesaj n memorie. Ea conine declaraiile din liniile 4 i
5. Apoi interpretorul citete comentariul din linia 6 care este ignorat. La sfrit citete linia
7 care invoc funcia mesaj. Aceasta face ca funcia s fie executat i s fie afiat ieirea.
Fig.2.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.
37
creezi o variabil local.
S luam un exemplu de program (pasari.py)30 care are dou funcii i care fiecare conine o
variabil cu acelai nume:
#Acest program demonstreaza doua functii
#care au variabile locale cu acelasi nume.
def main():
#Cheama functia dolj
dolj()
#Cheama functia gorj
gorj()
#Defineste functia dolj. Ea creeaza
#o variabila locala numita pasari
def dolj():
pasari = 5000
print(Doljul are, pasari, de pasari)
#Defineste functia gorj. Ea creeaza
#o variabila locala numita pasari
def gorj():
pasari = 8000
print(Gorjul are, pasari, de pasari)
#Cheama functia principala
main()
Trecerea argumentelor la funcii
Un argument este o poriune de date care este trecut ntr-o funcie atunci cnd funcia este
invocat.
Un parametru este o variabil care primete un argument ce este trecut ntr-o funcie.
Exemplu:
Scriei exemplele n editorul de text caracter cu caracter i nu le copiai (copy/paste) de pe formatul PDF n
care se gsete cartea pentru c exist mari anse s primii o eroare de tipul: SyntaxError: invalid character
in identifier. Aceasta se ntmpl pentru c formatele PDF, Word, ODT etc au caracteristici intime diferite,
care cel mai adesea, nu se potrivesc interpretorului Python ce pur i simplu nu distinge ceea ce scrie n
declaraii.
30
38
def dublul(numar):
rezultat = numar*2
print(rezultat)
Funcia se cheama dublul. Ea accept un numr (numar) ca parametru i afieaz
valoarea dublat a acelui numr. Sa vedem cum functioneaza in interpretorul Python:
Fig.2.3. Exemplul anterior complet
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:
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()
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
41
Fig.2.7. Funcia lambda
42
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
#o iau la stanga
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
<=
>=
==
Egal cu
!=
declaratie
declaratie
etc
else:
declaratie
declaratie
44
etc
Ex:
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)
Imbricat = mbucat(e), suprapus(e) ca indrilele de pe casa (cf.dexonline.ro)
31
32 Atunci cnd introducem date numerice putem utiliza eval fr sa ne mai gndim dac e vorba de o valoare n
virgul mobil sau de un ntreg. eval ine loc de float sau input.
45
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.6.Bucle
Buclele sunt acele pri dintr-un program care sunt folosite ca s execute o declaraie atta
timp ct o expresie este adevrat.
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
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!)
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.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()
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
3.10. Acumulatori
Un total de funcionare (running total) este o sum de numere care acumuleaz fiecare
iterare (trecere, execuie) a unei bucle. Variabila folosit ca s nmagazineze totalul se
cheam acumulator.
Multe programe cer s calculezi totalul unei serii de numere. De exemplu, se presupune c
scrii un program care calculeaz totalul vnzrilor pentru o sptmn. Programul citete
vnzrile din fiecare zi i calculeaz totalul acelor numere.
Acest tip de programe folosete de obicei dou elemente:
1. o bucl care citete fiecare numr al seriei
2. o variabil care acumuleaz totalul numerelor citite
S lum un program care demonstreaz un acumulator:
#Acest program calculeaza suma unei serii
#de numere introduse de user
#Ia constanta pentru numarul maxim
(Reine! Constanta se pune la nceput)
MAX = 5
Def main():
52
total = total+number
#Afiseaza totalul numerelor
print(Totalul este, total)
#Cheama functia principala
main()
53
Fig. 3.10. Date aberante i rspunsuri pe msur!
54
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.
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
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
Fig.4.2. Ilustrarea exemplului de mai sus
58
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)
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
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()
Valorarea math.pi
Suprafaa cercului este constanta pi nmulit cu raza cercului la ptrat, dup cum bine
tim din clasa a VII-a, de la studiul geometriei plane:
suprafata = math.pi*radius**2
Ce se ntmpl? Suprafaa cercului este S=pi**r (unde r este raza cercului) la ptrat. Dar
cum pi este o constant universal care aparine modulului matematic, trebuie s scriem
math.pi.
62
Un modul este doar un fiier care conine cod Python. Programele mari sunt (mai) uor de
reparat i ntreinut atunci cnd sunt mprite n module dar mai ales pot fi refolosite33
intr-un alt program. Un modul poart ntotdeauna extensia .py.
Modulul calendar
Sa luam de exmplu modulul implicit Python calendar. El se importa ca oricare alt modul,
asa cum am aratat mai devreme, cu declaratia import:
import calendar
Ca s afim de exemplu cum arta anul Revoluiei 1989 trebuie s ne referim la funcia
inclus n modulul calendar, prcal (printeaz calendar) folosind notaia cu punct:
calendar.prcal()
Programul urmtor afieaza anul amintit:
import calendar
an = int(input(Introdu anul dorit: ))
prcal(an)
S vedem cum funcioneaz n Python shell:
Fig.4.3. Modulul calendar
Reuse n lib.englez
33
63
procesoare word
editoare de imagine
tabele de date
jocuri de calculator
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.
65
unde:
-
mode este un ir care specific modul (scris, citit, etc) n care fiierul va fi deschis.
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)
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)
customer_file.close()
#in fisier
outfile.write(Ion Iliescu\n)
outfile.write(Emil Constantinescu\n)
outfile.write(Traian Basescu\n)
10
#Inchide fisierul
outfile.close()
12
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.
#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
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
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
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.
71
Fig. 5.3. Copierea fisierului barbati.txt
Fig. 5.4. Functionare in Terminal
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
AttributeError
EOFError
FloatingPointError
IOError
74
IndexError
Cand se foloseste un index aflat in afara gamei
(range)
KeyError
OSError
OverflowError
TypeError
ValueError
ZeroDivisionError
75
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].
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
Fig. 6.3. Acces index list
Dac folosim indeci negativi, vom identifica poziia elementelor relative la sfritul listei.
Aa se face c indexul -1 identific ultimul element al listei, -2 pe penultimul i tot aa.
Indexul 0 este acelai cu indexul -4. Ce se ntmpl ns dac vrem s aflm elementul care
numrat de la coada listei, are indexul -5 ?
Va aprea o eroare Traceback pentru c lista nu contine cinci indecsi:
Fig.6.4. Afiarea elementelor cu ajutorul indecsilor negativi
78
Funcia len
Cu ajutorul funciei len putem afla lungimea unei liste.
S lum urmtorul cod:
lista = [1, 2, 3, 4, 5]
lungime = len(lista)
Fig.6.5. Funcia len( )
Funcia len poate fi folosit ca s previn o excepie IndexError atunci cnd iterm peste o
list cu o bucl:
lista = [1, 2, 3, 4, 5]
index = 0
while index < len(lista):
print(lista[index])
index +=1
Listele sunt mutabile
Aa cum scriam la nceputul capitolului, listele n Python sunt mutabile ceea ce nseamn
c elementele ei pot fi schimbate.
S vedem un exemplu:
lista = [1, 2, 3,4, 5]
print(lista)
lista[0] = 50
print(lista)
Cum funcioneaz:
Pe rndul 1 crem lista lista iar apoi o afim pe rndul 2. Pe rndul 3, elementului 0 din
list care este 1 i reatribuim valoarea 50. Cu linia 4 afim noua componen modificat
79
a listei:
Fig.6.6. Listele pot fi modificate
Ce se ntmpl dac nu folosim un index valid, ci unul care depete numrul elementelor
listei? Va aprea o excepie:
Fig.6.7. Excepie de ieire din marj
Lista de mai sus are cinci elemente dar care au indecii de la 0 la 4. Cum nu exist index-ul
7, ncercarea de modificare va eua aprnd o eroare Traceback.
S luam un exemplu cu bucla while:
Fig. 6.8. Program list vnzri
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
Fig.6.11. Concatenare iruri
81
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()
84
print()
#afiseaza numele introduse
print('Iata numele pe care le-ai introdus.')
for nume in nume_lista:
print(nume)
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()
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
87
Fig. 6.22. Funcia min
88
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
Operatorul in
Operatorii + si *
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}
91
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
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
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
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
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)
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
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
Invocm funcia load din modulul pickle ca s recuperm un obiect din fiier
Fig. 6.55. Citirea binar a fiierului
101
102
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
OBIECT
Date
--//-
--//--
--//--
--//--
--//--
METODE
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
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
7.2. Clase
O clas este un cod care specific atributele datelor i metodele pentru un tip
particular de obiect.
nainte ca un obiect s fie creat, el trebuie s fie proiectat de un programator.
Programatorul determin atributele i metodele necesare i apoi creaz o clas. S ne
gndim la o clasa ca la un ablon dup care obiectele sunt creeate. ablonul servete acelai
scop ca acela folosit la proiectarea unei case. ablonul n sine nu este o cas dar el descrie n
detaliu o cas. Cnd folosim un ablon ca s construim o cas putem spune c construim o
instan a casei descrise de ablon. Dac vrem, putem s construim oricte case (identice)
dorim dup ablon. Fiecare cas este o instan separat a casei descrise de ablon.
Programatorii au mai imaginat i o alt asemnare pentru a descrie mai bine diferenele
dintre clase i obiect. Spre exemplu o form de prajitur i prjitura n sine. Sau, daca m
gndesc la gogoile pe care le fcea bunica mea cu paharul, atunci gura paharului descria o
gogoa dar nu era o gogoa la rndul ei. Forma de prajitur este deci folosit s faci
prjituri. S ne gndim la o clas ca la un ablon, o form de prjituri sau gura unui pahar
iar la obiectele create cu ele ca la prjituri, gogoi sau case.
106
Un alt exemplu foarte nimerit de clas este formularul de la ghieul primriei prin care
solicii ceva. Formularul este proiectat o singur dat iar apoi este multiplicat n mii de
exemplare. Solicitantul (ceteanul) vine la primrie cu o problem i i se nmneaz sau i
ia singur un formular pe care l completeaz. Fiecare cetean are datele lui personale pe
care le introduce. O dat formularul completat avem deja de a face cu o instan a clasei
formular.
Deci o clas descrie caracteristicile unui obiect. Cnd un program ruleaz el poate folosi o
clas ca s creeze n memorie oricte obiecte dorete. Fiecare obiect care este creat de o clas se
cheam instana clasei.
De exemplu, Andrei se ocup cu scrierea de programe de calculator. El proiecteaz un
program care s catalogheze diversele tipuri de automobile. Ca parte a programului,
Andrei creeaz o clas numit Vehicul care are caracteristicile comune oricror vehicule
(tip, productor, pre etc).
Clasa Vehicul specific obiectele ce pot fi create din ea. Apoi, Andrei scrie declaraiile de
program care creeaz un obiect numit automobil care este o instan a clasei Vehicul.
Obiectul automobil este o enitate care ocup un loc n memoria computerului i stocheaz
date despre automobil. El are atributele i metodele specific clasei Vehicul. Apoi Andrei
scrie o declaraie care creeaz un obiect numit bicicleta. Obiectul bicicleta este de asemenea
o instan a clasei Vehicul. El are propriul loc n memorie i stocheaz date despre bicicleta.
Altfel, obiectele automobil i bicicleta sunt dou entiti separate n memoria
computerului, ambele create din clasa Vehicul. Asta nseamn c fiecare dintre cele doua
obiecte are atributele i metodele descrise de clasa Vehicul.
Clasa
Vehicul
Obiectul
automobil
Obiectul
bicicleta
107
35
108
>>> b = PrimaMeaClasa()
>>> print(a)
< __main__.MyFirstClass object at 0xb7b7faec>
>>> print(b)
< __main__.MyFirstClass object at 0xb7b7fbac>
>>>
Explicaii
Codul de mai sus instaniaz dou obiecte ale clasei MyFirstClass, obiecte numite a i b.
Crearea instanei unei clase nseamn de fapt scrierea numelui clasei urmat de o pereche
de paranteze. Ea arat aproape la fel ca invocarea unei funcii normale, numai c Python
tie c invoc o clas i nu o funcie, deci nelege c sarcina lui e s creeze un obiect nou.
Cnd sunt afiate, cele dou obiecte ne spun despre ce clas e vorba i care e adresa de
memorie unde ele slluiesc. Adresele de memorie nu sunt prea mult folosite n Python,
dar n exemplul anterior ele demonstreaz c sunt implicate dou obiecte distincte.
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.
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.
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))
112
__init__(self):
self.in_sus = Cap
12
def intoarce(self):
13
if random.randint(0, 1) = = 0:
14
self.in_sus = Cap
15
else:
16
self.in_sus = Pajura
17
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
Linia 12
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:
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
116
Fig. 7.4. Ieirea programului polita.py
117
class Animal(Object):
S lum n continuare un exemplu.
#Aici avem superclasa
class Animal(object36):
vorbesteStr = Salut de la Animal!
pass
#Aici avem clasa derivata
class Caine(Animal):
pass
latra = Caine.vorbesteStr
print(latra)
La ieire vom avea Salut de la Animal!.
Fig. 7.5. Ieire program animal.py
Clasa Caine motenete atributele clasei Animal i afieaz irul pe care clasa Animal l-a
avut ca atribut. Dac ns vrem s suprascriem valoarea unui atribut din clasa derivat
Caine, facem astfel (caine.py):
class Animal(object):
vorbesteStr = Salut de la Animal!
pass
class Caine(Animal):
vorbesteStr = Salut de la caine!
pass
latra = Caine.vorbesteStr
print(latra)
care va avea ieirea Salut de la caine aa cum se poate vedea n figura de mai jos:
Putem s adugm sau nu object, functionarea programului nu va fi afectata.
36
118
Fig. 7.6. Ieirea programului caine.py
Putem de asemenea s executm o metod din clasa printe (superclas) nauntrul unei
subclase aa cum se poate vedea n urmtorul program rulat n interpretorul Python:
Fig. 7.7. Metoda inauntrul subclasei
S mai lum un exemplu - de aceast dat din geometrie. S spunem c dorim s aflm
suprafaa unui dreptunghi i a unui triunghi care sunt la origine poligoane.
Poligon
Dreptunghi
Triunghi
Prin urmare trebuie s crem superclasa Poligon i apoi subclasele Dreptunghi i
Triunghi care s o moteneasc.
Prima dat crem superclasa Poligon (poligon.py):
class Poligon:
lungime = 0
latime = 0
def set_valori(self, lungime, latime):
119
Poligon.lungime = lungime
Poligon.latime = latime
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
Browser
utilizator
Cerere
Web
Server
(raspuns
HTML)
Inter-
pretor
Python
Exist totui i posibilitatea rulrii scripturilor PHP din Terminal cu comanda php a, desigur dac PHP este
instalat pe calculatorul dumneavoastr.
37
123
Serverul web trebuie mai nti configurat ca s recunoasc scripturile (fiierele) Python
care au aa cum am nvat, extensia .py. Interpretorul Python proceseaz scriptul nainte
de a-l trimite ca un rspuns HTML serverului, care la rndul lui l returneaz browser-ului
utilizatorului. Un script Python cerut de browser poate s genereze un rspuns complet
HTML descriind tipul coninutului n prima linie a fiierului astfel:
Content-type:text/html\r\n\r\n
Ce facem totui cu scriptul (pe care nc nu l-am creat, linia de cod de mai sus arat doar
declaraia iniial din fiier), pentru c, altfel ca fiierele Python pe care le-am dezvoltat
pn acuma i care rulau din linia de comand a calculatorului, avem nevoie de un web
server ?
Exist aici dou posibiliti de luat n calcul:
a. S instalm serverul arhicunoscut i arhifolosit38 pe plan mondial Apache pe
propriul computer i apoi s-l configurm astfel nct s tie s proceseze scripturi
Python.
Aceasta este o operaie destul de dificil, care necesit timp, aflat nu la ndemna
nceptorilor. Totui, n Anexe gsii modul de configurare a fiierului httpd.conf (care
este creierul i inima serverului Apache) pentru a prelucra fiiere Ruby, CGI, Perl i
Python.
b. Cea mai la ndemn metod este s scriem propriul server n Python, operaie ce
necesit cteva linii de cod.
Vom apela la aceast a doua metod pentru c este mult mai puin complicat. Trebuie
reinut c fiierele vor fi afiate n regim local (localhost) n browser-ul calculatorului
dumneavoastr. Dac avei propriul website i vrei s exersai n lumea real putei
ntreba administratorul de sistem al serviciului de gzduire (hosting) dac exist
posibilitatea (n general, ea nu este setat implicit) de a v configura serverul pentru
scripturi Python. Oricum, dac atunci cnd ai nchiriat spaiu pe server n ofert nu era
trecut i opiunea scripturi CGI, sigur nu avei aceast posibilitate. Ca o parantez
vreau s mai adaug c gzduirea de scripturi sofisticate precum CGI, Perl, Python sau
Peste 60% din website-uri utilizeaz serverul Apache
38
124
Ruby cost enorm cel puin la anumite firme i mai ales pentru buzunarele noastre.
Serviciul meu de hosting de care de altfel nu m pot plnge, mi oferea pentru scripturi
Python un server dedicat la preul minim de 29 euro/lun! Normal c am zis pass ca-
ntr-o clas Python! Exist ansa s gsii i oferte ce includ scripturi CGI la preuri de bun
sim, dar dac spre exemplu, v bate gndul s v portai / alctuii un website n
framework-ul Django (scris n Python) ori n Mezzanine, vei primi rspunsul c nu e
posibil sau eventual, v vor pretinde o cru de bani.
Din acest motiv exemplele pe care le voi arta n continuare sunt pur i simplu oferite n
scop didactic, pentru a vedea cum poate fi utilizat Python n aplicaii de Internet.
Dar vorba mult srcia programatorului, aa c s dm drumul la treab i s scriem
codul serverului Python necesar aplicaiilor noastre, nu nainte de a crea pe desktopul
computerului un folder numit webdir iar nuntrul acestuia nc unul numit cgi-bin.
Scriptul webserver.py arat astfel:
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
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
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