Tutorial Python Versiune 2.2 Guido van Rossum Fred L. Drake, Jr., editor 9.

Decembrie 2001 PythonLabs Email: python-docs@python.org

Copyright c 2001 Python Software Foundation. All rights reserved. Copyright c 20 00 BeOpen.com. All rights reserved. Copyright c 1995-2000 Corporation for Nation al Research Initiatives. All rights reserved. Copyright c 1991-1995 Stichting Ma thematisch Centrum. All rights reserved. See the end of this document for comple te license and permissions information.

Abstract Python este un limbaj de programare puternic s i u sor de nv a tat. Are stru cturi de date de nivel nalt, e ciente s i o simpl a dar e cient a abordare a program ari orientate pe obiect. Sintaxa elegant as i natura sa interpretat a, fac din Python un limbaj ideal pentru elaborarea de script-uri s i dezvoltarea rapid a de aplica t ii n multe domenii, pe majoritatea platformelor. Interpretorul Python s i libr aria standard sunt oferite sub form a de surse sau compilate pentru majoritatea platf ormelor existente, pe site-ul Python, http://www.python.org/, s i pot distribuite gratuit. Pe acela si site pute ti g asi distribu tii Python s i module scrise de al t i programatori, precum s i documenta tie adi tional a. Interpretorul Python este u so r de extins prin ad augarea de noi func tii s i tipuri de date implementate n C sau C++ (sau alte limbaje apelabile din C). Python poate folosit s i drept limbaj de extensie pentru aplica tii. Acest material informeaz a cititorul despre conceptele de baz as i capabilit a tile sistemului s i limbajului Python. Ar de preferat s a av ti la ndemn a un interpretor Python pentru a experimenta, dar toate exemplele cupri nse n acest material pot n telese f ar a a imperativ a prezen ta interpretorului. u o descriere a obiectelor s i modulelor standard, consulta ti documentul Python L ibrary Reference. Documentul Python Reference Manual d a o de ni tie mai exact a a li mbajului. Dac a dori ti s a extinde ti sau s a implementa ti limbajul Python ntr-o apl ca tie cu ajutorul C++ consulta ti documentul Extending and Embedding the Python I nterpreter s i Python/C API Reference. Exist as i c ar ti care acoper a limbajul Pytho n n toat a complexitatea sa. Acest tutorial nu ncearc a s a acopere toate facilit a ti e Python-ului, sau m acar cele mai folosite dintre ele. n schimb, v a prezint a cele mai interesante s i importante facilit a ti, s i v a va da o idee despre modul de fu nc tionare al limbajului. Dup a ce ve ti citi acest tutorial, ve ti putea citi s i sc rie module sau programe Python, s i ve ti preg ati ti s a v a ta ti mai multe desp ritele libr arii incluse n distribu tia Python, descrise n documentul Python Library Reference.

CUPRINS 1 2 De ce Python? 1.1 n continuare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Utilizarea interpretorului Python 2. 1 Invocarea interpretorului . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Interpretorul s i mediul n care ruleaz a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . O introducere scurt a n Python 3.1 Utilizarea Python-ului drept calculator de birou . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Primii pa si n programare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Structuri de con trol 4.1 Instruc tiuni if . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Instruc tiuni for . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Func tia range() . . . . . . . . . . . . . . . . . . . . . . . . 4.4 Instruc tiuni break s i continue, s i clauze else pentru bucle 4.5 Instruc tiuni pass . . . . . . . . . . . . . . . . . . . . . . . . 4.6 Func tii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7 Mai multe despre func tii . . . . . . . . . . . . . . . . . . . . . Strucuri de date 5.1 Mai multe despre liste . . 5.2 Instruc tiunea d el . . . . 5.3 Perechi s i secven te . . . . 5.4 Dic tionare . . . . . . . . 5.5 Ma i multe despre condi tii 5.6 Compararea secven telor . Module 6.1 Mai multe despre module 6.2 Module standard . . . . . 6.3 Func tia dir() . . . . . 6.4 Pachete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 2 3 3 4 7 7 17 19 19 19 20 21 21 22 23 29 29 33 34 35 35 36 37 38 39 40 41 45 45 47 51 51 3 4 5 6 7 Intr ari s i ie siri 7.1 Formatarea mai elegant a a datelor la ie sire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Fi siere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erori s i excep tii 8.1 Erori de sintax a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 i

8.2 8.3 8.4 8.5 8.6 9 Excep tii . . . . . . . . . . . . Tratarea excep tiilor . . . . . . Generarea exce p tiilor . . . . . Excep tii de nite de utilizator . De nirea ac tiunilor de cur a tare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 52 54 55 56 59 59 60 61 64 65 66 67 69 Clase 9.1 Cteva cuvinte despre terminologie . . . . . . . . . . . . . . . . . . . . . . . . 9.2 Domenii de vizibilitate (Scopes) s i domenii de de ni tie a numelor(N ame Spaces) 9.3 O prim a privire asupra claselor . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4 Alte observa tii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.5 Mo stenirea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.6 Variabile private . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.7 Altfel de clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Continuarea? A Editarea n linie de comand as i repetarea comenzilor anterioare A .1 Editarea n linie de comand a . . . . . . . . . . . . . . . . . A.2 Repetarea co menzilor anterioare(History) . . . . . . . . . . A.3 Rede nirea tastelor func tiona le . . . . . . . . . . . . . . . . A.4 Comentarii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 71 71 72 73 75 77 79 79 80 B Aritmetica n virgul a otant a: rezultate s i limit ari B.1 Erori de reprezentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C Istoria s i licen ta C.1 Istoricul produsului Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C.2 Terms and conditions for accessing or otherwise using Python . . . . . . . . . . . . . . . . . . . . . ii

CAPITOL UNU

De ce Python? Dac a a ti construit vreodat a un shell complex, probabil cunoa ste ti senza tia: vre i s a ad auga ti nc a o facilitate, dar este deja att de lent, att de mare, att de co icat; sau ad augarea facilit a tii implic a un apel de func tie de sistem, sau alt a f unc tie care nu este accesibil a dec at din C. De obicei problema pe care o ave ti d e rezolvat nu este su cient de serioas a astfel nct s a merite s a rescrie ti shell-ul C; poate c a rezolvarea problemei necesit a folosirea s ir-urilor de lungime variab il a, sau a listelor sortate de nume de siere, lucruri accesibile ntr-un shell, dar care necesit a mult a munc a pentru a implementate n C; sau poate c a nu sunte ti su ent de familiarizat cu limbajul C. S a consider am o alt a situa tie: presupunem c a trebuie s a lucra ti cu anumite biblioteci C, s i ciclul obi snuit de scrierecompila re-testare-recompilare este prea lent. Vre ti s a dezvolta ti mult mai rapid softwa re. E posibil s a scris un program care poate folosi un limbaj de extensie, s i nu vre ti s a dezvolta ti un alt limbaj pentru asta, s a scrie ti s i s a veri ca ti de i un interpretor pentru acest limbaj, pentru ca apoi s a-l ad auga ti la aplica tia dumneavoastr a. n aceste cazuri Python este limbajul de care ave ti nevoie. Este si mplu de folosit, dar este un limbaj de programare adev arat, oferind posibilitate a unei mai bune structur ari, s i un suport mai bun pentru programe mari dect ofer a un shell. Pe de alt a parte dispune de o mult mai bun a veri care a erorilor dect Cul, s i ind un limbaj de nivel foarte nalt, dispune de tipuri de date de nivel nalt cum ar tablouri sau dic tionare foarte exibile, a c aror implementare n C ar lua pro gramatorului zile. Datorit a caracterului general al tipurilor de date Python poa te aplicat ntr-o arie mult mai larg a de probleme dect AWK sau PERL. Cu toate astea , multe lucruri se realizeaz a la fel de u sor n Python ca s i n aceste limbaje. Pyth on permite divizarea programelor dumneavoastr a n module care pot folosite apoi n a lte programe Python. Dispune de o colec tie vast a de module standard de la care p ute ti porni n construirea programului dumneavoastr a, sau pentru a nv a ta programare a n Python. Exist a de asemenea module ncorporate care ofer a facilit a ti pentru sist emul de intr ari ie siri (I/O), apeluri de sistem, sockets, s i chiar interfe te pen tru sisteme de interfa tare gra c a utilizator (GUI) precum TK. Python este un limba j interpretat, care v a poate accelera munca n timpul procesului de dezvoltare, ne mai ind nevoit s a compila ti codul de ecare dat a. Interpretorul poate folosit inte ractiv, ceea ce v a permite s a testa ti foarte u sor anumite facilit a ti ale limbaju lui, s a scrie ti imediat programe dispensabile, sau s a testa ti anumite func tii nai nte de a le folosi n programul dumneavoastr a. Este foarte folositor s i drept, cal culator de birou. Python permite scrierea unor programe foarte compacte s i u sor de citit. Programele scrise n Python sunt mult mai mici decat echivalentele n C sa u C++ pentru c a: tipurile de date de nivel nalt v a permit s a realiza ti opera tii omplexe ntr-o singur a instruc tiune; gruparea instruc tiunilor este dat a de paragra fare n loc de blocuri begin/end sau de acolade; nu este necesar a declararea varia bilelor. Python este extensibil: dac a ave ti cuno stin te de C pute ti foarte u sor s a ad auga ti o nou a func tie sau un modul, e pentru a efectua opera tii la vitez a ma im a, e pentru a lega programe Python la biblioteci disponibile numai n form a binar a (biblioteci gra ce). Pute ti de exemplu s a ad auga ti interpretorul Python ntr-o apl ica tie C s i s a l folosi ti ca un limbaj de comand a sau de extensie pentru acea apl ica tie. 1

Numele limbajului provine de la emisiunea BBC Monthy Pythons Flying Circus (Circul zbur ator al s arpelui Monty) s i nu are nici o leg atur a cu disgra tioasele reptile. Referin te la Monty Python n documenta tia ce urmeaz a nu numai c a sunt permise, su nt chiar ncurajate! 1.1 n continuare

Acum c a ave ti o idee despre Python, poate dori ti s a l examina ti mai n detaliu. Di moment ce, cea mai bun a metod a de a nva ta un limbaj de programare este utilizare a acestuia, sunte ti s i dumneavoastr a invita ti s a o face ti. n urmatorul capitol e te explicat a utilizarea interpretorului. Informa tiile ce urmeaz a pot p area banal e, dar sunt esen tiale pentru testarea exemplelor ce vor urma. Cealalt a parte a t utorialului prezint a diferite facilita ti ale limbajului Python. Aceast a prezenta re este bogat a n exemple, ncepnd cu expresii simple, instruc tiuni, tipuri de date s i terminnd cu func tii, module s i concepte avansate cum ar tratarea excep tiilor s clase de nite de utilizator. 2 Capitol 1. De ce Python?

CAPITOL DOI Utilizarea interpretorului Python 2.1 Invocarea interpretorului Interpretorul Python este deobicei instalat n /usr/local/bin/python pe ma sinile und e exist a aceast a cale. n lista cu directoarele de sistem a U NIX introduce ti cale a /usr/local/bin pentru a putea porni interpretorul cu comanda : python

Din moment ce directorul n care este instalat interpretorul, poate modi cat la inst alare, s i alte c ai sunt posibile. Vorbi ti cu administratorul dumneavoastr a de si stem nainte de a lua o decizie n privin ta directorului de instalare. (Ex: /usr/loca l/python este o alternativ a foarte popular a). Tastarea unui caracter de sfr sit de ier (Control-D pe U NIX, sau Control-Z pe DOS sau Windows) n timpul prompt-ului p rincipal determin a oprirea execu tiei interpretorului cu cod de ie sire zero. Dac a acest lucru nu func tioneaz a ncerca ti comenzile: import sys; sys.exit(). Facilit a le de editare n linie de comand a ale interpretorului nu sunt deloc deosebite. Pe sisteme U NIX, n timpul instal arii Python, pute ti activa op tiunea de suport a bib liotecii GNU de editare n linie de comand a, care adaug a mai multe facilit a ti pent ru editare n linie de comand a. Pentru a vedea dac a aceast a op tiune este activat a, tasta ti combina tia de taste Control-P la primul prompt Python. Dac a auzi ti un s unet, ave ti activat a op tiunea despre care vorbeam mai sus (consulta ti Anexa A, p entru o scurt a list a de combina tii de taste foarte utile). Dac a nu se ntampl a nim ic sau este a sat ^P, op tiunea de editare a liniei de comand a nu este activat a, de ci nu ve ti putea dect s as terge ti (BACKSPACE) sau s a introduce ti noi caractere n nie. Interpretorul func tioneaz a aseman ator shell-ului U NIX: Cnd este apelat cu i ntrarea standard conectat a la un dispozitiv TTY, cite ste s i execut a comenzi inte ractiv. Cnd este apelat cu un parametru reprezentnd un nume de sier, cite ste s i exe cut a un script (program) din acel sier. O a treia modalitate de a porni interpret orul este python -c command[arg] . . . care execut a instruc tiunea/instruc tiunile d in comand a, analog op tiunii -c a shell-ului. Din moment ce o comand a poate con ti ne spa tii sau alte caractere utilizate de shell (ca separatori de parametrii de exemplu) este bine s a introduce ti comanda/comenzile ntre ghilimele. ntre python fil e s Observa ti c a exist a o diferen ta i python <file. n primul caz, datele de intr le programului sunt oferite de sier. Din moment ce acest sier a fost deja citit pa n a la cap at nainte de nceperea programului, programul va ntlni sfr sit de sier i n al doilea caz (cel mai interesant s i folosit) datele de intrare sunt oferite d e orice sier sau dispozitiv conectat la intrarea standard a interpretorului Pytho n. Cnd este rulat un script, este cteodat a folositor ca dup a rularea script-ului s a se intre n modul interactiv. Acest lucru se realizeaz a foarte simplu folosind u n parametru -i nainte de numele sierului n care se a a script-ul. Evident c a acest p rametru nu va func tiona dac a script-ul este citit de la intrarea standard. 3

2.1.1 Transmiterea argumentelor

Atunci cnd dup a parametrul care reprezint a sierul n care se a a script-ul, interpr rului i se mai transmit s i al ti parametrii, acesta i va transmite mai departe scr ipt-ului prin intermediul variabilei sys.argv, variabil a ce con tine o list a (vec tor) de s iruri de caractere. Atunci cnd n loc de numele sierului se transmite _ (adi a intrarea standard), sys.argv[0] = _. Cnd este folosit a comanda -c, sys.argv[0] = c. Parametrii de dup a -c comand a nu sunt considera ti parametrii ai interpretorulu i, ci sunt scri si n sys.argv pentru a folosi ti de comand a. 2.1.2 Modul interactiv

Cnd comenzile sunt citite de la un TTY, se spune c a interpretorul se a a n modul int eractiv. n acest mod exist a dou a prompt-uri. Prompt-ul principal (de obicei >>> ) s i promptul secundar (de obicei ... ) folosit pentru continuarea liniilor. Interpre torul a seaz a imediat dup a pornire un mesaj de ntmpinare ncare se speci c a versiun autorii Python-ului, urmate de primul prompter : python Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos5 Copyrigh t 1991-1995 Stichting Mathematisch Centrum, Amsterdam >>> Liniile de continuare sunt folosite la introducerea unei construc tii multilinie. De exemplu: >>> pamantul_este_plat = 1 >>> if pamantul_este_plat: ... print "Ai grija sa nu cazi!" ... Ai grija sa nu cazi! 2.2 Interpretorul s i mediul n care ruleaza 2.2.1 Tratarea erorilor Cand are loc o eroare, interpretorul a seaz a un mesaj de eroare s i starea stivei n momentul respectiv. n modul interactiv revine la prompt-ul principal. Atunci cnd i ntr arile provin dintr-un sier, interpretorul se opre ste cu un cod de eroare difer it de zero dup a ce a a sat starea stivei.(Excep tiile tratate nu sunt erori n acest context). Unele erori sunt inevitabil fatale s i cauzeaz a terminarea anormal a cu cod de ie sire diferit de zero (Ex: lipsa de memorie). Toate mesajele de eroare s unt scrise la ie sirea pentru erori (standard error stream). Ie sirile provenite d in execu tia comenzilor sunt scrise la ie sirea standard. Dac a se apas a caracterul de ntrerupere (Control-C, DEL) n primul prompt sau n cel secundar, comanda scris a este pierdut a revenindu-se la promptul principal. ntreruperea unei comenzi n timpu l execu tiei creeaz a o excep tie de tip Keyboard Interrupt, care poate tratat a ntro instruc tiune try. 2.2.2 Script-uri Python Executabile Pe sisteme U NIX,BSD, scripturile Python pot a scripturile de shell, punnd linia #! /usr/bin/env python 4 Capitol 2. Utilizarea interpretorului Python f acute direct executabile, la fel c

(presupunem c a interpretorul se a a n variabila de sistem PATH a utilizatorului) la nceputul script-ului s i apoi transformnd sierul n executabil. Caracterele #! tre e neap arat primele dou a caractere din sier. Observa tie: Caracterul # este folosi entru comentarii n Python. 2.2.3 Fi sierul de ini tializare al modului interactiv

Cnd folosi ti Python n modul interactiv, poate foarte folositor s a ave ti cteva come zi care s a se execute automat de ecare dat a cnd este pornit interpretorul. Pute ti realiza acest lucru crend o variabil a de sistem cu numele PYTHONSTARTUP care s a c on tin a numele unui sier n care s a ave ti comenzile, care dori ti s a e executat rnirea interpretorului. Aceast a procedur a este similar a, facilit a tii .pro le de p istemele U NIX. Acest sier de ini tializare este interpretat numai cnd este pornit interpretorul Python n mod interactiv. Fi sierul nu este interpretat nici cnd inter pretorul Python are ca intrare un sier, nici cnd sursa explicit a a comenzilor este /dev/tty. Acest sier este executat n acela si cadru n care se execut as i comenzil eractive. n acest sier pot schimbate chiar s i prompt-urile sys.ps1 sau sys.ps2. Da c a dori ti s a executa ti s i alte siere de ini tializare, din directorul curent tr ie s a ad auga ti cteva linii la sierul principal de ini tializare, utiliznd un cod acesta if os.path.isfile(.pythonrc.py) : execfile(.pythonrc.py) Dac a dori ti s a fo i acest sier de ini tializare, ntr-un program, trebuie s a speci ca ti acest lucru exp icit n cadrul programului astfel: import os filename = os.environ.get(PYTHONSTARTUP) if filename and os.path.isfile( filename): execfile(filename) 2.2. Interpretorul s i mediul n care ruleaza 5

CAPITOL TREI

n Python O introducere scurta n exemplele ce urmeaz a, intr arile s i ie sirile vor deosebite prin prezen ta sau ab en ta prompt-urilor (principal >>> sau secundar ... ). Pentru a testa un exemplu tre buie s a scrie ti linia ce apare imediat dup a prompt. Liniile care nu sunt linii d e ie au caracterele >>> sau ... n fa ta sire, rezultate n urma comenzilor anterioar sau a ultimei comenzi. Un prompt secundar, f ar a nimic dup a el, nseamn a c a trebuie s a introduce ti o linie goal a. Acest procedeu este folosit pentru terminarea unu i bloc de instruc tiuni (de tipul begin...end;{...}). Multe din exemplele din acest t utorial con tin comentarii. n Python comentariile ncep cu un caracter # s i se termin la sfr situl liniei. Un comentariu poate ap area la sfr situl unei linii, dar nu poa te ap area n cadrul unui string. Un caracter # n cadrul unui string nu reprezint a nce utul unui comentariu ci doar un caracter #. Iat a cteva exemple: # primul comentariu SPAM = 1 # \c{s}i al doilea comentariu # ... \c{s}i al treilea! STRING = "# Acesta nu est e un comentariu." 3.1 Utilizarea Python-ului drept calculator de birou

S a ncerc am cteva comenzi simple Python. Porni ti interpretorul s i a stepta ti s a a prompt-ul principal >>> .(Nu ar trebui s a dureze prea mult). 3.1.1 Numere Interpretorul func tioneaz a ca un simplu calculator: pute ti scrie o expresie, s i ca r aspuns ve ti primi rezultatul. Ordinea opera tiilor s i modul de parantezare su nt la fel ca n majoritatea limbajelor (ex: Pascal sau C). De exemplu: 7

>>> 4 >>> ... 4 >>> 5 >>> ... ... 2 >>> -3 2+2 # Acesta este un comentariu 2+2 # Un comentariu pe aceia\c{s}i linie de cod (50 - 5 * 6) / 4 # Impartirea numerelor intregi are ca rezultat, de fapt, # part ea intreaga a rezultatului impartirii 7 / 3 7 / -3 La fel ca n C, semnul egal (=) este folosit la atribuire. Valoarea atribuit a nu con stituie o ie sire (nu este tip arit a pe ecran): >>> latime = 20 >>> inaltime = 5*9 >>> latime * inaltime 900 O valoare poate atribuit a simultan mai multor variabile: >>> >>> 0 >>> 0 >>> 0 x = y = z = 0 x y z # x, y \c{s}i z devin zero Exist a suport complet pentru virgul a mobil a. Operatorii care au operanzi de tipu ri diferite vor converti operandul ntreg n virgul a mobil a: >>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5

Numerele complexe sunt de asemenea suportate. Numerele imaginare sunt scrise cu su xul j sau J. Numerele complexe cu parte real a diferit a de zero au forma (real+ima sau pot create folosind func tia complex(real, imag): 8 n Python Capitol 3. O introducere scurta

>>> 1j * 1J (-1+0j) >>> 1j * complex(0,1) (-1+0j) >>> 3+1j*3 (3+3j) >>> (3+1j)*3 (9+3j) >>> (1+2j)/(1+1j) (1.5+0.5j)

Numerele complexe sunt ntotdeauna reprezentate ca dou a numere reale n virgul a mobi l a: partea real as i cea imaginar a. Pentru a a a partea real a sau cea imaginar a din r-un num ar complex z folosi ti z.real respectiv z.imag: >>> a=1.5+0.5j >>> a.real 1.5 >>> a.imag 0.5 Func tiile de conversie la numere reale sau ntregi nu func tioneaz a pentru numere c omplexe, neexistnd o metod a matematic a de a transforma un num ar complex ntr-un num ar real. Folosi ti func tia abs(z) pentru a calcula modulul, sau z.real pentru a a a partea real a: >>> a=3.0+4.0j >>> float(a) Traceback (most recent call last): File "<stdin>", l ine 1, in ? TypeError: cant convert complex to float; use e.g. abs(z) >>> a.real 3.0 >>> a.imag 4.0 >>> abs(a) # sqrt(a.real**2 + a.imag**2) 5.0 >>> n modul interactiv ultima valoare a sat a este atribuit a unei variabile _. Dac a folo si ti Python ca un calculator de birou este mult mai u sor s a p astra ti continuitat ea calculelor: >>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 11 3.0625 >>> round(_, 2) 113.06 >>>

Aceast a variabil a trebuie tratat a de utilizator ca avnd numai capacitatea de a ci tit a, nu s i scris a (READ-ONLY). Nu atribui ti valori acestei variabile, deoarece acest lucru nseamn a c a ve ti creea o variabil a nou a local a care va ascunde 3.1. U ilizarea Python-ului drept calculator de birou 9

variabila implicit a_s i comportamentul s au extraordinar. 3.1.2 Siruri de caractere

n afar a de numere Python poate manipula s i s iruri de caractere, care pot(exista) avea mai multe forme. Pot incluse ntre apostroafe sau ghilimele: >>> omleta omleta >>> n-a "n-a" >>> "n-a" "n-a" >>> "Da," a spus el. "Da," a spus el "\"Da,\" a spus el." "Da," a spus el. >>> "Nu," a spus ea. "Nu," a spus ea. Sirurile de caractere pot exista pe mai multe linii, separarea realizndu-se prin secven ta de control \n indicnd astfel ca linia urm atoare este continuarea logic a a liniei curente : hello = "Acesta este un \c{s}ir de caractere mai lung,\n\ care se intinde pe mai mai multe linii, exact ca \^{i}n C.\n\ Observati ca spatiile de la inceputul li niei\ au importanta." print hello De notat c a r amne necesar ca semnele de linie nou a s a e incluse n s ir utiliznd inia nou a care urmeaz a ultimului backslash este eliminat a. Acest exemplu va a sa u rm atoarele: Acesta este un \c{s}ir de caractere mai lung, care se intinde pe mai mai multe l inii, exact ca \^{i}n C. Observati ca spatiile de la inceputul liniei au importa nta.

Dac a construim s irul de caractere ca un s ir raw, atunci secven ta \n nu se converte ste n linie nou a, dar backslesh-ul de la sfr situl liniei s i caracterul de linie no u a din surs a sunt incluse n s ir ca date. Iat a un exemplu : hello = r"Acesta este un \c{s}ir de caractere mai lung,\n\ care se intinde pe ma i mai multe linii, exact ca \^{i}n C." print hello va tipari: 10 n Python Capitol 3. O introducere scurta

Acesta este un \c{s}ir de caractere mai lung,\n\ care se intinde pe mai mai mult e linii, exact ca \^{i}n C. Sirurile de caractere pot exista s i ntre perechi de cate trei ghilimele sau apost roafe (""" sau ). n acest caz nu ave ti nevoie de caracterele de control (ex: \n\) pe ntru a realiza separarea liniilor: print """ Usage: thingy [OPTIONS] -h -H hostname """ Display this usage message Hostname to connect to are urm atoarea ie sire: Usage: thingy [OPTIONS] -h -H hostname Display this usage message Hostname to connect to

Interpretorul a seaz a rezultatul opera tiilor cu s iruri de caractere exact n forma s peci cat a de utilizator atunci cnd a introdus sau de nit s irurile respectiv: ntre ghil imele, cu ghilimele sau alte caractere ciudate, pentru a a sa valoarea exact aas iru lui. Instruc tiunea print despre care v a vom vorbi mai ncolo poate folosit a pentru a a sa s iruri f ar a ghilimele s i caractere de control. Sirurile de caractere pot oncatenate: >>> word = Help + A >>> word HelpA >>> < + word*5 + > <HelpAHelpAHelpAHelpAHelpA>

Dou as iruri de caractere scrise unul lng a altul sunt concatenate. Prima linie din exemplul de mai sus poate rescris a astfel: word = HelpA. Acest lucru nu merge dect tru s iruri explicite de caractere, nu pentru orice expresie care are ca operanzi s iruri: >>> import string >>> str ing string >>> string.strip(str) + ing string >>> strin ng File "<stdin>", line 1, in ? string.strip(str) ing ^ SyntaxError: invalid syntax # # # <<<This is ok This is ok This is invalid Sirurile de caractere sunt tratate ca vectori, la fel ca nC: primul caracter al u nui s ir are indicele 0. Nu exist a un tip de date separat pentru caracter. Un sin gur caracter este reprezentat ca un s ir de lungime unu. Se pot speci ca de asemene a sub siruri ale unui s ir folosind doi indici, separa ti prin :. Primul indice repre zint a pozi tia de nceput a sub sirului, iar 3.1. Utilizarea Python-ului drept calculator de birou 11

cel de-al doilea indice, evident indicele n s irul principal la care se termin a su b sirul: >>> word[4] A >>> word[0:2] He >>> word[2:4] lp

Dac a al doilea indice nu este speci cat, se consider a c a sub sirul se termin a la sf situl s irului. Spre deosebire de C, n Python s irurile nu pot modi cate. Atribuirea unei valori unui anumit caracter, sau unui sub sir dintr-un s ir mai mare, va gene ra o eroare: >>> word[0] = x Traceback (most recent call last): File "<stdin>", line 1, in ? Ty peError: object doesnt support item assignment >>> word[:1] = Splat Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesnt support slice assignment n orice caz, creearea unui s ir nou cu un con tinut combinat este su cient de simpl as i e cient a: >>> x + word[1:] xelpA >>> Splat + word[4] SplatA Omiterea primului sau celui de-al doilea indice n speci carea parametrilor unui sub sir, are ca efect nlocuirea primului indice cu zero, respectiv cu lungimea s irulu i din care se ncearc a extragerea sub sirului, dac a se omite al doilea parametru. >>> word[:2] He >>> word[2:] lpA # Primele doua caractere # Tot \c{s}irul \^{i}nafar a de primele doua caractere Iat a inc a un exemplu: >>> word[:2] + word[2:] HelpA >>> word[:3] + word[3:] HelpA Transmiterea unor parametrii gre si ti, nu genereaz a o eroare, pentru c a n aceast a problem a Python este foarte elegant. Astfel un indice care este prea mare va nloc uit cu dimensiunea s irului: 12 n Python Capitol 3. O introducere scurta

>>> word[1:100] elpA >>> word[10:] >>> word[2:1]

Indicii pot s i numere negative, n acest caz se consider a c a indicele zero se a a c l mai la dreapta: >>> word[-1] A >>> word[-2] p >>> word[-2:] pA >>> word[:-2] Hel # ultimul caracter # nultimul caracter # ultimele doua caractere # totul \^{i}nafara de ultimele doua caractere Dar, aten tie -0 este acela si lucru cu 0! >>> word[-0] H # (deoarece -0 egal 0) Indicii negativi mai mari n valoare absolut a dect dimensiunea s irului sunt trunchi a ti.Acest lucru nu func tioneaz as i la selectarea unui singur caracter ( nu a unei subsecven te ) : >>> word[-100:] HelpA >>> word[-10] # error Traceback (most recent call last): Fil e "<stdin>", line 1, in ? IndexError: string index out of range Mai jos ave ti un tabel care v a va ajuta la n telegerea mecanismului de numerotare al unui s ir de caractere: +---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1 Prima linie de numere reprezint a leg atura indicilor pozitivi cu s irul. A doua li nie reprezint a coresponden ta dintre caracterele s irului s i indicii negativi. Un sub sir de la i la j este format din toate caracterele dintre cei doi indici i, r espectiv j. Pentru indicii pozitivi lungimea sub sirului este dat a de diferen ta i ndicilor m argina si, dac a nici unul dintre ei nu este mai mare dect lungimea s irul ui. De exemplu lungimea sub sirului word[1:3] este 2. Func tia len() ntoarce lungim ea unui s ir de caractere: >>> s = supercalifragilisticexpialidocious >>> len(s) 34 3.1. Utilizarea Python-ului drept calculator de birou 13

3.1.3 Siruri de caractere UNICODE ncepnd cu versiunea 2.0 a limbajului Python, este pus la dispozi tia programatorulu i un nou tip de dat a, pentru manipularea textelor: obiectul Unicode. Poate folos it pentru stocarea s i manipularea datelor de tip Unicode(consulta ti http://www.u nicode.org/) s i se integreaz a foarte bine cu obiectele string existente, avnd un mecanism de auto-conversie. Unicode are avantajul c a stabile ste o leg atur a unic a ntre un num ar s i orice caracter scris n scripturi moderne sau scripturi mai vechi . La nceput au existat numai 256 de numere ecare avnd asociat un caracter, s i toate textele erau asociate unei pagini de cod(code page) care f acea leg atura ntre carac tere s i numerele asociate. acest lucru a creat foarte mult a confuzie odat a cu in terna tionalizarea software-ului. Unicode rezolv a aceste probleme asocind o singur a pagin a tuturor scripturilor. Crearea s irurilor de caractere Unicode este la fe l de simpl a ca s i crearea s irurilor obi sniute : >>> uHello World ! uHello World !

Caracterul u din fa ta s irului indic a interpretorului c a trebuie s a creeze un s i nicode din expresia care urmeaz a. Dac a dori ti s a include ti caractere speciale, o pute ti face foarte simplu folosind secven tele Unicode-Escape. Iat a un exemplu: >>> uHello\u0020World ! uHello World !

Secven ta \u0020 indic a interpretorului s a insereze caracterul cu ordinalul 0x002 0 (caracterul spa tiu) npozi tia precizat a. Binen teles c a n acest mod pot introd i alte caractere, chiar s i cele obi snuite, folosind valoarea ordinalului s au ca ordinal Unicode. Datorit a faptului c a primele 256 de caractere Unicode sunt acel ea si ca s i n nota tia standard ri occidentale, procesul de introducere a caractere lor Unicode devine mult mai simplu. Latin-1, folosit a n multe ta Pentru exper ti e xist as i un mod direct(raw-mode) identic ca cel fel ca pentru s irurile normale. na intea s irului trebuie ad augat ur pentru ca Python s a intre n modul Unicode direct. Conversiile \uXXXX sunt utilizate numai dac a este folosit un num ar impar de cara ctere backslash(\, naintea caracterului u: >>> urHello\u0020World ! uHello World ! >>> urHello\\u0020World ! uHello\\\\u0020World ! Acest mod poate foarte util dac a ave ti de introdus un num ar mare de backslash-ur i. n afar a de metodele de creare a s irurilor Unicode standard, Python ofer a multe alte metode de a crea s iruri Unicode. Func tia built-in unicode() permite accesa rea tuturor CODECS-urilor Unicode (CODEC = COderDECoder). Cteva dintre codi c arile foarte cunoscute ale caror codex-uri au fost convertite sunt : Latin-1, ASCII, U TF-8 s i UTF-16. Ultimele dou a permit stocarea caracterelor Unicode pe unul sau m ai mul ti octe ti. Codi carea implicit a este ASCII, care permite treacerea caractere lor cuprinse ntre 0 s i 127, dar blochez a celelalte caractere semnalnd eroare. Cnd u n s ir Unicode este tip arit, scris ntr-un sier, sau convertit cu func tia str(), con versia porne ste utiliznd codarea implicit a. 14 n Python Capitol 3. O introducere scurta

>>> u"abc" uabc >>> str(u"abc") abc >>> u"" u\xe4\xf6\xfc >>> str(u"") Traceback t call last): File "<stdin>", line 1, in ? UnicodeError: ASCII encoding error: o rdinal not in range(128)

Pentru a converti un s ir Unicode ntr-un s ir pe 8 bi ti utiliznd o anumit a codi care, obiectele Unicode furnizeaz a metoda encode(), care are un singur argument, numel e codului. Este de preferat ca numele codurilor s a se scrie cu litere mici. >>> u"".encode(utf-8) \xc3\xa4\xc3\xb6\xc3\xbc

Dac a ave ti datele intr-o anume codi care s i dori ti s a ob tine ti un s ir Unicode spondent din ele, folosi ti func tia unicode() cu numele codului ca al doilea argu ment. >>> unicode(\xc3\xa4\xc3\xb6\xc3\xbc, utf-8) u\xe4\xf6\xfc 3.1.4 Liste Python pune la dispozi tia programatorului o serie de date structurate, folosite pentru a grupa, a aduna la un loc mai multe valori. Cea mai exibil a astfel de str uctur a este lista. O list a poate scris a ca o serie de valori separate prin virgu l a, s i a at a ntre paranteze p atrate. Elementele unei liste nu trebuie s a e neap de acela si tip: >>> a = [spam, eggs, 100, 1234] >>> a [spam, eggs, 100, 1234]

La fel ca s i la s iruri, primul element al unei liste are indicele 0. n acela si fe l ca s i la s iruri, listele pot pozi tionate, concatenate s i a sa mai departe: >>> a[0] spam >>> a[3] 1234 >>> a[-2] 100 >>> a[1:-1] [eggs, 100] >>> a[:2] + [bacon, 2*2] [spam, eggs, bacon, 4] >>> 3*a[:3] + [Boe!] [spam, eggs, 100, spam, eggs Boe!] 3.1. Utilizarea Python-ului drept calculator de birou 15

Spre deosebire se s iruri, elementele unei liste pot modi cate: >>> a [spam, eggs, 100, 1234] >>> a[2] = a[2] + 23 >>> a [spam, eggs, 123, 1234] Func tia len() se aplic as i listelor : >>> len(a) 4

Utilizarea sublistelor este de asemenea posibil a. Prin folosirea lor se poate mo di ca chiar s i dimensiunea listei : >>> # substituirea unor componente : ... a[0:2] = [1,12] >>> a [1,12,123,1234] > >> # eliminarea unor componente : ... a[0:2] = [] >>> a [123,1234] >>> # inserar ea unor componente : ... a[1:1] = [bletch,xyzzy] >>> a [123,bletch,xyzzy,1234] >>> # erarea unei liste la debutul ei ... a[:0] = a >>> a [123,bletch,xyzzy,1234,123,bletch, yzzy,1234] >>> len(a) 8 Este posibil s a crea ti liste din alte liste (de exemplu prin concatenare): >>> >>> >>> 3 >>> [2, >>> 2 >>> >>> [1, >>> [2, q = [2, 3] p = [1, q, 4] len(p) p[1] 3] p[1][0] p[1].append(xtra) p [2, 3, xtra], 4] q 3, xtra] # See section 5.1 Observa ti c a n ultimul exemplu , p[1] s i q fac referire la acela si obiect. Vom re veni cu detalii despre semantica obiectelor mai trziu. 16 n Python Capitol 3. O in troducere scurta

3.2 Primii pa si n programare Binen teles c a putem folosi Python s i la alte lucruri dect pentru a aduna 2 cu 2. P utem de exmplu s a gener am o din s subsecven ta irul lui Fibonacci: >>> ... ... >>> ... ... ... 1 1 2 3 5 8 # Seria lui Fibonacci: # Suma a doua ele mente reprezinta urmatorul element. a, b = 0, 1 while b < 10: print b a, b = b, a+b

Acest exemplu demonstreaz a urm atoarele no tiuni: Prima linie con tine o atribuire multipl a. Varibilele a s i b iau valorile 0 respectiv 1. Pe ultima linie, de asem enea este folosit a atribuirea multipl a. Evaluarea expresiilor din partea dreapt a a unei atribuiri se face nainte de orice atribuire. Evaluarea se face de la stnga la dreapta. Bucla while se execut a atta timp ct b < 10 (atta timp ct condi tia este adev arat a). La fel ca n C, zero nseamn a fals, s i orice num ar diferit de zero nse a adev arat. Condi tia poate un s ir, un element de list a, de lungime diferit absol t orice. Orice secven ta a de zero nseamn a adev arat, s i invers. Condi tia folosit a acest exemplu este o compara tie. Comparatorii standard sunt la fel ca n C: <(mai mic), >(mai mare), ==(egal), <=(mai mic sau egal), >=(mai mare sau egal), !=(di ferit). Instruc tiunile din bucl a sunt aliniate. Alinierea (indentation) reprezin t a modul n care Python grupeaz a instruc tiunile. Deocamdat a (!) Python nu dispune de un editor n linie de comand a inteligent, astfel nct alinierea, tabularea s a se f ac a automat. Sunte ti deci obligat s a folosi ti tab sau spa tii pentru a realiza gr uparea instruc tiunilor. Cnd ve ti scrie programe Python ve ti folosi un editor de t ext. Majoritatea editoarelor de la ora actual a realizeaz a automat tabularea. Pen tru a ncheia un bloc de instuc tiuni trebuie introdus a o linie goal a pentru a indi ca editorului c a editarea blocului de comenzi s-a ncheiat (editorul nu poate ghic i cnd a ti introdus ultima linie. Aten tie! ecare instruc tiune dintr-un bloc de inst ruc tiuni trebuie s a aib a acelea si num ar de spa tii s i taburi nainte, deci instr iunile trebuie s a e perfect aliniate. Instruc tiunea print a seaz a expresia pe care o prime ste ca parametru. Sirurile de caractere sunt a sate f ar a ghilimele, s i un pa tiu este inserat ntre elemente, astfel nct a sarea diverselor valori s a mearg a d a sine: >>> i = 256*256 >>> print Valoarea lui i este:, i Valoarea lui i este: 65536 O virgul a la sfr situl listei de parametrii ai instruc tiunii print, inhib a saltul cursorului pe linia urm atoare la sfr situl instruc tiunii: 3.2. Primii pa si n programare 17

>>> a, b = 0, 1 >>> while b < 1000: ... print b, ... a, b = b, a+b ... 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 Observa ti c a interpretorul sare la linia urm atoare nainte de a ncepe a sarea, dac ltima linie a fost incomplet a. 18 n Python Capitol 3. O introducere scurta

CAPITOL PATRU Structuri de control n afar a de buclele de tip while (explicate anterior), Python dispune de structuri le de control obi snuite, ntlnite s i n celelalte limbaje. 4.1 Instruc tiuni if Poate c a cea mai cunoscut a instruc tiune de control este instruc tiunea if. Exempl u: >>> >>> ... ... ... ... ... ... ... ... ... x = int(raw_input("Introduceti un nu mar \^{i}ntreg : ")) if x < 0: x = 0 print Negativul schimbat \^{i}nzero elif x == 0: print Zero elif x == 1: print Unul singur else: print Mai multi

Pot exista mai multe sec tiuni elif sau niciuna, iar sec tiunea else este op tional a. Cuvntul cheie elif este evident if..elif..elif prescurtarea de la elseif, s i este folositor pentru a evita tabularea excesiv a. O secven ta func tioneaz a ca un bloc case sau switch, secven te proprii altor limbaje . 4.2 Instruc tiuni for

de ce a- Instruc tiunea for din Python difer a un pic fa ta ti ntlnit n C sau Pascal loc de o itera tie dat a de o progresie aritmetic a (Pascal), sau de o itera tie foa rte exibil a, pentru care programatorul poate de ni att pasul itera tiei, ct s i condi a de oprire (C), itera tiile instruc tiunii Python for func tioneaz a dup a elementel e unei secven te (sir sau list a). 19

>>> # Masoara marimea unor \c{s}iruri ... a = [cat, window, defenestrate] >>> for x in a: ... print x, len(x) ... cat 3 window 6 defenestrate 12

Nu este normal( si sigur) ca secven ta iterat a s a e modi cat a n timpul secven tei este cazul numai al secventelor modi cabile, cum ar listele). Dac a apare necesita tea de a modi ca secven ta n timpul itera tiei, itera tia trebuie s a e asociat a unei pii a secven tei. Nota tia subsecventelor realizeaz a o particularitate convenabil a : >>> for x in a[:]: # copiaza intreaga lista ... if len(x) > 6: a.insert(0, x) .. . >>> a [defenestrate, cat, window, defenetrate] 4.3 Func tia range() Dac a este necesar a o itera tie pe o mul time de numere, pute ti folosi func tia rang e() pentru a genera liste ce contin progresii aritmetice : >>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Paramentrul furnizat func tiei range() nu va niciodat a un membru al secven tei. Es te posibil ca func tia range() ncepnd cu un alt num s a genereze o secven ta ar dect sau ra tia progresiei aritmetice poate modi cat a: >>> range(5, 10) [5, 6, 7, 8, 9] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(-10, -100, -30) [-10, -40, -70] Pentru a realiza o itera tie pe o mul time de numere folosi ti func tiile range() s i len() astfel: 20 Capitol 4. Structuri de control

>>> a = [Mary, had, a, little, lamb] >>> for i in range(len(a)): ... print i, a[i] ary 1 had 2 a 3 little 4 lamb 4.4 Instruc tiuni break s i continue, s i clauze else pentru bucle La fel ca n C, instruc tiunea break termin a for tat orice bucl a while sau for. Inst ruc tiunea continue trece necondi tionat la urm atoarea itera tie. Instruc tiunile it erative pot avea s i o clauz a else. Instruc tiunile din cadrul unei astfel de clau ze else sunt executate atunci cnd bucla se termin a odat a cu terminarea listei (fo r) sau atunci cnd condi tia buclei devine fals a (pentru while) aceste instruc tiuni nu sunt executate dac a bucla este terminat a printr-o instruc tiune break. Iat a u n exemplu care determin a numerele prime pn a la 10: >>> for n in range(2, 10): ... for x in range (2, n): ... if n % x == 0: ... pri nt n, egal cu, x, *, n/x ... break ... else: ... # bucla s-a epuizat f\u{a}ra sa g\u {a}seasc\u{a} un factor ... print n,este un numar prim ... 2 este un numar prim 3 este un numar prim 4 egal cu 2 * 2 5 este un numar prim 6 egal cu 2 * 3 7 este u n numar prim 8 egal cu 2 * 4 9 egal cu 3 * 3 4.5 Instruc tiuni pass Instruc tiunea pass nu execut a nimic. Poate folosit a atunci cnd este necesar a prez en ta sintactic a a unei instruc tiuni, f ar a ca aceasta s a execute ceva: >>> while 1: ... pass # Asteapta pentru intrerupere de la tastatura ... 4.4. Instruc tiuni break s i continue, s i clauze else pentru bucle 21

4.6 Func tii

Putem crea o func tie care genereaz as irul lui Fibonacci pn a la o limit a arbitrar a >>> ... ... ... ... ... ... >>> ... 1 1 def fib(n): # Scrie \c{s}irul lui Fibona cci pana la n "Scrie \c{s}irul lui Fibonacci pana la n" a, b = 0, 1 while b < n: print b, a, b = b, a+b # Folosim func\c{t}ia creata fib(2000) 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Cuvntul cheie def este primul din de ni tia unei func tii. Acesteia trebuie s a i urmez e numele func tiei s i o list a parantezat a de parametrii. Instruc tiunile care form eaz a func tia ncep pe linia imediat urm atoare s i trebuie s a e dis de margine. Pri instruc tan tate mai mult dect antetul func tiei fa ta tiune din corpul func tiei poat e un s ir de caractere(op tional), acest s ir reprezentnd documenta tia func tiei(doc tring = s irul de documenta tie al func tiei). Exist a utilitare care genereaz a docu menta tie pornind de la aceste s iruri, deci este o practic a bun a s a v a folosi ti e aceast a facilitate. Execu tia unei func tii creaz a o nou a tabel a de simboluri, f olosit a pentru variabilele locale. Altfel spus toate atribuirile din cadrul unei func tii vor stoca valorile n tabela de simboluri local a. Atunci cnd interpretorul g ase ste un nume de variabil a, nti caut a n tabela de simboluri local a, apoi n c obal as i apoi n cea prede nit a. Cu toate acestea variabilelor globale nu li se pot a tribui valori n cadrul unei func tii, dect dac a se folose ste instruc tiunea global. Parametrii actuali ai unei func tii apelate sunt introdu si n tabela de simboluri l ocal a a celei func tii nmomentul apel arii ei. Astfel transferul aegumentelor se fa ce utilizand apel prin valoare (unde valoare este totdeauna un obiect referin ta , nu valoarea obiectului).1 Cnd o func tie apeleaz a o alta func tie, este creat a o n ou a tabel a de simboluri pentru func tia apelat a. De nirea unei func tii trece numele func tiei n tabela de simboluri curent a. Func tia nou creat a este recunoscut a de i nterpretor ca o func tie de nit a de utilizator. n Python exist a un mecanism de reden umire a func tiilor: >>> fib <function object at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 3 4 55 89

A ti putea obiecta c a func tia fib este o procedur a nu o func tie. n Python, la fel ca nC, procedurile sunt func tii, numai c a nu returneaz a nici o valoare. Tehnic vo rbind, procedurile returneaz a totu si o valoare, aceasta este None(niciuna). None este un cuvnt cheie (prede nit). n mod normal valoarea None nu este a sat a de interpr etor. Totu si dac a dori ti s a v a convinge ti c a a sa func tioneaz a procedurile i urm atorul exemplu: 1 De fapt, apel prin referin ta va putea mai bine descris, atunci daca un obiect modi cabil este transmis, apelantul va vedea dac a nurma apelarii obiectul s-a modi ca t ( un element inserat ntr-o list a). 22 Capitol 4. Structuri de control

>>> print fib(0) None Este foarte simplu s a construim o func tie care ntoarce ca rezultat s irul lui Fibo nacci: >>> ... ... ... ... ... ... ... ... >>> >>> [1, def fib2(n): # Intoarce \c{s}iru l lui Fibonacci pana la n "Intoarce o lista continand \c{s}irul lui Fibonacci pa na la n" result = [] a, b = 0, 1 while b< n: result.append(b) # vezi mai jos a, b = b, a+b return result f100 = fib2(100) # apelarea func\c{t}iei f100 # afisare a rezultatului 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Acest exemplu demonstreaz a mai multe facilit a ti ale limbajului Python: Instruc ti unea return ntoarce rezultatul func tiei. return f ar a nici un parametru ntoarce ca rezultat al func tiei valoarea None. Pute ti folosi return f ar a parametrii pentru a ncheia execu tia unei func tii nainte de a se ajunge la nalul instruc tiunilor din c adrul func tiei. Valoarea None este de asemenea ntoars a ca rezultat al unei func ti i atunci cnd au fost executate toate instruc tiunile procedurii. Instruc tiunea res ult.append(b) apeleaz a o metod a a obiectului result. O metod a este o func tie car e apar tine unui obiect. Metodele sunt apelate folosind sintaxa obj.metod a(unde obj este un obiect, poate s i o expresie, iar metod a este numele metodei ce este ape lat a). n func tie de tipul lor, obiectele pot avea diferite metode. Este posibil s a existe metode de tipuri diferite f ar a a se crea confuzii. Este de asemenea pos ibil s a crea ti obiecte s i metode folosind clasele, dar despre clase vom discuta mai trziu. Metoda append este de nit a pentru obiecte de tip list a, s i adaug a un ele ment la sfr situl listei. n acest exemplu ar echivalent a cu result = result + [b] da mult mai e cient a. 4.7 Mai multe despre func tii Este posibil n Python s a de nim func tii cu un num ar variabil de argumente. Exist a t rei modalita ti de a realiza acest lucru, care pot combinate. 4.7.1 Valori implicite pentru argumente

Cea mai util a metod a este s a speci ca ti valori implicite pentru argumente. n acest fel crea ti o func tie care poate apelat a cu mai pu tine argumente dect a fost de nit : 4.7. Mai multe despre func tii 23

def ask_ok(prompt, retries=4, complaint=Da sau nu va rog!): while 1: ok = raw_inpu t(prompt) if ok in {d, da): return 1 if ok in {n, nu): return 0 retries = retries - 1 retries < 0: raise IOError, refusenik user print complaint Func tia de nit a mai sus poate apelat a n dou a moduri: ask_ok(Sunte ti sigur c a s a ie si ti?) fi sierul?, 2) sau: ask_ok(Dori ti s a sterge ti Valorile implicite sunt evaluate n timpul interpret arii de ni tiei func tiei, deci ur m atoarea secven ta i = 5 def f(arg=i): print arg i = 6 f()

va a sa 5. ATENTIE!!!: Valorile implicite sunt evaluate o singur a dat a. Ave ti grij a atunci cnd valoarea implicit a este un obiect modi cabil. De exemplu func tia urm at oare acumuleaz a ntr-o list a argumentele ce i sunt transmise n timpul unor apeluri c onsecutive: def f(a, L=[]): L.append(a) return L print f(1) print f(2) print f(3) va a sa [1] [1, 2] [1, 2, 3]

Dac a nu dori ti ca valoarea implicit a s a e re tinut a dup a terminarea func tiei, ti proceda ca n exemplul urm ator: def f(a, L=None): if L is None: L = [] L.append(a) return L 24 Capitol 4. Structuri de control

4.7.2 Argumente de tip cuvinte cheie Func tiile pot apelate folosind n loc de argumente cuvinte cheie de forma: cuvant_ cheie = valoare. Pentru exempli care observa ti func tia: def parrot(voltage, state=mort, action=zboara, type=Norvegian Blue): print "-- Acest p apagal nu", action print "daca pui", voltage, "volti prin el." print "-- Doamne! ", type print "-- E ", state, "!" care poate apelat a n mai multe moduri: parrot(1000) parrot(action=BOOM, voltage=10000) parrot(o mie, state=apasa iarba) parro t(un milion, fara viata, sare) Dar urm atoarele apeluri ar genera erori: parrot() # Lipseste argumentul obligatoriu parrot(voltage=5.0, mort) # Dupa cuvant ul cheie trebuie sa urmeze un argument tip cheie parrot(110, voltage=220) # Doua valori atribuite aceleia\c{s}i varibile parrot(actor=John Cleese) # Cuvant cheie necunoscut n general o list a de argumente trebuie s a aibe oricte argumente pozi tionale, urmat e de oricte argumente de tip cuvinte cheie, unde cuvintele cheie trebuie alese di n lista parametrilor formali. Nu este important dac a un parametru formal are o v aloare implicit a sau nu. Nici un argument nu poate primi o valoare de mai multe ori numele de parametrii formali corespunz atoare argumentelor pozi tionale nu pot folosite drept cuvinte cheie n cadrul aceluia si apel. Iat a un exemplu cu erori d atorate acestei reguli: >>> def function(a): ... pass ... >>> function(0, a=0) Traceback (most recent ca ll last): File "<stdin>", line 1, in ? TypeError: keyword parameter redefined Atunci cnd unul dintre parametrii este de forma **nume, func tia va primi o list a care va con tine parametrii de tip cuvnt cheie. Dac a se folose ste un parametru de tipul *nume, func tia va primi o list a con tinnd argumentele suplimentare n afara ce lor formale. Dac a sunt folosi ti mpreun a parametrul *nume trebuie s a se a e naintea elui de tip **nume. Totul poate p area ambiguu dar ve ti l amuri ti imediat: def cheeseshop(kind, *arguments, **keywords): print " - Aveti", kind, "?" print " - Nu, nu avem", kind for arg in arguments: print arg print -*40 for kw in keywor ds.keys(): print kw, :, keywords[kw] Un apel al acestei func tii ar ar ata astfel: 4.7. Mai multe despre func tii 25

cheeseshop(Limburger,"Se vinde foarte repede, d-le" "Se vinde foarte, FOARTE reped e, d-le" client=John Cleese manager=Michael Palin sketch=Cheese Shop Sketch) Iar rezultatul va urm atorul: - Aveti Limburger? - Nu, nu avem Limburger Se vinde foarte repede, d-le. Se vind e foarte, FOARTE repede, d-le. ---------------------------------------client : J ohn Cleese manager : Michael Palin sketch : Cheese Shop Sketch 4.7.3 Liste de argumente arbitrare O func tie poate apelat a cu un num ar arbitrar de argumente. nainte de argumentele arbitrare (op tionale) pot exista mai multe argumente normale: def fprintf(file, format, *args): file.write(format % args) 4.7.4 Forme Lambda La cererea utilizatorilor de Python, au fost ad augate cteva facilit a ti speci ce lim bajelor func tionale s i Lisp-ului. Folosind cuvntul cheie lambda pute ti crea mici func tii. Iat a o func tie care ntoarce ca rezultat suma argumentelor: lambda a, b : a+b. Formele lambda pot folosite acolo unde sunt necesare func tii obiect. Aceste func tii sunt restrnse sintactic la o singur a expresie: >>> ... ... >>> >>> 42 >>> 43 >>> def make_incrementor(n): return lambda x, incr =n: x+incr f = make_incrementor(42) f(0) f(1) 4.7.5 Sirurile de documenta tie Exist a anumite conven tii privind con tinutul s i formatarea s irurilor de documenta tie. Prima linie ar trebui s a e scurt as i foarte concis a. Pentru concizie nu ar tr ebui precizat numele obiectivului sau tipul, acestea ind subn telese. Aceast a linie trebuie s a nceap a cu liter a mare s i s a se termine cu virgul a. 26 Capitol 4. Structuri de control

Dac a exist a mai multe linii, cea de-a doua ar trebui s a e vid a, pentru a separa d escrierea scurt a de cea am anun tit a. Urm atoarele linii ar trebui s a descrie mai p e larg obiectul, semni ca tia parametrilor, etc. Interpretorul Python ia n considera tie spa tiile din s irurile de caractere mp ar tite pe mai multe linii, din aceast a c auz a pentru a avea o documenta tie aranjat a frumos trebuie s a v a folosi ti de un truc la fel ca n exemplul urm ator: >>> def my_function(): ... " " "Nu face decat documentarea. ... ... Chiar nu fac e nimic! ... " " " ... pass ... >>> print my_function.__doc__ Nu face decat docu mentarea. Chiar nu face nimic! 4.7. Mai multe despre func tii 27

28

CAPITOL CINCI Strucuri de date Acest capitol subliniaz a anumite lucruri deja cunoscute s i descrie altele noi. 5.1 Mai multe despre liste Tipul de date list a mai dispune de cteva metode. Iat a toate metodele obiectelor d e tip list a: append(x) Adaug a un element la sfr situl listei. extend(L) Adaug a la sfr situl listei, elementele listei furnizate ca parametru. insert(i, x) Insereaz a un element ntr-o anumit a pozi tie. Primul argument reprezint a indicele elementulu i din list a naintea c aruia se va face inser tia, deci a.insert(0,x) va insera elem entul x la nceputul listei, iar a.insert(len(a),x) este echivalent cu a.append(x). remove(x) Sterge din list a primul element g asit cu valoarea x. Dac a nu exist a un stfel de element apare o eroare. pop([i ]) Sterge din list a elementul de pe pozi tia i, s i ntoarce valoarea acestuia. Dac a nu este speci cat nici un parametru a.pop() , va s terge s i va returna ultimul element din list a. index(x) ntoarce indicele pr imului parametru din list a care are valoarea x. count(x) ntoarce num arul de apari ti i ale valorii x ntre elementele listei. sort() Sorteaz a elementele listei. reverse( ) Schimb a ordinea elementelor din list a. Iat a un exemplu care folose ste majorita tea metodelor: 29

>>> a = [66.6, 333, 333, 1, 1234.5] >>> print a.count(333), a.count(66.6), a.cou nt(x) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.6, 333, -1, 333, 1, 12 34.5, 333] >>> a.index(333) 1 >>> a.remove(333) >>> a [66.6, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.6] >>> a.sort() >>> a [ -1, 1, 66.6, 333, 333, 1234.5] 5.1.1 Folosirea listelor drept stive Obiectele de tip list a pot folosite foarte u sor pentru a simula comportamentul u nei stive. Pentru a ad auga un element pe stiv a (PUSH), pute ti folosi append(). P entru a scoate un element din stiv a (POP), folosi ti pop() f ar a a speci ca un index . Iat a un exemplu: >>> >>> >>> >>> [3, >>> 7 >>> [3, >>> 6 >>> 5 >>> [3, stack = [3, 4, 5] stack.ap pend(6) stack.append(7) stack 4, 5, 6, 7] stack.pop() stack 4, 5, 6] stack.pop() stack.pop() stack 4] 5.1.2 Folosirea listelor drept cozi Pute ti folosi listele foarte convenabil, pentru a implementa cozi. Spre deosebir e de stive unde primul element ad augat este ultimul scos, la cozi primul element ad augat este primul scos. Pentru a ad auga un element folosi ti append(), iar pen tru a extrage un element folosi ti pop(0): 30 Capitol 5. Strucuri de date

>>> queue = ["Eric", "Ion", "Mihai"] >>> queue.append("Razvan") >>> queue.append ("Cristi") >>> queue.pop(0) Eric >>> queue.pop(0) Ion >>> queue [Mihai, Razvan, Cris 5.1.3 Instrumente de programare func tionala

Exist a trei func tii prede nite care sunt foarte utile n lucrul cu liste: filter(), map(), reduce(). format Func tia filter() cu sintaxa filter(func tie, secven t a), o secven ta a din elementele secven tei speci cate ca parametru, care ndepline ste co ndi tia testat a de func tie. Exemplul care urmeaz a calculeaz a numerele prime din i ntervalul 2, 25: >>> def f(x): return x % 2 != 0 and x % 3 != 0 ... >>> filter(f, range(2, 25)) [ 5, 7, 11, 13, 17, 19, 23]

Func tia map() cu sintaxa map(func tie, secven t a), apeleaz a func tia speci cat a ca rametru pentru ecare , s element din secven ta i ntoarce o nou a list a format a din ultatele ntoarse de func tie. Pentru a calcula p atratele similar unor numere dintro list a pute ti folosi o secven ta a celei ce urmeaz a: >>> def cube(x): return x*x*x ... >>> map(cube, range(1, 11)) [1, 8, 27, 64, 125 , 216, 343, 512, 729, 1000] Func tia map() accept a ca parametrii mai multe secven te. n acest caz func tia trans mis a ca parametru trebuie s a e modi cat a corespunz ator, trebuie s a accepte acela num ar de parametrii cte secven te sunt transmise. Dac a secven tele sunt diferite ca lungime, atunci cnd una dintre secven te s-a terminat, n loc de un element func tie i i se transmite None. Dac a n loc de un nume de func tie, se transmite None func ti ei map(), atunci func tia va nlocuit a cu o func tie care va ntoarce ca rezultat para metrii primi ti. Pute ti folosi comportamentul func tiei map() pentru a genera perc hi de numere provenind din dou a liste: >>> seq = range(8) >>> def square(x): return x*x ... >>> map(None, seq, map(squa re, seq)) [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

) ntoarce o simpl Func tia reduce(func tie, secven ta a valoare care este calculat a ul urm ator: este apelat a func tia (care este obligatoriu o func tie binar a ce acce pt a numai 2 parametrii), cu parametrii primul s i al doilea termen al secven tei, func tia ntoarce un rezultat care mpreun a cu al treilea element sunt transmise din nou func tiei, care genereaz a un alt rezultat s i a sa mai departe, pn a ce lista est e epuizat a. 5.1. Mai multe despre liste 31

Exemplul de mai jos calculeaz a suma primelor numere naturale: >>> def add(x,y): return x+y ... >>> reduce(add, range(1, 11)) 55 valoarea acestuia va returnat Dac a exist a un singur element n secven ta a. Dac a ta este goal a, va generat a o excep tie. Func tia reduce() poate primi s i un al tre ilea parametru care semni c a valoarea de la care ncepe calculul. n acest caz primul apel al func tiei are ca parametrii aceast a valoare s i primul element al listei. Dac a func tia reduce() este apelat a cu trei parametrii, iar lista este goal a, ace asta va ntoarce ca rezultat al treilea parametru. Iat a un exemplu care ilustreaz a modul de lucru al func tiei reduce(): >>> def sum(seq): ... def add(x,y): return x+y ... return reduce(add, seq, 0) .. . >>> sum(range(1, 11)) 55 >>> sum([]) 0 5.1.4 Un alt mod de a genera liste Exist a un mod de a crea liste mult mai concis dect prin intermediul func tiilor ma p(), filter() sau lambda(). De ni tia listei este de cele mai multe ori mult mai cl ar a dect cea ob tinut a prin alte metode. Acest mod generalizat, de a genera, a de ni liste const a n asocierea unei expresii, cu o clauz a for s i cu niciuna sau mai mu lte clauze for sau if. Rezultatul va o list a care provine din evaluarea expresie i n contextul clauzelor for s i if ce urmeaz a. Dac a rezultatul evalu arii expresiei va o pereche, atunci expresia trebuie parantezat a corespunz ator: 32 Capitol 5. Strucuri de date

>>> freshfruit = [ banana, loganberry , passion fruit ] >>> [weapon.strip() for weapo n in freshfruit] [banana, loganberry, passion fruit] >>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18] >>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x < 2] [] >>> [{x: x**2} for x in vec] [{2: 4}, {4: 16}, {6: 36}] >>> [[ x,x**2] for x in vec] [[2, 4], [4, 16], [6, 36]] >>> [x, x**2 for x in vec] # er ror - parens required for tuples File "<stdin>", line 1, in ? [x, x**2 for x in vec] ^ SyntaxError: invalid syntax >>> [(x, x**2) for x in vec] [(2, 4), (4, 16) , (6, 36)] >>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y i n vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] 5.2 Instruc tiunea del Exist a o metod a de a s terge un element dintr-o list a speci cnd indicele elementului n loc de valoarea elementului. Aceast a metod a poate folosit as i pentru a s terge or tiuni dintr-o list a. Toate acestea pot realizate utiliznd instruc tiunea del: >>> a [-1, 1, 66.6, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.6, 333, 333, 123 4.5] >>> del a[2:4] >>> a [1, 66.6, 1234.5] del poate >>> del a folosit as i pentru a s terge variabile, de exemplu o ntreag a list a:

Vom vedea mai trziu s i alte modalit a ti de a utiliza instruc tiunea del. 5.2. Instruc tiunea del 33

5.3 1 Perechi s i secven te

Am obsevat pn a acum c a listele s i s irurile de caractere au multe caracteristici c omune, de exemplu: indexarea s i . Deoarece Python este un limbaj pozi tionarea (s licing). Sirurile s i listele sunt dou a exemple de tipuri de date secven ta . Exis t care evolueaz a, n timp pot ad augate s i alte tipuri de date secven ta as i un al ip standard de date: perechea (enumerarea). O pereche, o enumerare este format a din mai multe valori separate prin virgule: >>> t = 12345, 54321, hello! >>> t[0] 12345 >>> t (12345, 54321, hello!) >>> # enume rarile pot fi imbricate, combinate ... u = t, (1, 2, 3, 4 ,5) >>> u ((12345, 543 21, hello!), (1, 2, 3, 4 ,5))

Dup a cum pute ti vedea perechile(enumer arile) sunt a sate ntre paranteze astfel nct umer arile sau perechile mbricate s a e interpretate corect. Perechile pot introduse cu sau f ar a paranteze, ns a, adesea parantezele sunt necesare. Perechile au multe utiliz ari. De exemplu : perechi de coordonate (x,y), nregistr arile angaja tilor d intr-o baz a de date, etc. Pute ti face o analogie (atta timp ct r amne numai o analog ie menit a s a v a ajute la n telegerea acestui tip de date) ntre tipurile de date com puse ce pot de nite cu struct din C++, s i perechile din Python. Perechile, la fel ca s irurile nu pot modi cate: nu pot atribuite valori unui anumit element al unei perechi (pute ti ns a s a simula ti o modi care folosind alte metode). Este posibil s a crea ti perechi care con tin obiecte modi cabile, cum sunt listele de exemplu. O pro blem a deosebit a o constituie crearea perechilor cu zero sau un element. Exist a ns a cteva trucuri de sintax a care pot folosite pentru a rezolva aceast a problem a. Pe echile vide pot construite folosind o pereche de paranteze f ar a nimic ntre ele. O pereche cu un singur element poate construit a speci cnd valoarea care va con tinut n pereche urmat a de o virgul a. Cam nepl acut, dar func tioneaz a: >>> empty = () >>> singleton = hello, >>> len(empty) 0 >>> len(singleton) 1 (hello,) # <---- observati virgula

Instruc tiunea t = 12345, 54321, Salut! este un exemplu de mpachetare. Valorile 1234 5, 54321 s i Salut! sunt mpachetate mpreun a. Opera tia invers a este de asemenea p : >>> x, y, z = t

Aceast a opera tie este numit a su cient de elocvent despachtarea unei secven te. Despa hetarea unei secven te necesit a ca lista de variabile de la stnga atribuirii s a co n tin a tot attea variabile ct secven ta mpachetat a de la dreapta. De observat este f ptul c a mbricarea nu este dect o combina tie succesiv a de mpachet ari sau despachet i! Ingenios, nu?! Exist a o asimetrie aici: n timp ce o mpachetare va genera ntotdea una o pereche, despachtarea func tioneaz a pentru 1 N.T. termenul romnesc PERECHE este impropriu, forma original a 34 Capitol 5. Strucuri de date ind TUPLE.

. orice fel de secven ta 5.4 Dic tionare

Un alt tip de date prede nit n Python s i care se poate dovedi foarte folositor este dic tionarul. Dic tionarele pot ntlnite s i n alte limbaje, sub alte nume, cum ar rii asociative sau valori asociative. Spre deosebire de secven te (liste, s iruri, et c.) care sunt indexate cu numere (indicii sunt numere), dic tionarele sunt indexa te de chei, care pot de nite de oricare din tipurile de date invariabile(nemodi cabi le), de exemplu: s iruri de caractere sau numere. Perechile pot folosite drept ch ei ale unui dic tionar numai dac a con tin obiecte invariabile. Nu pute ti folosi dr ept chei listele deoarece acestea pot modi cate folosind metode ca append() sau ex tend(). Este indicat s a v a gndi ti la un dic tionar ca la o mul time neordonat a de erechi cheie-valoare, cu observa tia c a o cheie trebuie s a e unic a ntr-un dic tiona . O pereche de acolade creaz a un dic tionar gol: {}. Pute ti crea un dic tionar dac a ntre acolade introduce ti o list a (ale c arei elemente sunt separate prin virgul a ), de perechi cheie-valoare: dic tionar = jack:4098, Sape:4139. Opera tiile principale pe care le realizeaz a un dic tionar sunt: stocarea unei valori cu anumit a cheie s i extragerea unei valori cunoscndu-se o anumit a cheie. O pereche cheie-valoare p oate s tears a folosind instruc tiunea del. Dac a se adaug a o valoare n dic tionare ntru o cheie care exist a deja, valoarea veche asociat a acelei chei este pierdut a . O eroare este generat a, binen teles, dac a ve ti ncerca s a extrage ti o valoare p ru o cheie inexistent a. Metoda keys() a unui obiect dic tionar ntoarce o list a cu toate cheile existente n respectivul dic tionar. Lista returnat a nu este sortat a, n s a pentru a o sorta pute ti folosi metoda sort() a obiectului list a returnat de f unc tie. Pentru a veri ca dac a o anumit a cheie se a a deja n dic tionar folosi ti m has-key(). Iat a un mic exemplu: >>> tel = {jack: 4098, sape: 4139} >>> tel[guido] = 4127 >>> tel {sape: 4139, guido jack: 4098} >>> tel[jack] 4098 >>> del tel[sape] >>> tel[irv] = 4127 >>> tel {guido , irv: 4127, jack: 4098} >>> tel.keys() [guido, irv, jack] >>> tel.has_key(guido)

5.5 Mai multe despre condi tii Condi tiile folosite n cadrul instruc tiunilor while sau if pot con tine s i al ti ope ratori dect cei de compara tie. dat Operatorii de compara tie in s i not in veri c a a o anumit a valoare se a a sau nu ntr-o secven ta a. Operatorii is s i is not veri c ac a dou a obiecte sunt de fapt unul s i acela si obiect, acest lucru conteaz a n cazu l obiectelor modi cabile cum sunt listele de exemplu. Operatorii de compara tie pot combina ti. De exemplu a < b == c testeaz a nti dac a a < b iar apoi dac a b este eg l cu c. Condi tiile pot avea structuri foarte complexe dac a sunt folosi ti operato rii and, or sau not. Operatorii de compara tie au aceea si prioritate care este ma i mic a dect aceea a operatorilor numerici. Operatorii logici, booleeni(and,or,not ) au cea mai mic a prioritate, mai mic a dect aceea a operatorilor de compara tie. C ea mai mare prioritate ntre operatorii logici o au not, apoi and, iar cea mai mic a or. n concluzie A and not B or 5.4. Dic tionare 35

C este echivalent cu A and (not B) or C. Binen teles pute ti folosi paranteze pentru a combina condi tiile s i pentru claritate. Operatorii logici mai sunt denumi ti s i operatori pe scurt atur a (shortcut operator), argumentele acestea sunt evaluate de la stnga la dreapta, s i evaluarea se opre ste odat a ce rezultatul este determinat. De exemplu dac aAs i C sunt adev arate, iar B fals, expresia A and B and C nu este evaluat a pn a la sfr sit, deci expresia C nu este evaluat a pentru c a ar inutil. e posibil a atribuirea unei valori rezultate dintr-o compara tie sau orice alt a co ndi tie, unei variabile: >>> string1, string2, string3 = , Trondheim, Hammer Dance >>> non_null = string1 or st ring2 or string3 >>> non_null Trondheim Spre deosebire de C, n Python nu sunt permise atribuirii n cadrul expresiilor. Pro gramatorii de C pot critica acest lucru, dar prin aceasta se evit a o mul time de erori ntlnite n programele C, de exemplu = n loc de ==.

5.6 Compararea secven telor pot comparate cu obiecte secven de acela Obiectelor de tip secven ta ta si tip. Com para tiile ntre secven te folosesc principiile ordon arii lexicogra ce: sunt comparate nti primele dou a elemente din ecare list a, dac a difer a rezultatul este a sat, d unt egale se trece la compararea urm atoarelor dou a elemente, s i a sa mai departe pn a la epuizarea uneia dintre liste. Dac a elementele ce urmeaz a a comparate sunt la rdul lor liste, compararea lexicogra c a are loc recursiv. Dac a toate elementele celor dou a liste sunt egale se consider a c a listele sunt egale. Dac a una dintre secven te a ini mai scurt este o subsecven ta tial a a celeilalte, atunci secven ta este cea mai mic a. Ordonarea lexicogra c a pentru s iruri folose ste ordinea ASCII a caracterelor. Exemple de compara tii ntre secvenc te de acela si tip: (1, 2, 3) < (1, 2, 4) [1, 2, 3] < [1, 2, 4] ABC < C < Pascal < Python (1, 2, 3, 4) < 2, 4) (1, 2) < (1, 2, -1) (1, 2, 3) == (1.0, 2.0, 3.0) (1, 2, (aa, ab)) < (1, 2, (ab c, a), 4)

Se pot compara obiecte de tipuri diferite. Rezultatul este ns a arbitrar: tipurile ind ordonate dup a numele lor. n concluzie o list a va ntotdeauna mai mic a dect un r, un s ir mai mic dect o pereche, etc. Compara tiile ntre numere se fac lund n consid era tie valoarea numeric a chiar dac a numerele sunt de tipuri diferite, s i ca atar e 0 va egal cu 0.0, etc. 2 2 Regulile de compara tie ntre obiecte de tipuri diferite nu ar trebui considerate de foarte mare ncredere, deoarece acestea pot schimbate la versiuni viitoare ale limbajului. 36 Capitol 5. Strucuri de date

CAPITOL SASE

Module Dac a ie si ti din interpretorul Python s i intra ti din nou, de ni tiile pe care le-a f acut (func tii, varibile, etc.) se pierd. Dac a ave ti de gnd s a scrie ti un progr m mai lung, ar mai bine s a folosi ti un editor de texte pentru a scrie programul n tr-un sier, s i apoi s a rula ti interpretorul Python cu parametru sierul n care se programul. Fi sierul n care se a a programul se nume ste script. Pe m asur a ce progra ul se va m ari ve ti sim ti nevoia s a l mp ar ti ti n mai multe siere. S-ar put e bine s a dori ti s a folosi ti o func tie n mai multe programe f ar a a nevoit s a ti de ni tia func tiei n ecare program. n Python pute ti scrie anumite de ni tii n , pe care l pute ti include n alte programe. Un astfel de sier se nume ste modul. De n tiile dintr-un modul pot importate n alte module, sau n modulul principal (program ul ini tial). Un modul este un sier care con tine de ni tii s i instruc tiuni Python. mele sierului n care se a a un anumit modul este dat de numele modulului s i extensia .py la sfr sit. ntr-un modul, numele acestuia este accesibil prin intermediul variab ilei globale __name__. Folosi ti acum editorul dumneavoastr a de texte preferat pe ntru a creea sierul bo.py: # modul cu numerele lui Fibonacci def fib(n): # scrie \c{s}irul lui Fibonacci pa na la n a, b = 0, 1 while b < n: print b, a, b = b, a+b def fib2(n): # intoarce \c{s}irul lui Fibonacci pana la n result = [] a, b = 0, 1 while b < n: result.ap pend(b) a, b = b, a+b return result Acum deschide ti interpretorul Python s i tasta ti comanda: >>> import fibo

Aceast a instruc tiune nu ncarc a n tabela de simboluri numele func tiilor de nite n m lul bo, ci numai numele modulului. Folosind numele modulului pute ti accesa func ti ile de nite n interiorul acestuia: 37

>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2( 100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ fibo n cazul n care v a deranjeaz a aceste nume lungi pute ti proceda n felul urm ator: >>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 6.1 Mai multe despre module

Un modul poate con tine att instruc tiuni executabile ct s i de ni tii de func tii. Ac e instruc tiuni sunt menite s a realizeze ini tializarea modulului s i se execut a o singur a dat a atunci cnd modulul este importat. Fiecare modul are propria sa tabel a de simboluri care este folosit a de func tiile de nite n modul ca o tabel a de simbo luri global a. Cu toate astea, autorul unui modul se poate folosi de variabilele globale, f ar a a- si face griji pentru eventuale coliziuni cu variabilele globale ale mediului n care modulul va importat. Pe de alt a parte dac a ave ti neap arat nev oie pute ti modi ca direct variabilele globale ale unui modul, folosind aceea si con ven tie ca la apelarea func tiilor unui modul: modul.variabil a. Modulele pot impor ta alte module. Instruc tiunile import pot plasate la nceputul programului s i este indicat, dar nu este obligatoriu. Exist a o metod a de a nc arca de ni tiile unui anum it modul direct n tabela de simboluri global a a modulului care import a: >>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 3 77

n exemplul de mai sus, numele modulului nu a fost introdus n tabela de simboluri l ocal a. Pentru a nc arca toate de ni tiile modulului direct n tabela local a folosi ti exemplul de mai sus, n tabela local a au fost nc arcate toate numele de variabile s i func tii, mai putin cele care ncep cu caracterul _. >>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 6.1.1 Calea n care sunt cautate modulele Atunci cnd un modul numit xxx este importat, interpretorul caut a un sier numit xxx. py n directorul curent, s i n toate directoarele speci cate n variabila de sistem PYTHO NPATH. Aceasta are aceea si sintaxa variabila de sistem 38 Capitol 6. Module

PATH, care este o list a a directorului. Dac a variabila PYTHONPATH nu este de nit a modulul va c autat n directorul implicit de instalare, de obicei /usr/local/lib/pyt hon. 6.1.2 Fi siere Python compilate

Un important aport de vitez a la pornirea programelor care ncarc a o mul time de mod ule standard este adus de urm atorul comportament al Python-ului: dac a n directoru l unde este g asit sierul xxx.py se mai a as i xxx.pyc, se presupune c a acest ul on tine o variant a compilat a a modulului s i este nc arcat n loc de xxx.py. Timpul are a fost modi cat ultima oar a sierul .py este nregistrat n sierul .pyc n mom ste creat, iar n momentul importului dac a aceste momente de timp nu corespund sier ului .pyc este ignorat. De obicei nu trebuie s a face ti nimic deosebit pentru a cre a sierul xxx.pyc. Oridecteori xxx.py este compilat cu succes este creat sau suprascri s i sierul xxx.pyc. Dac a scrierea sierului compilat nu reu se ste ve ti aver run mesaj de eroare. Con tinutul sierelor de tip .pyc este independent de platform a, astfel nct Python devine un limbaj foarte portabil. Cteva indica tii pentru exper ti : Cnd interpretorul Python este apelat folosind op tiunea -O, se genereaz a cod opt imizat care va stocat n siere de tip .pyo. La momentul actual optimizatorul nu este de prea mare folos, nu face dect s a elimine din cod instruc tiunile assert s i SETLINENO. Atunci cnd se folose ste aceast a op tiune tot codul este optimizat, sierele pyc sunt ignorate iar sierele .py sunt compilate s i optimizate. Dac a interpretoru ython este lansat n execu tie folosind op tiunea -O, compilatorul poate genera n anu mite cazuri cod compilat eronat. Versiunea curent a elimin as irurile __doc__ din c odul compilat, astfel nct acesta s a e mai compact. Din moment ce unele programe pot folosi aceste s iruri, eliminarea lor ar putea genera erori. n concluzie, ar treb ui s a folosi ti aceast a op tiune numai atunci cnd s ti ti foarte bine ce face ti. nul Un program nu func tioneaz a mai rapid, atunci cnd este citit dintr-un sier de t ip .pyc sau .pyo, fa ta .py. Singurul lucru care difer a este viteza de nc arcare a p ramelor n memorie. Atunci cnd un script este rulat, prin lansarea interpretorului s i parametru numele sierului n care se a a scriptul, codul script-ului nu este compi lat s i nu se genereaz a siere de tip .pyc sau .pyo. n cazul n care ave ti un scr mensiuni mari, s i dori ti s a cre ste ti viteza de nc arcare, pute ti s a muta ti din cod ntr-un modul pe care s a l importa ti apoi n script. Interpretorul Python poa te lansat s i folosind direct un sier cu extensia .pyc sau .pyo. Este posibil s ti interpretorul Python doar cu un sier de tip .pyc (sau .pyo dac a se folose ste -O f ar a ca sierul .py asociat s a existe. Pute ti folosi aceast a facilitate atunci stribui ti o bibliotec as i nu dori ti s a e modi cat a. Modulul compileall poate pentru a crea siere .pyc sau .pyo pentru toate modulele dintr-un director. 6.2 Module standard Python dispune de o bilbliotec a de module standard, a c aror descriere o pute ti g asi ndocumentul The Python Library Reference. Unele module sunt integrate n interpre tor, de si nu fac parte din nucleul limbajului, din de ni tia acestuia, sau pentru a facilita accesul la primitivele sistemului de operare. Setul de module dar sunt integrate pentru e cien ta integrate este o optiune de con gurare, care de asemenea depinde de particularitatea platformei. De exemplu modulul amoeba este disponibi l pe sisteme care pun la dispozi tie primitive Amoeba. Un anumit modul necesit a o aten tie special a: sys care este integrat n orice interpretor Python. Variabilele sys.ps1 s i sys.ps2 de nesc s irurile de caractere ce vor folosite de interpretor p entru prompt-ul principal s i cel secundar: 6.2. Module standard 39

>>> import sys >>> sys.ps1 >>> >>> sys.ps2 ... >>> sys.ps1 = C> C> print Yuck! Yuc C>

Aceste dou a variabile sunt de nite doar dac a interpretorul se a a n mod interactiv. V ariabila sys.path con tine o lis a de directoare unde Python caut a module. Aceast a variabil a este ini tializat a din variabila de sistem PYTHONPATH, sau cu o valoar e implicit a n cazul n care PYTHONPATH nu este de nit a. Pute ti modi ca sys.path folosi d opera tii speci ce listelor: >>> import sys >>> sys.path.append(/ufs/guido/lib/python) 6.3 Func tia dir()

Func tia integrat a dir() poate folosit a pentru a determina ce nume(de variabile, func tii, etc.) de ne ste un modul. Rezultatul acestei func tii este o list a sortat a de s iruri de caractere: >>> import fibo, sys >>> dir(fibo) [__name__, fib, fib2] >>> dir(sys) [__name__, arg tin_module_names, copyright, exit, maxint, modules, path, ps1, ps2, setprofil n, stdout, version] Dac a func tia dir() este apelat a f ar a argumente, va lista numele ce sunt de nite (l ocal) pn a n momentul curent: >>> a = [1, 2, 3, 4, 5] >>> import fibo, sys >>> fib = fibo.fib >>> dir() [__name __, a, fib, fibo, sys] Observa ti c a listeaz a diferite tipuri de nume: variabile, func tii, module, etc. dir() nu listeaz a s i numele de func tii sau variabile integrate. Dac a dori ti o as tfel de list a, pute ti apela dir(__builtin__), unde __buildin__ este modulul n car e se a a func tiile s i variabilele integrate: 40 Capitol 6. Module

>>> import __builtin__ >>> dir(__builtin__) [AccessError, AttributeError, ConflictErr or, EOFError, IOError, ImportError, IndexError, KeyError, KeyboardInterrupt, Me ror, None, OverflowError, RuntimeError, SyntaxError, SystemError, SystemExit, T ror, ZeroDivisionError, __name__, abs, apply, chr, cmp, coerce, compile, di er, float, getattr, hasattr, hash, hex, id, input, int, len, long, map t, reduce, reload, repr, round, setattr, str, type, xrange] 6.4 Pachete

Pachetele sunt o modalitate prin care Python structureaz a modul de acces la modu le( si la de ni tiile existente n module). Pentru exempli care numele modulului A.B des emneaz a un submodul B de nit n cadrul pachetului A. S a presupunem c a dori ti s a ti o colec tie de module (un pachet) pentru manipularea sierelor de sunet, s i a su netelor. Exist a o multitudine de formate de sunet (de obicei recunoscute dup a ex tensia lor .wav, .aiff, .au) a sa c a este necesar a creearea s i ntre tinerea un de module ncontinu a cre stere care s a permit a conversia ntre diverse formate de re. Exist a multe alte opera tii pe care poate a ti dori s a le executa ti (mixaje, a d augarea ecoului, efecte stereo, etc.), a sa c a, de fapt, ve ti scrie o serie nesfr sit a de module care s a permit a aceste opera tii. Ave ti mai jos o posibil a structu r a a pachetului dumneavoastr a (n sensul unei ierahii de siere): Sound/ __init__.py Formats/ __init__.py wavread.py wavwrite.py aiffread.py aiffw rite.py auread.py auwrite.py ... Effects/ __init__.py echo.py surround.py revers e.py ... Filters/ __init__.py equalizer.py vocoder.py karaoke.py ... Pachet "tat a" Initializarea pachetului sound Subpachet pentru conversii intre fi\c{s}iere Subpachet pentru efecte acustice Subpachet pentru filtre Fi sierele de tipul __init__.py sunt necesare pentru a face Python s toarele ca pachete. Acestea sunt necesare pentru a preveni situa tia ca or cu un nume comun, de exemplu string, s a ascund a un modul valid cu e. n cel mai simplu caz __init.py__ poate un sier gol, dar poate ni tializare. Utilizatorii unui pachet pot importa doar un anumit modul l pachetului: 6.4. Pachete 41

a trateze direc un direct acela si num con tine s i cod d din cadru

import Sound.Effects.echo Instruc tiunea de mai sus a nc arcat modulul Sound.Effects.echo, dar o func tie din cadrul modulului trebuie aplelat a folosindu-i numele ntreg. Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4) O alternativ a pentru a importa un modul este: from Sound.Effects import echo n acest moment numele de nite n modul au fost nc arcate n tabela local a de simboluri, eci numele de func tii s i variabile sunt disponibile f ar a pre x: echo.echofilter(input, output, delay=0.7, atten=4) O alt a variant a este nc arcarea (importarea) direct a a func tiei sau variabilei dor ite: from Sound.Effects.echo import echofilter Un exemplu de utilizare a func tiei echofilter(): echofilter(input, output, delay=0.7, atten=4)

De observat c a atunci cnd se folose ste sintaxa from packet import element, elemen tul poate , e un submodul (sau subpachet), e un nume de nit n pachet, de exemplu un nu me de func tie sau variabil a, sau un nume de clas a. Instruc tiunea import testeaz a nti dac a elementul este de nit sau nu n pachet. Dac a elementul nu este de nit, Python presupune c a este vorba de un modul s i ncearc a s a-l ncarce. Dac a nc arcarea nu ste este generat ao excep tie de tipul ImportError. Cnd folosi ti o sintax a de genul : import element.subelement.subsubelement, ecare element, mai pu tin ultimul trebu ie obligatoriu s a e un pachet. Ultimul element poate un modul, un pachet, dar nu poate o clas a, o func tie, o variabil a, etc. de nit a n elementul anterior. 6.4.1 Importarea tuturor modulelor dintr-un pachet

Ce se va ntmpla dac a un programator va folosi o instruc tiune de genul: from Sound. Effects import *? ntr-un caz ideal, programatorul ar putea s a spere c a interpreto rul Python va realiza o c autare recursiv a n sistemul de siere s i directoare dup a odulele existente n pachet. Din nefericire nu func tioneaz a foarte bine pe platfor me Mac sau Windows, din varii motive. Pe astfel de platforme existen ta unui sier E CHO.PY nu garanteaz a c a n acest sier se a a un modul numit Echo, ct s i echo sau s i a sa mai departe. Spre exemplu Windows 95 are prostul obicei de a a sa numele de siere cu prima liter a mare. Sistemul de siere DOS 8+3 ridic a o alt a piedic a n a numelor lungi de module. Singura solu tie pentru astfel de probleme este ca aut orul pachetului s a speci ce exact ce module exist a n pachet. Instruc tiunea import() folose ste urm atoarea conven tie: dac a codul existent n sierul __init__.py de ne ist a cu numele __all__, aceasta este considerat a lista cu modulele ce ar trebui n c arcate la execu tia unei instruc tiuni from pachet import *. Este obliga tia autor ului pachetului s a modi ce lista atunci cnd este cazul. Autorii de pachete pot lua de asemenea decizia de a nu de ni aceast a list a, dac a nu vor ca programatorul care folose ste pachetul s a execute instruc tiuni de genul import *. Fi sierul Sounds/Ef fects/__init__.py ar trebui s a con tin a urm atoarele: 42 Capitol 6. Module

__all__ = ["echo", "surround", "reverse"] n acest caz instruc tiunea from Sound.Effects import * ar nc arca cele trei submodul e ale modulului Sound. Dac a variabila __all__ nu este de nit a, instruc tiunea de im port nu va importa toate submodulele ci va importa numai pachetul Sound.Effects (eventual va executa codul de ini tializare din __init__.py) s i apoi va importa toa te numele de nite n pachet. Se vor importa s i submodulele pachetului dac a acest luc ru este speci cat prin instruc tiuni import. Privi ti urm atorul cod : import Sound.Effects.echo import Sound.Effects.surround from Sound.Effects impor t * n exemplul anterior, modulele echo s i surround sunt importate deoarece acest lucr u este speci cat (prin instruc tiuni import) n cadrul pachetului Sound.Effects. Nu e ste foarte e cient s a folosi ti instruc tiuni de tipul import *, pentru c a n acest fe l codul dumneavoastr a va deveni neclar, ne ind clar care anume module sunt nc arcate . Totu si dac a a ti lansat interpretorul n mod interactiv, pute ti folosi astfel de instruc tiuni pentru a evita scrierea multor instruc tiuni. n concluzie nu este nim ic gre sit n folosirea unei instruc tiuni similare cu from Packet import submodul, de fapt aceasta este nota tia recomandat a. 6.4.2 Referen tieri ntre pachete

Apare deseori necesitatea ca ntr-un submodul s a apar a un alt submodul. De exemplu modulul surround s-ar putea folosi de modulele echo. De fapt astfel de referin t e sunt att de ntlnite nct instruc tiunea import examinaez a nti pachetul cel mai cu or, s i apoi caut a n lista de directoare. Cu toate astea modulul surround poate fol osi mult mai simplu o instruc tiune import echo sau from echo import echo lter. Dac a modulul ce se dore ste importat nu se a a n pachetul curent, instruc tiunea import caut a mai sus n ierarhia de modul a pachetului. Atunci cnd pachetele sunt strucutura te n subpachete, nu exist a o modalitate de a prescurta referirile la alte submodu le, ci trebuie folosite numele ntregi ale subpachetelor. De exemplu dac a modulul Sound.Filters.vocoder are nevoie de modulul echo din pachetul Sound.Effects, poa te folosi instruc tiunea: from Sound.Effects import echo. 6.4. Pachete 43

44

CAPITOL SAPTE

s Intrari i ie siri Exist a cteva modalit a ti de a prezenta rezultatele unui program. Datele pot a sate r-un format care poate n teles de om, sau pot scrise ntr-un sier pentru a putea p ucrate mai trziu. Acest capitol va explica cteva dintre posibilit a ti. 7.1 a datelor la ie Formatarea mai eleganta sire

Pn a acum am ntlnit dou a metode de a a sa valori: instruc tiunea print s i expresii a treia metod a este folosind metoda write() a obiectelor de tip sier. Fi sierul st andard de ie sire este referit ca sys.stdout.) Adesea ve ti dori s a ave ti mai mult c ontrol asupra modului de a sare a valorilor. Exist a dou a metode pentru a controla modul de a sare: prima este s a modi ca ti singur un s ir de caractere, folosind divers ele opera tii existente, iar apoi s a l a sa ti. Modulul string con tine cteva opera utile pentru manipularea s irurilor de caractere. O a doua metod a este folosirea operatorului %, cu un s ir, ca argument stnga. Operatorul % interpreteaz a argument ul stnga n acela si mod ca s i s irul de formatare al func tiei C sprintf() aplicndu-l asupra argumentului din dreapta s i returnnd s irul rezultat n urma ecestei format ar i. O singur a ntrebare r amne: cum pot convertite valorile n s iruri de caractere? Di fericire Python poate converti orice tip de valoare n s ir de caractere: e prin fu nc tia repr(), e scriind valoarea ntre apostroafe (). Iat a cteva exemple: Pn a acum tlnit dou a metode de a a sa valori: instruc tiunea print s i expresii. (O a treia met od a este folosind write() a obiectelor de tip sier. Fi sierul standard de ie sire e ste referit ca sys.stdout.) >>> x = 10 * 3.25 >>> y = 200 * 200 >>> s = Valoarea lui x este + x + , \c{s}i a lui y este + y + ... >>> print s Valoarea lui x este 32.5, \c{s}i a lui y este 40000... >>> # Apostroafele inverse operea\u{a} \^{i}n alt fel asupra numerelor : ... p = [x, y] >>> ps = repr(p) >>> ps [32.5, 40000] >>> # Convertirea unui \c{s}ir ad\u {a}ug\^{a}nd apostroafe \c{s}i backslashe-uri: ... hello = hello, world\n >>> hell os = hello >>> print hellos hello, world\n >>> # Argumentele unor apostroafe inverse pot fi perechi ( tuple ) : ... x, y, (spam, eggs) "(32.5, 40000, (spam, eggs))" Iat a dou a modalit a ti de a genera un tabel cu p atratele s i cuburile numerelor nat urale: 45

>>> import string >>> for x in range(1, 11): ... print string.rjust(x, 2), string. rjust(x*x, 3), ... # Observati ultimul caracter "," de pe ultima linie ... print s tring.rjust(x*x*x, 4) ... 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000 >>> for x in range(1,11): ... print %2d %3d %4d % (x, x*x, x*x*x) ... 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000

Observa ti c a ntre coloane a fost ad augat un spa tiu. Acest comportament este asigu rat de modul n care lucreaz a instruc tiunea print: ntotdeauna adaug a un spa tiu ntre argumentele sale. Acest exemplu demonstreaz a utilizarea func tiei string.rjust(), care aliniaz a la dreapta un s ir de caractere, ntr-un cmp de o anumit a dimensiune dat a, introducnd spa tii la stnga s irului. Exist a s i alte func tii similare strin just(), string.center(). Aceste func tii nu a seaz a nimic, nu fac dect s a returneze un alt s ir de caractere. Dac as irul primit este mai lung, aceste func tii nu l modi c a, ci l returneaz a intact. Acest mecanism probabil c a v a va strica aranjarea pe c oloane, dar este o variant a preferabil a celeilalte, adic a trunchierea s irului. D ac a dori ti s a truchia ti un s ir, pute ti oricnd s a folosi ti opera tiile de po e (slicing), ca de exemplu: string.ljust(x,n)[0:n]. Mai exist a o func tie util a, care umple cu zero-uri un s ir, ad augndu-le la stnga s irului original, pn a cnd a junge la o anumit a dimensiune. Aceast a func tie este string.zfill(): >>> import string >>> string.zfill(12, 5) 00012 >>> string.zfill(-3.14, 7) -003.14 >> tring.zfill(3.14159265359, 5) 3.14159265359 Folosind operatorul % ar ar ata astfel: 46 s Capitol 7. Intrari i ie siri

>>> import math >>> print Valoarea lui PI este aprox. %5.3f. % math.pi Valoarea lu i PI este aprox. 3.142. Dac a exist a mai multe format ari n s ir, trebuie s a se transmita ca operator dreapt a o pereche ( tupla ), astfel : >>> table = {Sjoerd: 4127, Jack: 4098, Dcab: 7678} >>> for name, phone in table.items( ): ... print %-10s ==> %10d % (name, phone) ... Jack ==> 4098 Dcab ==> 7678 Sjoerd ==> 4127

Majoritatea tipurilor de formate func tioneaz a exact ca n C, s i nu necesit a dect tr ansmiterea corect a a operandului din dreapta. Nerespectarea acestei reguli va ge nera o excep tie. Speci catorul de format %s este mai exibil, dac a parametrul asocia t din partea dreapt a nu este de tip s ir de caractere, va automat convertit la s i r de caractere folosind func tia integrat a str(). Speci catorii de format %u s i %p din C nu sunt accepta ti s i de Python. Dac a ave ti un s ir lung pe care nu dori ti s a-l mp ar ti ti n mai multe s iruri, ar interesant s a v a pute ti referi la varia in nume n loc de pozi tie. Acest lucru poate realizat folosind modalitatea numevar iabil a format, ca nurmatorul exemplu : >>> table = {Sjoerd: 4127, Jack: 4098, Dcab: 8637678} >>> print Jack: %(Jack)d; Sjoerd %(Sjoerd)d; Dcab: %(Dcab)d % table Jack: 4098; Sjoerd: 4127; Dcab: 8637678 Acest lucru se poate dovedi foarte util atunci cnd dori ti s a a sa ti variabilele pre de nite folosind func tia vars() care ntoarce un dic tionar cu toate variabilele loca le. 7.2 Fi siere

Func tia open() are ca rezultat un obiect de tip sier, s i este de cele mai multe o ri apelat a cu doi parametrii: numele de sier s i modul de acces la sier: >>> f=open(/tmp/workfile, w) >>> print f <open file /tmp/workfile, mode w at 80a0960>

Primul argument este un s ir de caractere care con tine numele sierului ce urmeaz a s a e deschis. Al doilea argument este tot un s ir de caractere ce con tine doar ctev a caractere ce descriu modul n care sierul va utilizat. Modul poate : - r = sieru putea numai citit - w = sierul va putea dect s a e scris (n cazul n care un si eja, acesta va suprascris) - a = sierul va deschis pentru actualizare (toate datele scrise vor ad augate la sfr situl sierului) - r+ = n sierul ce va deschis se a att opera tii de scriere ct s i de citire. 7.2. Fi siere 47

Pe Windows s i Macintosh ad augarea caracterului b la sfr situl s irului prin care se peci c a modul de acces, indic a interpretorului Python s a deschid a sierul n mod bi . Exist a deci modurile de acces rb, wb, r+b. Windows face distinc tie ntre sierel p text s i cele binare: caracterele de sfr sit de linie sunt modi cate atunci cnd se s criu sau se citesc date. Aceaste modi c ari din spatele scenei sunt binevenite n cazul sierelor text, dar nu pot face dect r au n cazul sierelor binare cum sunt .JPG sau EXE de exemplu. Ave ti deci grij a s a folosi ti modul binar cnd lucra ti cu astfel de siere. 7.2.1 Metodele obiectelor sier

Exemplele acestei sec tiuni vor presupune c a un obiect f de tip sier a fost deja cre at, deci sierul a fost deja deschis. Pentru a citi con tinutul unui sier apela ti f. read(dimensiune), care cite ste o cantitate de date s i o returneaz a ca string. Pa rametrul dimensiune este op tional. Atunci cnd acest parametru este omis sau este negativ, ntregul sier va citit s i returnat ca s ir de caractere. Apare o problem a inen teles dac a memoria ma sinii dumneavoastr a este mai mic a dect dimensiunea si i. Dac a parametrul dimensiune este transmis func tiei din sier vor citi ti cel mult at tia bytes c ti sunt speci ca ti prin acest parametru. Dac a s-a ajuns la sfr situ ului f.read() va returna un s ir vid(" "): >>> f.read() This is the entire file.\n >>> f.read()

Metoda f.readline() cite ste o singur a linie din sier. Un caracter linie nou a(newli e), \n este ad augat la sfr situl ec arui s ir. Acest caracter este omis dac a este despre ultima linie din sier s i dac a acesta nu se termin a cu un caracter linie no u a. Toate acestea fac rezultatul neclar. Dac a rezultatul este un s ir gol, atunci a fost atins sfr situl sierului, n timp ce dac a rezultatul este doar caracterul \n mn a c a din sier a fost citit a o linie goal a: >>> f.readline() This is the first line of the file.\n >>> f.readline() Second line of the file\n >>> f.readline()

Metoda f.readlines() a obiectelor de tip sier, ntoarce o list a con tinnd toate linii le din sier. Dac a metoda este apelat a cu argumentul dimensiune, atunci din sier su nt citi ti at tia bytes c ti sunt speci ca ti prin acest parametru s i nc a at tia unt necesari pentru a completa o linie. Aceast a metod a este folosit a pentru citi rea e cient a pe linii a sierelor de dimensiuni mari f ar a a ntmpina di cult a ti a. Vor returnate numai linii complete: >>> f.readlines() [This is the first line of the file.\n, Second line of the file\n] Metoda write(s ir) scrie con tinutul s irului de caractere n zultat: >>> f.write(This is a test\n)

sier, ntorc and None ca

f.tell() are ca rezultat un num ar ntreg reprezentnd pozi tia cursorului n sier, po ie m asurat a n bytes fa ta de nceputul sierului. Pentru a schimba pozi tia cursorul folosi ti func tia f.seek(deplasare,referin t a). 48 s Capitol 7. Intrari i ie siri

 de nceputul Noua pozi tie este calculat a n felul urm ator: cursorul va deplasat plasare bytes, fa ta sierului de pozi de sfr dac a referin t a este 0, fa ta tia a cursorului dac a referin t a este 1 s i fa ta situl sierului dac a referin t Dac a al doilea parametru este omis, valoarea lui implicit a va 0, deci punctul d e referin ta va nceputul sierului: >>> >>> >>> >>> 5 >>> >>> d f=open(/tmp/workfile, r+) f.write(0123456789abcdef) f.s # Go to the 5th byte in the file f.read(1) f.seek(-3, 2) # Go to the 3rd byte be fore the end f.read(1)

Cnd termina ti lucrul cu un sier, acesta trebuie nchis folosind f.close(). Dup a nchi erea sierului orice ncercare de opera tie asupra sierului va e sua: >>> f.close() >>> f.read() Traceback (most recent callk last): File "<stdin>", l ine 1, in ? ValueError: I/O operation on closed file Obiectele sier posead as i alte metode, cum ar isatty() s i truncate() care sunt mai pu tin folosite. (Consulta ti "Python Library Refference" pentru mai multe detali i). 7.2.2 Modulul pickle

Sirurile de caractere pot citite s i scrise foarte u sor dintr-un, respectiv ntr-un sier. Cu numerele lucrurile se complic a pu tin. A ti putea s a transforma ti naint e scrierea n sier, num arul n string, apoi s a l scrie ti, iar la citire s a l tra ti napoi n num ar, dar un astfel de mecanism este complet ine cient. Pentru aceste si tua tii, s i altele mult mai complicate Python dispune de modulul pickle care poat e transforma orice obiect Python ntr-un string. Acest proces se cheam a pickling, denumirea procesului invers se nume ste unpickling. ntre aceste dou a proceduri str ing-ul poate salvat ntr-un sier, transmis n re tea, etc. Cea mai simpl a metod a de salva un obiect ntr-un sier este urm atoarea: pickle.dump(x, f) Iar pentru a nc arca un obiect dintr-un sier: x = pickle.load(f)

Exist as i alte metode de a transforma un obiect ntr-un s ir f ar a a-l salva ntr-un r. Pentru mai multe detalii consulta ti Python Library Refference. Prin procedeele de pickling s i unpickling, pickle poate stoca obiecte ce pot apoi reutilizate. Terme nul tehnic pentru un astfel de obiect este obiect persistent. Deoarece aceste me tode sunt foarte des folosite, programatorii care creeaz a extensii ale limbajulu i Python au grij a ca tipurile de date nou de nite s a poat a salvate s i nc arcate c ct(mai bine zis s a se comporte corect n procesul de pickling s i apoi unpickling). 7.2. Fi siere 49

50

CAPITOL OPT Erori s i excep tii Pn a acum erorile au fost doar men tionate, dar dac a a ti ncercat exemplele prezentat e probabil a ti s i ntlnit cteva dintre ele. Exist a (cel pu tin) dou a categorii de ri: erori de sintax as i excep tii. 8.1 Erori de sintaxa

Erorile de sintax a sunt cel mai des ntlnite erori atta timp ct sunte ti un ncep ator imbajul Python: >>> while 1 print Hello world File "<stdin>", line 1, in ? while 1 print Hello worl d ^ SyntaxError: invalid syntax

Interpretorul reproduce linia care a cauzat eroarea s i a seaz a o s ageat a n dreptul instruc tinii care a generat eroarea. Eroarea este cauzat a (sau cel pu tin detecta t a) de instruc tiunea dinaintea s age tii. n exemplul de mai sus eroarea este genera t a de instruc tiunea print, deoarece naintea acestei instruc tiuni ar trebui s a exi ste un caracter :. Numele sierului s i num arul liniei care a generat eroarea sunt a te, astfel nct dac a eroarea provine dintr-un script s a pute ti corecta ct mai comod. 8.2 Excep tii Chiar dac a o expresie sau o instruc tiune este corect a din punct de vedere sintac tic, aceasta poate genera o eroare n momentul n care este executat a. Erorile gener ate (detectate) n timpul execu tiei se numesc excep tii, s i nu sunt neap arat fatale . Ve ti ntreba cum pute ti evita astfel de erori utiliznd limbajul Python. Majoritat ea excep tiilor nu sunt tratate de program s i genereaz a mesaje de eroare ca n exem plul de mai jos: 51

>>> 10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in ? Z eroDivisionError: integer division or modulo >>> 4 + spam*3 Traceback (most rece nt call last): File "<stdin>", line 1, in ? NameError: spam >>> 2 + 2 Traceback (m ost recent call last): File "<stdin>", line 1, in ? TypeError: illegal argument type for built-in operation Ultima linie a mesajului de eroare indic a ce s-a ntmplat. Excep tiile sunt de difer ite tipuri, iar tipul excep tiei este de asemenea a sat n corpul mesajului de eroare . n exemplul anterior: ZeroDivisionError, NameError s i TypeError, s irul a sat ce de semneaz a tipul excep tiei este un nume prede nit pentru respectivul tip de excep tie . Acest lucru este valabil pentru toate excep tiile prede nite, dar se pot de ni s i a lte tipuri de excep tii. A doua parte a liniei reprezint a detaliile excep tiei, de scriind mai bine ce s-a ntmplat. n Python Library Reference sunt listate excep tiile implicite s i semni ca tiile lor.

8.3 Tratarea excep tiilor Este posibil s a scrie ti programe care trateaz a anumite tipuri de excep tii . n urm atorul exemplu este implementat ao bucl a care cere utilizatorului introducerea un ui num ar. Bucla este ntrerupt a n momentul n care utilizatorul introduce un num ar co rect, astfel procesul de introducere continu a. Procesul poate ntrerupt folosind c ombina tia de taste CTRL-C. Dac a utilizatorul folose ste aceast a combina tie de tast , programul este ntrerupt, dar nainte este generat a excep tia: KeyboardInterrupt: >>> while 1: ... try: ... x = int(raw_input("Please enter a number: ")) ... brea k ... except ValueError: ... print "Oops! That was no valid number. Try again... " ...

Instruc tiunea try func tioneaz a n felul urm ator: nti sunt executate instruc tiun in blocul try (blocul de instruc tiuni dintre instruc tiunile try s i except). Dac a nu este generat a nici o excep tie, instruc tiunile din blocul except nu sunt exec utate s i programul continu a. Dac a apare o excep tie n timpul execu tiei instruc t ilor din blocul try s i dac a tipul excep tiei este acela pe care l trateaz as i blocu l except, atunci instru tiunile din acest bloc nu sunt executate. Dup a ce excep ti a este tratat a, execu tia continu a, nemai executndu-se instruc tiunile r amase din b locul try (adic a instruc tiunile ce urmeaz a dup a instruc tiunea care a generat exc ep tia). Dac a excep tia nu este prev azut a ntre excep tiile tratate n blocul exce a este transmis a altor structuri try.Dac a nu este g asit un bloc except care s a t rateze excep tia, programul este ntrerupt, iar respectiva excep tie se nume ste exce p tie netratat a (unhandled exception). 52 Capitol 8. Erori s i excep tii

O instruc tiune try poate avea mai multe clauze except, implementnd astfel mai mul te tipuri de tratament pentru mai multe tipuri de excep tii. Dintre toate clauzele except va executat a cel mult una. Instruc tiunile unei clauze except, trateaz a nu mai excep tiile generate n blocul try c aruia clauza i este asociat a, nu s i excep ti le ce pot apare n alte clauze except. O astfel de clauz a poate trata mai multe ti puri de excep tii desemnate printr-o lista inchis a ntre paranteze, ca de exemplu : ... except (RuntimeError, TypeError, NameError): ... pass

Ultima clauz a except poate folosit a f ar a a se speci ca ce anume excep tie trateaz n acest caz aceast a clauz a trateaz a toate excep tiile netratate de celelalte clau ze. Pute ti folosi aceast a ultim a precau tie, s i este indicat s a o face ti, pentru a ascunde toate erorile ce pot ap area s i pe care nu le-a ti anticipat. O pute ti d e asemenea folosi pentru a a sa un mesaj de eroare s i apoi a regenera excep tia, ca re va transmis a mai departe, urmnd s a e eventual tratat a de un alt bloc try: import string, sys try: f = open(myfile.txt) s = f.readline() i = int(string.strip (s)) except IOError, (errno, strerror): print "I/O error(%s): %s" % (errno, stre rror) except ValueError: print "Nu poate fi convertit \^{i}ninteger" except: pri nt "Eroare neasteptata:", sys.exc_info()[0] raise Instruc tiunile try dispun s i de o clauz a op tional a: else. Atunci cnd aceasta este folosit a, ea trebuie s a e ultima dintre clauze. Instruc tiunile acestei clauze vo r executate atunci cnd, blocul try nu genereaz a nici o excep tie. Iat a un exemplu: for arg in sys.argv[1:]: try: f = open(arg, r) except IOError: print cannot open, ar g else: print arg, has, len(f.readlines()), lines f.close() Utilizarea clauzei else este mai adecvat a dect ad augarea unor linii suplimentare de cod la sfr situl blocului try, pentru c a n acest fel se evit a detectarea unei ex cep tii care nu a fost generat a de instruc tiunile blocului try. O excep tie poate avea asociat as i o valoare, un argument al excep tiei. Prezen ta argumentului s i ti pul acestuia depinde de tipul excep tiei. Pentru acele excep tii care au un argume nt, clauza except poate avea nume de varibil a, dup a numele excep tiei, variabil a ce va con tine(dac a acea excep tie este detectat a) argumentul asociat excep tiei. U rm atorul exemplu este l amuritor n acest sens: 8.3. Tratarea excep tiilor 53

>>> try: ... spam() ... except NameError, x: ... print name, x, undefined ... name s pam undefined Dac a o excep tie are un argument, acesta va a sat n ultima parte a mesajului ce apar e cnd o excep tie nu este tratat a. ntr-un bloc try nu sunt detectate numai excep tii le generate n cadrul func tiilor apelate: >>> def this_fails(): ... x = 1/0 ... >>> try: ... this_fails() ... except ZeroD ivisionError, detail: ... print Handling run-time error:, detail ... Handling runtime error: integer division or modulo 8.4 Generarea excep tiilor Instruc tiunea raise i permite programatorului s a genereze o anumit a excep tie : >>> raise NameError, HiThere Traceback (most recent call last): File "<stdin>", li ne 1, in ? NameError: HiThere

Primul parametru reprezint a tipul excep tiei, iar al doilea este op tional s i repr ezint a un eventual argument. Dac a se vrea s a se stie cnd o excep tie a fost semnal ata a, dar nu se inten tioneaz a tratarea ei, o form a mai simpli cata a a instruc tiun i raise permite reapari tia excep tiei : >>> try: ... raise NameError, HiThere ... except NameError: ... print An exception flew by! ... raise ... An exception flew by! Traceback (most recent call last): F ile "<stdin>", line 2, in ? NameError: HiThere 54 Capitol 8. Erori s i excep tii

8.5 Excep tii de nite de utilizator Un programator si poate crea propriile excep tii prin creare unei clase de excep ti i noi. n mod obi snuit excep tiile pot i indirect. De exemplu : derivate din clasa E xception att nmod direct ct s >>> class MyError(Exception): ... def __init__(self, value): ... self.value = va lue ... def __str__(self): ... return self.value ... >>> try: ... raise MyError(2* 2) ... except MyError, e: ... print My exception occurred, value:, e.value ... My exception occurred, value: 4 >>> raise MyError, oops! Traceback (most recent call last): File "<stdin>", line 1, in ? __main__.MyError: oops! Clasele de excep tii pot proiectate ca oricare alta clas a, dar in mod uzual ele s unt simple, deseori oferind numai un num ar de atribute, ce permit s a informeze a supra erorii ce a fost tratat a. Cnd se implementeaz a un modul care poate genera u n num ar distinct de erori, se obi snuie ste s a se creeze o clasa de baz a a excep ti ilor de nite de acest modul, s i subclase care s a creeze clase speci ce pentru diferi te condi tii de eroare : 8.5. Excep tii de nite de utilizator 55

class Error(Exception): """Base class for exceptions in this module.""" pass cla ss InputError(Error): """Excetie generat\u{a} pentru eroare de intrare. Atribute : expression -- expresia de intrare \^{i}n care apare eroarea message -- explica rea erorii """ def __init__(self, expression, message): self.expression = expres sion self.message = message class TransitionError(Error): """Generata c\^{a}nd o opera\c{t}ie a\c{s}teapt\u{a} o modificare de stare care nu este permis\u{a} At tributes: previous -- starea la \^{i}nceputul tranzi\c{t}iei next -- noua stare care este de a\c{s}tept s\u{a} apar\u{a} message -- explica\c{t}ie privind impos ibilitatea tranzi\c{t}iei """ def __init__(self, previous, next, message): self. previous = previous self.next = next self.message = message Multe excep tii sunt de nite cu nume care se termina n Error, similar cu denumirea exc ep tiilor standard. Multe module si de nesc propriile excep tii pentru a raporta eror ile ce pot ap area nfunc tiile de nite de ele. Mai multe informa tii despre clase ve ti g asi n capitolul refclasses, Classes.. 8.6 tare De nirea ac tiunilor de cura Instruc tiunea try poate avea s i o alt a clauz a prin care se pot de ni ac tiuni de cu r a tare care vor executate n orice . De exemplu: circumstan ta >>> try: ... raise KeyboardInterrupt ... finally: ... print Goodbye, world! ... Go odbye, world! Traceback (most recent call last): File "<stdin>", line 2, in ? Ke yboardInterrupt

Clauza nally este executat a dac a a fost sau nu generat a o excep tie n blocul try. C d apare o excep tie, este regenerat a dup a ce sunt executate instruc tiunile clauze i finally. Clauza finally este de asemenea executat a la 56 Capitol 8. Erori s i e xcep tii

ie sire, chiar s i atunci cnd a fost apelat a o instruc tiune break sau return. Codul scris ncalauza finally este util a pentru eliberarea resurselor externe (cum ar sie re sau conect ari la re tea), fara a mai vedea daca utilizarea resurse s-a ncheiat cu succes. O instruc tiune try trebuie e s a aibe una sau mai multe clauze except, e o clauz a finally, dar nu ambele n acela si timp. tare 8.6. De nirea ac tiunilor de cura 57

58

CAPITOL NOUA

Clase Mecanismul de clase al limbajului Python face posibil a ad augarea de noi clase cu un minim de efort. Acest mecanism de clase este o combina tie ntre mecanismele di n C++ s i Modula-3. La fel ca s i pentru module, Python nu creeaz ao barier a absolu t a ntre de ni tie s i utilizator, ci se bazeaz a mai mult pe polite tea utilizatorul a nu p atrunde n de ni tie. Cele mai importante facilit a ti ale claselor sunt n con re disponibile. n terminologie C++, toate componentele unei clase( si datele membr e) sunt publice, s i toate func tiile membre sunt virtuale. Nu exist a constructori sau destructori specializa ti. La fel ca n Modula-3, nu exist a scurt aturi pentru a accesa membrii unei clase n cadrul unei metode a acelui obiect: metodele sunt d e nite cu un argument explicit reprezentnd obiectul, care este apoi transmis automa t n momentul n care func tia este apelat a. Clasele sunt n sine obiecte, iar n sens ma i larg: n Python toate tipurile de date sunt obiecte, acest comportament este spe ci c s i limbajului SmallTalk. Prin toate acestea sunt posibile importurile s i rede numirile. La fel ca n C++ s i Modula-3, tipurile prede nite nu pot de nite drept clase de baz a pentru eventuale extensii. De asemenea, la fel ca n C++, dar spre deoseb ire de Modula-3, majoritatea operatorilor cu sintax a special a(de exemplu: operat orii aritmetici) pot rede ni ti n cadrul claselor. 9.1 Cteva cuvinte despre terminologie

Deoarece nu exist a o terminologie unanim recunoscut a n ceea ce prive ste clasele, nu vom folosi aici termenii din SmallTalk s i C++. Am putea folosi termenii din M odula-3, deoarece semantica acestui limbaj este mai aproape de cea a Python-ului , dar foarte pu tini utilizatori au auzit de acest limbaj, de si C++ s i SmallTalk sunt o alegere mult mai bun a, ind limbaje cu o popularitate mult mai mare. Va tre bui de asemenea s a avertiz am cititorii asupra unei gre seli pe care o pot face n i nterpretarea celor ce urmeaz a: cuvntul obiect n Python nu nseamn a neap arat o insta ere a unei clase. n C++, Modula-3, de asemenea s i n Python, dar nu s i n SmallTalk, exist a anumite tipuri de date care nu sunt neap arat clase: numerele ntregi s i lis tele nu sunt clase, dar s i alte tipuri de date mai exotice, cum sunt sierele nu sun t clase. Toate tipurile de date n Python au aproximativ acela si comportament care este mai u sor de explicat dac a ne referim la aceste tipuri de date folosind cuvn tul obiect. Obiectele pot avea individualitate, sau pot avea mai multe nume(care p ot servi mai multor scopuri) care s a desemneze acela si obiect. Aceast procedeu s e nume ste aliasing n alte limbaje. De obicei n Python, la prima vedere, nu sunt ncura jate astfel de tehnici, care pot foarte bine ignorate cnd este vorba despre tipur ile de date nemodi cabile(numere, s iruri, perechi). n orice caz, tehnica aceasta, al iasing, are s i un efect inten tionat asupra sintaxei Python care prive ste obiectel e alterabile (liste, dic tionare, etc.) s i obiectele ce exist a n afara contextului n care se a a programul ( siere, ferestre. etc.). Pute ti utiliza tehnica aliasing, tru a bene cia de puterea oferit a n alte limbaje, de pointeri, ntruct pute ti consider a c a alias-urile func tioneaz a ntr-un anumit sens ca pointerii din C. Spre exemplu transmiterea unui obiect este mai simpl a, din moment ce se transmite doar un po inter. Dac a o func tie prime ste ca parametru un obiect pe care l modi c a, cel ce a a plelat func tia va putea observa efectul func tiei, deoarece modi c arile efectuate d e func tie au fost f acute asupra con tinutului obiectivului s i nu asupra unui repr ezent ari locale(n contextul func tiei). Explicnd toate acestea se observ a necesitat ea a dou a mecanisme de transmitere a parametrilor ca n Pascal. 59

9.2 1 Domenii de vizibilitate (Scopes) s i domenii de de ni tie a numelor(Name Spaces)

De ni tiile claselor manipuleaz a ntr-un mod foarte interesant domeniile de de ni tie a numelor, s i o foarte bun a n telegere a modului de func tionare a domeniilor de vizi bilitate s i de de ni tie a numelor este foarte impotant a. n telegerea acestor mecanis me este foarte important as i se va dovedi foarte util a oric arui programator avans at Python. S a ncepem cu cteva de ni tii: aceste domenii Un domeniu de de ni tii a num r este o hart a de leg aturi ntre nume s i obiecte. n momentul de fa ta sunt implemen e folosind dic tionare, dar metodele de implementare pot schimbate pe viitor. Exe mple de astfel de domenii sunt: domeniul numelor prede nite, domeniul numelor glob ale dintr-un modul, domeniul numelor locale creat la apelarea unei fun tii, etc. n tr-un anumit sens atributele unui anumit obiect formeaz a un domeniu de de ni tie. U n lucru foarte important de s tiut este acela c a ntre dou a nume existente n dou a do menii diferite nu exist a absolut nici o leg atur a. Din aceast a cauz a dou a module pot de ni o func tie cu aceea si denumire f ar a a se creea confuzie. Un atribut este orice nume care urmeaz a unui punct, de exemplu n expresia z.real,real este un atr ibut al obiectului z. ntr-un sens strict, referin tele la nume de nite ntr-un modul s unt de fapt referin te la atribute ale modulului: n expresia modul.func tie, modul este modulul iar func tie este un atribut al modulului. Numele globale ale modulu lui s i atributele modulului se a a n acela si domeniu de de ni tie al numelor.(Exist singur a excep tie. Modulele au un atribut nemodi cabil (read-only) secret: __dict__ n care se a a domeniul de de ni tie al numelor ce apar tine modulului. __dict__ este un atribut dar nu este un nume global.) Atributele pot nemodi cabile(read-only) sau m odi cabile(writeable). Atributele unui modul sunt modi cabile: de genul: modul.r pute t i folosi o secven ta aspuns = 42. Atributele modi cabile pot de asemenea s terse folo sind operatorul del. De exemplu del modul.r aspuns va elimina atributul r aspuns din obiectul denumit modul. diferite. Domeniul Domeniile de de ni tie a numelor sunt c reate la momente de timp diferite s i au perioade de via ta care con tine numele pr ede nite este creat odat a cu pornirea interpretorului Python s i nu este s ters nici odat a. Domeniul numelor globale de nite ntr-un modul este creat atunci cnd este nc arc at a de ni tia modulului s i este distrus de obicei tot n momentul n care interpretorul este nchis. Instruc tiunile executate la primul nivel al interpretorului e dintr-u n script, e interactiv, fac parte dintr-un modul numit __main__. Numele prede nite se a a n domeniul __builtin__. Domeniul de de ni tie a numelor pentru o func tie este c reat odat a cu apelul func tiei, s i este s ters odat a cu terminarea func tiei, e pri return, e dac a acesta genereaz a o excep tie netratat a. Binen teles c a apeluri re sive genereaz a mai multe domenii de de ni tie. Un domeniu de vizibilitate (scope) e ste o regiune a unui program Python n care un anumit domeniu de de ni tie a la un nu me va genera o c numelor este accesibil. Accesibil nseamn a c a o anumit a referin ta autare n domeniul de de ni tie al acelui modul dspre care spunem c a este accesibil. Domeniile de vizibilitate sunt determinate static, s i sunt folosite dinamic. n ti mpul execu tiei exist a exact trei domenii de vizibilitate (exact trei domenii de de ni tie sunt direct accesibile): primul cel mai adnc, con tine numele locale, cel deal doilea con tine numele globale ale modulului curent, iar cel de-al treilea cel mai de sus, care este ultimul n care se caut a un nume(dac a n celelalte c autarea nu a avut succes, s i care con tine numele prede nite. De obicei, cel mai adnc domeniu de vizibilitate este cel al func tiei care este executat a. n exteriorul unei func tii, acest domeniu este identic cu al doilea domeniu (cel din mijloc), n care se a a ac cesibile de ni tiile modulului. Domeniul de vizibilitate global al unei func tii de ni te ntr-un modul este domeniul de de ni tii al respectivului modul, indiferent de und e, sau cu ce alias este apelat a respectiva func tie. Pe de alt a parte c autarea un ui anumit nume este realizat a dinamic, n timpul execu tiei. Cu toate astea de ni tia limbajului evolueaz a c atre o rezolutie a numelor 1 (N.T. Traducerile celor doi termeni n limba romn a sunt improprii, iar n telegerea acestor termeni ar trebui s a e mai mult o n telegere sensului pe care o are traduce rea celor doi termeni). contextual a nednd o prea mare importan ta

60 Capitol 9. Clase

static a, n timpul compil arii. n concluzie nu v a baza ti prea tare pe varianta dinam ic a. Deja variabilele locale sunt determinate static. O caracteristic a a limbaju lui Python, aste c a atribuirile au loc n primul domeniu de vizibilitate(cel mai de jos sau cel mai adnc N.T. termenul original este innermost). Atribuirile nu realize az a o copiere a datelor ci leag a nume de obiecte. Acest lucru este valabil s i pe ntru s tergeri. Instruc tiunea del x s terge leg atura lui x din domeniul local de d e ni tie. De fapt toate opera tiile care introduc nume noi au impact asupra domeniul ui de de ni tii local: instruc tiunile import sau de ni tia unei func tii introduc numel e modulului importat, respectiv numele func tiei n domeniul de de ni tii local. Dac a este folosit a instruc tuinea global se indic a intrepretorului ca urm atorul nume s a e introdus n domeniul global. 9.3 privire asupra claselor O prima No tiunea de clase aduce cu sine s i cteva alte no tiuni noi de sintax a, trei tipuri noi de obiecte, s i cteva no tiuni noi de semantic a. 9.3.1 De nirea unei clase Cea mai simpl a de ni tie a unei clase arat a astfel: class ClassName: <statement-1> . . . <statement-N>

De ni tiile de clase, la fel ca de ni tiile de func tii, sunt valabile de abia dup a ce sunt executate. Pute ti insera o de ni tie de clas a n cadrul unei instruc tiuni if, s clasa nu va exista dect dac a condi tia instruc tiunii if va adev arat a. n practic instruc tiunile din interiorul unei clase vor de ni tii de func tii, dar sunt permise s i alte instruc tuni care pot de ce cunoa foarte utile uneori. De ni tiile de func i din cadrul unei clase sunt un pic deosebite fa ta ste ti, dar despre asta vom vo rbi mai trziu. Atunci cnd este introdus a de ni tia unei clase noi, un nou domeniu de de ni tii a numelor este creat s i folosit ca domeniu de vizibilitate local, deci to ate atribuirile vor afecta noul domeniu de de ni tii creat. De ni tiile de func tii vor introduce numele acelor func tii tot n acest domeniu. Cnd de ni tia unei clase se ter min a normal, f ar a erori, este creat un obiect nou de tipul class. Pe scurt, aces t obiect con tine noul domeniu de de ni tii creat odat a cu de ni tia clasei. n urm a sec tiune vom discuta mai mult despre obiecte de tip class. Domeniul de vizibilit ate existent naintea de ni tiei clasei este reactivat, s i obiectul class este introd us n respectivul domeniu de de ni tii sub numele dat de numele speci cat n de ni tia clas i (n exemplul de mai sus: ClassName). 9.3.2 Obiecte class

Aceast a categorie de obiecte accept a dou a categorii de opera tii: referen tieri de atribute s i instan tieri. Referen tierile de atribute folosesc sintaxa standard d in Python: obiect.atribut. Atribute valide sunt toate numele existente n domeniul de de ni tii n momentul cre arii obiectului class. A sa c a, dac a de ni tia clasei a astfel: privire asupra claselor 9.3. O prima 61

class MyClass: "Un exemplu simplu de clasa" i = 12345 def f(self): return hello w orld

Atunci MyClass.i s i MyClass.f sunt referin te la atribute valabile. Unul dintre a tribute este un ntreg (i), iar cel alalt o metod a(f). Se pot realiza atribuiri cu atributele unei clase, deci pute ti modi ca valoarea atributului MyClass.i printr-o atribuire. __doc__ este de asemenea un atribut al clasei, care are valoare Un ex emplu simplu de clasa. Instan tierea claselor folose ste nota tia de la func tii. Put em s a ne imagin am c a obiectul clas a este o func tie f ar a pentru respectiva cla rametrii care ntoarce ca rezultat o nou a instan ta a: Exemplul urm ator: x = MyClass() a clasei s creeaz a o nou a instan ta i atribuie acest obiect variabilei locale x. O pera tia de instan tiere creaz a un obiect vid. Multe clase prefer a s a creeze un ob iect ntr-o stare ini tial a. Pentru a realiza acest lucru o clas a trebuie s a aib a d e nit a o metod a special a numit a __init__() ca n exemplul de mai jos: def __init__(self): self.data = [] Atunci cnd o clas a are de nit a metoda __init__(), instan tierea respectivei clase ap eleaz a automat metoda ini __init__(). n acest fel se poate ob tine o instan ta tiali zat a a unei anumite clase: x = MyClass() Binen teles metoda __init__() poate avea argumente. n acest caz argumentele primite la instan tierea clasei sunt transmise automat metodei __init__(). De exemplu: >>> ... ... ... ... >>> >>> (3, class Complex: def __init__(self, realpart, imag part): self.r = realpart self.i = imagpart x = Complex( 3.0, -4.5) x.r, x.i 0, 4 .5) V a pute ti gndi la metoda __init__() ca la un constructor, de si nu este un constru ctor n toat a puterea cuvntului. 9.3.3 Obiecte instan tiate

Ce putem face cu instan tele? Singurele opera tii acceptate sunt opera tiile cu atr ibute. Exist a dou a tipuri de nume de atribute valide. Prima categorie: propiet a t ile sau atribute de tip dat a. Aceast a categorie corespunde variabilelor instan tei n SmallTalk, s i membrilor dat a n C++, create automat atunci cnd le sunt atribuite va ori. Dac a x este o instan ta a clasei MyClass urm atoarea por tiune de cod va a sa va loarea 16: 62 Capitol 9. Clase

x.counter = 1 while x.counter < 10: x.counter = x.counter * 2 print x.counter de l x.counter

A doua categorie sunt metodele. O metod a este o func tie ce apar tine unui anumit obiect.(n Python termenul de metod a nu desemneaz a doar o func tie ce apar tine inst an tei numai clase, adic a unui obiect; s i alte tipuri de obiecte au metode. De ex emplu, obiectele list a au metodele: append, insert, sort, etc. n cele ce urmeaz a vom folosi termenul de metod a numai n sensul mai sus de nit). Numele de metode disp onibile pentru un anumit obiect depind de clasa din care face parte obiectul. Pr in de ni tie, toate atributele de tip func tie ale unei clase devin metode pentru to ate instan tele respectivei clase. n exemplul nostru x.f este o metod a valabil a di n moment ce MyClass.f este o func tie, n mod contrar, este evident c a x.i nu este o ntre MyClass.f s metod a. MyClass.i nu este o func tie. Exist a o diferen ta i x.f: prima este un obiect func tie iar cea de-a doua un obiect metod a(una este func tie , a doua metod a). 9.3.4 Obiecte metoda n mod uzual o metod a este apelat a imediat: x.f() n exemplul nostru aceasta va returna s irul de caractere Hello World!. Oricum nu e ste neap arat necesar s a apel am o metod a. Putem face acest lucru mai trziu: xf = x.f while 1: print xf()

Exemplul de mai sus va apela Hello World! la in nit. Ce se ntmpl a exact atunci cnd es te apelat a o metod a? A ti observat c a x.f a fost apelat a f ar a nici un argument, hiar dac a n de ni tia func tiei era speci cat un argument. Python genereaz Ce s-a nt cu argumentul? Cu siguran ta a o excep tie atunci cnd o func tie care necesit a un ar gument(de si poate s a nu aibe neap arat nevoie de acesta), este apelat a f ar a argum ente. Probabil c a a ti ghicit deja r aspunsul: metodele au ntotdeauna ca prim param etru un obiect.n exemplul nostru apelul x.f() este absolut echivalent cu MyClass. f(x). n general a apela o metod a cu n parametrii este echivalent cu a apela func t ia corespondent a insernd la nceputul listei de n argumente obiectul a c arui metod a se dore ste apelat a. Dac a nu a ti n teles nc a cum func tioneaz a metodele, o pr supra implement arii probabil c a ar clari ca lucrurile. Atunci cnd se face o referir e la un atribut al unei instan te care nu este un atribut dat a, clasa din care fa ce parte este c autat a. Dac a numele denot a un atribut existent n respectiva clas a( deci un obiect de tip func tie), este creat un obiect s metod a punnd laolalt a(mpache d) obiectul instan ta i obiectul func tie(tocmai g asit). n acest fel se creeaza un ob iect metod a. Atunci cnd o metod a este apelat a cu o list a de argumente, obiectul m etod a este despachetat, o nou a ca prim parametru. n list a de argumente este const ruit a ad augnd la nceputul listei de argumente obiectul instan ta cele din urm a obie ctul func tie este apelat cu noua list a de argumente. privire asupra claselor 9.3. O prima 63

9.4 Alte observa tii

Atributele dat a suprascriu atributele metod a cu acela si nume. Pentru a evita con i cte de nume ce pot cauza defec tiuni greu de g asit n programe mari, este bine s a f olosi ti o conven tie pentru denumiri pentru a minimiza s ansa apari tiei unor astfe l de con icte. O posibil a conven tie ar scrierea numelelor de metode cu liter a ini t ial a mare, pre xarea numelor de atribute dat a cu un s ir de caractere mic s i unic, (poate un underscore), sau pentru metode folosi ti verbe, iar pentru propiet a ti s ubstantive. Propiet a tile pot accesate att de metode, ct s i de utilizatorii unui an umit obiect. Cu alte cuvinte clasele nu pot folosite pentru a implementa tipuri de date abstracte. De fapt, n Python nu exist a nici un fel de mecanism de ascunde re a datelor aceasta realizndu-se numai prin conven tie. (Pe de alt a parte, implem entarea limbajului Python, relizat a n C, poate ascunde complet detalii de impleme ntare controlnd accesul la datele unui obiect, dac a o astfel de abordare este nec esar a). Utilizatorii unui obiect ar trebui s a manipuleze atributele dat a (propie ta tile) cu aten tie orice modi care direct aa a obiectului respectiv. De notat este faptul c acestora putnd duce la o incoeren ta a utilizatorii unui obiect, pot ad auga propriile atribute dat a f ar a a afecta n vreun fel metodele, atta timp ct nu apar c on icte de nume( si aici existen ta unei conven tii v a poate scuti de multe nepl aceri ). Nu exist a nici o scurt atur a pentru referirea atributelor din interiorul unei metode. Acest lucru clari c a codul unei metode, nemaiexistnd posibilitatea confuzie i ntre variabilele locale s i variabilele instan tei. n mod conven tional, primul arg ument al unei metode are numele: self. Aceasta este numai o conven tie, numele se lf neavnd nici o semni ca tie special a n Python.(Folosind aceast a conven tie codul du neavoastr a va mai u sor de citit de c atre programatori). Orice obiect func tie ca atribut al unei clase de ne ste o metod a asociat a pentru instan tele unei clase. Nu este neap arat necesar ca de ni tia unei func tii s a se a e n cadrul de ni tiei clasei est sens se poate atribui un obiect func tie unei variabile locale. De exemplu: # Func\c{t}ie definita \^{i}nafara clasei def f1(self, x, y): return min(x, x+y) class C: f = f1 def g(self): return hello world h = g Acum f,g, s i h sunt toate atribute ale clasei C, s i sunt atribute func tiei, s i n mod consecvent sunt metode pentru toate instan tele clasei C. Aceast a practic a nu este indicat a, ntruct nu face dect s a ncurce cititorul programului. Metodele pot ap ela alte metode utiliznd metoda atributelor argumentului self : class Bag: def empty(self): self.data = [] def add(self, x): self.data.append(x) def addtwice(self, x): self.add(x) self.add(x) 64 Capitol 9. Clase

Metodele pot face referiri la nume globale n acela si mod ca func tiile obi snuite. Domeniul global de vizibilitate asociat unei metode permite accesul la domeniul de de ni tie a numelor asociat modului n care se a a de nit a clasa c areia i apar ti da. Clasa n sine nu este folosit a niciodat a ca un domeniu global de vizibilitate. Pot g asite multe utiliz ari ale domeniului global de vizibilitate, de si unii ar putea considera inutil a existen ta acestuia. 9.5 Mo stenirea Nu putem spune despre un limbaj c a este orientat obiect, dac a sistemul de clase nu pune la dispozi tie mecanismul de mo stenire. Sintaxa pentru mo stenire (adic a p entru crearea de ni tiei unei clase derivate dintr-o clas a de baz a) este urm atoarea : class DerivedClassName(BaseClassName): <statement-1> . . . <statement-N>

Clasa BaseClassName trebuie s a e de nit a pentru ca de ni tia clasei derivate s a e co t a. n loc de un nume de clas a pute ti folosi o expresie, acest lucru ind foarte uti l atunci cnd clasa de baz a se a a ntr-un alt modul: class DerivedClassName(modname.BaseClassName):

Atunci cnd obiectul class pentru clasa derivat a, este creat, este memorat as i clas a de baz a. Acest mecanism este folosit pentru a rezolva referirile la atribute: n caz c a un atribut nu este g asit n clasa derivat a, este c autat s i n clasa de baz Regula se aplic a recursiv dac a clasa de baz a este la rndul ei o clas a derivat a. Instan tierea unei clase se face la fel ca pn a acum. Dac a este apelat a o metod a a unei instan te, numele metodei este c autat nti n de ni tia clasei derivate, apoi n de a clasei de baz a, s i a sa mai departe pn a cnd este g asit un obiect func tie cores z ator n lan tul de mo steniri. Clasele derivate pot suprascrie metode ale clasei de baz a. Deoarece o metod a nu dispune de nici un privilegiu atunci cnd apeleaz a o a lt a metod a a aceluia si obiect, o metod a a clasei de baz a care apeleaz a o alt a m tod a, de nit a de asemenea n clasa de baz a, poate s a apeleze de fapt o metod a supra cris a de clasa derivat a (pentru programatorii C++ putem spune c a toate metodele din Python sunt virtuale). O astfel de metod a suprascris a poate chiar s a extind a metoda de baz a, n loc de a o nlocui. Exist a o cale simpl a de a apela o metod a a c lasei de baz a direct: Clas adeBaz a.metod a(self.argumente). Acest lucru poate foar te util chiar s i utilizatorilor(clien tilor) unei clase. 9.5.1 Mo stenirea multipla Python pune la dispozi tia programatorilor s i o form a de mo stenire multipl a. O de n i tie de clas a derivat a din mai multe clase de baz a arat a n felul urm ator: 9.5. Mo stenirea 65

class DerivedClassName(Base1, Base2, Base3): <statement-1> . . . <statement-N>

Regula dup a care sunt c autate atributele este urm atoarea: dac a un atribut nu est e de nit n clasa derivat a atunci acesta este c autat n de ni tia clasei Base1 s i n t clasele de la care aceasta mo stene ste, apoi este c autat n Base2 s i n Base3 dup a a elea si reguli. Putem rezuma aceast a regul a n felul urm ator: nti n adncime, s i ga la dreapta. (Avantajele s i dezavantajele acestei reguli pot discutate, ns a treb uie s a e foarte clar pentru toat a lumea c a o astfel de regul a este absolut necesa r a, fapt su cient de evident). Este su cient de clar c a folosirea mecanismului de mo stenire multipl a va crea mari probleme de ntre tinere, deoarece n Python con ictele c e pot ap area ntre nume sunt evitate numai prin conven tii. O problem a cunoscut a ap are atunci cnd o clas a mo stene ste de la dou a clase care la rndul lor sunt derivate dintr-o singur a clas a. De si este destul de simplu s a ne imagin am ce se va ntmpla acest caz, nu este clar c a regulile vor de folos pentru clari carea situa tiei. 9.6 Variabile private Exist a un suport limitat pentru identi catorii clselor private. Orice identi cator d e forma __spam (cel pu tin dou a underscore nainte, cel mult un underscore dup a) es te acum textual nlocuit cu _cla a__spam, unde clas a este suprimate. Mutilarea este realizat numele curent al clasei cu underscor-urile din fa ta a fara o analiza a pozi tiei sintactice a identi catorului, a sa nc at putnd folosit a la de nirea unei n tieri a unei clase private s i a variabilelor s i metodelor clasei ca globale, s i la memorarea instan tierii variabilelor private naceast a clas a la instan tierea al tei clase. O trunchere a numelui poate ap area cnd acesta este mai lung de 255 de caractere. n afara claselor, sau cnd numele clasei este alc atuit numai din undersc or-uri nu se face eliminarea underscor_urilor. Acest mecanism pune la dispozi tia programatorului o metod a foarte facil a de a crea atribute private, f ar a a- si fa ce griji c a aceste atribute pot provoca con icte de nume. Toate acestea sunt reali zate n Python pentru a preveni eventualele erori, totu si, este n continuare posibi l a modi carea atributelor private, ceea ce se poate dovedi foarte util n anumite ca zuri ca de exemplu la depanare. ( Observatie : o clas a derivat a care are acela si nume cu clasa de baz a poate folosi variabilele private ale clasei de baz a). Obs erva ti c a, codul ce este trimis instruc tiunilor exec, eval() sau evalfile() nu i a n considerare numele clasei care realizeaz a invoc arile, acest efect ind similar celui realizat prin instruc tiuni global, efect ce nu poate ob tinut pentru cod co mpilat. Aceea si restric tie se aplic as i pentru getattr(), setattr() s i delattr(), de asemenea s i pentru accesarea direct a a dic tionarului __dict__. Iat a un exemp lu de clase care implementeaz a propriile metode __getattr__() s i __setattr__(), s i stocheaz a toate datele n variabile private: class VirtualAttributes: __vdict = None __vdict_name = locals().keys()[0] def __ init__(self): self.__dict__[self.__vdict_name] = {} def __getattr__(self, name): return self.__vdict[name] def __setattr__(self, name, value): self.__vdict[name ] = value 66 Capitol 9. Clase

9.7 Altfel de clase Cteodat a, poate foarte util s a putem crea tipuri de date similare celei record di n Pascal, sau struct din C, tipuri de date care s a adune la un loc mai multe dat e de diferite tipuri. Pentru a realiza acest lucru pute ti folosi clasele. O de nir e a unei clase vide se poate face astfel : class Employee: pass john = Employee() # Se creaz\u{a} o \^{i}nregistrare vid\u{a} de tip employee # Fill the fields of the record john.name = John Doe john.dept = computer lab john.s alary = 1000

S a construim un alt scenariu: presupunnd c a ave ti o func tie care prelucreaz a anum ite date dintr-un obiect sier, pute ti s a de ni ti o clas a cu metodele read() s i r line() care s a citesc a informa tii dintr-un s ir de caractere n loc de un sier. Met dele obiectelor au de asemenea atribute: metod a.im__self reprezint a obiectul de care apar tine metoda speci cat a, iar metod a.im__func reprezint a func tia corespunz toare metodei. 9.7.1 Excep tiile pot clase

Excep tiile de nite de utilizator pot att obiecte de tip string, ct s i clase. Folosin d clasele pentru a de ni excep tii, pute ti crea o ntreag a ierarhie de excep tii care poate foarte u sor extins a. Exist a o alt a form a a insruc tiunii raise: raise Class, instance raise instance a clasei Class sau a unei clase derivate. A doua form n prima form a instance trebu ie s a e o instan ta a este o prescurtare pentru: raise instance.__class__, instance

O clauz a except poate a sa att excep tii de tip clas a, ct s i de tip s ir de carac Urm atorul exemplu va a sa B, C, D n aceast a ordine: 9.7. Altfel de clase 67

class B: pass class C(B): pass class D(C): pass for c in [B, C, D]: try: raise c() except D: print "D" except C: print "C" excep t B: print "B" De observat c a dac a ordinea clauzelor except ar fost invers a, (cu except B la nce put), exemplul ar a sat B, B, B; deoarece clasa B este clasa din care sunt derivat e clasele C s i D. Cnd un mesaj de eroare este a sat pentru o excep tie netratat a ce provine dintr-o clas a, numele clasei este de asemenea a sat. 68 Capitol 9. Clase

CAPITOL ZECE

Continuarea? S a sper am c a acest tutorial v-a trezit interesul n ceea ce prive ste limbajul Pyth on. Ce ar trebui s a face ti de acum ncolo? Ar trebui s a citi ti, sau cel pu tin s a asfoi ti Python Library Reference,document ce explic a foarte detaliat ecare func ti e, tip de date, modul, etc. existent n Python. Distribu tia standard de Python con tine o cantitate imens a de cod scris att n C, ct s i n Python, exist a module UNIX ce pot folosite pentru a citi c asu tele de po st a electronic a, module care faciliteaz a lucrul cu protocolul HTTP, module pentru generarea numerelor aleatoare, etc. U n site foarte util este http://www.python.org. Aici exist a documenta tii buc a ti d e cod scrise de al ti programatori s i link-uri legate de Python. Copii ale acestu i site exist a pe serverele din ntreaga lume (Europa, Australia, Japonia, etc). n f unc tie de locul n care v a a a ti, pentru o vitez a de acces mai mare, pute ti folosi na dintre aceste copii. Un alt site ce se poate dovedi foarte util este http://s tarship.python.net. Pentru ntreb ari sau raportarea anumitor probleme pute ti folos i grupul comp.lang.python, sau pute ti scrie la Pythonlist@python.org. n ecare zi s unt puse n jur de 120 de ntreb ari care, de obicei, si g asesc r aspunsul. nainte de pune o ntrebare, veri ca ti lista ntreb arilor puse frecvent (Freqvently Asked Questio ns = FAQ) care poate g asit a la adresa http://www.python.org/doc/faq.html. R aspun surile de la aceast a adres a, la diferite ntreb ari puse de al ti programatori, v a p ot ajuta de foarte multe ori n rezolvarea problemelor dumneavoastr a. 69

70

ANEXA A s Editarea n linie de comanda i repetarea comenzilor anterioare Unele versiuni ale interpretorului Python suport a editarea n linie de comand as i r epetarea unor comenzi anterioare, facilit a ti ntlnite n shell-urile Korn sau GNU Bas h. Aceste facilit a ti sunt implementate folosind biblioteca GNU Readline care sup ort a stilurile de editare speci ce Emacs s i Vi. Aceast a bibliotec a are propria doc umenta tie pe care nu o vom reproduce aici, ci vom face numai o scurt a introducer e. Facilit a tile despre care v a vom vorbi sunt disponibile n versiunile UNIX s i Cy gWin ale interpretorului. Acest capitol nu va explica facilit a tile pachetelor Ma rk Hammonds Python Win sau IDLE distribuite odat a cu Python.

A.1 Editarea n linie de comanda Dac a este suportat a, aceast a facilitate va disponibil a atunci cnd interpretorul a eaz a promptul principal sau cel secundar. Linia curent a poate editat a folosind c aracterele de control conven tionale Emacs. Cele mai importante sunt: C-A(Control -A) mut a cursorul la nceputul liniei; C-E(Control-E) mut a cursorul la sfr situl lin iei; C-B mut a cursorul cu o pozi tie la stnga; C-F mut a cursorul cu o pozi tie la reapta; BACKSPACE s terge caracterul de la stnga cursorului; C-D s terge caracterul de la dreapta cursorului; C-K s terge tot ce urmez a pe linie n dreapta cursorului ; C-Y reface ultimul s ir s ters cu C-K; C-_ anuleaz a ultima comand a efectuat a. O era tia poate repetat a. A.2 Repetarea comenzilor anterioare(History) Toate comenzile executate sunt salvate ntr-o zon a tampon (Buffer). Atunci cnd este executat a o nou a instruc tiune aceasta este salvat a la sfr situl buffer-ului. 71

C-P revine la o comand a anterioar a n buffer celei executate. C-M nainteaz a la urm a toarea instruc tiune din buffer. Orice linie din buffer poate modi cat a. Dac a o lin ie a fost modi cat a ve ti vedea un caracter * n fa ta acesteia care ndic a c a a fo at a. O instruc tiune din buffer este executat a dac a se apas a, evident, ENTER. C-R porne ste o c autare incremental a n buffer n sens invers. C-S porne ste o c autare ens normal.

A.3 Rede nirea tastelor func tionale Tastele func tionale s i al ti parametrii ai bibliotecii Readline, pot rede ni ti pri odi carea sierului /.inputrc. Pentru a rede ni func tia unei combina tii de taste tr folosit a sintaxa: tast a:func tie sau sir de caractere:func tie. O op tiune poate at a folosind set op tiune valoarenou a. Iat a un exemplu: # Prefer stil de editare Vi: set editing-mode vi # Editare pe o singura linie: s et horizontal-scroll-mode On # Redefinesc cateva taste: Meta-h: backward-kill-wo rd "\C-u": universal-argument "\C-x\C-r": re-read-init-file n Python principala func tie pentru Tab este aceea de a insera Tab, nu func tia de completare Readline. Dac a se dore ste ns a utilizarea sa n func tia de completare se va pune : Tab: complete

n /.inputrc. (Bine n teles c a acum va mai di cil de a scrie spa tiile de aliniere) tarea automat a a numelui unei variabile, sau a unui modul, este op tional a. Pentr u a o activa n modul de lucru interactiv ad auga t n sierul de startup urm atoarele : import rlcompleter, readline readline.parse_and_bind(tab: complete)

Aceasta leag a tasta Tab de func tia de completare, deci ap asnd tasta Tab de doua o ri activeaz a completarea; analizeaz a numele instruc tiunii Python, variabilele lo cale curente s i numele de module disponibile.Pentru expresiile cu punct de tipul string.a, evalueaz a expresia pn a la nal, dup a . s i apoi sugereaz a completarea de atributele obiectelor rezultate. De re tinut c a se poate executa codul unei ap lica tii de nite dac a un obiect ce are metoda __getattr__() face parte din expresie . Un sier startup mai cuprinz ator poate ar ata ca n exemplul urm ator. De notat c a l i si sterge numele pe care le creaz a n momentul n care nu-i mai sunt necesare. Ac est lucru se petrece cnd sierul de starup se execut a n acela si domeniu de de ni tie s i comenzile interactive, iar eliminarea numelor evit a generarea unor efecte co laterale n mediul interactiv. 1 Python va executa con tinutul unui sier identi cat prin variabila de mediu PYTHONSTA RTUP n momentul pornirii interpretorului interactiv. 72 s Anexa A. Editarea n linie de comanda i repetarea comenzilor anterioare

Pute ti g asi acest lucru convenabil pentru a p astra cteva module importate, cum ar os, s i care se dovedesc necesare n majoritatea sesiunilor interpretorului. # # # # # # # # # # La interpretorul interactiv Python se adaug\u{a} func\c{t}ia de autocompletare \c{s}i un fi\c{s}ier de tip jurnal pentru comenzi. Se cere Py thon 2.0+, readline. Autocompletarea este executat\u{a} implicit prin tasta Esc (dar, tasta poate fi \^{i}nlocuit\u{a} -- vezi documenta\c{t}ia readline). Pune\ c{t}i fi\c{s}ierul \^{i}n ~/.pystartup, iar variabila de mediu s\u{a}-l indice, cum ar fi \^{i}n bash "export PYTHONSTARTUP=/max/home/itamar/.pystartup". Re\c{t }ine\c{t}i c\u{a} PYTHONSTARTUP nu expandeaz\u{a} "~", deci va trebui indicat\u{ a} \^{i}ntraga cale a directorului home . atexit os readline rlcompleter import import import import historyPath = os.path.expanduser("~/.pyhistory") def save_history(historyPath=hi storyPath): import readline readline.write_history_file(historyPath) if os.path. exists(historyPath): readline.read_history_file(historyPath) atexit.register(sav e_history) del os, atexit, readline, rlcompleter, save_history, historyPath A.4 Comentarii Aceste facilit a ti reprezint a un pas enorm comparativ cu versiunile anterioare al e interpretorului; oricum au r amas cteva deziderate nemplinite : ar frumos ca s a e sugerat un alineat corect la continuarea unei linii (analizorul sintactic s tie d ac se va cere un alineat). Acest nou mecanism ar putea utiliza tabela de simbolur i a interpretorului. Util ar s i un mecanism care s a veri ce (sau s a sugereze) potr ivirea parantezelor, ghilimelelor, etc. A.4. Comentarii 73

74

ANEXA B otanta: rezultate s Aritmetica n virgula i limitari Numerele n virgul a otant a sunt reprezentate n hardware-ul calculatorului ca frac tii n baza 2 (binare). De exemplu, frac tia zecimal a 0.125 are valoarea 1/10 + 2/100 + 5/1000, s i n acela si fel frac tia binar a 0.001

real are valoarea 0/2 + 0/4 + 1/8. Aceste dou a frac tii au aceea si valoare, singur a diferen ta a ind c a prima este scris a n baza 10, iar a doua n baza 2. Din p acate ajoritatea frac tiilor zecimale nu pot reprezentate corect ca frac tii binare. O p rim a concluzie este c a, (n general, numerele n virgul a otant a zecimal a pe care l ntroduce ti au numai o reprezentare aproximativ a prin numerele n virgul a otant a bin ar a memorate n calculator. Problema este u sor de n teles nt n baza 10. S a conside rac tia 1/3. O pute t aproxima cu o frac tie baza 10: 0.3 sau, mai precis, 0.33 sau , si mai precis, 0.333

s i tot a sa. Nu conteaz a ce num ar de digi ti ve ti scrie, rezultatul nu va nicicd act 1/3, dar cre ste acurate tea aproxim arii lui 1/3. n acela si mod, nu conteaz a ct digi ti n baza 2 folosi ti, valoarea zecimal a 0.1 nu va reprezentat a exact nicioda t a printr-o frac tie. n baza 2, 1/10 este o frac tie care se repet a la in nit 0.0001100110011001100110011001100110011001100110011...

Oprirea la un num ar nit de bi ti d a o aproximare. Iat a ce se a seaz a n situa ti oare : 75

>>> 0.1 0.10000000000000001

Pe majoritatea ma sinilor existente ast azi acest rezultat se a seaz a dac a introduce ti 0.1 la prompterului Python-ului. Se ntmpl a a sa pentru c a num arul de bi ti utili a ti de hardware s a mememoreze valoarea n virgul a otant a variaz a de la o ma sin alta, iar Python listeaz a doar o aproxima tie zecimal a a valorii zecimale reale a aproxima tiei binare memorat a n ma sin a. Pe majoritatea ma sinilor, dac a Python va tip ari valoarea zecimal a real a a aproxima tiei binare memorate pentru 0.1, va a sa >>> 0.1 0.1000000000000000055511151231257827021181583404541015625

Prompterul Python utilizeaz a func tia implicit a repr() ca s a ob tin a o versiune de s ir pentru toate obiectele pe care le a seaz a. n cazul numerele otante repr( oat) ro unje ste valoarea zecimal a la 17 digi ti semni cativi, astfel 0.10000000000000001

repr( oat) folose ste 17 bi ti semni cativi pentru c a sunt considera ti su cien ti pe m ritatea ma sinilor, a sa c a rela tia eval(repr(x)) == x este exact a pentru toate nu merele otante nite x, dar rotunjirea la 16 bi ti nu este su cient a pentru a face rela tia adev arat a. Acesta este un lucru normal al aritmeticii binare n virgul a otant a : nu este un bug Python, nici un bug al codului dumneavoastr as i ve ti constata o astfel de anomalie n toate limbajele care folosesc aritmetica n virgul a otant a ofer it a de hardware (unele limbaje pot s a nu a seze implicit diferen ta) Func tia intern a Python str() genereaz a numai 12 digi ti semni cativi s i poate c a dori ti s a o fol si ti modi cat a. Este des utilizat a func tia eval(str(x)) pentru a-l ob tine pe x, da r este mai placut s a se a seze : >>> print str(0.1) 0.1

E bine de s tiut c a, n sens real, este o iluzie : n ma sin a valoarea nu este exact 1 /10, valoarea adev arat a din ma sin a este rotunjit a la a sare. Aceast a surpriz a urmata de altele. De exemplu dup a ce se a seaz a >>> 0.1 0.10000000000000001

apare tenta tia s a utiliza ti func tia round() ca s a trunchia ti iar as i la un dig Dar aceasta nu face nimic: >>> round(0.1, 1) 0.10000000000000001 Problema este c a valoarea memorat a nvirgul a otant a binar a pentru "0.1" a fost f t a n cea mai bun a aproximare binar a posibil a la 1/10, deci orice alt a rotunjire u lterioar a nu o poate face mai bine : a fost dat a deja cea mai bun a solu tie. a fa ptului c Alt a consecin ta a 0.1 nu este exact 1/10 este aceea c a ad augnd la 0.1 pe el nsu si de 10 ori nu se ob tine 1.0: 76 otanta: rezultate s Anexa B. Aritmetica n virgula i limitari

>>> sum = 0.0 >>> for i in range(10): ... sum += 0.1 ... fs>>> sum 0.99999999999 999989

Aritmetica binar a n virgul a otant a are multe surprize de acest gen. Problema cu "0 .1" este explicat a n sec tiunea urm atoare, "Erori de reprezentare". Vezi : The Per ils of Floating Point privind tratarea complet a a altor surprize de acest gen. C um s-ar spune la sfr sit: "nu este u sor de r aspuns". Totu si nu dispera ti din cauza rgulei otante! Erorile opera tiilor de otant a din Python sunt mo stenite de la virgu la otant a a hardware-ului s i la majoritatea ma sinilor sunt de un ordin mai mic de 1/2**53 pe opera tie. Acestea sunt mai mult dect acceptabile pentru cele mai mult e aplica tii, dar trebuie s a re tine ti c a nu sunt datorate aritmeticii zecimale s i c a la ecare opera tie nvirgul a otant a apare o eroare de rotunjire. Pn a la apari nor cazuri patologice, pentru cele mai multe situa tii de utilizare a aritmeticii nvirgul a otant a se ob tin rezultatele a steptate, dac a pur s i simplu se rotunje rezultatul nal a sat la num arul de zecimale dorit. Uzual func tia str() este su cient , iar pentru un control mai riguros a se vedea discu tia despre operatorul de for mat % : formatele %g, %f s i %e sunt moduri exibile s i u soare pentru a sarea rezulta telor. B.1 Erori de reprezentare

Sec tiunea explic a ndetaliu exemplul "0.1" s i arat a cum se poate face o analiz a ex act a a cazurilor. n principal se urm are ste familiarizarea cu reprezentarea binar a n virgul a oant a. Eroarea de reprezentare se refer a la faptul c a frac tiile zecima e nu se pot reprezenta exact ca frac tii binare (n baza 2). Acesta este motivul ma jor pentru care Python (sau Perl, C, C++,Java, Fortran, s i multe altele) nu a seaz a valoarea exact a a num arului zecimal pe care-l a stepta ti : >>> 0.1 0.10000000000000001 Ce este asta? 1/10 nu este reprezentat exact ca o frac tie binar a. Cele mai multe ma sini utilizeaz a ast azi (noiembrie 2000) aritmetica de virgul a otant a IEEE-754 s i cele mai multe platforme mapeaz a otantele Python n"dubl a precizie" IEEE-754. Du blele 754 au 53 bi ti de precizie. A sa c a la intrarea n calculator se chinuie s a c onverteasc a 0.1 ncea mai apropiat a frac tie posibil a de forma J /2**N , unde J est e un ntreg de exact 53 de bi ti. Se rescrie 1 / 10 ~= J / (2**N) ca J ~= 2**N / 10 s i reapelnd J are exact 53 de bi ti (este >= 2**52 dar < 2**53), s i cea mai bun a v aloare pentru N este 56: B.1. Erori de reprezentare 77

>>> 2L**52 4503599627370496L >>> 2L**53 9007199254740992L >>> 2L**56/10 72057594 03792793L Asta este, 56 este singura valoare pentru N care las a J cu exact 53 de bi ti. Atu nci cea mai bun a valoare posibil a pentru J este ctul rotunjit: >>> q, r = divmod(2L**56, 10) >>> r 6L Dup a ce restul este mai mare dect jum atatea lui 10, cea mai bun a aproxima tie se o b tine prin rotunjirea: >>> q+1 7205759403792794L Astfel cea mai bun a aproxima tie a lui 1/10, n dubla precizie 754, este peste 2**5 6, sau 7205759403792794 / 72057594037927936 De remarcat c a pn a la rotunjire, valoarea este de fapt un pic mai mare dect 1/10; dac a nu am rotunji ctul va un pic mai mic dect 1/10. Dar n nici un caz nu poate exa ct 1/10! Deci, niciodata computerul nu va ar ata 1/10: ce va ar ata este exact frac t ia dat a mai jos, cea mai bun a aproxima tie n 754 care poate dat a: >>> .1 * 2L**56 7205759403792794.0 Dac a se nmul te ste frac tia cu 10**30, vom vedea valoarea (truncheat a) a celor mai semni cativi 30 de digi ti zecimali ai s ai: >>> 7205759403792794L * 10L**30 / 2L**56 100000000000000005551115123125L

nsemnnd c a num arul exact memorat n calculator este aproximativ egal cu valoarea zec imal a 0.100000000000000005551115123125. Rotunjind la 17 digi ti semni cativi rezult a 0.100000000000000001 pe care Python l a seaz a (va a sa pe orice platform a conform 754 care va face tot posibilul s a converteasc a intrare s i ie sire prin biblioteca C proprie al dumneavoastr a s-ar putea s a nu reu seasc a acest lucru!) 78 otanta: rezultate s Anexa B. Aritmetica n virgula i limitari

ANEXA C Istoria s i licen ta C.1 Istoricul produsului Python Python a fost creat la nceputul anilor 1990 de c atre Guido van Rossum la Stichtin g Mathematisch Centrum (CWI, vezi http://www.cwi.nl/) din Olanda, ca succesor al limbajului ABC. Guido a r amas principalul autor al Pythonului, care acumuleaz a multe contribu tii ale altora. n 1995 Guido i si continu a munca la Python la Corpor ation for National Research Initiatives (CNRI, vezi http: //www.cnri.reston.va.u s/) n Reston, Virginia, unde a lansat cteva versiuni ale software-ului. n mai 2000, Guido s i echipa de dezvoltare a Python-ului s-a mutat la BeOpen.com, unde a for mat echipa BeOpen PythonLabs. octombrie 2000, colectivul PythonLabs s-a mutat la Digital Creations (vezi http:// www.digicool.com/).n 2001 ia na stere Python Soft ware Foundation (PSF, vezi http://www.python.org/ psf/) o organiza tie non pro t cr eat a special pentru a de tne drepturile de autor1 referitoare la Python. Digital Creations este unul din sponsorii PSF. Toate lans arile2 Python sunt Open Source (vezi http://www.opensource.org/ pentru a g asi de ni tia Open Source ). Istorice ste vorbind cele mai multe dintre lans arile Python, nu toate, sunt de asemenea comp atibile GPL(General Public License). Tabelul urm ator face un sumar al diferitelo r lans ari. Release 0.9.0 thru 1.2 1.3 thru 1.5.2 1.6 2.0 1.6.1 2.1 2.0.1 2.1.1 2 .2 Derived from n/a 1.2 1.5.2 1.6 1.6 2.0+1.6.1 2.0+1.6.1 2.1+2.0.1 2.1.1 Year 1 991-1995 1995-1999 2000 2000 2001 2001 2001 2001 2001 Owner CWI CNRI CNRI BeOpen .com CNRI PSF PSF PSF PSF GPL compatible? yes yes no no no no yes yes yes

Not a: Compatibil GPL nu nseamn a c a Python este distribuit sub GPL. Toate licen tel e Python, spre deosebire de GPL, i ti permit s a distribui o versiune modi cat a f ar a a- ti face s i modi c arile open source. Licen tele compatibile GPL fac posibil a com area Pyton-ului cu alte software care au ap arut sub GPL; celelate neputnd face ac est lucru. Mul tumim acelor voluntari numero si din exteriorul echipei, care lucrnd sub coordonarea lui Guido au f acut posibile aceste lans ai. 1 Intellectual 2 N.T. Property = termenul de lansaree g asit nanex a este traducerea termenului englezesc release 79

C.2 Terms and conditions for accessing or otherwise using Python PSF LICENSE AGREEMENT FOR PYTHON 2.2 1. This LICENSE AGREEMENT is between the Python Software Foundation (PSF), and the Individual or Organization (Licensee) accessing and otherwise using Python 2.2 so ftware in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, per form and/or display publicly, prepare derivative works, distribute, and otherwis e use Python 2.2 alone or in any derivative version, provided, however, that PSFs License Agreement and PSFs notice of copyright, i.e., Copyright c 2001 Python Sof tware Foundation; All Rights Reserved are retained in Python 2.2 alone or in any derivative version prepared by Licensee. 3. In the event Licensee prepares a der ivative work that is based on or incorporates Python 2.2 or any part thereof, an d wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the chang es made to Python 2.2. 4. PSF is making Python 2.2 available to Licensee on an AS IS basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION O R WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.2 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.2 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTH ERWISE USING PYTHON 2.2, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSI BILITY THEREOF. 6. This License Agreement will automatically terminate upon a ma terial breach of its terms and conditions. 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint vent ure between PSF and Licensee. This License Agreement does not grant permission t o use PSF trademarks or trade name in a trademark sense to endorse or promote pr oducts or services of Licensee, or any third party. 8. By copying, installing or otherwise using Python 2.2, Licensee agrees to be bound by the terms and condit ions of this License Agreement. BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 BEOP EN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 1. This LICENSE AGREEMENT is b etween BeOpen.com (BeOpen), having an of ce at 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization (Licensee) accessing and otherwise using this software in source or binary form and its associated documentation (the Sof tware). 2. Subject to the terms and conditions of this BeOpen Python License Agre ement, BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide l icense to reproduce, analyze, test, perform and/or display publicly, prepare der ivative works, distribute, and otherwise use the Software alone or in any deriva tive version, provided, however, that the BeOpen Python License is retained in t he Software, alone or in any derivative version prepared by Licensee. 3. BeOpen is making the Software available to Licensee on an AS IS basis. BEOPEN MAKES NO RE PRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMI TATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANT ABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WI LL NOT INFRINGE ANY THIRD PARTY RIGHTS. 80 Anexa C. Istoria s i licen ta

4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVI SED OF THE POSSIBILITY THEREOF. 5. This License Agreement will automatically ter minate upon a material breach of its terms and conditions. 6. This License Agree ment shall be governed by and interpreted in all respects by the law of the Stat e of California, excluding con ict of law provisions. Nothing in this License Agre ement shall be deemed to create any relationship of agency, partnership, or join t venture between BeOpen and Licensee. This License Agreement does not grant per mission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products or services of Licensee, or any third party. As an exception , the BeOpen Python logos available at http://www.pythonlabs.com/logos.html may be used according to the permissions granted on that web page. 7. By copying, inst alling or otherwise using the software, Licensee agrees to be bound by the terms and conditions of this License Agreement. CNRI LICENSE AGREEMENT FOR PYTHON 1.6 .1 1. This LICENSE AGREEMENT is between the Corporation for National Research In itiatives, having an of ce at 1895 Preston White Drive, Reston, VA 20191 (CNRI), and the Individual or Organization (Licensee) accessing and otherwise using Python 1. 6.1 software in source or binary form and its associated documentation. 2. Subje ct to the terms and conditions of this License Agreement, CNRI hereby grants Lic ensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, te st, perform and/or display publicly, prepare derivative works, distribute, and o therwise use Python 1.6.1 alone or in any derivative version, provided, however, that CNRIs License Agreement and CNRIs notice of copyright, i.e., Copyright c 1995 -2001 Corporation for National Research Initiatives; All Rights Reserved are reta ined in Python 1.6.1 alone or in any derivative version prepared by Licensee. Al ternately, in lieu of CNRIs License Agreement, Licensee may substitute the follow ing text (omitting the quotes): Python 1.6.1 is made available subject to the ter ms and conditions in CNRIs License Agreement. This Agreement together with Python 1.6.1 may be located on the Internet using the following unique, persistent ide nti er (known as a handle): 1895.22/1013. This Agreement may also be obtained from a proxy server on the Internet using the following URL: http://hdl.handle.net/1 895. 22/1013. 3. In the event Licensee prepares a derivative work that is based o n or incorporates Python 1.6.1 or any part thereof, and wants to make the deriva tive work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 1.6.1. 4 . CNRI is making Python 1.6.1 available to Licensee on an AS IS basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCH ANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. CNRI SHALL NOT BE LIABLE TO LICENS EE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENT IAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING P YTHON 1.6.1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THERE OF. 6. This License Agreement will automatically terminate upon a material breac h of its terms and conditions. 7. This License Agreement shall be governed by th e federal intellectual property law of the United States, including without limi tation the federal copyright law, and, to the extent such U.S. federal law does not apply, by the law of the Commonwealth of Virginia, excluding Virginias con ict of law provisions. Notwithstanding the foregoing, with regard to derivative work s based on Python 1.6.1 that incorporate non-separable material that was previou sly distributed under the GNU General Public License (GPL), the law of the Commo nwealth of C.2. Terms and conditions for accessing or otherwise using Python 81

Virginia shall govern this License Agreement only as to issues arising under or with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in thi s License Agreement shall be deemed to create any relationship of agency, partne rship, or joint venture between CNRI and Licensee. This License Agreement does n ot grant permission to use CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. 8. By clicking on the ACCEPT button where indicated, or by copying, installing or otherw ise using Python 1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement. ACCEPT CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 Copyright c 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Neth erlands. All rights reserved. Permission to use, copy, modify, and distribute th is software and its documentation for any purpose and without fee is hereby gran ted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documenta tion, and that the name of Stichting Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without spec i c, written prior permission. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRAN TIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTA BILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE F OR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESU LTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLI GENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 82 Anexa C. Istoria s i licen ta