Sfetcu, Nicolae (2025), Definirea și utilizarea funcțiilor în limbajul de programare Python, IT & C, 4:4, 33-49, DOI: 10.58679/IT50624, https://www.internetmobile.ro/definirea-si-utilizarea-functiilor-in-limbajul-de-programare-python/

Defining and Using Functions in the Python Programming Language

Abstract

In the context of programming, a function is a sequence of instructions grouped under a name that performs a specific operation or calculates a value. Functions allow a complex program to be divided into smaller, more manageable components, each component performing a specific task. For example, the Python language provides numerous predefined functions. In addition, programmers can define their own (user-defined) functions to solve particular problems.

Keywords: programming, Python programming language, Python, Python functions, defining functions, using functions

Rezumat

În contextul programării, funcția reprezintă o secvență de instrucțiuni grupate sub un nume, care îndeplinesc o anumită operație sau calculează o valoare. Funcțiile permit împărțirea unui program complex în componente mai mici și ușor de gestionat, fiecare componentă realizând o sarcină specifică. De exemplu, limbajul Python oferă numeroase funcții predefinite. Pe lângă acestea, programatorii își pot defini funcții proprii (user-defined) pentru a rezolva probleme particulare.

Cuvinte cheie: programare, limbajul de programare Python, Python, funcții Python, definirea funcțiilor, utilizarea funcțiilor

IT & C, Volumul 4, Numărul 4, Decembrie 2025, pp. 33-49
ISSN 2821 – 8469, ISSN – L 2821 – 8469, DOI: 10.58679/IT50624
URL: https://www.internetmobile.ro/definirea-si-utilizarea-functiilor-in-limbajul-de-programare-python/
© 2025 Nicolae SFETCU. Responsabilitatea conținutului, interpretărilor și opiniilor exprimate revine exclusiv autorilor.

Definirea și utilizarea funcțiilor în limbajul de programare Python

Nicolae SFETCU[1]
nicolae@sfetcu.com

[1] Cercetător – Academia Română (Comitetul Român de Istoria și Filosofia Științei și Tehnicii (CRIFST) , Divizia de Istoria Științei (DIS)), ORCID: 0000-0002-0162-9973

Introducere

În contextul programării, funcția reprezintă o secvență de instrucțiuni grupate sub un nume, care îndeplinesc o anumită operație sau calculează o valoare (Downey 2015). Funcțiile permit împărțirea unui program complex în componente mai mici și ușor de gestionat, fiecare componentă realizând o sarcină specifică (GeeksforGeeks 2025). De exemplu, limbajul Python oferă numeroase funcții predefinite (built-in) precum print(), len() sau round(), pe care le-am folosit deja intuitiv. Pe lângă acestea, programatorii își pot defini funcții proprii (user-defined) pentru a rezolva probleme particulare.

Funcțiile joacă un rol esențial în scrierea de cod clar și reutilizabil. Importanța utilizării funcțiilor în Python (ca și în alte limbaje) se reflectă în multiple beneficii:

• Modularizarea codului: Funcțiile ajută la structurarea programelor în module mai mici. Fiecare funcție poate fi dezvoltata și testată independent, ceea ce face programul general mai ușor de înțeles și de întreținut (GeeksforGeeks 2025).
• Reutilizarea codului: Odată definită, o funcție poate fi apelată de oricâte ori este nevoie, din diferite părți ale programului, evitând duplicarea acelorași secvențe de cod (GeeksforGeeks 2025). Așa cum subliniază o resursă, „în loc să scrii același cod ori de câte ori programul are nevoie să efectueze aceeași sarcină, doar apelezi funcția!” (Acsany 2025). Acest lucru îmbunătățește eficiența și reduce șansele de eroare.
• Claritate și întreținere: Funcțiile bine proiectate îmbunătățesc lizibilitatea codului prin izolarea funcționalităților. Programatorii pot înțelege mai ușor un program dacă acesta este împărțit în funcții cu nume semnificative, fiecare realizând o sarcină clară (GeeksforGeeks 2025). De asemenea, depanarea este facilitată, deoarece eventualele probleme pot fi izolate în funcția aferentă, făcând mai simplă identificarea și rezolvarea erorilor (GeeksforGeeks 2025).
• Abstracție: Prin utilizarea funcțiilor, detaliile de implementare ale unei operații pot fi ascunse în spatele numelui funcției. Modul în care funcția își realizează sarcina nu mai este relevant pentru restul programului; este important doar ce face funcția, nu cum. Această abstracție permite folosirea funcției ca o cutie neagră, reducând complexitatea percepută a programului.

Având în vedere aceste aspecte, funcțiile reprezintă „piese de bază” ale aproape oricărui program Python (Acsany 2025), fiind fundamentale în dezvoltarea de programe scalabile și ușor de înțeles. În continuare, în cadrul metodologiei, vom discuta cum se definesc funcțiile în Python, cum se folosesc parametrii și valorile returnate, precum și conceptul de variabile locale vs. globale în contextul funcțiilor. Ulterior, în secțiunea de Rezultate, vom prezenta exemple practice de utilizare a funcțiilor Python pentru rezolvarea unor probleme educaționale din matematică și algoritmică de bază.

Metodologie

Definirea funcțiilor în Python

În limbajul Python, definirea unei funcții se realizează cu ajutorul cuvântului-cheie def, urmat de numele funcției și lista de parametri (dacă există) între paranteze, apoi simbolul :. Instrucțiunile care constituie corpul funcției sunt plasate pe liniile următoare, indentate (aliniate la dreapta) față de definiția def (Stackless 2021). Acest format este ilustrat mai jos:

def salut():

print(„Bună ziua!”)

În exemplul de mai sus, salut este numele funcției, nu are parametri (lista dintre paranteze este goală) și conține o singură instrucțiune în corp: afișarea unui mesaj. Definirea funcției nu execută automat codul din interiorul ei; instrucțiunile respective vor fi rulate doar atunci când apelăm funcția, folosind sintaxa salut() în cod.

Conform documentației oficiale Python, prima linie a corpului funcției poate fi opțional un șir de caractere (string) literal, care servește drept șir de documentație sau docstring al funcției (Stackless 2021). Acest docstring descrie pe scurt ce face funcția și este o bună practică de programare să fie inclus, deoarece poate fi folosit de instrumente automate sau de funcția built-in help() pentru a genera documentație. Exemplu:

def salut():

„””Această funcție afișează un mesaj de salut generic.”””

print(„Bună ziua!”)

În codul de mai sus, textul dintre triplele ghilimele este docstring-ul funcției salut. Deși opțional, adăugarea docstring-urilor este încurajată în dezvoltarea de software educațional și academic, contribuind la claritatea și întreținerea codului.

Crearea funcțiilor

Iată un exemplu despre ceea ce ați putea face, dar nu ar trebui: (Sfetcu 2025)

a = 23b = -23 if a < 0:    a = -aif b < 0:    b = -bif a == b:    print(„The absolute values of”, a, „and”, b, „are equal.”)else:    print(„The absolute values of”, a, „and”, b, „are different.”)

cu ieșirea fiind:

The absolute values of 23 and 23 are equal.

Programul pare puțin repetitiv. Programatorii urăsc să repete lucrurile – pentru asta sunt computerele, până la urmă! (Rețineți, de asemenea, că găsirea valorii absolute a schimbat valoarea variabilei, motiv pentru care se tipărește 23 și nu -23 în ieșire.) Din fericire, Python vă permite să creați funcții pentru a elimina duplicarea. Iată exemplul rescris:

a = 23b = -23 def absolute_value(n):    if n < 0:        n = -n    return n if absolute_value(a) == absolute_value(b):    print(„The absolute values of”, a, „and”, b, „are equal.”)else:    print(„The absolute values of”, a, „and”, b, „are different.”)

cu ieșirea fiind:

The absolute values of 23 and -23 are equal.

Caracteristica cheie a acestui program este declarația def. def (prescurtare de la definire) începe o definiție a funcției. def este urmat de numele funcției absolute_value. Urmează un „(” urmat de parametrul n (n este trecut din program în funcție când funcția este apelată). Instrucțiunile de după „:” sunt executate când funcția este utilizată. Instrucțiunile continuă până când fie instrucțiunile indentate se termină fie se întâlnește o return. Instrucțiunea return returnează o valoare înapoi la locul unde a fost apelată funcția. Am întâlnit deja o funcție în primul nostru program, funcția print. Acum putem face noi funcții.

Observați cum valorile lui a și  b nu sunt modificate. Funcțiile pot fi folosite pentru a repeta sarcini care nu returnează valori. Aici sunt cateva exemple:

def hello():    print(„Hello”) def area(width, height):    return width * height def print_welcome(name):    print(„Welcome”, name) hello()hello() print_welcome(„Fred”)w = 4h = 5print(„width =”, w, ” height =”, h, ” area =”, area(w, h))

cu ieșirea fiind:

Hello

Hello

Welcome Fred

width = 4  height = 5  area = 20

Acest exemplu arată mai multe lucruri pe care le puteți face cu funcții. Observați că nu puteți utiliza niciun argument sau două sau mai multe. Observați, de asemenea, când o funcție nu trebuie să trimită înapoi o valoare, returnarea este opțională. (Sfetcu 2025)

Parametrii funcțiilor și apelarea acestora

O funcție poate fi definită astfel încât să primească una sau mai multe valori de intrare, numite parametri. Parametrii apar între parantezele de după numele funcției, separați prin virgulă dacă sunt multipli. La apelul funcției, valorile efective transmise se numesc argumente și vor fi atribuite parametrilor definiți, în ordinea specificată.

De exemplu, definim o funcție care calculează aria unui dreptunghi pe baza lungimilor laturilor sale, lungime și lățime, transmise ca parametri:

def aria_dreptunghi(lungime, latime):

„””Calculează aria unui dreptunghi cu laturile date.”””

return lungime * latime

Funcția aria_dreptunghi are doi parametri (lungime și latime). Folosim cuvântul-cheie return (discutat în secțiunea următoare) pentru a furniza rezultatul calculului. Pentru a utiliza această funcție, o putem apela cu argumente numerice astfel:

print(aria_dreptunghi(5, 3))  # Va afișa 15, deoarece 5*3 = 15

La apel, valoarea 5 este atribuită parametrului lungime și 3 parametrului latime, astfel funcția va calcula 5 * 3 și va returna 15.

Este important de reținut că, implicit, o funcție trebuie apelată cu exact numărul de argumente specificat de parametri la definire. Dacă, de exemplu, încercăm să apelăm aria_dreptunghi(5) cu un singur argument sau aria_dreptunghi(5, 3, 2) cu trei argumente, Python va genera o eroare de tip (pentru că numărul de argumente nu corespunde parametrilor așteptați). Totuși, Python suportă și parametri opționali sau cu valoare implicită. Putem specifica o valoare implicită pentru un parametru direct în definiție, ceea ce face ca argumentul respectiv să devină opțional la apel. De exemplu:

def salut_persoana(nume=”utilizator”):

print(f”Bună, {nume}!”)

În această definiție, parametrul nume are valoarea implicită „utilizator”. Astfel, funcția poate fi apelată fie cu un argument (salut_persoana(„Ana”) va afișa Bună, Ana!), fie fără niciun argument (salut_persoana() va afișa Bună, utilizator!), caz în care se folosește valoarea prestabilită. Parametrii cu valori implicite permit crearea de funcții flexibile, care pot fi apelate în moduri diferite fără a provoca erori.

Valorile returnate de funcții

O funcție în Python poate returna o valoare către locul din care a fost apelată, folosind instrucțiunea return. Atunci când execuția întâlnește return în interiorul funcției, aceasta se încheie, iar valoarea (sau valorile) specificată după return este trimisă apelantului. Dacă o funcție nu conține nicio instrucțiune return sau dacă return este folosit fără a indica vreo expresie, funcția va returna implicit valoarea specială None (care indică „nimic”/absența unei valori) (Chelliah 2020).

În exemplul anterior aria_dreptunghi, folosirea lui return lungime * latime face ca rezultatul înmulțirii să fie disponibil în programul care a apelat funcția. Prin contrast, o funcție care doar afișează ceva cu print nu transmite niciun rezultat programului apelant, ci produce doar un efect vizual. De exemplu:

def afisare_suma(a, b):

print(a + b)

def calculeaza_suma(a, b):

return a + b

x = afisare_suma(2, 3)   # va imprima 5, dar nu returnează nimic util

y = calculeaza_suma(2, 3)  # nu afișează nimic, dar returnează 5

print(x, y)

În codul de mai sus, apelul afisare_suma(2, 3) va tipări 5 pe ecran, însă variabila x va primi valoarea None (funcția nu a returnat explicit nimic). În schimb, calculeaza_suma(2, 3) returnează valoarea 5 fără a o afișa; astfel, variabila y va conține 5, iar instrucția print(x, y) va afișa None 5. În general, pentru funcțiile care calculează valori ce trebuie folosite ulterior în program, este preferabil să se folosească return în loc de print în interiorul funcției.

Python permite returnarea oricărui tip de obiect, inclusiv a mai multor valori simultan. De fapt, atunci când se scriu mai multe expresii separate prin virgulă după return, funcția va returna un tuplu care conține acele valori. Aceasta este o caracteristică utilă pentru a evita folosirea variabilelor globale sau a structurilor complicate pentru a obține mai multe rezultate dintr-o singură funcție. De exemplu, următoarea funcție întoarce atât suma, cât și produsul a două numere date:

def suma_si_produs(x, y):

„””Returnează atât suma cât și produsul lui x și y.”””

return x + y, x * y

# Utilizare:

s, p = suma_si_produs(3, 4)

print(s, p)  # Va afișa: 7 12

Aici, suma_si_produs(3, 4) returnează simultan două valori (în spate, un tuplu (7, 12)). Aceste valori sunt atribuite variabilelor s și p prin destructurare (unpacking). Această tehnică evidențiază puterea și flexibilitatea funcțiilor în Python – ele pot fi folosite nu doar pentru un rezultat unic, ci și pentru a livra seturi de rezultate complexe către restul programului.

Variabile în funcții

Când eliminați codul repetat, aveți adesea variabile în codul repetat. (Sfetcu 2025) În Python, acestea sunt tratate într-un mod special. Până acum toate variabilele pe care le-am văzut sunt variabile globale. Funcțiile au un tip special de variabilă numită variabile locale. Aceste variabile există doar în timp ce funcția rulează. Când o variabilă locală are același nume cu o altă variabilă (cum ar fi o variabilă globală), variabila locală o ascunde pe cealaltă. Sună confuz? Ei bine, aceste exemple următoare (care sunt puțin artificioase) ar trebui să ajute la clarificarea lucrurilor.

a = 4 def print_func():    a = 17    print(„in print_func a =”, a) print_func()print(„a = „, a)

Când rulăm, vom primi o ieșire de:

in print_func a = 17

a = 4

Atribuțiile de variabile în interiorul unei funcții nu înlocuiesc variabilele globale, ele există doar în interiorul funcției. Chiar dacă lui a i-a fost atribuită o nouă valoare în interiorul funcției, această valoare nou atribuită a fost relevantă doar pentru print_func, când funcția se termină de rulat și valorile lui a sunt imprimate din nou, vedem valorile atribuite inițial.

Iată un alt exemplu mai complex.

a_var = 10b_var = 15e_var = 25 def a_func(a_var):    print(„in a_func a_var =”, a_var)    b_var = 100 + a_var    d_var = 2 * a_var    print(„in a_func b_var =”, b_var)    print(„in a_func d_var =”, d_var)    print(„in a_func e_var =”, e_var)    return b_var + 10 c_var = a_func(b_var) print(„a_var =”, a_var)print(„b_var =”, b_var)print(„c_var =”, c_var)print(„d_var =”, d_var)

ieșirea:

in a_func a_var =  15

in a_func b_var =  115

in a_func d_var =  30

in a_func e_var =  25

a_var =  10

b_var =  15

c_var =  125

d_var =

Traceback (most recent call last):

File „C:\def2.py”, line 19, in <module>

print(„d_var = „, d_var)

NameError: name ‘d_var’ is not defined

În acest exemplu, variabilele a_var, b_var și d_var sunt toate variabile locale atunci când sunt în interiorul funcției a_func. După rularea instrucțiunii return b_var + 10, toate încetează să mai existe. Variabila a_var este automat o variabilă locală, deoarece este un nume de parametru. Variabilele b_var și d_var sunt variabile locale deoarece apar în stânga unui semn egal în funcție în instrucțiunile b_var = 100 + a_var și d_var = 2 * a_var.

În interiorul funcției a_var nu are nicio valoare atribuită. Când funcția este apelată cu c_var = a_func(b_var), 15 este atribuit lui a_var, deoarece în acel moment b_var este 15, făcând apel la funcția a_func(15). Aceasta se termină setând a_var la 15 când este în interiorul lui a_func.

După cum puteți vedea, odată ce funcția se termină de rulat, variabilele locale a_var și b_var care au ascuns variabilele globale cu același nume dispar. Apoi instrucțiunea print(„a_var = „, a_var) afișează valoarea 10 și nu valoarea 15, deoarece variabila locală care a ascuns variabila globală a dispărut.

Un alt lucru de observat este NameError care se întâmplă la sfârșit. Aceasta apare deoarece variabila d_var nu mai există de când a_func a terminat. Toate variabilele locale sunt șterse atunci când funcția iese. Dacă doriți să obțineți ceva dintr-o funcție, atunci va trebui să utilizați return something.

Un ultim lucru de observat este că valoarea lui e_var rămâne neschimbată în interiorul a_func, deoarece nu este un parametru și nu apare niciodată în stânga unui semn egal în interiorul funcției a_func. Când o variabilă globală este accesată în interiorul unei funcții, aceasta este variabila globală din exterior.

Funcțiile permit variabile locale care există numai în interiorul funcției și pot ascunde alte variabile care se află în afara funcției. (Sfetcu 2025)

Variabile locale și variabile globale în funcții

În interiorul unei funcții definite în Python, variabilele locale sunt cele create și utilizate doar în acel bloc al funcției, pe când variabilele globale sunt cele definite în afara oricărei funcții (de obicei la nivel de modul) și accesibile în tot programul. În momentul apelării unei funcții, se creează un spațiu de nume local (un context local) nou, unde vor fi rezolvate numele variabilelor folosite în funcție. Prin urmare, toate atribuțiile de valori către variabile făcute în interiorul funcției vor afecta variabile locale (din acest context intern), și nu variabile globale cu același nume (dacă există) (Stackless 2021).

În Python, dacă într-o funcție doar se citește valoarea unei variabile (fără a i se atribui ceva), atunci acea variabilă este considerată globală, Python căutând-o în mediul global al programului (Python 2025). În schimb, dacă o variabilă este asignată (i se dă o valoare) oriunde în corpul funcției, interpretul o va considera locală (creată în cadrul funcției), cu excepția cazului în care este declarată explicit ca fiind globală. Această regulă poate produce un efect surprinzător pentru începători. Să analizăm un exemplu:

x = 10      # variabilă globală

def exemplu():

print(x)  # încercare de a folosi variabila globală x

x += 1    # atribuire către x – Python o consideră variabilă locală

exemplu()

La prima vedere, am putea aștepta ca apelul exemplu() să afișeze valoarea lui x și apoi să mărească x cu 1. Însă codul de mai sus va produce o eroare de execuție, deoarece Python interpretează instrucțiunea x += 1 ca o atribuire către o variabilă locală x, shadowing (ascunzând) variabila globală cu același nume. Astfel, când execută print(x), funcția găsește că x local nu a fost inițializat și declanșează o eroare de tip UnboundLocalError, cu mesajul „local variable ‘x’ referenced before assignment” (Python 2025). În esență, prezența unei atribuiri lui x în funcție face ca x să devină locală, chiar dacă exista o variabilă globală x. Pentru a corecta acest comportament și a indica explicit că dorim să folosim variabila globală x în funcție (inclusiv pentru modificare), Python oferă instrucțiunea global. Rescriind exemplul:

x = 10

def exemplu_global():

global x      # declarăm că vom folosi variabila globală x

print(x)      # afișează valoarea globală a lui x

x += 1        # modifică variabila globală

exemplu_global()

print(x)  # afișăm valoarea lui x după apelul funcției

Acum, exemplu_global() va accesa variabila globală x, va afișa 10 și apoi o va incrementa la 11. Instrucțiunea global x informează interpretorul că toate referirile la x din această funcție trebuie să se refere la variabila globală existentă, nu la o variabilă locală nouă. În mod analog, Python oferă și cuvântul-cheie nonlocal pentru cazurile în care avem funcții definite în interiorul altor funcții (variabile închise în scopuri intermediare). nonlocal permite accesul și modificarea unei variabile dintr-o funcție exterioară (dar care nu este globală) (Python 2025) (Stackless 2021). Aceste mecanisme previn efectele colaterale nedorite: în absența global, orice atribuire involuntară într-o funcție nu va afecta variabilele globale, protejând astfel datele la nivel de program de modificări accidentale.

Recomandare: În practica programării (și în special în context educațional), este indicat să se evite pe cât posibil utilizarea variabilelor globale pentru a transmite informații între funcții. În schimb, preferați transmiterea de parametri și returnarea de valori. Codul devine astfel mai ușor de urmărit și de testat, fiecare funcție având dependențe explicite (prin parametri) și efecte vizibile (prin valorile returnate), în loc să se bazeze pe stări globale ascunse.

Rezultate

În această secțiune vom demonstra utilizarea funcțiilor Python în rezolvarea unor probleme simple, de natură educațională, evidențiind avantajele abordării modulare. Vom prezenta două exemple relevante: unul din domeniul matematic (calculul factorial al unui număr) și unul algoritmic (verificarea dacă un număr este prim). Fiecare exemplu include definirea funcției, folosirea acesteia și interpretarea rezultatului.

Exemplul 1: Calculul factorial al unui număr

Problema factorialului este un exemplu clasic atât în matematică, cât și în programare. Factorialul unui număr întreg nenegativ n, notat n!, este definit ca produsul tuturor numerelor întregi de la 1 la n (cu convenția că 0! = 1). Vom scrie o funcție Python, factorial(n), care calculează această valoare. Implementarea poate fi realizată iterativ (prin parcurgerea unui șir de valori și înmulțirea lor) sau recursiv. Aici vom folosi o abordare iterativă:

def factorial(n):

„””Calculează factorialul lui n (n!).”””

rezultat = 1

for i in range(1, n + 1):

rezultat *= i

return rezultat

# Exemplu de utilizare și afișare a rezultatului:

print(f”5! = {factorial(5)}”)  # 5! = 120

Funcția factorial inițializează o variabilă locală rezultat cu valoarea 1, apoi parcurge toate valorile i de la 1 la n și le înmulțește succesiv în rezultat. La final, rezultat reprezintă chiar factorialul lui n și este returnat. Am inclus un docstring care explică pe scurt ce calculează funcția.

La apelul exemplificat (factorial(5)), funcția va efectua calculul 1 × 2 × 3 × 4 × 5 și va întoarce valoarea 120. Instrucțiunea print(f”5! = {factorial(5)}”) va afișa mesajul 5! = 120. Putem testa funcția și pe alte valori: factorial(0) va returna 1 (prin convenție), factorial(1) va returna 1, iar factorial(6) va returna 720. Acest exemplu evidențiază modul în care funcțiile pot fi folosite pentru a implementa algoritmi matematici într-un mod clar și reutilizabil: odată ce funcția factorial este definită, o putem folosi oriunde în program pentru a calcula factorialul oricărui număr, fără a rescrie logica de la zero.

Exemplul 2: Verificarea dacă un număr este prim

Un alt exemplu instructiv este determinarea dacă un număr întreg dat este număr prim (adică are exact doi divizori: 1 și el însuși). Aceasta este o problemă algoritmică fundamentală. Vom crea o funcție este_prim(n) care returnează True dacă n este număr prim și False altfel. Strategia simplă de rezolvare este să verificăm dacă n are vreun divizor între 2 și √n (deoarece dacă n are un factor mai mare decât √n, va avea și unul mai mic decât √n, deci nu e nevoie să testăm până la n-1). Iată implementarea:

def este_prim(n):

„””Verifică dacă n este număr prim.”””

if n < 2:

return False

for i in range(2, int(n**0.5) + 1):

if n % i == 0:

return False

return True

# Exemplu de utilizare și rezultate:

print(„17 este prim?”, este_prim(17))  # 17 este prim? True

print(„18 este prim?”, este_prim(18))  # 18 este prim? False

Funcția este_prim începe prin a trata un caz special: orice număr mai mic decât 2 (adică 0 sau 1, sau chiar numere negative) nu este considerat prim, astfel se returnează direct False pentru aceste situații. Apoi, pentru n >= 2, funcția iterează variabila i în intervalul [2, √n] (folosind int(n**0.5) + 1 ca limită superioară a intervalului, deoarece range nu include capătul de interval). Dacă n este divizibil exact (n % i == 0) de vreo valoare i din acest interval, atunci n are un divizor diferit de 1 și el însuși, deci nu este prim – funcția returnează False. Dacă bucla se termină fără a găsi vreun divizor, înseamnă că n este prim, și funcția returnează True.

În exemplul de utilizare de mai sus, este_prim(17) va parcurge i de la 2 până la 4 (deoarece √17 ≈ 4.12, deci range(2, 5) = {2,3,4}). 17 nu este divizibil cu 2, 3 sau 4, așadar funcția va returna True. În schimb, este_prim(18) va detecta că 18 este divizibil cu 2 (chiar la primul pas al buclei) și va returna imediat False. Când rulăm codul, se afișează:

17 este prim? True

18 este prim? False

Rezultatele confirmă așteptările: 17 este număr prim, iar 18 nu este. Acest exemplu demonstrează cum funcțiile pot implementa algoritmi de bază (aici, un algoritm de testare a primalității) și pot fi reutilizate pentru diferite intrări. De pildă, putem folosi este_prim într-un program mai mare pentru a genera o listă de numere prime sau pentru a verifica rapid primalitatea numerelor introduse de un utilizator, fără a reimplementa logica de fiecare dată.

Observație: Implementarea de mai sus a testului de primalitate este eficientă pentru valori relativ mici ale lui n. Pentru numere foarte mari, există algoritmi mai avansați, însă scopul aici este ilustrarea principiului utilizării funcțiilor. În context educațional, astfel de funcții oferă ocazia de a discuta atât optimizarea algoritmilor, cât și importanța structurării programelor.

Exemplul 3: Convertește temperatura în Fahrenheit sau Celsius (Wikibooks 2025)

#! /usr/bin/python#-*-codare: utf-8 -*-# convertește temperatura în Fahrenheit sau Celsius def print_options():    print(„Options:”)    print(” ‘p’ print options”)    print(” ‘c’ convert from Celsius”)    print(” ‘f’ convert from Fahrenheit”)    print(” ‘q’ quit the program”) def celsius_to_fahrenheit(c_temp):    return 9.0 / 5.0 * c_temp + 32 def fahrenheit_to_celsius(f_temp):    return (f_temp – 32.0) * 5.0 / 9.0 choice = „p”while choice != „q”:    if choice == „c”:        c_temp = float(input(„Celsius temperature: „))        print(„Fahrenheit:”, celsius_to_fahrenheit(c_temp))        choice = input(„option: „)    elif choice == „f”:        f_temp = float(input(„Fahrenheit temperature: „))        print(„Celsius:”, fahrenheit_to_celsius(f_temp))        choice = input(„option: „)    else:        choice = „p”    #Alternative alege != „q”: so that print                         #când nu a intrat nimic neașteptat        print_options()        choice = input(„option: „)

La rulare:

Options:

‘p’ print options

‘c’ convert from celsius

‘f’ convert from fahrenheit

‘q’ quit the program

option: c

Celsius temperature: 30

Fahrenheit: 86.0

option: f

Fahrenheit temperature: 60

Celsius: 15.5555555556

option: q

Exemplul 4: Calculează o suprafață dreptunghiulară dată (Wikibooks 2025)

#! /usr/bin/python#-*-codare: utf-8 -*-# calculează o suprafață dreptunghiulară dată def hello():    print(‘Hello!’) def area(width, height):    return width * height def print_welcome(name):    print(‘Welcome,’, name) def positive_input(prompt):    number = float(input(prompt))    while number <= 0:        print(‘Must be a positive number’)        number = float(input(prompt))    return number name = input(‘Your Name: ‘)hello()print_welcome(name)print()print(‘To find the area of a rectangle,’)print(‘enter the width and height below.’)print()w = positive_input(‘Width: ‘)h = positive_input(‘Height: ‘) print(‘Width =’, w, ‘ Height =’, h, ‘ so Area =’, area(w, h))

La rulare:

Your Name: Josh

Hello!

Welcome, Josh

To find the area of a rectangle,

enter the width and height below.

Width: -4

Must be a positive number

Width: 4

Height: 3

Width = 4  Height = 3  so Area = 12

Discuție

Exemplele prezentate evidențiază avantajele definării și utilizării funcțiilor în Python, mai ales într-un cadru educațional. Prin encapsularea logicii într-o funcție cu un nume descriptiv, am separat clar ce face programul de cum face. Atât calculul factorial, cât și testul de primalitate au fost implementate sub forma unor funcții reutilizabile, pe care le-am putut apela cu ușurință pentru a obține rezultatele dorite. Acest mod de organizare a codului facilitează reutilizarea (putem folosi factorial sau este_prim oriunde în alt program fără modificări), precum și testarea modulară – de exemplu, putem verifica funcția este_prim separat, asigurându-ne că funcționează corect, independent de restul programului.

De asemenea, discuția despre variabilele locale și globale în contextul funcțiilor subliniază un aspect important: funcțiile introduc propriul mediu de execuție, protejând astfel spațiul global de interferențe neintenționate. Aceasta obligă la gândirea în termeni de intrări (parametri) și ieșiri (valori returnate), un exercițiu benefic în formarea unui stil de programare curat. Pe de altă parte, utilizarea conștientă a variabilelor globale (cu global) sau a variabilelor nonlocal (cu nonlocal în funcții imbricate) le arată studenților mecanismele prin care diferitele părți ale unui program pot comunica, subliniind totodată necesitatea documentării acestor efecte (pentru a evita confuzia).

Pentru a avansa dincolo de nivelul intermediar, studenții pot explora și alte concepte legate de funcții în Python. Recursivitatea, de pildă, este tehnica prin care o funcție se apelează pe ea însăși pentru a rezolva o sub-problemă (multe definiții matematice, inclusiv factorialul, pot fi implementate recursiv). De asemenea, Python permite definirea de funcții anonime (lambda) pentru calcule simple și suportă concepte de programare funcțională (precum transmiterea de funcții ca argumente către alte funcții, closuri, decoratori etc.). Aceste subiecte mai avansate se bazează pe înțelegerea solidă a definiției și utilizării funcțiilor, așa cum au fost expuse în acest articol.

În concluzie, funcțiile constituie un instrument fundamental în Python, esențial pentru scrierea de cod structurat, eficient și ușor de întreținut. Stăpânirea conceptului de funcție și a mecanismelor asociate (parametri, valori returnate, domeniul variabilelor) le permite programatorilor să abordeze probleme din ce în ce mai complexe prin divide et impera – împărțirea problemelor în sub-probleme rezolvabile independent. Literatura de specialitate și documentația oficială Python consolidează aceste cunoștințe, oferind îndrumări și bune practici, precum cele menționate în referințele de mai jos.

Bibliografie

• Acsany, Philipp. 2025. “Python Basics: Functions and Loops – Real Python.” https://realpython.com/courses/python-basics-functions-loops/.
• Chelliah, Indhumathy. 2020. “Everything You Ever Wanted to Know About Python Return Statements.” All About AI-ML, September 4. https://indhumathychelliah.com/2020/09/04/everything-you-ever-wanted-to-know-about-python-return-statements/.
• Downey, Allen. 2015. “Think Python – How to Think Like a Computer Scientist.” Green Tea Press. https://greenteapress.com/thinkpython2/thinkpython2.pdf.
• GeeksforGeeks. 2025. “Functions in Programming.” GeeksforGeeks. https://www.geeksforgeeks.org/dsa/functions-programming/.
• Python. 2025. “Programming FAQ.” Python Documentation. https://docs.python.org/3/faq/programming.html.
• Sfetcu, Nicolae. 2025. Limbajul de programare Python 3 pentru non-programatori. MultiMedia Publishing.
• Stackless. 2021. “4. More Control Flow Tools — Stackless-Python 3.8.1 Documentation.” https://stackless.readthedocs.io/en/3.8-slp/tutorial/controlflow.html.
• Wikibooks. 2025. “Non-Programmer’s Tutorial for Python 3.” https://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_3.

Articol cu Acces Deschis (Open Access) distribuit în conformitate cu termenii licenței de atribuire Creative Commons CC BY SA 4.0 (https://creativecommons.org/licenses/by-sa/4.0/).