Python

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 2000 BeOpen.com. All rights reserved.
Copyright c 1995-2000 Corporation for National Research Initiatives. All rights reserved.
Copyright c 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
See the end of this document for complete license and permissions information.
Abstract
Python este un limbaj de programare puternic si u sor de nv atat. Are structuri de date de nivel nalt, eciente si o
simpl a dar ecient a abordare a program arii orientate pe obiect.
Sintaxa elegant a si natura sa interpretat a, fac din Python un limbaj ideal pentru elaborarea de script-uri si dezvoltarea
rapid a de aplicatii n multe domenii, pe majoritatea platformelor.
Interpretorul Python si libr aria standard sunt oferite sub form a de surse sau compilate pentru majoritatea platformelor
existente, pe site-ul Python, http://www.python.org/, si pot distribuite gratuit. Pe acela si site puteti g asi
distributii Python si module scrise de alti programatori, precum si documentatie aditional a.
Interpretorul Python este u sor de extins prin ad augarea de noi functii si tipuri de date implementate n C sau C++ (sau
alte limbaje apelabile din C). Python poate folosit si drept limbaj de extensie pentru aplicatii.
Acest material informeaz a cititorul despre conceptele de baz a si capabilit atile sistemului si limbajului Python. Ar
de preferat s a aveti la ndemn a un interpretor Python pentru a experimenta, dar toate exemplele cuprinse n acest
material pot ntelese f ar a a imperativ a prezenta interpretorului.
Pentru o descriere a obiectelor si modulelor standard, consultati documentul Python Library Reference. Documentul
Python Reference Manual d a o denitie mai exact a a limbajului. Dac a doriti s a extindeti sau s a implementati limbajul
Python ntr-o aplicatie cu ajutorul C++ consultati documentul Extending and Embedding the Python Interpreter si
Python/C API Reference. Exist a si c arti care acoper a limbajul Python n toat a complexitatea sa.
Acest tutorial nu ncearc a s a acopere toate facilit atile Python-ului, sau m acar cele mai folosite dintre ele. n schimb,
v a prezint a cele mai interesante si importante facilit ati, si v a va da o idee despre modul de functionare al limbajului.
Dup a ce veti citi acest tutorial, veti putea citi si scrie module sau programe Python, si veti preg atiti s a v atati mai
multe despre diferitele libr arii incluse n distributia Python, descrise n documentul Python Library Reference.
CUPRINS
1 De ce Python? 1
1.1 n continuare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 Utilizarea interpretorului Python 3
2.1 Invocarea interpretorului . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Interpretorul si mediul n care ruleaz a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 O introducere scurt a n Python 7
3.1 Utilizarea Python-ului drept calculator de birou . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Primii pa si n programare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4 Structuri de control 19
4.1 Instructiuni if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Instructiuni for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.3 Functia range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.4 Instructiuni break si continue, si clauze else pentru bucle . . . . . . . . . . . . . . . . . . . . 21
4.5 Instructiuni pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.6 Functii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.7 Mai multe despre functii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5 Strucuri de date 29
5.1 Mai multe despre liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2 Instructiunea del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.3 Perechi si secvente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.4 Dictionare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.5 Mai multe despre conditii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.6 Compararea secventelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6 Module 37
6.1 Mai multe despre module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
6.2 Module standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6.3 Functia dir() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.4 Pachete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
7 Intr ari si ie siri 45
7.1 Formatarea mai elegant a a datelor la ie sire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.2 Fi siere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8 Erori si exceptii 51
8.1 Erori de sintax a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
i
8.2 Exceptii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.3 Tratarea exceptiilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.4 Generarea exceptiilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.5 Exceptii denite de utilizator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.6 Denirea actiunilor de cur atare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
9 Clase 59
9.1 Cteva cuvinte despre terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
9.2 Domenii de vizibilitate (Scopes) si domenii de denitie a numelor(Name Spaces) . . . . . . . . . . 60
9.3 O prim a privire asupra claselor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.4 Alte observatii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.5 Mo stenirea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
9.6 Variabile private . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
9.7 Altfel de clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
10 Continuarea? 69
A Editarea n linie de comand a si repetarea comenzilor anterioare 71
A.1 Editarea n linie de comand a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
A.2 Repetarea comenzilor anterioare(History) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
A.3 Redenirea tastelor functionale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
A.4 Comentarii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
B Aritmetica n virgul a otant a: rezultate si limit ari 75
B.1 Erori de reprezentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
C Istoria si licenta 79
C.1 Istoricul produsului Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
C.2 Terms and conditions for accessing or otherwise using Python . . . . . . . . . . . . . . . . . . . . . 80
ii
CAPITOL
UNU
De ce Python?
Dac a ati construit vreodat a un shell complex, probabil cunoa steti senzatia: vreti s a ad augati nc a o facilitate, dar este
deja att de lent, att de mare, att de complicat; sau ad augarea facilit atii implic a un apel de functie de sistem, sau alt a
functie care nu este accesibil a dec at din C. De obicei problema pe care o aveti de rezolvat nu este sucient de serioas a
astfel nct s a merite s a rescrieti shell-ul n C; poate c a rezolvarea problemei necesit a folosirea sir-urilor de lungime
variabil 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 sunteti sucient de familiarizat cu limbajul C.
S a consider am o alt a situatie: presupunem c a trebuie s a lucrati cu anumite biblioteci C, si ciclul obi snuit de scriere-
compilare-testare-recompilare este prea lent. Vreti s a dezvoltati mult mai rapid software. E posibil s a scris un
program care poate folosi un limbaj de extensie, si nu vreti s a dezvoltati un alt limbaj pentru asta, s a scrieti si s a
vericati de erori un interpretor pentru acest limbaj, pentru ca apoi s a-l ad augati la aplicatia dumneavoastr a.
n aceste cazuri Python este limbajul de care aveti nevoie. Este simplu de folosit, dar este un limbaj de programare
adev arat, oferind posibilitatea unei mai bune structur ari, si un suport mai bun pentru programe mari dect ofer a un
shell. Pe de alt a parte dispune de o mult mai bun a vericare a erorilor dect C-ul, si ind un limbaj de nivel foarte
nalt, dispune de tipuri de date de nivel nalt cum ar tablouri sau dictionare foarte exibile, a c aror implementare n
C ar lua programatorului zile. Datorit a caracterului general al tipurilor de date Python poate 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 si
n aceste limbaje.
Python permite divizarea programelor dumneavoastr a n module care pot folosite apoi n alte programe Python.
Dispune de o colectie vast a de module standard de la care puteti porni n construirea programului dumneavoastr a, sau
pentru a nv ata programarea n Python.
Exist a de asemenea module ncorporate care ofer a facilit ati pentru sistemul de intr ari ie siri (I/O), apeluri de sistem,
sockets, si chiar interfete pentru sisteme de interfatare grac a utilizator (GUI) precum TK.
Python este un limbaj interpretat, care v a poate accelera munca n timpul procesului de dezvoltare, ne mai ind nevoit
s a compilati codul de ecare dat a. Interpretorul poate folosit interactiv, ceea ce v a permite s a testati foarte u sor
anumite facilit ati ale limbajului, s a scrieti imediat programe dispensabile, sau s a testati anumite functii nainte de a le
folosi n programul dumneavoastr a. Este foarte folositor si drept, calculator de birou.
Python permite scrierea unor programe foarte compacte si u sor de citit. Programele scrise n Python sunt mult mai
mici decat echivalentele n C sau C++ pentru c a:
tipurile de date de nivel nalt v a permit s a realizati operatii complexe ntr-o singur a instructiune;
gruparea instructiunilor este dat a de paragrafare n loc de blocuri begin/end sau de acolade;
nu este necesar a declararea variabilelor.
Python este extensibil: dac a aveti cuno stinte de C puteti foarte u sor sa ad augati o nou a functie sau un modul, e pentru
a efectua operatii la vitez a maxim a, e pentru a lega programe Python la biblioteci disponibile numai n form a binar a
(biblioteci grace). Puteti de exemplu s a ad augati interpretorul Python ntr-o aplicatie C si s a l folositi ca un limbaj
de comand a sau de extensie pentru acea aplicatie.
1
Numele limbajului provine de la emisiunea BBC Monthy Pythons Flying Circus (Circul zbur ator al sarpelui Monty)
si nu are nici o leg atur a cu disgratioasele reptile. Referinte la Monty Python n documentatia ce urmeaz a nu numai c a
sunt permise, sunt chiar ncurajate!
1.1 n continuare
Acum c a aveti o idee despre Python, poate doriti s a l examinati mai n detaliu. Din moment ce, cea mai bun a metod a
de a nvata un limbaj de programare este utilizarea acestuia, sunteti si dumneavoastr a invitati s a o faceti.
n urmatorul capitol este explicat a utilizarea interpretorului. Informatiile ce urmeaz a pot p area banale, dar sunt es-
entiale pentru testarea exemplelor ce vor urma.
Cealalt a parte a tutorialului prezint a diferite facilitati ale limbajului Python. Aceast a prezentare este bogat a n exemple,
ncepnd cu expresii simple, instructiuni, tipuri de date si terminnd cu functii, module si concepte avansate cum ar
tratarea exceptiilor si clase denite 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 unde exist a aceast a cale. n lista cu
directoarele de sistem a UNIX introduceti calea /usr/local/bin pentru a putea porni interpretorul cu comanda :
python
Din moment ce directorul n care este instalat interpretorul, poate modicat la instalare, si alte c ai sunt posibile.
Vorbiti cu administratorul dumneavoastr a de sistem nainte de a lua o decizie n privinta directorului de instalare. (Ex:
/usr/local/python este o alternativ a foarte popular a).
Tastarea unui caracter de sfr sit de sier (Control-D pe UNIX, sau Control-Z pe DOS sau Windows) n tim-
pul prompt-ului principal determin a oprirea executiei interpretorului cu cod de ie sire zero. Dac a acest lucru nu
functioneaz a ncercati comenzile: import sys; sys.exit().
Facilit atile de editare n linie de comand a ale interpretorului nu sunt deloc deosebite. Pe sisteme UNIX, n timpul
instal arii Python, puteti activa optiunea de suport a bibliotecii GNU de editare n linie de comand a, care adaug a mai
multe facilit ati pentru editare n linie de comand a. Pentru a vedea dac a aceast a optiune este activat a, tastati combinatia
de taste Control-P la primul prompt Python. Dac a auziti un sunet, aveti activat a optiunea despre care vorbeam mai
sus (consultati Anexa A, pentru o scurt a list a de combinatii de taste foarte utile). Dac a nu se ntampl a nimic sau este
a sat ^P, optiunea de editare a liniei de comand a nu este activat a, deci nu veti putea dect s a stergeti (BACKSPACE)
sau s a introduceti noi caractere n linie.
Interpretorul functioneaz a aseman ator shell-ului UNIX: Cnd este apelat cu intrarea standard conectat a la un dispozitiv
TTY, cite ste si execut a comenzi interactiv. Cnd este apelat cu un parametru reprezentnd un nume de sier, cite ste si
execut a un script (program) din acel sier.
O a treia modalitate de a porni interpretorul este python -c command[arg] . . . care execut a instructi-
unea/instructiunile din comand a, analog optiunii -c a shell-ului. Din moment ce o comand a poate contine spatii sau
alte caractere utilizate de shell (ca separatori de parametrii de exemplu) este bine s a introduceti comanda/comenzile
ntre ghilimele.
Observati c a exist a o diferent a ntre python file si python <file. n primul caz, datele de intrare ale
programului sunt oferite de sier. Din moment ce acest sier a fost deja citit pan a la cap at nainte de nceperea
programului, programul va ntlni sfr sit de sier imediat. n al doilea caz (cel mai interesant si folosit) datele de
intrare sunt oferite de orice sier sau dispozitiv conectat la intrarea standard a interpretorului Python.
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 un parametru -i nainte de numele sierului n care se a a script-ul. Evident c a
acest parametru nu va functiona 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, interpretorului i se mai transmit si alti
parametrii, acesta i va transmite mai departe script-ului prin intermediul variabilei sys.argv, variabil a ce contine o
list a (vector) de siruri de caractere. Atunci cnd n loc de numele sierului se transmite _ (adic 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 considerati parametrii ai interpretorului, ci sunt scri si n sys.argv pentru a folositi 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 interactiv. n acest mod exist a
dou a prompt-uri. Prompt-ul principal (de obicei >>> ) si promptul secundar (de obicei ... ) folosit pentru
continuarea liniilor. Interpretorul a seaz a imediat dup a pornire un mesaj de ntmpinare ncare se specic a versiunea
si 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
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>>
Liniile de continuare sunt folosite la introducerea unei constructii 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 si mediul n care ruleaz a
2.2.1 Tratarea erorilor
Cand are loc o eroare, interpretorul a seaz a un mesaj de eroare si starea stivei n momentul respectiv. n modul
interactiv revine la prompt-ul principal. Atunci cnd intr arile provin dintr-un sier, interpretorul se opre ste cu un cod
de eroare diferit de zero dup a ce a a sat starea stivei.(Exceptiile tratate nu sunt erori n acest context). Unele erori
sunt inevitabil fatale si cauzeaz a terminarea anormal a cu cod de ie sire diferit de zero (Ex: lipsa de memorie). Toate
mesajele de eroare sunt scrise la ie sirea pentru erori (standard error stream). Ie sirile provenite din executia 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 timpul executiei creeaz a o exceptie de
tip Keyboard Interrupt, care poate tratat a ntr-o instructiune try.
2.2.2 Script-uri Python Executabile
Pe sisteme UNIX,BSD, scripturile Python pot f acute direct executabile, la fel ca scripturile de shell, punnd linia
#! /usr/bin/env python
4 Capitol 2. Utilizarea interpretorului Python
(presupunem c a interpretorul se a a n variabila de sistem PATH a utilizatorului) la nceputul script-ului si apoi trans-
formnd sierul n executabil. Caracterele #! trebuie s a e neap arat primele dou a caractere din sier.
Observatie: Caracterul # este folosit pentru comentarii n Python.
2.2.3 Fi sierul de initializare al modului interactiv
Cnd folositi Python n modul interactiv, poate foarte folositor s a aveti cteva comenzi care s a se execute automat de
ecare dat a cnd este pornit interpretorul. Puteti realiza acest lucru crend o variabil a de sistem cu numele PYTHON-
STARTUP care s a contin a numele unui sier n care s a aveti comenzile, care doriti s a e executate la pornirea inter-
pretorului. Aceast a procedur a este similar a, facilit atii .prole de pe sistemele UNIX. Acest sier de initializare este
interpretat numai cnd este pornit interpretorul Python n mod interactiv. Fi sierul nu este interpretat nici cnd interpre-
torul 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 a si comenzile interactive. n acest sier pot schimbate chiar si prompt-urile sys.ps1
sau sys.ps2.
Dac a doriti s a executati si alte siere de initializare, din directorul curent trebuie s a ad augati cteva linii la sierul
principal de initializare, utiliznd un cod ca acesta if os.path.isfile(.pythonrc.py) : exec-
file(.pythonrc.py)
Dac a doriti s a folositi acest sier de initializare, ntr-un program, trebuie s a specicati acest lucru explicit n cadrul
programului astfel:
import os
filename = os.environ.get(PYTHONSTARTUP)
if filename and os.path.isfile(filename):
execfile(filename)
2.2. Interpretorul si mediul n care ruleaz a 5
6
CAPITOL
TREI
O introducere scurt a n Python
n exemplele ce urmeaz a, intr arile si ie sirile vor deosebite prin prezenta sau absenta prompt-urilor (principal >>>
sau secundar ... ). Pentru a testa un exemplu trebuie s a scrieti linia ce apare imediat dup a prompt. Liniile care nu
au caracterele >>> sau ... n fat a sunt linii de ie sire, rezultate n urma comenzilor anterioare, sau a ultimei
comenzi. Un prompt secundar, f ar a nimic dup a el, nseamn a c a trebuie s a introduceti o linie goal a. Acest procedeu
este folosit pentru terminarea unui bloc de instructiuni (de tipul begin...end;{...}).
Multe din exemplele din acest tutorial contin comentarii. n Python comentariile ncep cu un caracter # si se termin a
la sfr situl liniei. Un comentariu poate ap area la sfr situl unei linii, dar nu poate ap area n cadrul unui string. Un
caracter # n cadrul unui string nu reprezint a nceputul 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 este un comentariu."
3.1 Utilizarea Python-ului drept calculator de birou
S a ncerc am cteva comenzi simple Python. Porniti interpretorul si a steptati s a apar a prompt-ul principal >>> .(Nu
ar trebui s a dureze prea mult).
3.1.1 Numere
Interpretorul functioneaz a ca un simplu calculator: puteti scrie o expresie, si ca r aspuns veti primi rezultatul. Ordinea
operatiilor si modul de parantezare sunt la fel ca n majoritatea limbajelor (ex: Pascal sau C).
De exemplu:
7
>>> 2+2
4
>>> # Acesta este un comentariu
... 2+2 # Un comentariu pe aceia\c{s}i linie de cod
4
>>> (50 - 5 * 6) / 4
5
>>> # Impartirea numerelor intregi are ca rezultat, de fapt,
... # partea intreaga a rezultatului impartirii
... 7 / 3
2
>>> 7 / -3
-3
La fel ca n C, semnul egal (=) este folosit la atribuire. Valoarea atribuit a nu constituie 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:
>>> x = y = z = 0 # x, y \c{s}i z devin zero
>>> x
0
>>> y
0
>>> z
0
Exist a suport complet pentru virgul a mobil a. Operatorii care au operanzi de tipuri 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 suxul j sau J. Numerele
complexe cu parte real a diferit a de zero au forma (real+imagj) sau pot create folosind functia complex(real,
imag):
8 Capitol 3. O introducere scurt a n Python
>>> 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 mobil a: partea real a si cea imagi-
nar a. Pentru a aa partea real a sau cea imaginar a dintr-un num ar complex z folositi z.real respectiv z.imag:
>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5
Functiile de conversie la numere reale sau ntregi nu functioneaz a pentru numere complexe, neexistnd o metod a
matematic a de a transforma un num ar complex ntr-un numar real. Folositi functia abs(z) pentru a calcula modulul,
sau z.real pentru a aa partea real a:
>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
File "<stdin>", line 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 folositi Python ca un calculator de birou
este mult mai u sor s a p astrati continuitatea calculelor:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
>>>
Aceast a variabil a trebuie tratat a de utilizator ca avnd numai capacitatea de a citit a, nu si scris a (READ-ONLY). Nu
atribuiti valori acestei variabile, deoarece acest lucru nseamn a c a veti creea o variabil a nou a local a care va ascunde
3.1. Utilizarea Python-ului drept calculator de birou 9
variabila implicit a _ si comportamentul s au extraordinar.
3.1.2 Siruri de caractere
n afar a de numere Python poate manipula si siruri 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 secventa 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 liniei\
au importanta."
print hello
De notat c a r amne necesar ca semnele de linie nou a s a e incluse n sir utiliznd \n; linia nou a care urmeaz a ultimului
backslash este eliminat a. Acest exemplu va a sa urm atoarele:
Acesta este un \c{s}ir de caractere mai lung,
care se intinde pe mai mai multe linii, exact ca \^{i}n C.
Observati ca spatiile de la inceputul liniei
au importanta.
Dac a construim sirul de caractere ca un sir raw, atunci secventa \n nu se converte ste n linie nou a, dar backslesh-ul
de la sfr situl liniei si caracterul de linie nou a din surs a sunt incluse n sir ca date. Iat a un exemplu :
hello = r"Acesta este un \c{s}ir de caractere mai lung,\n\
care se intinde pe mai mai multe linii, exact ca \^{i}n C."
print hello
va tipari:
Acesta este un \c{s}ir de caractere mai lung,\n\
care se intinde pe mai mai multe linii, exact ca \^{i}n C.
Sirurile de caractere pot exista si ntre perechi de cate trei ghilimele sau apostroafe (""" sau ). n acest caz nu
aveti nevoie de caracterele de control (ex: \n\) pentru a realiza separarea liniilor:
print """
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
"""
are urm atoarea ie sire:
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
Interpretorul a seaz a rezultatul operatiilor cu siruri de caractere exact n forma specicat a de utilizator atunci cnd a
introdus sau denit sirurile respectiv: ntre ghilimele, cu ghilimele sau alte caractere ciudate, pentru a a sa valoarea
exact a a sirului. Instructiunea print despre care v a vom vorbi mai ncolo poate folosit a pentru a a sa siruri f ar a
ghilimele si caractere de control.
Sirurile de caractere pot concatenate:
>>> word = Help + A
>>> word
HelpA
>>> < + word*5 + >
<HelpAHelpAHelpAHelpAHelpA>
Dou a siruri de caractere scrise unul lng a altul sunt concatenate. Prima linie din exemplul de mai sus poate re-
scris a astfel: word = HelpA. Acest lucru nu merge dect pentru siruri explicite de caractere, nu pentru orice
expresie care are ca operanzi siruri:
>>> import string
>>> str ing # <- This is ok
string
>>> string.strip(str) + ing # <- This is ok
string
>>> string.strip(str) ing # <- This is invalid
string.strip(str) ing
^
SyntaxError: invalid syntax
Sirurile de caractere sunt tratate ca vectori, la fel ca nC: primul caracter al unui sir are indicele 0. Nu exist a un tip de
date separat pentru caracter. Un singur caracter este reprezentat ca un sir de lungime unu. Se pot specica de asemenea
sub siruri ale unui sir folosind doi indici, separati prin :. Primul indice reprezint a pozitia de nceput a sub sirului, iar
cel de-al doilea indice, evident indicele n sirul principal la care se termin a sub sirul:
>>> word[4]
A
>>> word[0:2]
He
>>> word[2:4]
lp
Dac a al doilea indice nu este specicat, se consider a c a sub sirul se termin a la sfr situl sirului.
Spre deosebire de C, n Python sirurile nu pot modicate. Atribuirea unei valori unui anumit caracter, sau unui sub sir
dintr-un sir mai mare, va genera o eroare:
>>> word[0] = x
TypeError: object doesnt support item assignment
>>> word[:1] = Splat
TypeError: object doesnt support slice assignment
n orice caz, creearea unui sir nou cu un continut combinat este sucient de simpl a si ecient a:
>>> x + word[1:]
xelpA
>>> Splat + word[4]
SplatA
Omiterea primului sau celui de-al doilea indice n specicarea parametrilor unui sub sir, are ca efect nlocuirea primu-
lui indice cu zero, respectiv cu lungimea sirului din care se ncearc a extragerea sub sirului, dac a se omite al doilea
parametru.
>>> word[:2] # Primele doua caractere
He
>>> word[2:] # Tot \c{s}irul \^{i}nafara de primele doua caractere
lpA
Iat a inc a un exemplu:
>>> word[:2] + word[2:]
HelpA
>>> word[:3] + word[3:]
HelpA
Transmiterea unor parametrii gre siti, 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 nlocuit cu dimensiunea sirului:
>>> word[1:100]
elpA
>>> word[10:]
>>> word[2:1]
Indicii pot si numere negative, n acest caz se consider a c a indicele zero se a a cel mai la dreapta:
>>> word[-1] # ultimul caracter
A
>>> word[-2] # penultimul caracter
p
>>> word[-2:] # ultimele doua caractere
pA
>>> word[:-2] # totul \^{i}nafara de ultimele doua caractere
Hel
Dar, atentie -0 este acela si lucru cu 0!
>>> word[-0] # (deoarece -0 egal 0)
H
Indicii negativi mai mari n valoare absolut a dect dimensiunea sirului sunt trunchiati.Acest lucru nu functioneaz a si
la selectarea unui singur caracter ( nu a unei subsecvente ) :
>>> word[-100:]
HelpA
>>> word[-10] # error
IndexError: string index out of range
Mai jos aveti un tabel care v a va ajuta la ntelegerea mecanismului de numerotare al unui sir 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 sirul. A doua linie reprezint a corespondenta dintre
caracterele sirului si indicii negativi. Un sub sir de la i la j este format din toate caracterele dintre cei doi indici i,
respectiv j. Pentru indicii pozitivi lungimea sub sirului este dat a de diferenta indicilor m argina si, dac a nici unul dintre
ei nu este mai mare dect lungimea sirului. De exemplu lungimea sub sirului word[1:3] este 2.
Functia len() ntoarce lungimea unui sir de caractere:
>>> s = supercalifragilisticexpialidocious
>>> len(s)
34
3.1.3 Siruri de caractere UNICODE
ncepnd cu versiunea 2.0 a limbajului Python, este pus la dispozitia programatorului un nou tip de dat a, pentru ma-
nipularea textelor: obiectul Unicode. Poate folosit pentru stocarea si manipularea datelor de tip Unicode(consultati
http://www.unicode.org/) si 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 si orice caracter scris n scripturi moderne sau
scripturi mai vechi.
La nceput au existat numai 256 de numere ecare avnd asociat un caracter, si toate textele erau asociate unei pagini
de cod(code page) care f acea leg atura ntre caractere si numerele asociate. acest lucru a creat foarte mult a confuzie
odat a cu internationalizarea software-ului. Unicode rezolv a aceste probleme asocind o singur a pagin a tuturor script-
urilor.
Crearea sirurilor de caractere Unicode este la fel de simpl a ca si crearea sirurilor obi sniute :
>>> uHello World !
uHello World !
Caracterul u din fata sirului indic a interpretorului c a trebuie s a creeze un sir Unicode din expresia care urmeaz a.
Dac a doriti s a includeti caractere speciale, o puteti face foarte simplu folosind secventele Unicode-Escape. Iat a un
exemplu:
>>> uHello\u0020World !
uHello World !
Secventa \u0020 indic a interpretorului s a insereze caracterul cu ordinalul 0x0020 (caracterul spatiu) npozitia pre-
cizat a. Binenteles c a n acest mod pot introduse si alte caractere, chiar si cele obi snuite, folosind valoarea ordinalu-
lui s au ca ordinal Unicode. Datorit a faptului c a primele 256 de caractere Unicode sunt acelea si ca si n notatia standard
Latin-1, folosit a n multe t ari occidentale, procesul de introducere a caracterelor Unicode devine mult mai simplu.
Pentru experti exist a si un mod direct(raw-mode) identic ca cel fel ca pentru sirurile normale. naintea sirului 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 caractere backslash(\, naintea caracterului u:
>>> urHello\u0020World !
uHello World !
>>> urHello\\u0020World !
uHello\\\\u0020World !
Acest mod poate foarte util dac a aveti de introdus un num ar mare de backslash-uri.
n afar a de metodele de creare a sirurilor Unicode standard, Python ofer a multe alte metode de a crea siruri Unicode.
Functia built-in unicode() permite accesarea tuturor CODECS-urilor Unicode (CODEC = COderDECoder).
Cteva dintre codic arile foarte cunoscute ale caror codex-uri au fost convertite sunt : Latin-1, ASCII, UTF-8 si
UTF-16. Ultimele dou a permit stocarea caracterelor Unicode pe unul sau mai multi octeti. Codicarea implicit a este
ASCII, care permite treacerea caracterelor cuprinse ntre 0 si 127, dar blochez a celelalte caractere semnalnd eroare.
Cnd un sir Unicode este tip arit, scris ntr-un sier, sau convertit cu functia str(), conversia porne ste utiliznd
codarea implicit a.
>>> u"abc"
uabc
>>> str(u"abc")
abc
>>> u""
u\xe4\xf6\xfc
>>> str(u"")
UnicodeError: ASCII encoding error: ordinal not in range(128)
Pentru a converti un sir Unicode ntr-un sir pe 8 biti utiliznd o anumit a codicare, obiectele Unicode furnizeaz a
metoda encode(), care are un singur argument, numele 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 aveti datele intr-o anume codicare si doriti s a obtineti un sir Unicode corespondent din ele, folositi functia
unicode() cu numele codului ca al doilea argument.
>>> unicode(\xc3\xa4\xc3\xb6\xc3\xbc, utf-8)
u\xe4\xf6\xfc
3.1.4 Liste
Python pune la dispozitia programatorului o serie de date structurate, folosite pentru a grupa, a aduna la un loc mai
multe valori. Cea mai exibil a astfel de structur a este lista. O list a poate scris a ca o serie de valori separate prin
virgul a, si aat a ntre paranteze p atrate. Elementele unei liste nu trebuie s a e neap arat de acela si tip:
>>> a = [spam, eggs, 100, 1234]
>>> a
[spam, eggs, 100, 1234]
La fel ca si la siruri, primul element al unei liste are indicele 0. n acela si fel ca si la siruri, listele pot pozitionate,
concatenate si 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, 100, spam, eggs, 100, Boe!]
Spre deosebire se siruri, elementele unei liste pot modicate:
>>> a
[spam, eggs, 100, 1234]
>>> a[2] = a[2] + 23
>>> a
[spam, eggs, 123, 1234]
Functia len() se aplic a si listelor :
>>> len(a)
4
Utilizarea sublistelor este de asemenea posibil a. Prin folosirea lor se poate modica chiar si dimensiunea listei :
>>> # substituirea unor componente :
... a[0:2] = [1,12]
>>> a
[1,12,123,1234]
>>> # eliminarea unor componente :
... a[0:2] = []
>>> a
[123,1234]
>>> # inserarea unor componente :
... a[1:1] = [bletch,xyzzy]
>>> a
[123,bletch,xyzzy,1234]
>>> # inserarea unei liste la debutul ei
... a[:0] = a
>>> a
[123,bletch,xyzzy,1234,123,bletch,xyzzy,1234]
>>> len(a)
8
Este posibil s a creati liste din alte liste (de exemplu prin concatenare):
>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append(xtra) # See section 5.1
>>> p
[1, [2, 3, xtra], 4]
>>> q
[2, 3, xtra]
Observati c a n ultimul exemplu , p[1] si q fac referire la acela si obiect. Vom reveni cu detalii despre semantica
obiectelor mai trziu.
3.2 Primii pa si n programare
Binenteles c a putem folosi Python si la alte lucruri dect pentru a aduna 2 cu 2. Putem de exmplu s a gener am o
subsecvent a din sirul lui Fibonacci:
>>> # Seria lui Fibonacci:
... # Suma a doua elemente reprezinta urmatorul element.
... a, b = 0, 1
>>> while b < 10:
... print b
... a, b = b, a+b
...
1
1
2
3
5
8
Acest exemplu demonstreaz a urm atoarele notiuni:
Prima linie contine o atribuire multipl a. Varibilele a si b iau valorile 0 respectiv 1. Pe ultima linie, de asemenea
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 conditia este adev arat a). La fel ca n C, zero
nseamn a fals, si orice num ar diferit de zero nseamn a adev arat. Conditia poate un sir, un element de list a,
absolut orice. Orice secvent a de lungime diferit a de zero nseamn a adev arat, si invers. Conditia folosit a n
acest exemplu este o comparatie. Comparatorii standard sunt la fel ca n C: <(mai mic), >(mai mare), ==(egal),
<=(mai mic sau egal), >=(mai mare sau egal), !=(diferit).
Instructiunile din bucl a sunt aliniate. Alinierea (indentation) reprezint a modul n care Python grupeaz a instructi-
unile. Deocamdat a (!) Python nu dispune de un editor n linie de comand a inteligent, astfel nct alinierea,
tabularea s a se fac a automat. Sunteti deci obligat s a folositi tab sau spatii pentru a realiza gruparea instructiu-
nilor. Cnd veti scrie programe Python veti folosi un editor de text. Majoritatea editoarelor de la ora actual a
realizeaz a automat tabularea. Pentru a ncheia un bloc de instuctiuni trebuie introdus a o linie goal a pentru a
indica editorului c a editarea blocului de comenzi s-a ncheiat (editorul nu poate ghici cnd ati introdus ultima
linie. Atentie! ecare instructiune dintr-un bloc de instructiuni trebuie s a aib a acelea si num ar de spatii si taburi
nainte, deci instructiunile trebuie s a e perfect aliniate.
Instructiunea print a seaz a expresia pe care o prime ste ca parametru. Sirurile de caractere sunt a sate f ar a
ghilimele, si un spatiu este inserat ntre elemente, astfel nct a sarea diverselor valori s a mearg a de la 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 instructiunii print, inhib a saltul cursorului pe linia urm atoare la
sfr situl instructiunii:
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
Observati c a interpretorul sare la linia urm atoare nainte de a ncepe a sarea, dac a ultima linie a fost incomplet a.
CAPITOL
PATRU
Structuri de control
n afar a de buclele de tip while (explicate anterior), Python dispune de structurile de control obi snuite, ntlnite si n
celelalte limbaje.
4.1 Instructiuni if
Poate c a cea mai cunoscut a instructiune de control este instructiunea if. Exemplu:
>>> x = int(raw_input("Introduceti un numar \^{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 sectiuni elif sau niciuna, iar sectiunea else este optional a. Cuvntul cheie elif este evident
prescurtarea de la elseif, si este folositor pentru a evita tabularea excesiv a. O secvent a if..elif..elif
functioneaz a ca un bloc case sau switch, secvente proprii altor limbaje .
4.2 Instructiuni for
Instructiunea for din Python difer a un pic fat a de ce a-ti ntlnit n C sau Pascal. n loc de o iteratie dat a de o progresie
aritmetic a (Pascal), sau de o iteratie foarte exibil a, pentru care programatorul poate deni att pasul iteratiei, ct si
conditia de oprire (C), iteratiile instructiunii Python for functioneaz a dup a elementele unei secvente (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 secventa iterat a s a e modicat a n timpul secventei for ( este cazul numai al secventelor
modicabile, cum ar listele). Dac a apare necesitatea de a modica secventa n timpul iteratiei, iteratia trebuie s a e
asociat a unei copii a secventei. Notatia 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 Functia range()
Dac a este necesar a o iteratie pe o multime de numere, puteti folosi functia range() pentru a genera liste ce contin
progresii aritmetice :
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Paramentrul furnizat functiei range() nu va niciodat a un membru al secventei. Este posibil ca functia range()
s a genereze o secvent a ncepnd cu un alt num ar dect 0, sau ratia progresiei aritmetice poate modicat 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 iteratie pe o multime de numere folositi functiile range() si len() astfel:
20 Capitol 4. Structuri de control
>>> a = [Mary, had, a, little, lamb]
>>> for i in range(len(a)):
... print i, a[i]
...
0 Mary
1 had
2 a
3 little
4 lamb
4.4 Instructiuni break si continue, si clauze else pentru bucle
La fel ca n C, instructiunea break termin a fortat orice bucl a while sau for. Instructiunea continue trece
neconditionat la urm atoarea iteratie. Instructiunile iterative pot avea si o clauz a else. Instructiunile din cadrul unei
astfel de clauze else sunt executate atunci cnd bucla se termin a odat a cu terminarea listei (for) sau atunci cnd
conditia buclei devine fals a (pentru while) aceste instructiuni nu sunt executate dac a bucla este terminat a printr-o
instructiune break. Iat a un 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:
... print 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
4 egal cu 2 * 2
6 egal cu 2 * 3
8 egal cu 2 * 4
9 egal cu 3 * 3
4.5 Instructiuni pass
Instructiunea pass nu execut a nimic. Poate folosit a atunci cnd este necesar a prezenta sintactic a a unei instructiuni,
f ar a ca aceasta s a execute ceva:
>>> while 1:
... pass # Asteapta pentru intrerupere de la tastatura
...
4.4. Instructiuni break si continue, si clauze else pentru bucle 21
4.6 Functii
Putem crea o functie care genereaz a sirul lui Fibonacci pn a la o limit a arbitrar a:
>>> def fib(n): # Scrie \c{s}irul lui Fibonacci 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)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
Cuvntul cheie def este primul din denitia unei functii. Acesteia trebuie s a i urmeze numele functiei si o list a
parantezat a de parametrii. Instructiunile care formeaz a functia ncep pe linia imediat urm atoare si trebuie s a e dis-
tantate mai mult dect antetul functiei fat a de margine. Prima instructiune din corpul functiei poate un sir de
caractere(optional), acest sir reprezentnd documentatia functiei(docstring = sirul de documentatie al functiei). Exist a
utilitare care genereaz a documentatie pornind de la aceste siruri, deci este o practic a bun a s a v a folositi de aceast a
facilitate.
Executia unei functii creaz a o nou a tabel a de simboluri, folosit a pentru variabilele locale. Altfel spus toate atribuirile
din cadrul unei functii 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 cea global a si apoi n cea predenit a.
Cu toate acestea variabilelor globale nu li se pot atribui valori n cadrul unei functii, dect dac a se folose ste instructi-
unea global.
Parametrii actuali ai unei functii apelate sunt introdu si n tabela de simboluri local a a celei functii nmomentul apel arii
ei. Astfel transferul aegumentelor se face utilizand apel prin valoare (unde valoare este totdeauna un obiect referint a,
nu valoarea obiectului).
1
Cnd o functie apeleaz a o alta functie, este creat a o nou a tabel a de simboluri pentru functia apelat a.
Denirea unei functii trece numele functiei n tabela de simboluri curent a.
Functia nou creat a este recunoscut a de interpretor ca o functie denit a de utilizator. n Python exist a un mecanism de
redenumire a functiilor:
>>> fib
<function object at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89
Ati putea obiecta c a functia fib este o procedur a nu o functie. n Python, la fel ca nC, procedurile sunt functii, numai
c a nu returneaz a nici o valoare. Tehnic vorbind, procedurile returneaz a totu si o valoare, aceasta este None(niciuna).
None este un cuvnt cheie (predenit). n mod normal valoarea None nu este a sat a de interpretor. Totu si dac a doriti
s a v a convingeti c a a sa functioneaz a procedurile ncercati urm atorul exemplu:
1
De fapt, apel prin referint a va putea mai bine descris, atunci daca un obiect modicabil este transmis, apelantul va vedea dac a nurma apelarii
obiectul s-a modicat ( un element inserat ntr-o list a).
>>> print fib(0)
None
Este foarte simplu s a construim o functie care ntoarce ca rezultat sirul lui Fibonacci:
>>> def fib2(n): # Intoarce \c{s}irul lui Fibonacci pana la n
... "Intoarce o lista continand \c{s}irul lui Fibonacci pana 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 # afisarea rezultatului
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Acest exemplu demonstreaz a mai multe facilit ati ale limbajului Python:
Instructiunea return ntoarce rezultatul functiei. return f ar a nici un parametru ntoarce ca rezultat al
functiei valoarea None. Puteti folosi return f ar a parametrii pentru a ncheia executia unei functii nainte
de a se ajunge la nalul instructiunilor din cadrul functiei. Valoarea None este de asemenea ntoars a ca rezultat
al unei functii atunci cnd au fost executate toate instructiunile procedurii.
Instructiunea result.append(b) apeleaz a o metod a a obiectului result. O metod a este o functie care
apartine unui obiect. Metodele sunt apelate folosind sintaxa obj.metoda(unde obj este un obiect, poate
si o expresie, iar metoda este numele metodei ce este apelat a). n functie 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 posibil s a creati
obiecte si metode folosind clasele, dar despre clase vom discuta mai trziu. Metoda append este denit a pentru
obiecte de tip list a, si adaug a un element la sfr situl listei. n acest exemplu ar echivalent a cu result =
result + [b] dar mult mai ecient a.
4.7 Mai multe despre functii
Este posibil n Python s a denim functii cu un num ar variabil de argumente. Exist a trei modalitati de a realiza acest
lucru, care pot combinate.
4.7.1 Valori implicite pentru argumente
Cea mai util a metod a este s a specicati valori implicite pentru argumente. n acest fel creati o functie care poate
apelat a cu mai putine argumente dect a fost denit a:
4.7. Mai multe despre functii 23
def ask_ok(prompt, retries=4, complaint=Da sau nu va rog!):
while 1:
ok = raw_input(prompt)
if ok in {d, da): return 1
if ok in {n, nu): return 0
retries = retries - 1
if retries < 0: raise IOError, refusenik user
print complaint
Functia denit a mai sus poate apelat a n dou a moduri:
ask_ok(Sunteti sigur ca doriti sa iesiti?) sau: ask_ok(Doriti sa stergeti
fisierul?, 2)
Valorile implicite sunt evaluate n timpul interpret arii denitiei functiei, deci urm atoarea secvent a
i = 5
def f(arg=i):
print arg
i = 6
f()
va a sa 5.
ATEN TIE!!!: Valorile implicite sunt evaluate o singur a dat a. Aveti grij a atunci cnd valoarea implicit a este un obiect
modicabil. De exemplu functia urm atoare acumuleaz a ntr-o list a argumentele ce i sunt transmise n timpul unor
apeluri consecutive:
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 doriti ca valoarea implicit a s a e retinut a dup a terminarea functiei, puteti proceda ca n exemplul urm ator:
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
4.7.2 Argumente de tip cuvinte cheie
Functiile pot apelate folosind n loc de argumente cuvinte cheie de forma: cuvant_cheie = valoare. Pentru
exemplicare observati functia:
def parrot(voltage, state=mort, action=zboara, type=Norvegian Blue):
print "-- Acest papagal 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)
parrot(un milion, fara viata, sare)
Dar urm atoarele apeluri ar genera erori:
parrot() # Lipseste argumentul obligatoriu
parrot(voltage=5.0, mort) # Dupa cuvantul 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 pozitionale, urmate de oricte argumente de tip
cuvinte cheie, unde cuvintele cheie trebuie alese din lista parametrilor formali. Nu este important dac a un parametru
formal are o valoare implicit a sau nu. Nici un argument nu poate primi o valoare de mai multe ori numele de
parametrii formali corespunz atoare argumentelor pozitionale nu pot folosite drept cuvinte cheie n cadrul aceluia si
apel. Iat a un exemplu cu erori datorate acestei reguli:
>>> def function(a):
... pass
...
>>> function(0, a=0)
TypeError: keyword parameter redefined
Atunci cnd unul dintre parametrii este de forma **nume, functia va primi o list a care va contine parametrii de
tip cuvnt cheie. Dac a se folose ste un parametru de tipul *nume, functia va primi o list a continnd argumentele
suplimentare n afara celor formale. Dac a sunt folositi mpreun a parametrul *nume trebuie s a se ae naintea celui de
tip **nume. Totul poate p area ambiguu dar veti l amuriti 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 keywords.keys(): print kw, :, keywords[kw]
Un apel al acestei functii ar ar ata astfel:
cheeseshop(Limburger,"Se vinde foarte repede, d-le"
"Se vinde foarte, FOARTE repede, 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 vinde foarte, FOARTE repede, d-le.
----------------------------------------
client : John Cleese
manager : Michael Palin
sketch : Cheese Shop Sketch
4.7.3 Liste de argumente arbitrare
O functie poate apelat a cu un num ar arbitrar de argumente. nainte de argumentele arbitrare (optionale) 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 ati specice limbajelor functionale si Lisp-ului.
Folosind cuvntul cheie lambda puteti crea mici functii. Iat a o functie care ntoarce ca rezultat suma argumentelor:
lambda a, b : a+b. Formele lambda pot folosite acolo unde sunt necesare functii obiect. Aceste functii
sunt restrnse sintactic la o singur a expresie:
>>> def make_incrementor(n):
... return lambda x, incr=n: x+incr
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43
>>>
4.7.5 Sirurile de documentatie
Exist a anumite conventii privind continutul si formatarea sirurilor de documentatie.
Prima linie ar trebui s a e scurt a si foarte concis a. Pentru concizie nu ar trebui precizat numele obiectivului sau tipul,
acestea ind subntelese. Aceast a linie trebuie s a nceap a cu liter a mare si s a se termine cu virgul a.
Dac a exist a mai multe linii, cea de-a doua ar trebui s a e vid a, pentru a separa descrierea scurt a de cea am anuntit a.
Urm atoarele linii ar trebui s a descrie mai pe larg obiectul, semnicatia parametrilor, etc.
Interpretorul Python ia n consideratie spatiile din sirurile de caractere mp artite pe mai multe linii, din aceast a cauz a
pentru a avea o documentatie aranjat a frumos trebuie s a v a folositi de un mic truc la fel ca n exemplul urm ator:
>>> def my_function():
... " " "Nu face decat documentarea.
...
... Chiar nu face nimic!
... " " "
... pass
...
>>> print my_function.__doc__
Nu face decat documentarea.
Chiar nu face nimic!
28
CAPITOL
CINCI
Strucuri de date
Acest capitol subliniaz a anumite lucruri deja cunoscute si descrie altele noi.
5.1 Mai multe despre liste
Tipul de date list a mai dispune de cteva metode. Iat a toate metodele obiectelor de 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 pozitie. Primul argument reprezint a indicele elementului din
list a naintea c aruia se va face insertia, deci a.insert(0,x) va insera elementul 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 astfel de element apare o eroare.
pop([i]) Sterge din list a elementul de pe pozitia i, si ntoarce valoarea acestuia. Dac a nu este specicat nici un
parametru a.pop(), va sterge si va returna ultimul element din list a.
index(x) ntoarce indicele primului parametru din list a care are valoarea x.
count(x) ntoarce num arul de aparitii 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 majoritatea metodelor:
29
>>> a = [66.6, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.6), a.count(x)
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.6, 333, -1, 333, 1, 1234.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 unei stive. Pentru a ad auga un element
pe stiv a (PUSH), puteti folosi append(). Pentru a scoate un element din stiv a (POP), folositi pop() f ar a a specica
un index. Iat a un exemplu:
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
5.1.2 Folosirea listelor drept cozi
Puteti folosi listele foarte convenabil, pentru a implementa cozi. Spre deosebire 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 folositi append(),
iar pentru a extrage un element folositi 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, Cristi]
5.1.3 Instrumente de programare functional a
Exist a trei functii predenite care sunt foarte utile n lucrul cu liste: filter(), map(), reduce().
Functia filter() cu sintaxa filter(functie, secventa), ntoarce o secvent a format a din elementele
secventei specicate ca parametru, care ndepline ste conditia testat a de functie. Exemplul care urmeaz a calculeaz a
numerele prime din intervalul 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]
Functia map() cu sintaxa map(functie, secventa), apeleaz a functia specicat a ca parametru pentru ecare
element din secvent a, si ntoarce o nou a list a format a din rezultatele ntoarse de functie. Pentru a calcula p atratele
unor numere dintr-o list a puteti folosi o secvent a similar 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]
Functia map() accept a ca parametrii mai multe secvente. n acest caz functia transmis a ca parametru trebuie s a e
modicat a corespunz ator, trebuie s a accepte acela si num ar de parametrii cte secvente sunt transmise. Dac a secventele
sunt diferite ca lungime, atunci cnd una dintre secvente s-a terminat, n loc de un element functiei i se transmite None.
Dac a n loc de un nume de functie, se transmite None functiei map(), atunci functia va nlocuit a cu o functie care
va ntoarce ca rezultat parametrii primiti. Puteti folosi comportamentul functiei map() pentru a genera perchi de
numere provenind din dou a liste:
>>> seq = range(8)
>>> def square(x): return x*x
...
>>> map(None, seq, map(square, seq))
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]
Functia reduce(functie, secventa) ntoarce o simpl a valoare care este calculat a n felul urm ator: este
apelat a functia (care este obligatoriu o functie binar a ce accept a numai 2 parametrii), cu parametrii primul si al doilea
termen al secventei, functia ntoarce un rezultat care mpreun a cu al treilea element sunt transmise din nou functiei,
care genereaz a un alt rezultat si a sa mai departe, pn a ce lista este 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
Dac a exist a un singur element n secvent a valoarea acestuia va returnat a. Dac a lista este goal a, va generat a
o exceptie. Functia reduce() poate primi si un al treilea parametru care semnic a valoarea de la care ncepe
calculul. n acest caz primul apel al functiei are ca parametrii aceast a valoare si primul element al listei. Dac a functia
reduce() este apelat a cu trei parametrii, iar lista este goal a, aceasta va ntoarce ca rezultat al treilea parametru. Iat a
un exemplu care ilustreaz a modul de lucru al functiei 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 functiilor map(), filter() sau lambda().
Denitia listei este de cele mai multe ori mult mai clar a dect cea obtinut a prin alte metode. Acest mod generalizat, de
a genera, a deni liste const a n asocierea unei expresii, cu o clauz a for si cu niciuna sau mai multe clauze for sau
if. Rezultatul va o list a care provine din evaluarea expresiei n contextul clauzelor for si if ce urmeaz a. Dac a
rezultatul evalu arii expresiei va o pereche, atunci expresia trebuie parantezat a corespunz ator:
>>> freshfruit = [ banana, loganberry , passion fruit ]
>>> [weapon.strip() for weapon 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] # error - parens required for tuples
[x, x**2 for x in vec]
^
>>> [(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 in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
5.2 Instructiunea del
Exist a o metod a de a sterge un element dintr-o list a specicnd indicele elementului n loc de valoarea elementu-
lui. Aceast a metod a poate folosit a si pentru a sterge portiuni dintr-o list a. Toate acestea pot realizate utiliznd
instructiunea del:
>>> a
[-1, 1, 66.6, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.6, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.6, 1234.5]
del poate folosit a si pentru a sterge variabile, de exemplu o ntreag a list a:
>>> del a
Vom vedea mai trziu si alte modalit ati de a utiliza instructiunea del.
5.2. Instructiunea del 33
5.3 Perechi si secvente
1
Am obsevat pn a acum c a listele si sirurile de caractere au multe caracteristici comune, de exemplu: indexarea si
pozitionarea (slicing). Sirurile si listele sunt dou a exemple de tipuri de date secvent a. Deoarece Python este un limbaj
care evolueaz a, n timp pot ad augate si alte tipuri de date secvent a. Exist a si un alt tip 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!)
>>> # enumerarile pot fi imbricate, combinate
... u = t, (1, 2, 3, 4 ,5)
>>> u
((12345, 54321, hello!), (1, 2, 3, 4 ,5))
Dup a cum puteti vedea perechile(enumer arile) sunt a sate ntre paranteze astfel nct enumer arile sau perechile mbri-
cate 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 angajatilor dintr-o baz a de date,
etc. Puteti face o analogie (atta timp ct r amne numai o analogie menit a s a v a ajute la ntelegerea acestui tip de
date) ntre tipurile de date compuse ce pot denite cu struct din C++, si perechile din Python. Perechile, la fel
ca sirurile nu pot modicate: nu pot atribuite valori unui anumit element al unei perechi (puteti ns a s a simulati
o modicare folosind alte metode). Este posibil s a creati perechi care contin obiecte modicabile, cum sunt listele de
exemplu.
O problem 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. Perechile vide pot construite folosind o pereche de paranteze
f ar a nimic ntre ele. O pereche cu un singur element poate construit a specicnd valoarea care va continut a n
pereche urmat a de o virgul a. Cam nepl acut, dar functioneaz a:
>>> empty = ()
>>> singleton = hello, # <---- observati virgula
>>> len(empty)
0
>>> len(singleton)
1
(hello,)
Instructiunea t = 12345, 54321, Salut! este un exemplu de mpachetare. Valorile 12345, 54321 si
Salut! sunt mpachetate mpreun a. Operatia invers a este de asemenea posibil a:
>>> x, y, z = t
Aceast a operatie este numit a sucient de elocvent despachtarea unei secvente. Despachetarea unei secvente necesit a
ca lista de variabile de la stnga atribuirii s a contin a tot attea variabile ct secventa mpachetat a de la dreapta. De
observat este faptul c a mbricarea nu este dect o combinatie succesiv a de mpachet ari sau despachet ari! Ingenios,
nu?!
Exist a o asimetrie aici: n timp ce o mpachetare va genera ntotdeauna o pereche, despachtarea functioneaz a pentru
1
N.T. termenul romnesc PERECHE este impropriu, forma original a ind TUPLE.
orice fel de secvent a.
5.4 Dictionare
Un alt tip de date predenit n Python si care se poate dovedi foarte folositor este dictionarul. Dictionarele pot
ntlnite si n alte limbaje, sub alte nume, cum ar memorii asociative sau valori asociative. Spre deosebire de
secvente (liste, siruri, etc.) care sunt indexate cu numere (indicii sunt numere), dictionarele sunt indexate de chei, care
pot denite de oricare din tipurile de date invariabile(nemodicabile), de exemplu: siruri de caractere sau numere.
Perechile pot folosite drept chei ale unui dictionar numai dac a contin obiecte invariabile. Nu puteti folosi drept chei
listele deoarece acestea pot modicate folosind metode ca append() sau extend().
Este indicat s a v a gnditi la un dictionar ca la o multime neordonat a de perechi cheie-valoare, cu observatia c a o cheie
trebuie s a e unic a ntr-un dictionar. O pereche de acolade creaz a un dictionar gol: {}. Puteti crea un dictionar dac a
ntre acolade introduceti o list a (ale c arei elemente sunt separate prin virgul a), de perechi cheie-valoare: dictionar
= jack:4098, Sape:4139. Operatiile principale pe care le realizeaz a un dictionar sunt: stocarea unei
valori cu anumit a cheie si extragerea unei valori cunoscndu-se o anumit a cheie. O pereche cheie-valoare poate
stears a folosind instructiunea del. Dac a se adaug a o valoare n dictionare pentru o cheie care exist a deja, valoarea
veche asociat a acelei chei este pierdut a. O eroare este generat a, binenteles, dac a veti ncerca s a extrageti o valoare
pentru o cheie inexistent a.
Metoda keys() a unui obiect dictionar ntoarce o list a cu toate cheile existente n respectivul dictionar. Lista returnat a
nu este sortat a, ns a pentru a o sorta puteti folosi metoda sort() a obiectului list a returnat de functie. Pentru a verica
dac a o anumit a cheie se a a deja n dictionar folositi metoda has-key(). Iat a un mic exemplu:
>>> tel = {jack: 4098, sape: 4139}
>>> tel[guido] = 4127
>>> tel
{sape: 4139, guido: 4127, jack: 4098}
>>> tel[jack]
4098
>>> del tel[sape]
>>> tel[irv] = 4127
>>> tel
{guido: 4127, irv: 4127, jack: 4098}
>>> tel.keys()
[guido, irv, jack]
>>> tel.has_key(guido)
1
5.5 Mai multe despre conditii
Conditiile folosite n cadrul instructiunilor while sau if pot contine si alti operatori dect cei de comparatie.
Operatorii de comparatie in si not in veric a dac a o anumit a valoare se a a sau nu ntr-o secvent a dat a. Operatorii
is si is not veric a dac a dou a obiecte sunt de fapt unul si acela si obiect, acest lucru conteaz a n cazul obiectelor
modicabile cum sunt listele de exemplu.
Operatorii de comparatie pot combinati. De exemplu a < b == c testeaz a nti dac a a < b iar apoi dac a b este
egal cu c.
Conditiile pot avea structuri foarte complexe dac a sunt folositi operatorii and, or sau not. Operatorii de
comparatie au aceea si prioritate care este mai 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 comparatie. Cea 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. Dictionare 35
C este echivalent cu A and (not B) or C. Binenteles puteti folosi paranteze pentru a combina conditiile si
pentru claritate.
Operatorii logici mai sunt denumiti si operatori pe scurt atur a (shortcut operator), argumentele acestea sunt evaluate
de la stnga la dreapta, si evaluarea se opre ste odat a ce rezultatul este determinat. De exemplu dac a A si 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.
Este posibil a atribuirea unei valori rezultate dintr-o comparatie sau orice alt a conditie, unei variabile:
>>> string1, string2, string3 = , Trondheim, Hammer Dance
>>> non_null = string1 or string2 or string3
>>> non_null
Trondheim
Spre deosebire de C, n Python nu sunt permise atribuirii n cadrul expresiilor. Programatorii de C pot critica acest
lucru, dar prin aceasta se evit a o multime de erori ntlnite n programele C, de exemplu = n loc de ==.
5.6 Compararea secventelor
Obiectelor de tip secvent a pot comparate cu obiecte secvent a de acela si tip. Comparatiile ntre secvente folosesc
principiile ordon arii lexicograce: sunt comparate nti primele dou a elemente din ecare list a, dac a difer a rezultatul
este a sat, dac a sunt egale se trece la compararea urm atoarelor dou a elemente, si 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 lexicograc 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 secvente
este o subsecvent aa initial a a celeilalte, atunci secvent a mai scurt a este cea mai mic a. Ordonarea lexicograc a pentru
siruri folose ste ordinea ASCII a caracterelor. Exemple de comparatii ntre secvencte de acela si tip:
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
ABC < C < Pascal < Python
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, (aa, ab)) < (1, 2, (abc, 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 sir, un sir mai mic dect o pereche, etc. Comparatiile ntre
numere se fac lund n consideratie valoarea numeric a chiar dac a numerele sunt de tipuri diferite, si ca atare 0 va
egal cu 0.0, etc.
2
2
Regulile de comparatie ntre obiecte de tipuri diferite nu ar trebui considerate de foarte mare ncredere, deoarece acestea pot schimbate la
versiuni viitoare ale limbajului.
CAPITOL
SASE
Module
Dac a ie siti din interpretorul Python si intrati din nou, denitiile pe care le-ati f acut (functii, varibile, etc.) se pierd.
Dac a aveti de gnd s a scrieti un program mai lung, ar mai bine s a folositi un editor de texte pentru a scrie programul
ntr-un sier, si apoi s a rulati interpretorul Python cu parametru sierul n care se a a programul. Fi sierul n care se
a a programul se nume ste script. Pe m asur a ce programul se va m ari veti simti nevoia s a l mp artiti n mai multe
siere. S-ar putea la fel de bine s a doriti s a folositi o functie n mai multe programe f ar a a nevoit s a copiati denitia
functiei n ecare program.
n Python puteti scrie anumite denitii ntr-un sier, pe care l puteti include n alte programe. Un astfel de sier
se nume ste modul. Denitiile dintr-un modul pot importate n alte module, sau n modulul principal (programul
initial). Un modul este un sier care contine denitii si instructiuni Python. Numele sierului n care se a a un
anumit modul este dat de numele modulului si extensia .py la sfr sit. ntr-un modul, numele acestuia este accesibil
prin intermediul variabilei globale __name__. Folositi acum editorul dumneavoastr a de texte preferat pentru a creea
sierul bo.py:
# modul cu numerele lui Fibonacci
def fib(n): # scrie \c{s}irul lui Fibonacci pana 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.append(b)
a, b = b, a+b
return result
Acum deschideti interpretorul Python si tastati comanda:
>>> import fibo
Aceast a instructiune nu ncarc a n tabela de simboluri numele functiilor denite n modulul bo, ci numai numele
modulului. Folosind numele modulului puteti accesa functiile denite 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 puteti 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 contine att instructiuni executabile ct si denitii de functii. Aceste instructiuni sunt menite s a
realizeze initializarea modulului si 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 functiile denite n modul ca o tabel a de simboluri
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 aveti neap arat nevoie puteti
modica direct variabilele globale ale unui modul, folosind aceea si conventie ca la apelarea functiilor unui modul:
modul.variabila.
Modulele pot importa alte module. Instructiunile import pot plasate la nceputul programului si este indicat, dar
nu este obligatoriu.
Exist a o metod a de a nc arca denitiile unui anumit 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 377
n exemplul de mai sus, numele modulului nu a fost introdus n tabela de simboluri local a. Pentru a nc arca toate
denitiile modulului direct n tabela local a folositi:
n exemplul de mai sus, n tabela local a au fost nc arcate toate numele de variabile si functii, 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 c autate modulele
Atunci cnd un modul numit xxx este importat, interpretorul caut a un sier numit xxx.py n directorul curent, si n
toate directoarele specicate n variabila de sistem PYTHONPATH. 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 denit a modulul va c autat n directorul
implicit de instalare, de obicei /usr/local/lib/python.
6.1.2 Fi siere Python compilate
Un important aport de vitez a la pornirea programelor care ncarc a o multime de module standard este adus de urm atorul
comportament al Python-ului: dac a n directorul unde este g asit sierul xxx.py se mai a a si xxx.pyc, se presupune
c a acest ultim sier contine o variant a compilat a a modulului si este nc arcat n loc de xxx.py. Timpul la care a fost
modicat ultima oar a sierul .py este nregistrat n sierul .pyc n momentul n care este creat, iar n momentul
importului dac a aceste momente de timp nu corespund sierului .pyc este ignorat.
De obicei nu trebuie s a faceti nimic deosebit pentru a crea sierul xxx.pyc. Oridecteori xxx.py este compilat cu
succes este creat sau suprascris si sierul xxx.pyc. Dac a scrierea sierului compilat nu reu se ste veti avertizat printr-
un mesaj de eroare. Continutul sierelor de tip .pyc este independent de platform a, astfel nct Python devine un
limbaj foarte portabil.
Cteva indicatii pentru experti:
Cnd interpretorul Python este apelat folosind optiunea -O, se genereaz a cod optimizat 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
instructiunile assert si SET-LINENO. Atunci cnd se folose ste aceast a optiune tot codul este optimizat,
sierele .pyc sunt ignorate iar sierele .py sunt compilate si optimizate.
Dac a interpretorul Python este lansat n executie folosind optiunea -O, compilatorul poate genera n anumite
cazuri cod compilat eronat. Versiunea curent a elimin a sirurile __doc__ din codul compilat, astfel nct acesta
s a e mai compact. Din moment ce unele programe pot folosi aceste siruri, eliminarea lor ar putea genera erori.
n concluzie, ar trebui s a folositi aceast a optiune numai atunci cnd stiti foarte bine ce faceti.
Un program nu functioneaz a mai rapid, atunci cnd este citit dintr-un sier de tip .pyc sau .pyo, fat a de unul
.py. Singurul lucru care difer a este viteza de nc arcare a programelor n memorie.
Atunci cnd un script este rulat, prin lansarea interpretorului si parametru numele sierului n care se a a script-
ul, codul script-ului nu este compilat si nu se genereaz a siere de tip .pyc sau .pyo. n cazul n care aveti un
script de dimensiuni mari, si doriti s a cre steti viteza de nc arcare, puteti s a mutati buc ati din cod ntr-un modul
pe care s a l importati apoi n script. Interpretorul Python poate lansat si folosind direct un sier cu extensia
.pyc sau .pyo.
Este posibil s a lansati 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. Puteti folosi aceast a facilitate atunci cnd distribuiti o bibliotec a si nu doriti s a
e modicat a.
Modulul compileall poate folosit 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 puteti g asi ndocumentul The Python Library
Reference. Unele module sunt integrate n interpretor, de si nu fac parte din nucleul limbajului, din denitia acestuia,
dar sunt integrate pentru ecient a sau pentru a facilita accesul la primitivele sistemului de operare. Setul de module
integrate este o optiune de congurare, care de asemenea depinde de particularitatea platformei. De exemplu modulul
amoeba este disponibil pe sisteme care pun la dispozitie primitive Amoeba. Un anumit modul necesit a o atentie
special a: sys care este integrat n orice interpretor Python. Variabilele sys.ps1 si sys.ps2 denesc sirurile de
caractere ce vor folosite de interpretor pentru prompt-ul principal si cel secundar:
6.2. Module standard 39
>>> import sys
>>> sys.ps1
>>>
>>> sys.ps2
...
>>> sys.ps1 = C>
C> print Yuck!
Yuck!
C>
Aceste dou a variabile sunt denite doar dac a interpretorul se a a n mod interactiv. Variabila sys.path contine o lis a
de directoare unde Python caut a module. Aceast a variabil a este initializat a din variabila de sistem PYTHONPATH, sau
cu o valoare implicit a n cazul n care PYTHONPATH nu este denit a. Puteti modica sys.path folosind operatii
specice listelor:
>>> import sys
>>> sys.path.append(/ufs/guido/lib/python)
6.3 Functia dir()
Functia integrat a dir() poate folosit a pentru a determina ce nume(de variabile, functii, etc.) dene ste un modul.
Rezultatul acestei functii este o list a sortat a de siruri de caractere:
>>> import fibo, sys
>>> dir(fibo)
[__name__, fib, fib2]
>>> dir(sys)
[__name__, argv, builtin_module_names, copyright, exit,
maxint, modules, path, ps1, ps2, setprofile, settrace,
stderr, stdin, stdout, version]
Dac a functia dir() este apelat a f ar a argumente, va lista numele ce sunt denite (local) pn a n momentul curent:
>>> a = [1, 2, 3, 4, 5]
>>> import fibo, sys
>>> fib = fibo.fib
>>> dir()
[__name__, a, fib, fibo, sys]
Observati c a listeaz a diferite tipuri de nume: variabile, functii, module, etc.
dir() nu listeaz a si numele de functii sau variabile integrate. Dac a doriti o astfel de list a, puteti apela
dir(__builtin__), unde __buildin__ este modulul n care se a a functiile si variabilele integrate:
>>> import __builtin__
>>> dir(__builtin__)
[AccessError, AttributeError, ConflictError, EOFError, IOError,
ImportError, IndexError, KeyError, KeyboardInterrupt,
MemoryError, NameError, None, OverflowError, RuntimeError,
SyntaxError, SystemError, SystemExit, TypeError, ValueError,
ZeroDivisionError, __name__, abs, apply, chr, cmp, coerce,
compile, dir, divmod, eval, execfile, filter, float,
getattr, hasattr, hash, hex, id, input, int, len, long,
map, max, min, oct, open, ord, pow, range, raw_input,
reduce, reload, repr, round, setattr, str, type, xrange]
6.4 Pachete
Pachetele sunt o modalitate prin care Python structureaz a modul de acces la module( si la denitiile existente n mod-
ule). Pentru exemplicare numele modulului A.B desemneaz a un submodul B denit n cadrul pachetului A.
S a presupunem c a doriti s a proiectati o colectie de module (un pachet) pentru manipularea sierelor de sunet, si a
sunetelor. Exist a o multitudine de formate de sunet (de obicei recunoscute dup a extensia lor .wav, .aiff, .au) a sa
c a este necesar a creearea si ntretinerea unei colectii de module ncontinu a cre stere care s a permit a conversia ntre
diverse formate de siere. Exist a multe alte operatii pe care poate ati dori s a le executati (mixaje, ad augarea ecoului,
efecte stereo, etc.), a sa c a, de fapt, veti scrie o serie nesfr sit a de module care s a permit a aceste operatii. Aveti mai jos
o posibil a structur a a pachetului dumneavoastr a (n sensul unei ierahii de siere):
Sound/ Pachet "tata"
__init__.py Initializarea pachetului sound
Formats/ Subpachet pentru conversii intre fi\c{s}iere
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
Effects/ Subpachet pentru efecte acustice
__init__.py
echo.py
surround.py
reverse.py
...
Filters/ Subpachet pentru filtre
__init__.py
equalizer.py
vocoder.py
karaoke.py
...
Fi sierele de tipul __init__.py sunt necesare pentru a face Python s a trateze directoarele ca pachete. Acestea sunt
necesare pentru a preveni situatia ca un director cu un nume comun, de exemplu string, s a ascund a un modul valid
cu acela si nume. n cel mai simplu caz __init.py__ poate un sier gol, dar poate contine si cod de initializare.
Utilizatorii unui pachet pot importa doar un anumit modul din cadrul pachetului:
6.4. Pachete 41
import Sound.Effects.echo
Instructiunea de mai sus a nc arcat modulul Sound.Effects.echo, dar o functie 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 denite n modul au fost nc arcate n tabela local a de simboluri, deci numele de functii si
variabile sunt disponibile f ar a prex:
echo.echofilter(input, output, delay=0.7, atten=4)
O alt a variant a este nc arcarea (importarea) direct a a functiei sau variabilei dorite:
from Sound.Effects.echo import echofilter
Un exemplu de utilizare a functiei echofilter():
echofilter(input, output, delay=0.7, atten=4)
De observat c a atunci cnd se folose ste sintaxa from packet import element, elementul poate , e un submodul
(sau subpachet), e un nume denit n pachet, de exemplu un nume de functie sau variabil a, sau un nume de clas a.
Instructiunea import testeaz a nti dac a elementul este denit sau nu n pachet. Dac a elementul nu este denit,
Python presupune c a este vorba de un modul si ncearc a s a-l ncarce. Dac a nc arcarea nu reu se ste este generat a o
exceptie de tipul ImportError.
Cnd folositi o sintax a de genul: import element.subelement.subsubelement, ecare element, mai
putin ultimul trebuie obligatoriu s a e un pachet. Ultimul element poate un modul, un pachet, dar nu poate o
clas a, o functie, o variabil a, etc. denit a n elementul anterior.
6.4.1 Importarea tuturor modulelor dintr-un pachet
Ce se va ntmpla dac a un programator va folosi o instructiune de genul: from Sound.Effects import *?
ntr-un caz ideal, programatorul ar putea s a spere c a interpretorul Python va realiza o c autare recursiv a n sistemul de
siere si directoare dup a modulele existente n pachet. Din nefericire nu functioneaz a foarte bine pe platforme Mac
sau Windows, din varii motive. Pe astfel de platforme existenta unui sier ECHO.PY nu garanteaz a c a n acest sier
se a a un modul numit Echo, ct si echo sau ecHo, si 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 calea numelor
lungi de module.
Singura solutie pentru astfel de probleme este ca autorul pachetului s a specice exact ce module exist a n pachet.
Instructiunea import() folose ste urm atoarea conventie: dac a codul existent n sierul __init__.py dene ste o list a
cu numele __all__, aceasta este considerat a lista cu modulele ce ar trebui nc arcate la executia unei instructiuni
from pachet import *. Este obligatia autorului pachetului s a modice lista atunci cnd este cazul. Autorii de
pachete pot lua de asemenea decizia de a nu deni aceast a list a, dac a nu vor ca programatorul care folose ste pachetul
s a execute instructiuni de genul import *. Fi sierul Sounds/Effects/__init__.py ar trebui s a contin a urm atoarele:
__all__ = ["echo", "surround", "reverse"]
n acest caz instructiunea from Sound.Effects import * ar nc arca cele trei submodule ale modulului
Sound.
Dac a variabila __all__ nu este denit a, instructiunea de import nu va importa toate submodulele ci va importa
numai pachetul Sound.Effects (eventual va executa codul de initializare din __init__.py) si apoi va importa toate
numele denite n pachet. Se vor importa si submodulele pachetului dac a acest lucru este specicat prin instructiuni
import. Priviti urm atorul cod :
import Sound.Effects.echo
import Sound.Effects.surround
from Sound.Effects import *
n exemplul anterior, modulele echo si surround sunt importate deoarece acest lucru este specicat (prin instructiuni
import) n cadrul pachetului Sound.Effects.
Nu este foarte ecient s a folositi instructiuni de tipul import *, pentru c a n acest fel codul dumneavoastr a va
deveni neclar, neind clar care anume module sunt nc arcate. Totu si dac a ati lansat interpretorul n mod interactiv,
puteti folosi astfel de instructiuni pentru a evita scrierea multor instructiuni.
n concluzie nu este nimic gre sit n folosirea unei instructiuni similare cu from Packet import submodul, de fapt
aceasta este notatia recomandat a.
6.4.2 Referentieri 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 referinte sunt att de ntlnite nct instructiunea import examinaez a nti
pachetul cel mai cuprinz ator, si apoi caut a n lista de directoare. Cu toate astea modulul surround poate folosi
mult mai simplu o instructiune import echo sau from echo import echolter. Dac a modulul ce se dore ste
importat nu se a a n pachetul curent, instructiunea import caut a mai sus n ierarhia de modul a pachetului.
Atunci cnd pachetele sunt strucuturate n subpachete, nu exist a o modalitate de a prescurta referirile la alte submod-
ule, ci trebuie folosite numele ntregi ale subpachetelor. De exemplu dac a modulul Sound.Filters.vocoder
are nevoie de modulul echo din pachetul Sound.Effects, poate folosi instructiunea: from Sound.Effects
import echo.
6.4. Pachete 43
44
CAPITOL
SAPTE
Intr ari si ie siri
Exist a cteva modalit ati de a prezenta rezultatele unui program. Datele pot a sate ntr-un format care poate nteles
de om, sau pot scrise ntr-un sier pentru a putea prelucrate mai trziu. Acest capitol va explica cteva dintre
posibilit ati.
7.1 Formatarea mai elegant a a datelor la ie sire
Pn a acum am ntlnit dou a metode de a a sa valori: instructiunea print si expresii. (O a treia metod a este folosind
metoda write() a obiectelor de tip sier. Fi sierul standard de ie sire este referit ca sys.stdout.)
Adesea veti dori s a aveti mai mult control asupra modului de a sare a valorilor. Exist a dou a metode pentru a controla
modul de a sare: prima este s a modicati singur un sir de caractere, folosind diversele operatii existente, iar apoi s a
l a sati. Modulul string contine cteva operatii utile pentru manipularea sirurilor de caractere. O a doua metod a
este folosirea operatorului %, cu un sir, ca argument stnga. Operatorul % interpreteaz a argumentul stnga n acela si
mod ca si sirul de formatare al functiei C sprintf() aplicndu-l asupra argumentului din dreapta si returnnd sirul
rezultat n urma ecestei format ari. O singur a ntrebare r amne: cum pot convertite valorile n siruri de caractere?
Din fericire Python poate converti orice tip de valoare n sir de caractere: e prin functia repr(), e scriind valoarea
ntre apostroafe (). Iat a cteva exemple:
Pn a acum am ntlnit dou a metode de a a sa valori: instructiunea print si expresii. (O a treia metod a este folosind
write() a obiectelor de tip sier. Fi sierul standard de ie sire este 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
>>> hellos = 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 ati de a genera un tabel cu p atratele si cuburile numerelor naturale:
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 string.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
Observati c a ntre coloane a fost ad augat un spatiu. Acest comportament este asigurat de modul n care lucreaz a
instructiunea print: ntotdeauna adaug a un spatiu ntre argumentele sale.
Acest exemplu demonstreaz a utilizarea functiei string.rjust(), care aliniaz a la dreapta un sir de caractere,
ntr-un cmp de o anumit a dimensiune dat a, introducnd spatii la stnga sirului. Exist a si alte functii similare
string.ljust(), string.center(). Aceste functii nu a seaz a nimic, nu fac dect s a returneze un alt sir
de caractere. Dac a sirul primit este mai lung, aceste functii nu l modic a, ci l returneaz a intact. Acest mecan-
ism probabil c a v a va strica aranjarea pe coloane, dar este o variant a preferabil a celeilalte, adic a trunchierea sir-
ului. Dac a doriti s a truchiati un sir, puteti oricnd s a folositi operatiile de portionare (slicing), ca de exemplu:
string.ljust(x,n)[0:n].
Mai exist a o functie util a, care umple cu zero-uri un sir, ad augndu-le la stnga sirului original, pn a cnd acesta
ajunge la o anumit a dimensiune. Aceast a functie este string.zfill():
>>> import string
>>> string.zfill(12, 5)
00012
>>> string.zfill(-3.14, 7)
-003.14
>>> string.zfill(3.14159265359, 5)
3.14159265359
Folosind operatorul % ar ar ata astfel:
46 Capitol 7. Intr ari si ie siri
>>> import math
>>> print Valoarea lui PI este aprox. %5.3f. % math.pi
Valoarea lui PI este aprox. 3.142.
Dac a exist a mai multe format ari n sir, trebuie s a se transmita ca operator dreapta 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 functioneaz a exact ca n C, si nu necesit a dect transmiterea corect a a operandului
din dreapta. Nerespectarea acestei reguli va genera o exceptie. Specicatorul de format %s este mai exibil, dac a
parametrul asociat din partea dreapt a nu este de tip sir de caractere, va automat convertit la sir de caractere folosind
functia integrat a str(). Specicatorii de format %u si %p din C nu sunt acceptati si de Python.
Dac a aveti un sir lung pe care nu doriti s a-l mp artiti n mai multe siruri, ar interesant s a v a puteti referi la vari-
abile prin nume n loc de pozitie. Acest lucru poate realizat folosind modalitatea numevariabila 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 doriti s a a sati variabilele predenite folosind functia vars() care
ntoarce un dictionar cu toate variabilele locale.
7.2 Fi siere
Functia open() are ca rezultat un obiect de tip sier, si este de cele mai multe ori apelat a cu doi parametrii: numele
de sier si modul de acces la sier:
>>> f=open(/tmp/workfile, w)
>>> print f
<open file /tmp/workfile, mode w at 80a0960>
Primul argument este un sir de caractere care contine numele sierului ce urmeaz a s a e deschis. Al doilea argument
este tot un sir de caractere ce contine doar cteva caractere ce descriu modul n care sierul va utilizat. Modul poate
:
- r = sierul va putea numai citit
- w = sierul va putea dect s a e scris (n cazul n care un sier exist a deja, 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 pot executa att operatii de scriere ct si de citire.
7.2. Fi siere 47
Pe Windows si Macintosh ad augarea caracterului b la sfr situl sirului prin care se specic a modul de acces, indic a
interpretorului Python s a deschid a sierul n mod binar. Exist a deci modurile de acces rb, wb, r+b. Windows face
distinctie ntre sierele de tip text si cele binare: caracterele de sfr sit de linie sunt modicate atunci cnd se scriu sau
se citesc date. Aceaste modic 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. Aveti deci grij a s a folositi modul binar cnd lucrati
cu astfel de siere.
7.2.1 Metodele obiectelor sier
Exemplele acestei sectiuni vor presupune c a un obiect f de tip sier a fost deja creat, deci sierul a fost deja deschis.
Pentru a citi continutul unui sier apelati f.read(dimensiune), care cite ste o cantitate de date si o returneaz a
ca string. Parametrul dimensiune este optional. Atunci cnd acest parametru este omis sau este negativ, ntregul sier
va citit si returnat ca sir de caractere. Apare o problem a binenteles dac a memoria ma sinii dumneavoastr a este mai
mic a dect dimensiunea sierului. Dac a parametrul dimensiune este transmis functiei din sier vor cititi cel mult
attia bytes cti sunt specicati prin acest parametru.
Dac a s-a ajuns la sfr situl sierului f.read() va returna un sir 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(newline), \n este ad augat la
sfr situl ec arui sir. Acest caracter este omis dac a este vorba despre ultima linie din sier si dac a acesta nu se termin a
cu un caracter linie nou a. Toate acestea fac rezultatul neclar. Dac a rezultatul este un sir gol, atunci a fost atins
sfr situl sierului, n timp ce dac a rezultatul este doar caracterul \n nseamn 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 continnd toate liniile din sier. Dac a metoda
este apelat a cu argumentul dimensiune, atunci din sier sunt cititi attia bytes cti sunt specicati prin acest parametru
si nc a attia bytes cti sunt necesari pentru a completa o linie. Aceast a metod a este folosit a pentru citirea ecient a pe
linii a sierelor de dimensiuni mari f ar a a ntmpina dicult ati cu memoria. Vor returnate numai linii complete:
>>> f.readlines()
[This is the first line of the file.\n, Second line of the file\n]
Metoda write( sir) scrie continutul sirului de caractere n sier, ntorc and None ca rezultat:
>>> f.write(This is a test\n)
f.tell() are ca rezultat un num ar ntreg reprezentnd pozitia cursorului n sier, pozitie m asurat a n bytes fat a
de nceputul sierului. Pentru a schimba pozitia cursorului folositi functia f.seek(deplasare,referinta).
48 Capitol 7. Intr ari si ie siri
Noua pozitie este calculat a n felul urm ator: cursorul va deplasat cu deplasare bytes, fat a de nceputul sierului
dac a referinta este 0, fat a de pozitia curent a a cursorului dac a referinta este 1 si fat a de sfr situl sierului
dac a referinta este 2. Dac a al doilea parametru este omis, valoarea lui implicit a va 0, deci punctul de referint a
va nceputul sierului:
>>> f=open(/tmp/workfile, r+)
>>> f.write(0123456789abcdef)
>>> f.seek(5) # Go to the 5th byte in the file
>>> f.read(1)
5
>>> f.seek(-3, 2) # Go to the 3rd byte before the end
>>> f.read(1)
d
Cnd terminati lucrul cu un sier, acesta trebuie nchis folosind f.close(). Dup a nchiderea sierului orice ncer-
care de operatie asupra sierului va e sua:
>>> f.close()
>>> f.read()
Traceback (most recent callk last):
ValueError: I/O operation on closed file
Obiectele sier posead a si alte metode, cum ar isatty() si truncate() care sunt mai putin folosite. (Consultati
"Python Library Refference" pentru mai multe detalii).
7.2.2 Modulul pickle
Sirurile de caractere pot citite si scrise foarte u sor dintr-un, respectiv ntr-un sier. Cu numerele lucrurile se complic a
putin. Ati putea s a transformati nainte de scrierea n sier, num arul n string, apoi s a l scrieti, iar la citire s a l
transformati napoi n num ar, dar un astfel de mecanism este complet inecient.
Pentru aceste situatii, si altele mult mai complicate Python dispune de modulul pickle care poate 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 string-ul poate salvat ntr-un sier, transmis n retea, etc.
Cea mai simpl a metod a de a 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 a si alte metode de a transforma un obiect ntr-un sir f ar a a-l salva ntr-un sier. Pentru mai multe detalii consultati
Python Library Refference.
Prin procedeele de pickling si unpickling, pickle poate stoca obiecte ce pot apoi reutilizate. Termenul tehnic
pentru un astfel de obiect este obiect persistent. Deoarece aceste metode sunt foarte des folosite, programatorii care
creeaz a extensii ale limbajului Python au grij a ca tipurile de date nou denite s a poat a salvate si nc arcate corect(mai
bine zis s a se comporte corect n procesul de pickling si apoi unpickling).
7.2. Fi siere 49
50
CAPITOL
OPT
Erori si exceptii
Pn a acum erorile au fost doar mentionate, dar dac a ati ncercat exemplele prezentate probabil ati si ntlnit cteva
dintre ele. Exist a (cel putin) dou a categorii de erori: erori de sintax a si exceptii.
8.1 Erori de sintax a
Erorile de sintax a sunt cel mai des ntlnite erori atta timp ct sunteti un ncep ator n limbajul Python:
>>> while 1 print Hello world
while 1 print Hello world
^
Interpretorul reproduce linia care a cauzat eroarea si a seaz a o s ageat a n dreptul instructinii care a generat eroarea.
Eroarea este cauzat a (sau cel putin detectat a) de instructiunea dinaintea s agetii. n exemplul de mai sus eroarea este
generat a de instructiunea print, deoarece naintea acestei instructiuni ar trebui s a existe un caracter :. Numele
sierului si num arul liniei care a generat eroarea sunt a sate, astfel nct dac a eroarea provine dintr-un script s a puteti
corecta ct mai comod.
8.2 Exceptii
Chiar dac a o expresie sau o instructiune este corect a din punct de vedere sintactic, aceasta poate genera o eroare n
momentul n care este executat a. Erorile generate (detectate) n timpul executiei se numesc exceptii, si nu sunt neap arat
fatale. Veti ntreba cum puteti evita astfel de erori utiliznd limbajul Python.
Majoritatea exceptiilor nu sunt tratate de program si genereaz a mesaje de eroare ca n exemplul de mai jos:
51
>>> 10 * (1/0)
ZeroDivisionError: integer division or modulo
>>> 4 + spam*3
NameError: spam
>>> 2 + 2
TypeError: illegal argument type for built-in operation
Ultima linie a mesajului de eroare indic a ce s-a ntmplat. Exceptiile sunt de diferite tipuri, iar tipul exceptiei este
de asemenea a sat n corpul mesajului de eroare. n exemplul anterior: ZeroDivisionError, NameError si
TypeError, sirul a sat ce desemneaz a tipul exceptiei este un nume predenit pentru respectivul tip de exceptie.
Acest lucru este valabil pentru toate exceptiile predenite, dar se pot deni si alte tipuri de exceptii.
A doua parte a liniei reprezint a detaliile exceptiei, descriind mai bine ce s-a ntmplat.
n Python Library Reference sunt listate exceptiile implicite si semnicatiile lor.
8.3 Tratarea exceptiilor
Este posibil s a scrieti programe care trateaz a anumite tipuri de exceptii . n urm atorul exemplu este implementat a o
bucl a care cere utilizatorului introducerea unui num ar. Bucla este ntrerupt a n momentul n care utilizatorul introduce
un num ar corect, astfel procesul de introducere continu a. Procesul poate ntrerupt folosind combinatia de taste
CTRL-C. Dac a utilizatorul folose ste aceast a combinatie de taste, programul este ntrerupt, dar nainte este generat a
exceptia: KeyboardInterrupt:
>>> while 1:
... try:
... x = int(raw_input("Please enter a number: "))
... break
... except ValueError:
... print "Oops! That was no valid number. Try again..."
...
Instructiunea try functioneaz a n felul urm ator:
nti sunt executate instructiunile din blocul try (blocul de instructiuni dintre instructiunile try si except).
Dac a nu este generat a nici o exceptie, instructiunile din blocul except nu sunt executate si programul continu a.
Dac a apare o exceptie n timpul executiei instructiunilor din blocul try si dac a tipul exceptiei este acela pe care
l trateaz a si blocul except, atunci instrutiunile din acest bloc nu sunt executate. Dup a ce exceptia este tratat a,
executia continu a, nemai executndu-se instructiunile r amase din blocul try (adic a instructiunile ce urmeaz a
dup a instructiunea care a generat exceptia).
Dac a exceptia nu este prev azut a ntre exceptiile tratate n blocul except, ea este transmis a altor structuri
try.Dac a nu este g asit un bloc except care s a trateze exceptia, programul este ntrerupt, iar respectiva exceptie
se nume ste exceptie netratata (unhandled exception).
52 Capitol 8. Erori si exceptii
O instructiune try poate avea mai multe clauze except, implementnd astfel mai multe tipuri de tratament pentru
mai multe tipuri de exceptii. Dintre toate clauzele except va executat a cel mult una. Instructiunile unei clauze
except, trateaz a numai exceptiile generate n blocul try c aruia clauza i este asociat a, nu si exceptiile ce pot apare
n alte clauze except. O astfel de clauz a poate trata mai multe tipuri de exceptii 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 specica ce anume exceptie trateaz a, n acest caz aceast a clauz a
trateaz a toate exceptiile netratate de celelalte clauze. Puteti folosi aceast a ultim a precautie, si este indicat s a o faceti,
pentru a ascunde toate erorile ce pot ap area si pe care nu le-ati anticipat. O puteti de asemenea folosi pentru a a sa un
mesaj de eroare si apoi a regenera exceptia, care 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, strerror)
except ValueError:
print "Nu poate fi convertit \^{i}ninteger"
except:
print "Eroare neasteptata:", sys.exc_info()[0]
raise
Instructiunile try dispun si de o clauz a optional a: else. Atunci cnd aceasta este folosit a, ea trebuie s a e ultima
dintre clauze. Instructiunile acestei clauze vor executate atunci cnd, blocul try nu genereaz a nici o exceptie. Iat a
un exemplu:
for arg in sys.argv[1:]:
try:
f = open(arg, r)
except IOError:
print cannot open, arg
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 exceptii care nu a fost generat a de instructiunile blocului try.
O exceptie poate avea asociat a si o valoare, un argument al exceptiei. Prezenta argumentului si tipul acestuia depinde
de tipul exceptiei. Pentru acele exceptii care au un argument, clauza except poate avea nume de varibil a, dup a
numele exceptiei, variabil a ce va contine(dac a acea exceptie este detectat a) argumentul asociat exceptiei. Urm atorul
exemplu este l amuritor n acest sens:
8.3. Tratarea exceptiilor 53
>>> try:
... spam()
... except NameError, x:
... print name, x, undefined
...
name spam undefined
Dac a o exceptie are un argument, acesta va a sat n ultima parte a mesajului ce apare cnd o exceptie nu este tratat a.
ntr-un bloc try nu sunt detectate numai exceptiile generate n cadrul functiilor apelate:
>>> def this_fails():
... x = 1/0
...
>>> try:
... this_fails()
... except ZeroDivisionError, detail:
... print Handling run-time error:, detail
...
Handling run-time error: integer division or modulo
8.4 Generarea exceptiilor
Instructiunea raise i permite programatorului s a genereze o anumit a exceptie :
>>> raise NameError, HiThere
NameError: HiThere
Primul parametru reprezint a tipul exceptiei, iar al doilea este optional si reprezint a un eventual argument.
Dac a se vrea s a se stie cnd o exceptie a fost semnalata a, dar nu se intentioneaz a tratarea ei, o form a mai simplicata a
a instructiunii raise permite reaparitia exceptiei :
>>> try:
... raise NameError, HiThere
... except NameError:
... print An exception flew by!
... raise
...
An exception flew by!
NameError: HiThere
8.5 Exceptii denite de utilizator
Un programator si poate crea propriile exceptii prin creare unei clase de exceptii noi. n mod obi snuit exceptiile pot
derivate din clasa Exception att nmod direct ct si indirect. De exemplu :
>>> class MyError(Exception):
... def __init__(self, value):
... self.value = value
... 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!
__main__.MyError: oops!
Clasele de exceptii pot proiectate ca oricare alta clas a, dar in mod uzual ele sunt simple, deseori oferind numai un
num ar de atribute, ce permit s a informeze asupra erorii ce a fost tratat a. Cnd se implementeaz a un modul care poate
genera un num ar distinct de erori, se obi snuie ste s a se creeze o clasa de baz a a exceptiilor denite de acest modul, si
subclase care s a creeze clase specice pentru diferite conditii de eroare :
8.5. Exceptii denite de utilizator 55
class Error(Exception):
"""Base class for exceptions in this module."""
pass
class InputError(Error):
"""Excetie generat\u{a} pentru eroare de intrare.
Atribute:
expression -- expresia de intrare \^{i}n care apare eroarea
message -- explicarea erorii
"""
def __init__(self, expression, message):
self.expression = expression
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}
Attributes:
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 imposibilitatea tranzi\c{t}iei
"""
def __init__(self, previous, next, message):
self.previous = previous
self.next = next
self.message = message
Multe exceptii sunt denite cu nume care se termina n Error, similar cu denumirea exceptiilor standard.
Multe module si denesc propriile exceptii pentru a raporta erorile ce pot ap area nfunctiile denite de ele. Mai multe
informatii despre clase veti g asi n capitolul refclasses, Classes..
8.6 Denirea actiunilor de cur atare
Instructiunea try poate avea si o alt a clauz a prin care se pot deni actiuni de cur atare care vor executate n orice
circumstant a. De exemplu:
>>> try:
... raise KeyboardInterrupt
... finally:
... print Goodbye, world!
...
Goodbye, world!
KeyboardInterrupt
Clauza nally este executat a dac a a fost sau nu generat a o exceptie n blocul try. Cnd apare o exceptie, este
regenerat a dup a ce sunt executate instructiunile clauzei finally. Clauza finally este de asemenea executat a la
ie sire, chiar si atunci cnd a fost apelat a o instructiune break sau return.
Codul scris ncalauza finally este util a pentru eliberarea resurselor externe (cum ar siere sau conect ari la retea),
fara a mai vedea daca utilizarea resurse s-a ncheiat cu succes.
O instructiune try trebuie e s a aibe una sau mai multe clauze except, e o clauz a finally, dar nu ambele n
acela si timp.
8.6. Denirea actiunilor de cur atare 57
58
CAPITOL
NOU
A
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 combinatie ntre mecanismele din C++ si Modula-3. La fel ca si pentru module, Python nu creeaz a o
barier a absolut a ntre denitie si utilizator, ci se bazeaz a mai mult pe politetea utilizatorului de a nu p atrunde n
denitie. Cele mai importante facilit ati ale claselor sunt n continuare disponibile.
n terminologie C++, toate componentele unei clase( si datele membre) sunt publice, si toate functiile membre sunt
virtuale. Nu exist a constructori sau destructori specializati. 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 denite cu un argument explicit reprezentnd
obiectul, care este apoi transmis automat n momentul n care functia este apelat a. Clasele sunt n sine obiecte, iar n
sens mai larg: n Python toate tipurile de date sunt obiecte, acest comportament este specic si limbajului SmallTalk.
Prin toate acestea sunt posibile importurile si redenumirile. La fel ca n C++ si Modula-3, tipurile predenite nu pot
denite drept clase de baz a pentru eventuale extensii. De asemenea, la fel ca n C++, dar spre deosebire de Modula-3,
majoritatea operatorilor cu sintax a special a(de exemplu: operatorii aritmetici) pot redeniti 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 si C++. Am putea folosi termenii din Modula-3, deoarece semantica acestui limbaj este mai aproape de
cea a Python-ului, dar foarte putini utilizatori au auzit de acest limbaj, de si C++ si SmallTalk sunt o alegere mult mai
bun a, ind limbaje cu o popularitate mult mai mare.
Va trebui de asemenea s a avertiz am cititorii asupra unei gre seli pe care o pot face n interpretarea celor ce urmeaz a:
cuvntul obiect n Python nu nseamn a neap arat o instantiere a unei clase. n C++, Modula-3, de asemenea si n
Python, dar nu si n SmallTalk, exist a anumite tipuri de date care nu sunt neap arat clase: numerele ntregi si listele nu
sunt clase, dar si alte tipuri de date mai exotice, cum sunt sierele nu sunt 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
cuvntul obiect.
Obiectele pot avea individualitate, sau pot avea mai multe nume(care pot servi mai multor scopuri) care s a desemneze
acela si obiect. Aceast procedeu se nume ste aliasing n alte limbaje. De obicei n Python, la prima vedere, nu sunt n-
curajate astfel de tehnici, care pot foarte bine ignorate cnd este vorba despre tipurile de date nemodicabile(numere,
siruri, perechi). n orice caz, tehnica aceasta, aliasing, are si un efect intentionat asupra sintaxei Python care prive ste
obiectele alterabile (liste, dictionare, etc.) si obiectele ce exist a n afara contextului n care se a a programul ( siere,
ferestre. etc.). Puteti utiliza tehnica aliasing, pentru a benecia de puterea oferit a n alte limbaje, de pointeri, n-
truct puteti considera c a alias-urile functioneaz 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 pointer. Dac a o functie prime ste ca parametru un
obiect pe care l modic a, cel ce a aplelat functia va putea observa efectul functiei, deoarece modic arile efectuate
de functie au fost f acute asupra continutului obiectivului si nu asupra unui reprezent ari locale(n contextul functiei).
Explicnd toate acestea se observ a necesitatea a dou a mecanisme de transmitere a parametrilor ca n Pascal.
59
9.2 Domenii de vizibilitate (Scopes) si domenii de denitie a nu-
melor(Name Spaces)
1
Denitiile claselor manipuleaz a ntr-un mod foarte interesant domeniile de denitie a numelor, si o foarte bun a
ntelegere a modului de functionare a domeniilor de vizibilitate si de denitie a numelor este foarte impotant a.
ntelegerea acestor mecanisme este foarte important a si se va dovedi foarte util a oric arui programator avansat Python.
S a ncepem cu cteva denitii:
Un domeniu de denitii a numelor este o hart a de leg aturi ntre nume si obiecte. n momentul de fat a aceste domenii
sunt implementate folosind dictionare, dar metodele de implementare pot schimbate pe viitor. Exemple de astfel
de domenii sunt: domeniul numelor predenite, domeniul numelor globale dintr-un modul, domeniul numelor locale
creat la apelarea unei funtii, etc. ntr-un anumit sens atributele unui anumit obiect formeaz a un domeniu de denitie.
Un lucru foarte important de stiut este acela c a ntre dou a nume existente n dou a domenii diferite nu exist a absolut
nici o leg atur a. Din aceast a cauz a dou a module pot deni o functie 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 atribut al obiectului
z. ntr-un sens strict, referintele la nume denite ntr-un modul sunt de fapt referinte la atribute ale modulului: n
expresia modul.functie, modul este modulul iar functie este un atribut al modulului.
Numele globale ale modulului si atributele modulului se a a n acela si domeniu de denitie al numelor.(Exist a o
singur a exceptie. Modulele au un atribut nemodicabil (read-only) secret: __dict__ n care se a a domeniul de
denitie al numelor ce apartine modulului. __dict__ este un atribut dar nu este un nume global.)
Atributele pot nemodicabile(read-only) sau modicabile(writeable). Atributele unui modul sunt modicabile:
puteti folosi o secvent a de genul: modul.raspuns = 42. Atributele modicabile pot de asemenea sterse
folosind operatorul del. De exemplu del modul.raspuns va elimina atributul raspuns din obiectul denumit
modul.
Domeniile de denitie a numelor sunt create la momente de timp diferite si au perioade de viat a diferite. Domeniul
care contine numele predenite este creat odat a cu pornirea interpretorului Python si nu este sters niciodat a. Domeniul
numelor globale denite ntr-un modul este creat atunci cnd este nc arcat a denitia modulului si este distrus de
obicei tot n momentul n care interpretorul este nchis. Instructiunile executate la primul nivel al interpretorului e
dintr-un script, e interactiv, fac parte dintr-un modul numit __main__. Numele predenite se a a n domeniul
__builtin__.
Domeniul de denitie a numelor pentru o functie este creat odat a cu apelul functiei, si este sters odat a cu terminarea
functiei, e prin return, e dac a acesta genereaz a o exceptie netratat a. Binenteles c a apeluri recursive genereaz a
mai multe domenii de denitie.
Un domeniu de vizibilitate (scope) este o regiune a unui program Python n care un anumit domeniu de denitie a
numelor este accesibil. Accesibil nseamn a c a o anumit a referint a la un nume va genera o c autare n domeniul de
denitie al acelui modul dspre care spunem c a este accesibil.
Domeniile de vizibilitate sunt determinate static, si sunt folosite dinamic. n timpul executiei exist a exact trei domenii
de vizibilitate (exact trei domenii de denitie sunt direct accesibile): primul cel mai adnc, contine numele locale,
cel de-al doilea contine 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, si care contine numele predenite.
De obicei, cel mai adnc domeniu de vizibilitate este cel al functiei care este executat a. n exteriorul unei functii,
acest domeniu este identic cu al doilea domeniu (cel din mijloc), n care se a a accesibile denitiile modulului.
Domeniul de vizibilitate global al unei functii denite ntr-un modul este domeniul de denitii al respectivului modul,
indiferent de unde, sau cu ce alias este apelat a respectiva functie. Pe de alt a parte c autarea unui anumit nume este
realizat a dinamic, n timpul executiei. Cu toate astea denitia limbajului evolueaz a c atre o rezolutie a numelor
1
(N.T. Traducerile celor doi termeni n limba romn a sunt improprii, iar ntelegerea acestor termeni ar trebui s a e mai mult o ntelegere
contextual a nednd o prea mare important a sensului pe care o are traducerea celor doi termeni).
60 Capitol 9. Clase
static a, n timpul compil arii. n concluzie nu v a bazati prea tare pe varianta dinamic a. Deja variabilele locale sunt
determinate static.
O caracteristic a a limbajului 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 realizeaz a o copiere a datelor ci leag a nume
de obiecte. Acest lucru este valabil si pentru stergeri. Instructiunea del x sterge leg atura lui x din domeniul local de
denitie. De fapt toate operatiile care introduc nume noi au impact asupra domeniului de denitii local: instructiunile
import sau denitia unei functii introduc numele modulului importat, respectiv numele functiei n domeniul de
denitii local. Dac a este folosit a instructuinea global se indic a intrepretorului ca urm atorul nume s a e introdus n
domeniul global.
9.3 O prim a privire asupra claselor
Notiunea de clase aduce cu sine si cteva alte notiuni noi de sintax a, trei tipuri noi de obiecte, si cteva notiuni noi de
semantic a.
9.3.1 Denirea unei clase
Cea mai simpl a denitie a unei clase arat a astfel:
class ClassName:
<statement-1>
.
.
.
<statement-N>
Denitiile de clase, la fel ca denitiile de functii, sunt valabile de abia dup a ce sunt executate. Puteti insera o denitie
de clas a n cadrul unei instructiuni if, si clasa nu va exista dect dac a conditia instructiunii if va adev arat a.
n practic a, instructiunile din interiorul unei clase vor denitii de functii, dar sunt permise si alte instructuni care pot
foarte utile uneori. Denitiile de functii din cadrul unei clase sunt un pic deosebite fat a de ce cunoa steti, dar despre
asta vom vorbi mai trziu.
Atunci cnd este introdus a denitia unei clase noi, un nou domeniu de denitii a numelor este creat si folosit ca
domeniu de vizibilitate local, deci toate atribuirile vor afecta noul domeniu de denitii creat. Denitiile de functii vor
introduce numele acelor functii tot n acest domeniu.
Cnd denitia unei clase se termin a normal, f ar a erori, este creat un obiect nou de tipul class. Pe scurt, acest obiect
contine noul domeniu de denitii creat odat a cu denitia clasei. n urm atoarea sectiune vom discuta mai mult despre
obiecte de tip class. Domeniul de vizibilitate existent naintea denitiei clasei este reactivat, si obiectul class este
introdus n respectivul domeniu de denitii sub numele dat de numele specicat n denitia clasei (n exemplul de mai
sus: ClassName).
9.3.2 Obiecte class
Aceast a categorie de obiecte accept a dou a categorii de operatii: referentieri de atribute si instantieri.
Referentierile de atribute folosesc sintaxa standard din Python: obiect.atribut. Atribute valide sunt toate numele
existente n domeniul de denitii n momentul cre arii obiectului class. A sa c a, dac a denitia clasei arat a astfel:
9.3. O prim a privire asupra claselor 61
class MyClass:
"Un exemplu simplu de clasa"
i = 12345
def f(self):
return hello world
Atunci MyClass.i si MyClass.f sunt referinte la atribute valabile. Unul dintre atribute este un ntreg (i), iar
cel alalt o metod a(f). Se pot realiza atribuiri cu atributele unei clase, deci puteti modica valoarea atributului My-
Class.i printr-o atribuire. __doc__ este de asemenea un atribut al clasei, care are valoare Un exemplu simplu de
clasa.
Instantierea claselor folose ste notatia de la functii. Putem s a ne imagin am c a obiectul clas a este o functie f ar a
parametrii care ntoarce ca rezultat o nou a instant a pentru respectiva clas a: Exemplul urm ator:
x = MyClass()
creeaz a o nou a instant a a clasei si atribuie acest obiect variabilei locale x.
Operatia de instantiere creaz a un obiect vid. Multe clase prefer a s a creeze un obiect ntr-o stare initial a. Pentru a
realiza acest lucru o clas a trebuie s a aib a denit 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 denit a metoda __init__(), instantierea respectivei clase apeleaz a automat metoda
__init__(). n acest fel se poate obtine o instant a initializat a a unei anumite clase:
x = MyClass()
Binenteles metoda __init__() poate avea argumente. n acest caz argumentele primite la instantierea clasei sunt
transmise automat metodei __init__(). De exemplu:
>>> class Complex:
... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex( 3.0, -4.5)
>>> x.r, x.i
(3, 0, 4.5)
V a puteti gndi la metoda __init__() ca la un constructor, de si nu este un constructor n toat a puterea cuvntului.
9.3.3 Obiecte instantiate
Ce putem face cu instantele? Singurele operatii acceptate sunt operatiile cu atribute. Exist a dou a tipuri de nume de
atribute valide.
Prima categorie: propiet atile sau atribute de tip dat a. Aceast a categorie corespunde variabilelor instantei n
SmallTalk, si membrilor dat a n C++, create automat atunci cnd le sunt atribuite valori. Dac a x este o instant a
a clasei MyClass urm atoarea portiune de cod va a sa valoarea 16:
62 Capitol 9. Clase
x.counter = 1
while x.counter < 10:
x.counter = x.counter * 2
print x.counter
del x.counter
A doua categorie sunt metodele. O metod a este o functie ce apartine unui anumit obiect.(n Python termenul de
metod a nu desemneaz a doar o functie ce apartine instantei numai clase, adic a unui obiect; si alte tipuri de obiecte
au metode. De exemplu, 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 denit).
Numele de metode disponibile pentru un anumit obiect depind de clasa din care face parte obiectul. Prin denitie,
toate atributele de tip functie ale unei clase devin metode pentru toate instantele respectivei clase. n exemplul nostru
x.f este o metod a valabil a din moment ce MyClass.f este o functie, n mod contrar, este evident c a x.i nu este o
metod a. MyClass.i nu este o functie. Exist a o diferent a ntre MyClass.f si x.f: prima este un obiect functie iar
cea de-a doua un obiect metod a(una este functie, a doua metod a).
9.3.4 Obiecte metod a
n mod uzual o metod a este apelat a imediat:
x.f()
n exemplul nostru aceasta va returna sirul de caractere Hello World!. Oricum nu este 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 innit.
Ce se ntmpl a exact atunci cnd este apelat a o metod a? Ati observat c a x.f a fost apelat a f ar a nici un argument,
chiar dac a n denitia functiei era specicat un argument.
Ce s-a ntmplat cu argumentul? Cu sigurant a Python genereaz a o exceptie atunci cnd o functie care necesit a un
argument(de si poate s a nu aibe neap arat nevoie de acesta), este apelat a f ar a argumente.
Probabil c a ati ghicit deja r aspunsul: metodele au ntotdeauna ca prim parametru 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 functia corespondent a insernd la nceputul listei de n argumente obiectul a c arui metod a se dore ste apelat a.
Dac a nu ati nteles nc a cum functioneaz a metodele, o privire asupra implement arii probabil c a ar clarica lucrurile.
Atunci cnd se face o referire la un atribut al unei instante care nu este un atribut dat a, clasa din care face parte este
c autat a. Dac a numele denot a un atribut existent n respectiva clas a(deci un obiect de tip functie), este creat un obiect
metod a punnd laolalt a(mpachetnd) obiectul instant a si obiectul functie(tocmai g asit). n acest fel se creeaza un
obiect metod a. Atunci cnd o metod a este apelat a cu o list a de argumente, obiectul metod a este despachetat, o nou a
list a de argumente este construit a ad augnd la nceputul listei de argumente obiectul instant a ca prim parametru. n
cele din urm a obiectul functie este apelat cu noua list a de argumente.
9.3. O prim a privire asupra claselor 63
9.4 Alte observatii
Atributele dat a suprascriu atributele metod a cu acela si nume. Pentru a evita conicte de nume ce pot cauza defectiuni
greu de g asit n programe mari, este bine s a folositi o conventie pentru denumiri pentru a minimiza sansa aparitiei unor
astfel de conicte. O posibil a conventie ar scrierea numelelor de metode cu liter a initial a mare, prexarea numelor
de atribute dat a cu un sir de caractere mic si unic, (poate un underscore), sau pentru metode folositi verbe, iar pentru
propiet ati substantive.
Propiet atile pot accesate att de metode, ct si de utilizatorii unui anumit 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 ascundere
a datelor aceasta realizndu-se numai prin conventie. (Pe de alt a parte, implementarea limbajului Python, relizat a n
C, poate ascunde complet detalii de implementare controlnd accesul la datele unui obiect, dac a o astfel de abordare
este necesar a).
Utilizatorii unui obiect ar trebui s a manipuleze atributele dat a (propietatile) cu atentie orice modicare direct a a
acestora putnd duce la o incoerent a a obiectului respectiv. De notat este faptul c 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 conicte de nume( si aici
existenta unei conventii 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 claric a codul unei
metode, nemaiexistnd posibilitatea confuziei ntre variabilele locale si variabilele instantei.
n mod conventional, primul argument al unei metode are numele: self. Aceasta este numai o conventie, numele
self neavnd nici o semnicatie special a n Python.(Folosind aceast a conventie codul dumneavoastr a va mai u sor
de citit de c atre programatori).
Orice obiect functie ca atribut al unei clase dene ste o metod a asociat a pentru instantele unei clase. Nu este neap arat
necesar ca denitia unei functii s a se ae n cadrul denitiei clasei. n acest sens se poate atribui un obiect functie 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, si h sunt toate atribute ale clasei C, si sunt atribute functiei, si n mod consecvent sunt metode pentru toate
instantele clasei C. Aceast a practic a nu este indicat a, ntruct nu face dect s a ncurce cititorul programului.
Metodele pot apela 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 functiile obi snuite. Domeniul global de vizibilitate asociat
unei metode permite accesul la domeniul de denitie a numelor asociat modului n care se a a denit a clasa c areia i
apartine metoda.
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 existenta acestuia.
9.5 Mo stenirea
Nu putem spune despre un limbaj c a este orientat obiect, dac a sistemul de clase nu pune la dispozitie mecanismul
de mo stenire. Sintaxa pentru mo stenire (adic a pentru crearea denitiei 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 denit a pentru ca denitia clasei derivate s a e corect a. n loc de un nume de
clas a puteti folosi o expresie, acest lucru ind foarte util 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 a si clasa 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 si n clasa
de baz a. Regula se aplic a recursiv dac a clasa de baz a este la rndul ei o clas a derivat a.
Instantierea unei clase se face la fel ca pn a acum. Dac a este apelat a o metod a a unei instante, numele metodei este
c autat nti n denitia clasei derivate, apoi n denitia clasei de baz a, si a sa mai departe pn a cnd este g asit un obiect
functie corespunz ator n lantul 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 alt a metod a a aceluia si obiect, o metod a a clasei de baz a care apeleaz a o alt a metod a, denit a de
asemenea n clasa de baz a, poate s a apeleze de fapt o metod a suprascris 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 clasei de baz a direct: ClasadeBaza.metoda(self.argumente).
Acest lucru poate foarte util chiar si utilizatorilor(clientilor) unei clase.
9.5.1 Mo stenirea multipl a
Python pune la dispozitia programatorilor si o form a de mo stenire multipl a. O denitie 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 este denit n clasa derivat a atunci acesta
este c autat n denitia clasei Base1 si n toate clasele de la care aceasta mo stene ste, apoi este c autat n Base2 si
n Base3 dup a acelea si reguli. Putem rezuma aceast a regul a n felul urm ator: nti n adncime, si de la stnga la
dreapta. (Avantajele si dezavantajele acestei reguli pot discutate, ns a trebuie s a e foarte clar pentru toat a lumea
c a o astfel de regul a este absolut necesar a, fapt sucient de evident).
Este sucient de clar c a folosirea mecanismului de mo stenire multipl a va crea mari probleme de ntretinere, deoarece
n Python conictele ce pot ap area ntre nume sunt evitate numai prin conventii. O problem a cunoscut a apare 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 n acest caz, nu este clar c a regulile vor de folos pentru claricarea situatiei.
9.6 Variabile private
Exist a un suport limitat pentru identicatorii clselor private. Orice identicator de forma __spam (cel putin dou a
underscore nainte, cel mult un underscore dup a) este acum textual nlocuit cu _claa__spam, unde clasa este
numele curent al clasei cu underscor-urile din fat a suprimate. Mutilarea este realizat a fara o analiza a pozitiei sintactice
a identicatorului, a sa nc at putnd folosit a la denirea unei instantieri a unei clase private si a variabilelor si
metodelor clasei ca globale, si la memorarea instantierii variabilelor private naceast a clas a la instantierea altei 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 underscor-uri nu se face eliminarea underscor_urilor.
Acest mecanism pune la dispozitia programatorului o metod a foarte facil a de a crea atribute private, f ar a a- si face griji
c a aceste atribute pot provoca conicte de nume. Toate acestea sunt realizate n Python pentru a preveni eventualele
erori, totu si, este n continuare posibil a modicarea atributelor private, ceea ce se poate dovedi foarte util n anumite
cazuri 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).
Observati c a, codul ce este trimis instructiunilor exec, eval() sau evalfile() nu ia n considerare numele
clasei care realizeaz a invoc arile, acest efect ind similar celui realizat prin instructiuni global, efect ce nu poate
obtinut pentru cod compilat. Aceea si restrictie se aplic a si pentru getattr(), setattr() si delattr(), de
asemenea si pentru accesarea direct a a dictionarului __dict__.
Iat a un exemplu de clase care implementeaz a propriile metode __getattr__() si __setattr__(), si 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 din Pascal, sau struct din C, tipuri
de date care s a adune la un loc mai multe date de diferite tipuri. Pentru a realiza acest lucru puteti folosi clasele. O
denire 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.salary = 1000
S a construim un alt scenariu: presupunnd c a aveti o functie care prelucreaz a anumite date dintr-un obiect sier, puteti
s a deniti o clas a cu metodele read() si readline() care s a citesc a informatii dintr-un sir de caractere n loc de
un sier.
Metodele obiectelor au de asemenea atribute: metoda.im__self reprezint a obiectul de care apartine metoda spec-
icat a, iar metoda.im__func reprezint a functia corespunz atoare metodei.
9.7.1 Exceptiile pot clase
Exceptiile denite de utilizator pot att obiecte de tip string, ct si clase. Folosind clasele pentru a deni exceptii,
puteti crea o ntreag a ierarhie de exceptii care poate foarte u sor extins a.
Exist a o alt a form a a insructiunii raise:
raise Class, instance
raise instance
n prima form a instance trebuie s a e o instant a a clasei Class sau a unei clase derivate. A doua form a este o
prescurtare pentru:
raise instance.__class__, instance
O clauz a except poate a sa att exceptii de tip clas a, ct si de tip sir de caractere. 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"
except B:
print "B"
De observat c a dac a ordinea clauzelor except ar fost invers a, (cu except B la nceput), exemplul ar a sat B,
B, B; deoarece clasa B este clasa din care sunt derivate clasele C si D.
Cnd un mesaj de eroare este a sat pentru o exceptie 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 Python. Ce ar trebui s a faceti de acum
ncolo?
Ar trebui s a cititi, sau cel putin s a r asfoiti Python Library Reference,document ce explic a foarte detaliat ecare functie,
tip de date, modul, etc. existent n Python. Distributia standard de Python contine o cantitate imens a de cod scris att
n C, ct si n Python, exist a module UNIX ce pot folosite pentru a citi c asutele de po st a electronic a, module care
faciliteaz a lucrul cu protocolul HTTP, module pentru generarea numerelor aleatoare, etc.
Un site foarte util este http://www.python.org. Aici exist a documentatii buc ati de cod scrise de alti program-
atori si link-uri legate de Python.
Copii ale acestui site exist a pe serverele din ntreaga lume (Europa, Australia, Japonia, etc). n functie de locul n care
v a aati, pentru o vitez a de acces mai mare, puteti folosi una dintre aceste copii. Un alt site ce se poate dovedi foarte
util este http://starship.python.net.
Pentru ntreb ari sau raportarea anumitor probleme puteti folosi grupul comp.lang.python, sau puteti scrie la Python-
list@python.org. n ecare zi sunt puse n jur de 120 de ntreb ari care, de obicei, si g asesc r aspunsul.
nainte de a pune o ntrebare, vericati lista ntreb arilor puse frecvent (Freqvently Asked Questions = FAQ) care poate
g asit a la adresa http://www.python.org/doc/faq.html. R aspunsurile de la aceast a adres a, la diferite
ntreb ari puse de alti programatori, v a pot ajuta de foarte multe ori n rezolvarea problemelor dumneavoastr a.
69
70
ANEXA
A
Editarea n linie de comand a si repetarea
comenzilor anterioare
Unele versiuni ale interpretorului Python suport a editarea n linie de comand a si repetarea unor comenzi anterioare,
facilit ati ntlnite n shell-urile Korn sau GNU Bash. Aceste facilit ati sunt implementate folosind biblioteca GNU
Readline care suport a stilurile de editare specice Emacs si Vi. Aceast a bibliotec a are propria documentatie pe care
nu o vom reproduce aici, ci vom face numai o scurt a introducere.
Facilit atile despre care v a vom vorbi sunt disponibile n versiunile UNIX si CygWin ale interpretorului.
Acest capitol nu va explica facilit atile pachetelor Mark Hammonds Python Win sau IDLE distribuite odat a cu Python.
A.1 Editarea n linie de comand a
Dac a este suportat a, aceast a facilitate va disponibil a atunci cnd interpretorul a seaz a promptul principal sau cel
secundar.
Linia curent a poate editat a folosind caracterele de control conventionale 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 liniei;
C-B mut a cursorul cu o pozitie la stnga;
C-F mut a cursorul cu o pozitie la dreapta;
BACKSPACE sterge caracterul de la stnga cursorului;
C-D sterge caracterul de la dreapta cursorului;
C-K sterge tot ce urmez a pe linie n dreapta cursorului;
C-Y reface ultimul sir sters cu C-K;
C-_ anuleaz a ultima comand a efectuat a. Operatia 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 instructiune
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 atoarea instructiune din buffer.
Orice linie din buffer poate modicat a. Dac a o linie a fost modicat a veti vedea un caracter * n fata acesteia care
ndic a c a a fost modicat a. O instructiune 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 n sens normal.
A.3 Redenirea tastelor functionale
Tastele functionale si alti parametrii ai bibliotecii Readline, pot redeniti prin modicarea sierului
/.inputrc.
Pentru a redeni functia unei combinatii de taste trebuie folosit a sintaxa:
tasta:functie sau sir de caractere:functie.
O optiune poate setat a folosind
set optiune valoarenoua.
Iat a un exemplu:
# Prefer stil de editare Vi:
set editing-mode vi
# Editare pe o singura linie:
set horizontal-scroll-mode On
# Redefinesc cateva taste:
Meta-h: backward-kill-word
"\C-u": universal-argument
"\C-x\C-r": re-read-init-file
n Python principala functie pentru Tab este aceea de a insera Tab, nu functia de completare Readline. Dac a se
dore ste ns a utilizarea sa n functia de completare se va pune :
Tab: complete
n /.inputrc. (Bine nteles c a acum va mai dicil de a scrie spatiile de aliniere)
Completarea automat a a numelui unei variabile, sau a unui modul, este optional a. Pentru a o activa n modul de lucru
interactiv ad augat n sierul de startup urm atoarele :
1
import rlcompleter, readline
readline.parse_and_bind(tab: complete)
Aceasta leag a tasta Tab de functia de completare, deci ap asnd tasta Tab de doua ori activeaz a completarea; anal-
izeaz a numele instructiunii Python, variabilele locale curente si numele de module disponibile.Pentru expresiile
cu punct de tipul string.a, evalueaz a expresia pn a la nal, dup a . si apoi sugereaz a completarea dat a de
atributele obiectelor rezultate. De retinut c a se poate executa codul unei aplicatii denite 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 el i si sterge numele pe care le creaz a n
momentul n care nu-i mai sunt necesare. Acest lucru se petrece cnd sierul de starup se execut a n acela si domeniu de
denitie ca si comenzile interactive, iar eliminarea numelor evit a generarea unor efecte colaterale n mediul interactiv.
1
Python va executa continutul unui sier identicat prin variabila de mediu PYTHONSTARTUP n momentul pornirii interpretorului interactiv.
72 Anexa A. Editarea n linie de comand a si repetarea comenzilor anterioare
Puteti g asi acest lucru convenabil pentru a p astra cteva module importate, cum ar os, si 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 Python 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 .
import atexit
import os
import readline
import rlcompleter
historyPath = os.path.expanduser("~/.pyhistory")
def save_history(historyPath=historyPath):
import readline
readline.write_history_file(historyPath)
if os.path.exists(historyPath):
readline.read_history_file(historyPath)
atexit.register(save_history)
del os, atexit, readline, rlcompleter, save_history, historyPath
A.4 Comentarii
Aceste facilit ati reprezint a un pas enorm comparativ cu versiunile anterioare ale interpretorului; oricum au r amas
cteva deziderate nemplinite : ar frumos ca s a e sugerat un alineat corect la continuarea unei linii (analizorul
sintactic stie dac se va cere un alineat). Acest nou mecanism ar putea utiliza tabela de simboluri a interpretorului.
Util ar si un mecanism care s a verice (sau s a sugereze) potrivirea parantezelor, ghilimelelor, etc.
A.4. Comentarii 73
74
ANEXA
B
Aritmetica n virgul a otant a: rezultate si
limit ari
Numerele n virgul a otant a sunt reprezentate n hardware-ul calculatorului ca fractii n baza 2 (binare). De exemplu,
fractia zecimal a
0.125
are valoarea 1/10 + 2/100 + 5/1000, si n acela si fel fractia binar a
0.001
are valoarea 0/2 + 0/4 + 1/8. Aceste dou a fractii au aceea si valoare, singura diferent a real a ind c a prima este scris a
n baza 10, iar a doua n baza 2. Din p acate majoritatea fractiilor zecimale nu pot reprezentate corect ca fractii
binare. O prim a concluzie este c a, (n general, numerele n virgul a otant a zecimal a pe care le introduceti au numai o
reprezentare aproximativ a prin numerele n virgul a otant a binar a memorate n calculator.
Problema este u sor de nteles nt n baza 10. S a consider am fractia 1/3. O putet aproxima cu o fractie baza 10:
0.3
sau, mai precis,
0.33
sau , si mai precis,
0.333
si tot a sa. Nu conteaz a ce num ar de digiti veti scrie, rezultatul nu va nicicd exact 1/3, dar cre ste acuratetea aprox-
im arii lui 1/3.
n acela si mod, nu conteaz a cti digiti n baza 2 folositi, valoarea zecimal a 0.1 nu va reprezentat a exact niciodat a
printr-o fractie. n baza 2, 1/10 este o fractie care se repet a la innit
0.0001100110011001100110011001100110011001100110011...
Oprirea la un num ar nit de biti d a o aproximare. Iat a ce se a seaz a n situatia urm atoare :
75
>>> 0.1
0.10000000000000001
Pe majoritatea ma sinilor existente ast azi acest rezultat se a seaz a dac a introduceti 0.1 la prompterului Python-ului.
Se ntmpl a a sa pentru c a num arul de biti utilizati de hardware s a mememoreze valoarea n virgul a otant a variaz a
de la o ma sin a la alta, iar Python listeaz a doar o aproximatie zecimal a a valorii zecimale reale a aproximatiei binare
memorat a n ma sin a. Pe majoritatea ma sinilor, dac a Python va tip ari valoarea zecimal a real a a aproximatiei binare
memorate pentru 0.1, va a sa
>>> 0.1
0.1000000000000000055511151231257827021181583404541015625
Prompterul Python utilizeaz a functia implicit a repr() ca s a obtin a o versiune de sir pentru toate obiectele pe care le
a seaz a. n cazul numerele otante repr(oat) rotunje ste valoarea zecimal a la 17 digiti semnicativi, astfel
0.10000000000000001
repr(oat) folose ste 17 biti semnicativi pentru c a sunt considerati sucienti pe majoritatea ma sinilor, a sa c a relatia
eval(repr(x)) == x este exact a pentru toate numerele otante nite x, dar rotunjirea la 16 biti nu este sucient a
pentru a face relatia 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 a si veti constata o astfel de anomalie n toate limbajele care folosesc aritmetica n virgul a otant a oferit a
de hardware (unele limbaje pot s a nu a seze implicit diferenta)
Functia intern a Python str() genereaz a numai 12 digiti semnicativi si poate c a doriti s a o folositi modicat a. Este
des utilizat a functia eval(str(x)) pentru a-l obtine pe x, dar este mai placut s a se a seze :
>>> print str(0.1)
0.1
E bine de stiut 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 este urmata de altele. De exemplu dup a ce se a seaz a
>>> 0.1
0.10000000000000001
apare tentatia s a utilizati functia round() ca s a trunchiati iar a si la un digit. 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 acut a n cea mai bun a aproximare
binar a posibil a la 1/10, deci orice alt a rotunjire ulterioar a nu o poate face mai bine : a fost dat a deja cea mai bun a
solutie.
Alt a consecint a a faptului c 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 obtine
1.0:
76 Anexa B. Aritmetica n virgul a otant a: rezultate si limit ari
>>> sum = 0.0
>>> for i in range(10):
... sum += 0.1
...
fs>>> sum
0.99999999999999989
Aritmetica binar a n virgul a otant a are multe surprize de acest gen. Problema cu "0.1" este explicat a n sectiunea
urm atoare, "Erori de reprezentare". Vezi : The Perils of Floating Point privind tratarea complet a a altor surprize de
acest gen.
Cum s-ar spune la sfr sit: "nu este u sor de r aspuns". Totu si nu disperati din cauza rgulei otante! Erorile operatiilor
de otant a din Python sunt mo stenite de la virgula otant a a hardware-ului si la majoritatea ma sinilor sunt de un ordin
mai mic de 1/2**53 pe operatie. Acestea sunt mai mult dect acceptabile pentru cele mai multe aplicatii, dar trebuie
s a retineti c a nu sunt datorate aritmeticii zecimale si c a la ecare operatie nvirgul a otant a apare o eroare de rotunjire.
Pn a la aparitia unor cazuri patologice, pentru cele mai multe situatii de utilizare a aritmeticii nvirgul a otant a se
obtin rezultatele a steptate, dac a pur si simplu se rotunje ste rezultatul nal a sat la num arul de zecimale dorit. Uzual
functia str() este sucient a, iar pentru un control mai riguros a se vedea discutia despre operatorul de format % :
formatele %g, %f si %e sunt moduri exibile si u soare pentru a sarea rezultatelor.
B.1 Erori de reprezentare
Sectiunea explic a ndetaliu exemplul "0.1" si arat a cum se poate face o analiz a exact 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 fractiile zecimale nu se pot reprezenta exact ca fractii binare (n baza
2). Acesta este motivul major pentru care Python (sau Perl, C, C++,Java, Fortran, si multe altele) nu a seaz a valoarea
exact a a num arului zecimal pe care-l a steptati :
>>> 0.1
0.10000000000000001
Ce este asta? 1/10 nu este reprezentat exact ca o fractie binar a. Cele mai multe ma sini utilizeaz a ast azi (noiembrie
2000) aritmetica de virgul a otant a IEEE-754 si cele mai multe platforme mapeaz a otantele Python n"dubl a precizie"
IEEE-754. Dublele 754 au 53 biti de precizie. A sa c a la intrarea n calculator se chinuie s a converteasc a 0.1 ncea mai
apropiat a fractie posibil a de forma J/2**N, unde J este un ntreg de exact 53 de biti. Se rescrie
1 / 10 ~= J / (2**N)
ca
J ~= 2**N / 10
si reapelnd J are exact 53 de biti (este >= 2**52 dar < 2**53), si cea mai bun a valoare pentru N este 56:
B.1. Erori de reprezentare 77
>>> 2L**52
4503599627370496L
>>> 2L**53
9007199254740992L
>>> 2L**56/10
7205759403792793L
Asta este, 56 este singura valoare pentru N care las a J cu exact 53 de biti. Atunci 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 aproximatie se obtine prin rotunjirea:
>>> q+1
7205759403792794L
Astfel cea mai bun a aproximatie a lui 1/10, n dubla precizie 754, este peste 2**56, 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 exact 1/10!
Deci, niciodata computerul nu va ar ata 1/10: ce va ar ata este exact fractia dat a mai jos, cea mai bun a aproximatie n
754 care poate dat a:
>>> .1 * 2L**56
7205759403792794.0
Dac a se nmulte ste fractia cu 10**30, vom vedea valoarea (truncheat a) a celor mai semnicativi 30 de digiti zecimali
ai s ai:
>>> 7205759403792794L * 10L**30 / 2L**56
100000000000000005551115123125L
nsemnnd c a num arul exact memorat n calculator este aproximativ egal cu valoarea zecimal a
0.100000000000000005551115123125. Rotunjind la 17 digiti semnicativi rezult a 0.100000000000000001 pe
care Python l a seaz a (va a sa pe orice platform a conform a 754 care va face tot posibilul s a converteasc a intrare si
ie sire prin biblioteca C proprie al dumneavoastr a s-ar putea s a nu reu seasc a acest lucru!)
78 Anexa B. Aritmetica n virgul a otant a: rezultate si limit ari
ANEXA
C
Istoria si licenta
C.1 Istoricul produsului Python
Python a fost creat la nceputul anilor 1990 de c atre Guido van Rossum la Stichting Mathematisch Centrum (CWI, vezi
http://www.cwi.nl/) din Olanda, ca succesor al limbajului ABC. Guido a r amas principalul autor al Python-
ului, care acumuleaz a multe contributii ale altora.
n 1995 Guido i si continu a munca la Python la Corporation for National Research Initiatives (CNRI, vezi http:
//www.cnri.reston.va.us/) n Reston, Virginia, unde a lansat cteva versiuni ale software-ului.
n mai 2000, Guido si echipa de dezvoltare a Python-ului s-a mutat la BeOpen.com, unde a format echipa
BeOpen PythonLabs. octombrie 2000, colectivul PythonLabs s-a mutat la Digital Creations (vezi http://
www.digicool.com/).n 2001 ia na stere Python Software Foundation (PSF, vezi http://www.python.org/
psf/) o organizatie non prot creat a special pentru a detne drepturile de autor
1
referitoare la Python. Digital Creations
este unul din sponsorii PSF.
Toate lans arile
2
Python sunt Open Source (vezi http://www.opensource.org/ pentru a g asi denitia Open
Source ). Istorice ste vorbind cele mai multe dintre lans arile Python, nu toate, sunt de asemenea compatibile
GPL(General Public License). Tabelul urm ator face un sumar al diferitelor lans ari.
Release Derived from Year Owner GPL compatible?
0.9.0 thru 1.2 n/a 1991-1995 CWI yes
1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
1.6 1.5.2 2000 CNRI no
2.0 1.6 2000 BeOpen.com no
1.6.1 1.6 2001 CNRI no
2.1 2.0+1.6.1 2001 PSF no
2.0.1 2.0+1.6.1 2001 PSF yes
2.1.1 2.1+2.0.1 2001 PSF yes
2.2 2.1.1 2001 PSF yes
Not a: Compatibil GPL nu nseamn a c a Python este distribuit sub GPL. Toate licentele Python, spre deosebire de GPL,
iti permit s a distribui o versiune modicat a f ar a a-ti face si modic arile open source. Licentele compatibile GPL fac
posibil a combinarea Pyton-ului cu alte software care au ap arut sub GPL; celelate neputnd face acest lucru.
Multumim acelor voluntari numero si din exteriorul echipei, care lucrnd sub coordonarea lui Guido au f acut posibile
aceste lans ai.
1
Intellectual Property
2
N.T. = 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 Or-
ganization (Licensee) accessing and otherwise using Python 2.2 software 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, perform and/or display publicly, prepare derivative
works, distribute, and otherwise 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 Software 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 derivative work that is based on or incorporates Python 2.2 or any part thereof,
and 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 changes made to Python 2.2.
4. PSF is making Python 2.2 available to Licensee on an AS IS basis. PSF MAKES NO REPRESENTA-
TIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION,
PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABIL-
ITY 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 IN-
CIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING,
DISTRIBUTING, OR OTHERWISE USING PYTHON 2.2, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks
or trade name in a trademark sense to endorse or promote products 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 conditions
of this License Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
1. This LICENSE AGREEMENT is between BeOpen.com (BeOpen), having an ofce 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 Software).
2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee
a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly,
prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided,
however, that the BeOpen Python License is retained in the 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 REPRE-
SENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMI-
TATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MER-
CHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFT-
WARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
80 Anexa C. Istoria si licenta
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 AD-
VISED OF THE POSSIBILITY THEREOF.
6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of Cali-
fornia, excluding conict of law provisions. Nothing in this License Agreement shall be deemed to create any
relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License Agreement
does not grant permission 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, installing 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 Initiatives, having an ofce
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. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclusive,
royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise 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 retained in Python 1.6.1 alone or in any derivative
version prepared by Licensee. Alternately, in lieu of CNRIs License Agreement, Licensee may substitute the
following text (omitting the quotes): Python 1.6.1 is made available subject to the terms 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 identier (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/1895.
22/1013.
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part thereof,
and 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 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 REPRESENTA-
TIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION,
CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABIL-
ITY 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 LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY
INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING,
DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.
7. This License Agreement shall be governed by the federal intellectual property lawof the United States, including
without limitation 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 conict of law provisions. Notwithstanding the
foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable material that
was previously distributed under the GNU General Public License (GPL), the law of the Commonwealth 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 this License Agreement shall be deemed to create any relationship
of agency, partnership, or joint venture between CNRI and Licensee. This License Agreement does not 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 otherwise 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 Netherlands. All rights reserved.
Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is
hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and
this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch Centrum or
CWI not be used in advertising or publicity pertaining to distribution of the software without specic, written prior
permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFT-
WARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CON-
SEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
82 Anexa C. Istoria si licenta

Python

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Python

Enviado por

Direitos autorais:

Formatos disponíveis

Tutorial Python

Você também pode gostar