...
← Curs Python
Lecțiile 211–280

Continuă cu Python OOP

Primele 15 lecții din Curs Python sunt gratuite, fără card. Începe cu ele și vezi dacă ți se potrivește înainte să plătești ceva.

Începe gratuit de la lecția 1 →

Academia Programatorilor
Certificat de competență Seria PREVIZUALIZARE

Se certifică faptul că

Numele tău

a finalizat cu succes lecțiile 211–280 din Curs Python, cu exerciții practice rezolvate și verificate automat.

Diplomă Python OOP
Tudor Dumitrescu Tudor Dumitrescu Fondator · Trainer & formator autorizat
Data emiterii 19 noiembrie 2026 Verificare online academiaprogramatorilor.ro/certificat/PREVIZUALIZARE/
La finalul modulului primești Diplomă Python OOP
Lecția 241 · Python OOP

Returnarea timpurie cu return în Python

În această lecție vei învăța cum poți opri imediat executarea unei funcții folosind return atunci când apare o situație specială.

Ce face return?

Instrucțiunea return trimite o valoare înapoi către locul în care funcția a fost apelată și oprește executarea funcției.

def dublu(number):
    return number * 2
print(dublu(5))
10

Codul de după return nu mai este executat

def mesaj():
    return "Salut"
    print("Această linie nu se execută")
print(mesaj())
Salut

După executarea lui return, funcția se încheie imediat.

Ce este returnarea timpurie?

Returnarea timpurie înseamnă folosirea lui return înainte de finalul funcției pentru a trata rapid un caz special.

def verifica_varsta(age):
    if age < 18:
        return "Acces refuzat"
    return "Acces permis"

Dacă vârsta este mai mică de 18 ani, funcția se oprește imediat. Al doilea return este executat doar pentru persoanele majore.

Exemplu fără else

def verifica_numar(number):
    if number < 0:
        return "Negativ"
    return "Zero sau pozitiv"

Nu este necesar un bloc else, deoarece primul return oprește funcția.

De ce este utilă?

Oprire imediată

Funcția se încheie când apare cazul special.

Cod mai clar

Eviți blocuri else mari și indentări inutile.

Validare

Poți respinge rapid valorile invalide.

Execuție eficientă

Nu mai rulezi pași care nu sunt necesari.

Validarea unui text gol

def formateaza_nume(name):
    if name == "":
        return "Nume invalid"
    return name.upper()
print(formateaza_nume(""))
Nume invalid

Funcția nu mai încearcă să proceseze valoarea dacă textul este gol.

Mai multe returnări timpurii

def verifica_nota(grade):
    if grade < 1:
        return "Nota prea mica"
    if grade > 10:
        return "Nota prea mare"
    return "Nota valida"

Fiecare verificare poate opri funcția cu propriul mesaj. Ultimul return este executat numai dacă valoarea trece toate verificările.

Fluxul funcției

Funcția primește argumentul. Verifică primul caz special. Dacă regula este îndeplinită, returnează imediat. În caz contrar, continuă cu restul funcției.

Returnare timpurie versus else

def verifica_stoc(stock):
    if stock == 0:
        return "Indisponibil"
    else:
        return "Disponibil"

Poate fi simplificat astfel:

def verifica_stoc(stock):
    if stock == 0:
        return "Indisponibil"
    return "Disponibil"

Ambele variante funcționează, dar a doua este mai simplă.

Exemplu cu mai multe condiții

def calculeaza_reducere(price, is_member):
    if price <= 0:
        return 0
    if not is_member:
        return price
    return price * 0.9

Valorile invalide și clienții fără abonament sunt tratați înaintea calculului final.

Return fără valoare

def afiseaza_mesaj(message):
    if message == "":
        return
    print(message)

Un return fără valoare oprește funcția și returnează implicit None.

Greșeli frecvente

Scrii cod important după return

Orice instrucțiune aflată după un return executat este ignorată.

Folosești print() în loc de return

Print doar afișează o valoare. Return o trimite înapoi și oprește funcția.

Păstrezi blocuri else inutile

După o returnare timpurie, funcția poate continua fără else.

Uiți returnarea finală

Dacă niciun caz special nu este îndeplinit, funcția trebuie să returneze rezultatul normal.

Rezumat

return oprește funcția

Codul următor nu mai este executat.

Cazuri speciale

Sunt tratate la începutul funcției.

Fără else inutil

Fluxul rămâne mai simplu și mai clar.

Rezultat final

Este returnat dacă verificările sunt trecute.

Exercițiul lecției

Creează funcția verifica_comanda(stoc, cantitate). Nu folosi elif sau else. Folosește trei instrucțiuni if separate și patru instrucțiuni return. Afișează cele patru rezultate, în această ordine, folosind patru apeluri print().

  • result_1 pentru verifica_comanda(10, 0);
  • result_2 pentru verifica_comanda(0, 2);
  • result_3 pentru verifica_comanda(3, 5);
  • result_4 pentru verifica_comanda(10, 4).

Exercițiul, editorul și verificarea automată se deblochează cu Python OOP.

Ce urmează în curs

  1. Python Începător Lecțiile 16–80 · 65 de lecții certificat
  2. Python Intermediar Lecțiile 81–140 · 60 de lecții certificat
  3. Python Avansat Lecțiile 141–210 · 70 de lecții certificat
  4. Python OOP Lecțiile 211–280 · 70 de lecții certificat
  5. Junior Python Developer Lecțiile 281–350 · 70 de lecții certificat

Ce primești

  • Lecții interactive în limba română, cu cod scris și rulat direct în browser
  • Exerciții verificate automat, cu feedback pe loc
  • Certificat la finalul fiecărui modul, verificabil online
  • Acces pe viață, în ritmul tău, fără abonament

4,9 din 5 · 128 de recenzii Google

Profesorii si colegii foarte prietenosi,modul in care se preda simplu si usor de inteles cu exemple practice incat oricine poate prinde usor.
Alex Cristian
Foarte profi si utile cursurile. Practica aplicata si explicata de traineri inarmati cu rabdare si cunostine solide.
Iulian Pahom
Cursuri foarte utile si profesori foarte pregatiti. Recomand cu toata increderea.
Catalina Ioana Dan
Toate recenziile pe Google