Capitolul 4

Python Fundamentals
 Funcții
• Folosite pentru a grupa instrucțiunile care sunt executate de mai
multe ori
• Cuvânt cheie pentru definire: def
• Semnătura unei funcții este reprezentată de:
def nume_functie(parametrii): #parametrii sunt opționali
... bloc_instructiuni
... return valoare_rezultata # funcțiile nu trebuie neaparăt să
returneze ceva
 Implementarea unei funcții

>>> def square(x):

... return x*x
...
>>> square(5)
25
• Executați funcția de mai sus atât în REPL cât și în PyCharm. Ce diferențe
observăm?
 Implementarea unei funcții

>>> def par_impar(n):

... if n % 2 == 0:
... print(“par")
... return #atunci când return nu este urmat de o valoare, funcția întoarce None
... print(“impar")
...
>>> par_impar(4)
par
>>> par_impar(5)
impar
>>>
 Parametrizarea funcțiilor
• Funcțiile pot avea parametrii, fără a fi nevoie să specificăm tipul
acestora, întrucât lucrăm cu un limbaj dynamic
def functie_suma(a, b):
print(a + b)
• Bazându-ne pe definiția de mai sus, putem apela funcția cu mai multe
tipuri de parametrii
functie_suma(10, 5)
functie_suma(20.7, 13.2)
functie_suma([1, 2, 3], [4, 5, 6])
functie_suma(“Telecom”, “ Academy”)
Q: Ce se va afișa la următorul apel?
functie_suma(10.2, “7”)
Argumente cu valoare implicită
 Argumente cu valoare implicită

>>> def banner(message, border='-'):

... line = border * len(message)
... print(line)
... print(message)
... print(line)
...
>>> banner("Norwegian Blue")
--------------
Norwegian Blue
--------------
 Argumente cu valoare implicită

>>> banner("Sun, Moon and Stars", "*")

*******************
Sun, Moon and Stars
*******************

>>> banner(border=".",message="Hello from Earth")

................
Hello from Earth
................
 Returnarea valorilor de către funcții
• Cuvântul cheie return
• Nu specificăm de la început ce tip de date returnăm
• Putem returna mai multe valori din cadrul unei funcții – vor fi
întoarse sub formă de tuplu
def calculeaza(x):
patrat = x ** 2
cub = x ** 3
return patrat, cub

rez = calculeaza(5)
rez[0] = 25
rez[1] = 125
Argumente poziționale și argumente cheie-valoare
 Multiple argumente poziționale
*args – ne oferă posibilitatea de a da mai multe argumente
poziționale, fără a specifica numărul acestora

>>> def hypervolume(*args):

... print(args)
... print(type(args))
>>> hypervolume(3,4)
(3, 4)
<class 'tuple'>
>>> hypervolume(3,4,5)
(3, 4, 5)
<class 'tuple'>
 Multiple argumente cheie-valoare
**kwargs – ne oferă posibilitatea de a parametriza cu mai multe argumente de
tip cheie-valoare

>>> def tag(name,**kwargs):

... print(name)
... print(kwargs)
... print(type(kwargs))
...
>>> tag('img',src="monet.jpg",alt="Sunrise by Claude Monet",border=1)
img
{'src': 'monet.jpg', 'border': 1, 'alt': 'Sunrise by Claude Monet'}
<class 'dict'>
Argumente multiple în cadrul unei funcții
>>> def print_args(**kwargs,*args):
File "<stdin>", line 1
def print_args(**kwargs,*args):
^
SyntaxError: invalid syntax
Argumente multiple în cadrul unei funcții
>>> def print_args(arg1,arg2,*args):
... print(arg1)
... print(arg2)
... print(args)
...
>>> print_args(1,2,3,4,5)
1
2
(3, 4, 5)
Argumente multiple în cadrul unei funcții
>>> def print_args(arg1,arg2,*args,kwarg1,kwarg2):
... print(arg1)
... print(arg2)
... print(args)
... print(kwarg1)
... print(kwarg2)
...
>>> print_args(1,2,3,4,5,kwarg1=6,kwarg2=7)
1
2
(3, 4, 5)
6
7
Argumente multiple în cadrul unei funcții
>>> print_args(1,2,3,4,5,6,7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: print_args() missing 2 required keyword-only
arguments: 'kwarg1' and 'kwarg2'
>>>
Argumente multiple în cadrul unei funcții
>>> def print_args(arg1,arg2,*args,kwarg1,kwarg2,**kwargs):
... print(arg1)
... print(arg2)
... print(args)
... print(kwarg1)
... print(kwarg2)
... print(kwargs)
>>> print_args(1,2,3,4,5,kwarg1=6,kwarg2=7,kwarg3=8,kwarg4=9)
1
2
(3, 4, 5)
6
7
{'kwarg3': 8, 'kwarg4': 9}
Argumente multiple în cadrul unei funcții
>>>
print_args(arg1,arg2,*args,kwarg1,kwarg2,**kwargs,kwargs99):
File "<stdin>", line 1

print_args(arg1,arg2,*args,kwarg1,kwarg2,**kwargs,kwargs99):
^
SyntaxError: invalid syntax
 Exerciții opționale:

1.Creați o funcție asemănătoare cu min din python numită min_lista

care va primi ca argument o listă și va returna minimul acelei liste
(opțional și pentru max).
2.Creați o funcție asemănătoare cu sum din python numită sum_list
care va primi ca argument o listă și va returna suma acelei liste.
3.Bazându-vă pe punctul 1 creați altă funcție care primește o listă și o
ordonează crescător (asemănătoare cu sort)
 Excepțiile
• Reprezintă evenimente nepermise în cadrul programului nostru
• Pot bloca execuția programului dacă nu sunt tratate (spre
diferență de erori)
• Pot fi excepții de sistem (definite de limbaj) sau de aplicație (de
business)
 Managementul excepțiilor în Python
• Cazul cel mai general de tratare al excepțiilor este:

try:
bloc de cod care ar putea genera excepție
except:
bloc de cod executat în cazul apariției unei excepții

• Aferent unui bloc de try putem avea mai multe blocuri de except
 Exemplu try/except

x = input(“Valoare: ”) Q1: Ce se va afișa dacă valoarea citită de

y=5 la tastatură este 2?
try:
print(“:)”) Q2: Ce se va afișa dacă valoarea citită
z = y/x de la tastatură este 0?
print(“:(”)
except:
print(“:D”)
 Blocul finally
• Instrucțiunile aferente blocului finally se vor executa indiferent dacă se aruncă sau nu o excepție

lista_mea = [“telacad”, “python”, “java”]

try:
lista_mea[1] = “microsoft iis”
lista_mea[4] = “docker”
print(“:)”)

except:
print(“Ai folosit un index inexistent”)
finally:
print(“Am terminat lucrul cu lista_mea”)

Q: Care va fi diferența la afișare dacă este comentată linia în care se face referire la indexul 4?
 Tratarea excepțiilor specifice
• Putem avea mai multe blocuri de except pentru a trata mai multe
tipuri de excepții
try:
bloc de instrucțiuni
except ValueError:
print(“Ai folosit o valoare invalida”)
except ZeroDivisonError:
print(“Ai incercat sa imparti la zero…”)
 Ridicarea propriilor excepții
• Excepțiile pot fi folosite pentru a dicta anumite elemente de logică
programelor noastre
• Ridicarea/aruncarea unei excepții se face cu ajutorul cuvântului
cheie raise urmat de tipul excepției, și un mesaj corespunzător
def radical(x):
if x < 0:
raise ValueError(“Radicalul se aplica pe valori pozitive”)
Docstrings
 Exemplu docstrings
def exemplu_functie():
""
Documentatia unei functii trebuie sa fie
actualizata pentru a putea fi folosita si
de altcineva
"""
pass

print(exemplu_functie.__doc__)
 Exemplu documentare functie
def radical(x):
"“”
Calculeaza radical dintr-o valoare x data ca parametru
:param x: Valoarea din care se calculeaza radical
:return: Valoare de tip float reprezentand radicalul valorii date
ca si parametru
:raise: ValueError in cazul in care valoarea lui x este mai mica
decat 0

"""
 Utilizarea help
>>> import requests
>>> help(requests.get) # sau folosim print(requests.get.__doc__)

get(url, params=None, **kwargs)

Sends a GET request.

:param url: URL for the new :class:`Request` object.

:param params: (optional) Dictionary, list of tuples or bytes to send
in the query string for the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
 Utilizarea comentariilor

• Docstring – cel mai potrivit pentru documentarea unui

script/modul/funcții
• Comentariile – indicații mai specifice pentru o anumită linie

if __name__ == '__main__':
main(sys.argv[1]) # argumentul 0 este numele “fișierului”
executat