Tutorial Python 3.2 ( Partea 4 )

[R0cc0]

Exceptii de manipulare

(Exception Handling)

Cel mai rau moment pentru cineva care programeaza este acela cand se blocheaza programul din cauza unei erori .

Sunt 2 tipuri de erori :

Erori sintactice : In acest caz eroarea este de la o comanda sau de la o functie .

Erori runtime ( de rulare ) : In acest caz numele sunt corecte , dar este o eroare a valorii asumate unei variabile . Exemple :

Impartirea la 0 .

Citirea fisierelor inexistente .

Cand intampinam o eroare , programul se opreste si ne arata un mesaj in care este specificata eroare . Asta provoaca o brusca intrerupere a programului si a controlului asupra acestuia , deci nu este posibil ca programul sa mai ruleze .

Voi da un exemplu de eroare RunTime :

>>> a, b = 5, 0
>>> print a / b
traceback (most recent call last):
File “<pyshell#5>”, line 1, in ?
print a / b
ZeroDivisionError: integer division or modulo by zero 

Este posibil sa controlam anumite erori fara ca programul sa fie terminat , pentru a face asta , se foloseste un constructor care ne perite de a releva executii si a trece la controlul de flux si a trece la un alt bloc de instructii . Exemplu :

try:
<Grupul de instructii sub test>
except:
<Grup de instructii care vor fii puse in aplicare in caz de eroare>
else: # optional
<grup de instructii2>
finally: # optinal, in loc de except
<grup de instructii 3>

Toate instructiile incluse in bloc “ try “ sunt sub control pe durata executarii programului . Daca “try “ este gol este ok , blocul execept va fii ignorat . In caz contrar , va aparea o exceptie , care va sarii la blocul de instructiuni care urmeaza cuvantul “ except “ .

Daca introducem orice operatie cu riscul de exceptii in blocul “ try “ vom fii in gradul de a reactiona la fiecare eroare “ runtime “ fara a intrerupe programul . Exemplu :

>>> a, b = 5, 0
>>> try:
… print a / b
… except:
… print ‘Nu ai studiat matematica ! =) !’

Nu ai studiat matematica ! =) ! 

Este posibil chiar gestionare tipuri diverse de exceptii in acelasi timp , si urmand blocuri de instructii diverse in functie de tipul erori . Pentru asta este necesar urmarire “ except “ si numele claseri de eroare . Exemplu :

>>> a, b = 5, 0
>>> try:
… print a / b
… except ZeroDivisionError:
… print ‘nu ai studiat matematica, dar cu python esti ok !’

nu ai studiat matematica, dar cu python esti ok ! 

In cazul in care exista o excep?ie prin divizarea la 0 ar avea loc de asemenea un bloc de program, chiar si in blocul try.

In cazul in care doresti un alt set de instructiuni , dar doar in cazut in care nu are loc nici o exceptie poti folosii “ else “ dupa are pune blocul de instructii dorite .

Clase in Python

Un exemplu de definire a unei clase in Python :

class <nume clasa> [(<clasa R0cc0>,...)]:
<lista cu datele membre cu , care vom incepe>
<lista metode> 

Datele membru se exprima ca si normale variabile de Python . Daca trebuie sa initiazizati date membru , faceti o simpla cesiune sau puteti defini pe moment uilitatea exacta cum se face la o variabila normala .

Pentru metode este de ajunt sa folositi aceleasi lucruri de sintaxa cu anumite exeptii :

Orice metoda trebuie sa aiba ca si prim parametru obiectul in sine , practic de fiecare data cand vine invocat un obiect , Python rezolva primul parametru referirea la acel obiect , asta se numeste “ self “ . Exemplu :

class persoana:
nume = ”
prenume = ”
adresa = ”
telefon = ”
statut_civil = ”

def inlocieste_adresa(self,s):
self.adresa = s
def inlocuieste_telefon(self,s):
self.telefon = s
def inlocuieste_statut_civil(self,s):
self.status_civil = s
def print(self):
print self.nume,self.prenume,self.adresa,
self.statu_civil

class student (persoana): # ecco ereditarea’ !
scoala = ”
classe = 0

def inlocuieste_scoala(self,s):
self.scoala = s
def trecut(self):
if self.clasa == 5:
print ‘scoala terminata’
else:
self.clasa = self.clasa + 1 

Daca acum vrem sa initiem un obiect , este suficient sa invocam numele clasei , ca si o functie .

Daca vrem sa deschidem datele membru si metodele , este suficient sa folosim “ . “ ( punct ) .

p1 = persona() # parantezele sunt obligatorii
p1.nume = ‘stefan’ # adaugare directa a datelor membru
p1.prenume = ‘R0cc0’
p1.inlocuieste_adresa(‘str. Rst.com nr.14?) # invocare metoda
p1.print() # rezultat : stefan R0cc0 Str. Rst.com nr.14

“ P1 “ este un obiect al clasei de la persoana care are acele valori .

Ati notat cum am adaugat date membru si valori direct sau pe parcurs la metode .

Am utilizat metoda “ inlocuieste_adresa “ trecand un singur paramentru ( metoda ne cere 2 ) , dar asta a fost posibil deoarece Python a asociat paramentrul “ self “ cu obiectul “ p1 “ .

s1 = student()
s1.nume = ‘stefan’
s1.prenume = ‘R0cc0’
s1.inlocuieste_adresa(‘Str. Rstforum nr.14?)
s1.Inlocuieste_scoala(‘liceu’)
s1.print() # rezultat : stefan R0cc0 Str. Rst.com nr.14

Rezultatul metodei “ print “ nu ne permite sa vedem scoala si clasa in care este “ stefan R0cc0 “ .

Asta se va intampla daca invocam metoda clasei “ persoana “ (“liceu”) la care nu se cunoaste valoarea datelor membru “ student “ clasa “ fiu “.

Pentru a rezolva asta , ne vine in ajutor polimorfismul , practic este necesar sa redefinim metoda “ print “ contruind o metoda specifica pentru student .

class student (persoana):
scoala = ”
clasa = 0

def inlocuieste_scola(self,s):
self.scoala = s
def trecut(self):
if self.clasa == 5:
print ‘scoala terminata’
else:
self.clasa = self.clasa + 1
def print(self):
print self.nume,self.prenume,self.adresa,
self.statut_civil
print ‘scoala: ‘+self.scoala+’ clasa ‘
+str(self.clasa)

Metoda print este polimorfica , pare o metoda urata , dar asta inseamna ca ia forma diersa in baza tipului de obiect aspupra caruia vine aplicata .

Aplicatia imediata asuprea unei clase ,provoaca o creatie de obiect .

Mai mereu este necesar sa incepemm datele memebru ale obiectului in momentul creari .

In exemplul nostru este util sa incepem cu persoana , numele si prenumele , defapt numele si prenumele sunt date la nastere si nu se pot schimba deloc .

Pentru a face asta , teoria programarii orientata spre obiecte , prevede utilizarea unui constructor . In Python , este ceva asemanator : “ __init__() ”.

Cand in internul unei clase vine declarat aceasta functie cu acest nume , atunci vine invocat automat la creeare obiectului . Exemplu :

class persoana:
adresa = ”
telefon = ”
statut_civil = ”

def __init__(self,n,c):
self.nume = n
self.prenume = c
def inlocuieste_adresa(self,s):
self.adresa = s
def inlocuieste_telefon(self,s):
self.telefon = s
def inlocieste_statut_civil(self,s):
self.statut_civil = s
def print(self):
print self.nume,self.prenume,self.adresa,
self.statut_civil 

Iar acum dupa invocare :

p1 = persoana(‘stefan’,'R0cc0’)
p1.print() # rezultat : stefan R0cc0

Notati ca am eliminat string-ul gol de la cele 2 variabile ( nume / prenume ) in clasa . Ele practic sunt inutile petru ca variabilele sunt create in internul functiei

“ __int__ “ .

Pana acum mai mult am vorbit , dar nu am aplicat acest principiu , practic prima operatie facut asupra obiectului “ p1 “ a fost aceea de a incepe cu datele membru ( nume si prenume ) direct .

Python , asuma toate datele membru publice , deci pentru a realica cu adevarat incapsularea , trebuie antepus la nume variabile cu , caracterele “ __ “( 2 underline ) . Faand asa , nici unu nu poate modifica datele fara a utiliza aceasta functie . Exemplu :

class persoana:
__adresa = ”
__telefon = ”
__statut_civil = ”

def __init__(self,n,c):
self.__nume = n
self.__prenume = c
def inlocieste_adresa(self,s):
self.__adresa = s
def inlocuieste_telefon(self,s):
self.__telefon = s
def inlocuieste_statut_civil(self,s):
self.__statut_civil = s
def print(self):
print self.__nume,self.__prenume,self.__adresa,
self.__statut_civil

Daca incercam sa adaugam direct “ __nume ” si ” __prenume “ comanda va venii ignorata.

p1.__nume = ‘proba’
p1.print()
# rezultatul ramane: stefan R0cc0
Str. Rst.com nr.14

Exista un alt concept al programarii orientata pe obiecte , el consta in posibilitatea de efectuare a polimorfului si a operatorilor , chiar si a metodelor . Exemplu :

class num_comp:
partea_reala = 0
partea_imaginara = 0

def suma(self,num):
# num este un obiect in clasa num_comp
self.partea_reala = self.partea_reala + num.partea_reala
self.partea_imaginara = self.partea_imaginara +
num.partea_imaginara

def print(self):
print str(self.partea_reala) + ‘+’
+str(self.partea_imaginara) + ‘i’ 

Un numar complex compus din doua valori : partea reala si cea imaginara , este o metoda care nu se asuma . Exemplu :

n1 = num_comp()
n1.partea_reala = 1
n1.partea_imaginara = 1

n2 = num_comp()
n2.partea_reala = 2
n2.partea_imaginara = 3

n1.suma(n2)
n1.print() # rezultat 3+4i 

Sintaxa din pacate este articulata . Ar fii frumos sa putem scrie ( n1 + n2 ) exact ca in matematica .

Pentru a putea face asta , este necesar sa punem operatorul “ + “ ( ne aducem aminte ce sunt aia operatori ? ) . Exemplu :

class num_comp:
partea_reala = 0
partea_imaginara = 0

def __add__(self,num):
ris = num_comp()
ris.partea_reala = self.partea_reala+ num.partea_reala
ris.partea_imaginara = self.partea_imaginara
+ num.partea_imaginara
return ris

def print(self):
print str(self.partea_reala) + ‘+’
+str(self.partea_imaginara) + ‘i’ 

Am declarat o functie speciala numita “ __add__ “ , in grad de a efectua “ overloading “ ( substiturirea ) operatorului ADD(+) .

Ea creeaza un nou obiect si aduna variabilele singure . Exemplu :

n1 = num_comp()
n1.partea_reala = 1
n1.partea_imaginara = 1

n2 = num_comp()
n2.partea_realea = 2
n2.partea_imaginara = 3

r = n1 + n2 # ca si in matematica !
r.print() # rezultat 3+4i 

Trecand ptin “ overloading “ operatorii pot crea clase mult sofisticte si utilizabile cu o sintaxa eleganta .

Uitasem , aici gasiti module ( toate ) .

Cam asta am avut de spus despre Python , un limbaj frumos si usor de inteles ,

Scuzati eventualele greseli gramaticale ,

Sper ca v-a placut .

Edited March 2, 2013 by R0cc0