INTRODUCERE IN PROGRAMARE

FOLOSIND PYTHON
SPAM

Dr. Elena Ovreiu

Universitatea POLITEHNICA din Bucuresti
www.ovreiu.com
CURS 6 & 7
Functiile matematice
Functiile in Python sunt similare cu functiile matematice
In matematica o functie calculeaza un rezultat dintr-o valoare data.
Definitia functiei Input: x

f(x)= 2*x +3
functia f
f(x)=sin(x)

Definitia functiei
Output: f(x)
Functiile matematice

• Apelul unei functii inseamna sa i se dea functiei input-ul

necesar astfel incat sa execute instructiunile si sa returneze
un output.
2
• Ex: f(x)=2*x +3
• f(2) = 7 2*x+3

7
Functii in Python

§ In Python, functia este un bloc de cod care are un nume si

care executa un task specific.
§ Functiile folosite pana acum sunt:
1. Functiile din biblioteca standard a lui Python precum:
print, input, eval, int, float, range,
type. Acestea sunt functii built-in, care sunt tot
timpul recunoscute de interpretor
2. Functii din module (math.sqrt, math.pow).
Pentru a fi recunoscute de intrepretor, trebuie importate
Module

9 sqrt 3

from math import sqrt

nr=eval(input("Introduceti un numar:"))
root=sqrt(nr)
print("Radacina numarului {} este {}".format(nr,root))
Module
§ sqrt(nr): prin aceasta scriere, functia sqrt este apelata.
§ Cand apelam o functie, numele functiei este urmat de
paranteze rotunde ( ).
§ In acest exemplu, nr se numeste argument sau parametru.
§ Exemplu de apeluri ale functiei sqrt:
sqrt(9.0)
>>>3.0
x=5
sqrt(2*x-3)
>>>2.6457513110645907
sqrt(sqrt(16))
>>> 2.0
sqrt(int('4’))
>>>2.0
§ Functiile sunt vazute ca niste cutii negre (black box). De obicei nu ne
intereseaza ce contin functiile, doar ceea ce fac
§ Unele functii, precum range, poate avea mai multi parametri
Functiile au 3 parti importante:
■ Nume: este folosita pentru a identifica codul care va fi executat.
Numele functiei este un identificator.
■ Parametri: functia este apelata cu un numar de parametri. Fiecare
parametru trebuie sa aiba tipul corect.
print si range au un numar variabil de parametri, sqrt are un numar
fix. Daca utilizatorul incearca sa ruleze un program cu un numar mai
mare sau mai mic de parametrii, va primi un mesaj de eroare si refuza sa
ruleze.
§ Valoarea returnata: o functie returneaza o valoare. Tipul parametrilor
si tipul valorii returnate nu sunt corelate.
■ Unele functii nu accepta niciun parametru:
from random import random
random()
>>> 0.8585428081934681
§ Unele functii nu returneaza nimic:
print(print(10))
>>> None
Python ne ofera 3 posibilitati pentru a importa functii din module:
1. Pentru a importa una sau mai multe functii specifice
from math import sqrt, pow
In acest caz, doar sqrt si pow pot fi utilizate in program.
2. Pentru a importa toate functiile din modul
from math import *
3. Importa intreg modulul, in loc de componentele sale
import math
Pentru a folosi o functie din modul, in acest caz:
root=math.sqrt(16)
Scrierea functiilor
■ Cu cat programul devine mai complex, cu atat programatorul ar trebui
sa isi structureze programul in asa fel incat sa ii poata controla
complexitatea.
 Sunt folosite pentru a evita duplicarea codului
si pentru a face programul mai usor de inteles
si de mentinut

Functia este un subprogram (un program mai

mic in interiorul unui program sau un bloc de
cod, care are un nume) .
Functiile
Ideea de baza: scriem o secventa de
instructiuni si ii dam acelei secvente un
nume.

Putem apoi executa acea secventa oricand,

doar folosind numele secventei.
Exista 2 aspecte ale oricarei functii in Python:
• Definitia functiei –contine codul care determina
comportamentul functiei
• Apelul functiei –functia poate fi folosita intr-un program prin
apelarea acesteia.
• Orice functie are o singura definitie, dar poate avea mai
multe apeluri
Definitia unei functii contine:
• Nume – numele functiei este un identificator. Ca si la
variabile, numele descrie functionalitatea acesteia
• Parametri – definitia unei functii specifica parametrii pe
care aceasta ii accepta. Parametrii sunt o lista de elemete,
separate prin vrigula
• Corpul functiei – corpul functiei este un bloc de instructiuni
care sunt indentate. Corpul functiei este cel responsabil sa
produca un rezultat
Definitia unei functii
def square_root (number):
# Compute a provisional square root root = 1.0
# How far off is our provisional root? diff = root*root - val
while diff > 0.00000001 or diff < -0.00000001:
root = (root + val/root) / 2
diff = root*root - val
return root
Definitia unei functii
def - cuvant cheie folosit pentru a introduce definitia functiei
square_root –numele functiei
number – parametru functiei
Corpul functiei :
while diff > 0.00000001 or diff < -0.00000001:
root = (root + val/root) / 2
diff = root*root - val
return root
• Definitia unei functii:
def nume_functie ([lista_parametri])
corpul_functiei
//EX: Definitia Functiei
def afisare():
print("Introduceti un numar: ")
//Programul in care este apelata:
afisare()
nr1=int(input())
afisare()
nr2=int(input())
s=nr1+nr2
>>> Introduceti un numar:
3
>>> Introduceti un numar:
4
Ex functie:
def prompt(): //definitia functiei
n=int(input("Introduceti un numar intreg "))
return n
nr1=prompt() //apelul functiei
nr2=prompt() //apelul functiei
print(“Suma este”,nr1+nr2)
>>>Introduceti un numar intreg 3
>>>Introduceti un numar intreg 5
>>>Suma este 8
def prompt(): //definitia functiei
n=int(input("Introduceti un numar intreg "))
return n

§ In acest caz, variabila n este folosita in interiorul functiei prompt.

Este numita variabila locala
§ Variabila locala: daca este folosita in afara functiei, nu este
recunoscuta si programul va genera NameError: name ’
‘ is not defined
§ O variabila cu acelasi nume poate fi folosita in afara functiei, dar are
alt rol
#Ex utilizare variabila locala
def prompt():
a=10
n=int(input("Introduceti un numar intreg "))
return n
nr1=prompt() //apelul functiei
nr2=prompt() //apelul functiei
print(“Suma este”,nr1+nr2+a)
Introduceti un numar 6

Introduceti un numar 2

Traceback (most recent call last):

File "main.py", line 18, in <module>

print(nr1+nr2+a)

NameError: name 'a' is not defined

#Ex utilizare variabila locala
def prompt():
a=10
n=int(input("Introduceti un numar intreg "))
return n
nr1=prompt()
nr2=prompt()
a=5
print(“Suma este ”,nr1+nr2+a)
Introduceti un numar intreg 2
Introduceti un numar intreg 7
Suma este 14
Rolul functiilor
• Ex. def main():
print("Happy birthday to you!" )
print("Happy birthday to you!" )
print("Happy birthday, dear Alex...")
print("Happy birthday to you!")
• >>> main()
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Alex….
Happy birthday to you!
Rolul functiilor

• Programul contine cod duplicat:

print("Happy birthday to you!" )
• Putem defini o functie care sa contina aceasta linie:
def happy():
print("Happy birthday to you!")
• Folosind aceasta functie, putem rescrie programul
Rolul functiilor

def happy():
print("Happy birthday to you!")
def singAlex():
happy()
happy()
print("Happy birthday, dear Alex...")
happy()
>>> singAlex()
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Alex...
Happy birthday to you!
Rolul functiilor

• Ce se intampla daca este ziua Anei?

• def singAna():
happy()
happy()
print("Happy birthday, dear Ana...")
happy()
• Putem crea un program principal in care le cantam Happy
birthday si Anei si lui Alex.
• def main():
singAlex()
print()
singAna()
• >>> main()
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Alex..
Happy birthday to you!

Happy birthday to you!

Happy birthday to you!
Happy birthday, dear Ana...
Happy birthday to you!
• Singura diferenta dintre singAlex si singAna este
numele din a 3a instructiune ( print)
• Aceste 2 functii pot fi puse in una singura, folosind un
parametru
• Definim o singura functie, generala, sing:
• def sing(person):
happy()
happy()
print("Happy birthday, dear", person +
".")
happy()
• def sing(person):
• Aceasta functie foloseste un parametru numit person.
• Un parametru este o variabila care este initializata atunci
cand functia este apelata
• sing(”Alex")
>>>Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Alex.
Happy birthday to you!
Functii
• Noul program devine:
• def main():
sing(”Alex")
print()
sing(”Ana")
Functii
• >>> main()
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Alex.
Happy birthday to you!

Happy birthday to you!

Happy birthday to you!
Happy birthday, dear Ana.
Happy birthday to you!
Functii care returneaza valori
def suma():
x=5
y=10
print(“Suma este ”,x+y)
>>>suma()
Suma este 15
>>>a=suma() #in variabila a se pune rezultatul returnat de suma()
>>>a
None
§ valoarea lui a este un obiect de tip None
Functii care returneaza valori

■ Orice functie in Python returneaza ceva. In exemplul anterior, functia a

returnat un obiect None.
■ Pentru a returna o valoare, in functie se foloseste return
Functii care returneaza valori
■ Pentru a returna o valoare, in functie se foloseste return valoare_returnata
■ Ex:
def suma():
x=5
y=10
return x+y
>>>s=suma() # variabilei s i se pune atribuie valoarea #returnata de suma(),
adica x+y
>>>print(s)
15
§ return returneaza x+y
§ Astfel, apelul functiei suma() returneaza x+y, adica o valoare
Functia poate returna mai multe valori
def suma_dif():
x=5
y=10
return x+y, x-y
§ In cazul acesta, suma_dif() returneaza un tuplu format din (x+y, x-y)
§ Cand functia este apelata, valorile returnate pot fi puse in 2 variabile, folosind
scrierea de la tuplu:
>>>s,d=suma_dif()
>>>s
15
>>>d
-5
Functia poate returna mai multe valori
• Deci, s primeste prima valoare returnata si d pe cea de-a 2a.
• Toate functiile din Python returneaza o valoare, chiar daca contin
instructiunea return sau nu.
• Functiile care nu contin return returneaza un obiect special, numit
None
Variabile locale vs globale
• Domeniul unei variabile se refera la locul in program in care variabila
poate fi mentionata.
• Variabilele folosite in interiorul unei functii sunt variabile locale
functiei respective.
• In functia suma_dif(), ambele variabile x si y sunt locale,
deoarece sunt initializate in interiorul functiei.
Variabile locale vs globale
def suma_dif():
x=5
y=10
return x+y, x-y
>>> suma_dif()
>>>print(x)
NameError: name 'x' is not defined
§ Folosita in exteriorul functiei in care este definita (suma_dif),
variabila x nu este recunoscuta. La fel si y
§ Pentru a putea fi recunoscuta atat in exetriorul cat si in interiorul
functiei, x trebuie sa fie variabila globala.
Variabile locale vs globale
x=5 # x este variabila globala, fiind definita in afara
functiei
def suma_dif():
y=10 #y ramane variabila locala
return x+y, x-y
>>> suma_dif()
15, -5
>>>print(x)
5
>>> print(y)
NameError: name ‘y' is not defined
Variabile locale vs globale
x, y=5, 10
def suma_dif():
return x+y, x-y
>>> suma_dif()
15, -5
>>>print(x)
5
>>> print(y)
10
§ Ambele variabile x si y sunt globale, astfel incat ele pot fi folosite atat
in interiorul functiei cat si in afara acesteia.
Variabile locale vs globale
x, y=5, 10 #x si y sunt variabile globale
def suma_dif():
x=15 # x este o variabila locala, diferita de x=5
return x+y, x-y #valorile sunt calculate cu x local si y global
>>> suma_dif()
25, 5
>>>print(x) #este afisata variabila globala
5
>>> print(y)
10
Variabile locale vs globale
■ Pentru a putea folosi ambele variabile (locala + globala) care au
acelasi nume in interiorul functiei, se foloseste functia globals() ,
astfel:
x, y=5, 10
def suma_dif():
x=15
return globals()[‘x’]+y, x-y
>>> suma_dif()
15, 5
globals()[‘x’] returneaza x global
Parametrii unei functii
■ Variabilele x si y pot fi transmise functiei si argumente ale acesteia.
■ In cazul acesta functia devine:
def suma_dif(x,y):
return x+y, x-y
§ Cand se apeleaza functia, se dau si valorile argumentelor (care se ai
numesc si parametri):
>>> s,d=suma_dif(10,5)
>>>print(s)
15
>>>print(d)
-5
Parametrii unei functii
def suma_dif(x,y):
return x+y, x-y
>>> s,d=suma_dif(10,5)
§ In momentul in care functia este apelata, automat x este initializat
cu 10 si y cu 5
§ In definitia functiei, def suma_dif(x,y) x si y se numesc
parametri formali
§ In apelul functiei, suma_dif(10,5), 10 si 5 sunt
parametri actuali.
Parametrii unei functii
■ Parametrii unei functii, la fel ca si variabilele locale, sunt vizibili doar
in interiorul functiei respective.
§ Parametrii multipli sunt despartiti prin virgula
§ Parametrii formali si actuali sunt asociati pe baza pozitiei: primul
parametru actual este atribuit primului parametru formal si asa mai
departe.
Parametrii unei functii
■ O functie poate primi ca parametri (sau argumente) orice tip de date
def sort_lista (lista):
return lista.sort()
>>>sort_lista([6,2,5,9,1])
[1,2,5,6,9]
§ Variabila lista este initializata cu [6,2,5,9,1] in apelul functiei
Modificarea oridinii parametrilor
§ Regula pozitiei in asocierea parametrilor actuali cu formali poate fi
modificata daca specificam numele parametrilor formali in apelul
functiei. De ex:
def suma_dif(x,y):
return x+y, x-y
>>> s,d=suma_dif(y=10,x=5)
>>>s
15
>>>d
-5
Parametri cu valori implicite
def suma_dif(x=3,y=6):
return x+y, x-y
s,d=suma_dif( )
>>>s
9
>>>d
-3
§ Daca functia este apelata fara parametri actuali, atunci acestia vor fi
initializati cu valorile lor implicite (de ex. x=3, y=6)
Parametri cu valori implicite
def suma_dif(x=3,y=6):
return x+y, x-y
>>>s,d=suma_dif(11) #x=11, y=6
>>>s
17
>>>d
5
>>>s,d=suma_dif(y=20) #x=3, y=20
>>>s
23
>>>d
-17
Functie in functie
def calculator(x,y):
def suma():
print(“suma este ”,x+y)
def dif():
print(“diferenta este ”,x-y)
§ In functia calculator sunt definite alte 2 functii: suma() si
dif()
Functie care returneaza o functie
def calculator(x,y):
def suma():
return x+y
def dif():
return x-y
return suma, dif
>>>s,d=calculator(5,2)
§ s si d sunt 2 functii. Pentru a putea fi afisate, trebuie sa le apelam. De
ex:
>>> s()
7
>>>d()
3
Functia care primeste ca parametru o
alta functie
def calculator(x,y):
return x+y, x-y
def get_nr()
nr=int(input(“Introduceti nr))
return nr
>>> calculator(get_nr(), 5)
§ Parametrul x este initializat cu get_nr()
■ Revenim la exemplul anterior:
def happy():
print("Happy birthday to you!")
def sing(person):
happy()
happy()
print("Happy birthday, dear", person + ".")
happy()
def main():
sing(”Alex")
print()
sing(”Ana")
>>>main()
Functii si parametri
• Parametrii formali, la fel ca si toate variabilele folosite intr-o functie,
sunt accesibile doar in corpul functiei respective.
• Variabilele cu nume identice, din alte functii sau din orice alta parte a
programului, sunt diferite fata de cele din interiorul functiei sau de
parametrii functiei.

def sing (person):

happy()
happy() parametru formal
print("Happy birthday, dear", person + ".")
happy()
Functii si parametri

• O functie este apelata folosind numele functiei, urmat de

lista de parametri actuali (argumente):
• <name>(<actual-parameters>)
def main(): parametru actual
sing("Alex")
sing("Ana")

•Cand Python apeleaza o functie, are loc un process in 4 pasi.

Functii si parametri

1. Programul isi suspenda executia in punctul in care functia

este apelata.
2. Parametrilor formali ai functiei li se atribuie valorile
furnizate de parametri reali in apel.
3. Corpul functiei este executat.
4. Comanda revine la punctul imediat dupa ce a fost apelata
functia
Functii si parametri
• Sa luam ex. codul urmator:
• sing(”Alex")
print()
sing(”Ana")
• Cand Python ajunge la sing(”Alex"), executia
programului main este temporar suspendata.
• Python merge la definitia lui sing si vede ca are un
parametru formal,person
Functii si parametri
• Parametrului formal ii este atribuita valoarea
parametrului actual. Aceasta se intampla automat:
• person=“Alex”
A lex”
o n= “ def sing(person):
def main( ): per s
happy()
sing(“Alex”) happy()
print print(“Happy birthday, dear”, person+ “.”)
sing(“Ana”)
 def sing(person ):
def main( ): e r so n = “A lex”
P happy()
sing(“Alex”) happy()
print () print(“Happy birthday, dear”, person+ “.”)
sing(“Ana”) happy()

• Observati ca variabila person se intializeaza automat.

• In acest punct, Python incepe executia corpului functiei
sing
• Prima instructiune este apelul unei alte functii, happy
• Ce urmeaza sa se intample? Python suspenda executia
functiei sing si transfera controlul functiei happy
• happy contine o singura instructiune, care este executata, apoi controlul
se intoarce acolo unde ramasese, adica in functia sing

def happy():
def sing(person ):
person=“Alex” print(“Happy birthday,
def main( ): happy()
to you!”)
sing(“Alex”) happy()
print() print(“Happy birthday,
sing(“Ana”) dear”, person+ “.”)
happy()
• Cand Python ajunge la finalul lui sing, se reintoarce in
functia main si continua executia de acolo de unde
ramasese.

def sing(person ):
def main( ): r so n = “A lex” happy()
Pe
sing(“Alex”) happy()
print() print(“Happy birthday, dear”, person+ “.”)
sing(“Ana”) happy()

• Variabilele locale nu pastreaza nicio valoare de la o executie

a functiei la alta
• Python intalneste un nou call al functiei sing si transfera
controlul catre functia sing, de aceasta data cu
parametrul ”Ana”
• Corpul functiei sing este executat din nou, de data asta
cu parametrul formal “Ana”, dupa care Python se intoarce in
main

def sing(person ):
def main( ): o n= “A lex”
pers happy()
sing(“Alex”) happy()
print() print(“Happy birthday, dear”, person+ “.”)
sing(“Ana”) happy()
Ordinea definitiilor functiilor in program,

• Ordinea definitiilor functiilor in program nu este importanta

• Nu trebuie decat sa fim siguri ca functia este definita
inainte ca programul sa incerce sa o ruleze (inainte de
apelul functiei)
• Deoarece apelul catre functia main se face, de obicei, pe
ultima linie a modulului (programului), toate functiie trebuie
definite inainte de rularea programului
Functii care modifica parametrii

• Una dintre cele mai comune probleme: omiterea

instructiunii return dintr-o functie care returneaza o
valoare
• Valorile returnate sunt principala modalitate de a trimite
informatii de la o functie inapoi la apelant
• Uneori, putem comunica inapoi apelantului prin modificarea
parametrilor functiei.
Functii care modifica parametrii
• Sa presupunem ca scriem un program care gestioneaza
conturi bancare.
def addInterest(balance, rate):
newBalance = balance * (1 + rate)
balance = newBalance
• Ideea este de a seta soldul contului la o noua valoare care
include si dobanda
Functii care modifica parametrii
• Programul principal care testeaza aceasta functie:
• def test():
amount = 1000
rate = 0.05
addInterest(amount, rate)
print(amount)
• Ne asteptam ca, daca adunam 5% la suma initiala, sa
obtinem 1050
• >>> test()
1000
Functii care modifica parametrii
def addInterest(balance, rate):
• Primele 2 linii ale functiei newBalance = balance * (1 + rate)
balance = newBalance
test creeaza 2 variabile
locale: amount si rate def test():
amount = 1000
carora le sunt atribuite rate = 0.05
valorile initiale 1000 si 0.05 addInterest(amount, rate)
print(amount)
Functii care modifica parametrii
def addInterest(balance, rate):
• Pe a 3a linie, controlul este newBalance = balance * (1 + rate)
balance = newBalance
preluat de functia
addInterest def test():
amount = 1000
• Parametrilor formali rate = 0.05
addInterest(amount, rate)
balance si rate le sunt print(amount)
atribuite valorile amount si
rate ale parametrilor reali
(1000 si 0.05)
Functii care modifica parametrii
def addInterest(balance, rate):
• Chiar daca variabila rate newBalance = balance * (1 + rate)
balance = newBalance
apare in ambele, acestea
sunt variabile separate, din def test():
amount = 1000
cauza regulilor de domeniu. rate = 0.05
addInterest(amount, rate)
print(amount)
Functii care modifica parametrii

• Atribuirea acestor parametri def addInterest(balance, rate):

newBalance = balance * (1 + rate)
determina balance si balance = newBalance
rate din functia
def test():
addInterest sa ia amount = 1000
valorile parametrilor reali rate = 0.05
addInterest(amount, rate)
(1000 si 0.05) print(amount)
 Functii care modifica parametrii

ou nt def addInterest(balance, rate):

def test(): am
amount = 1000 nce = te newBalance = balance * (1 + rate)
la a
ba te =r balance = newBalance
rate = 0.05 ra
addInterest(amount, rate)
print(amount)

amount 1000 balance

rate 0.05 rate

Functii care modifica parametrii

• Executia primei linii a functiei addInterest creeaza o

noua variabila, newBalance
• balance este apoi atribuita variabilei newBalance
• balance se refera acum la aceeasi valoare ca
newBalance,dar aceasta nu are niciun efect asupra
variabilei amount din functia test
Functii care modifica parametroi
m ount
def test(): e = a def addInterest(balance, rate):
alanc te newBalance = balance * (1 + rate)
amount = 1000b =ra
rate balance = newBalance
rate = 0.05
addInterest(amount, rate)
print(amount)

amount 1000 balance

rate 0.05 rate

newBalance

1005
Functii care modifica parametri

• Executia functiei addInterest s-a terminat si controlul se intoarce

la functia test
• Variabilele locale, inclusiv parametrii, sunt sterse, iar variabilele
amount si rate din functia test fac referire la valorile lor initiale
(1000 si 0.05)
• Parametrii formali ai unei functii primesc doar valorile parametrilor
reali. Functia nu are acces la variabilele care fac referire la acesti
parametri (amount si rate)
Functii care modifica parametri
• Pentru a modifica variabila amount, functia addInterest
este modificata, astfel incat sa returneze o valoare.
def addInterest(balance, rate):
newBalance = balance * (1 + rate)
return newBalance
def test():
amount = 1000
rate = 0.05
amount = addInterest(amount, rate)
print(amount)
>>>test()
Functii care modifica parametrii

• In loc sa modificam un singur cont, putem scrie un program

pentru o banca ce se ocupa de mai multe conturi
• Putem memora soldurile conturilor intr-o lista, apoi
adaugam dobanda acumulata fiecaruia dintre soldurile din
lista.
• Putem sa modificam primul cont din lista folosind codul:
balances[0] = balances[0] * (1 + rate)
Functii care modifica parametri

balances[0] = balances[0] * (1 + rate)

• Valoarea de pe prima pozitie din lista (balances[0]) este
multiplicata cu (1 + rate). Rezultatul este pus inapoi in lista, la
pozitia 0.
• La modul general, acest lucru se poate realiza cu ajutorul unei bucle
care merge prin pozitiile 0, 1, …length -1
# addinterest3.py
def addInterest(balances, rate):
for i in range(len(balances)):
balances[i] = balances[i] * (1+rate)
return balances

def test():
amounts = [1000, 2200, 800, 360]
rate = 0.05
amounts =addInterest(amounts, 0.05)
print(amounts)
>>>test()
Functii care modifica parametrii
• Pentru valorile initiale ale soldurilor:
[1000, 2200, 800, 360]
programul returneaza
[1050.0, 2310.0, 840.0, 378.0]
 Functii care modifica parametrii

• Primele 2 linii ale programului creaza variabilele amounts si rate

• Valoarea variabilei amounts este un obiect lista care contine 4 valori
int.

def test(): def addInterest(balances, rate):

amounts = [1000, 2200, 800, 360] for i in range(len(balances)):
rate = 0.05 balances[i] = balances[i] *
(1+rate)
addInterest(amounts, 0.05)
print(amounts)
Functii care modifica parametrii
def test (): def addInterest(balances, rate):
amounts=[1000, 2200, 800, 360 ] for i in range(len(balances)):
balances[i] = balances[i] *
rate=0.5 (1+rate)
addInterest(amounts, rate)
print(amounts)

rate 0.5 rate

amounts [ …. ………… …………………] balances

1000 2200 800 360

 Functii care modifica parametrii
• Pe linia a 3a este executata functia addInterest.
• Bucla for trece prin fiecare index de la 0 la length-1 si updateaza
valoarea din balances

def addInterest(balances, rate):

for i in range(len(balances)):
balances[i] = balances[i] * (1+rate)
Functii care modifica parametrii
def test (): def addInterest(balances, rate):
amounts=[1000, 2200, 800, 360 ] for i in range(len(balances)):
balances[i] = balances[i] *
rate=0.5 (1+rate)
addInterest(amounts, rate)
print(amounts)

rate 0.5 rate

amounts [ …. ………… …………………] balances

1050 2310 840 378

Functii care modifica parametrii

• La incheierea functiei addInterest, lista din variabila

amounts va contine noile valori.
• In urma executiei functiei addInterest, variabila
amounts nu se schimba (ramane tot o lista), doar ca
valorile acesteia vor fi modificate.
Functii lambda
■ Functiile lambda in Python sunt functii anonime, nu au nume
Forma generala:
lambda lista_argumente: expresie
Functie pentru a calcula patratul unui numar:
def patrat(x)
return x*x
Folosind lambda:
lambda x:x*x
Functii lambda
lambda x:x*x
§ Daca atribuim rezultatul unei variabile:
f=lambda x:x*x
§ Atunci, pentru a apela functia, se foloseste:
>>>f(5)
25
§ Rareori se foloseste aceasta scriere, de obicei expresiile lambda sunt
folosite in interiorul altor functii
Cubul unui numar folosind lambda
■ Functia clasica pentru a calcula cubul unui numar:
def cub (x)
return x**3
>>>print(cub(2)
§ Folosind lambda:
f=lambda x:x**3
f(2)
Concluzii

• Pana acum functiile au fost folosite ca un mecanism pentru

a reduce dublarea codului.
• Un alt motiv pentru a folosi functii este modularea
programului.
• Pe masura ce algoritmii pe care ii proiectam devin din ce in
ce mai complecsi, programul este din ce in ce mai dificil de
inteles.
• O modalitatea de a modula un program este de a-l imparti
in subprograme, fiecare subprogram executand un anumit
task.