...
← 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 214 · Python OOP

throw() în generatoare Python

În această lecție vei învăța cum folosești metoda throw() pentru a trimite o excepție în interiorul unui generator aflat în pauză.

Recapitulare: generatorul se oprește la yield

Atunci când un generator ajunge la yield, el produce o valoare și își suspendă temporar execuția.

def genereaza_mesaje():
    yield "Primul mesaj"
    yield "Al doilea mesaj"
generator = genereaza_mesaje()
print(next(generator))
Primul mesaj

În acest moment generatorul este pus pe pauză la primul yield.

Ce face throw()?

Metoda throw() trimite o excepție în generator, exact în locul în care acesta este suspendat.

generator.throw(ValueError)

Generatorul poate trata excepția folosind try/except sau o poate lăsa să se propage în afara funcției.

Primul exemplu cu throw()

def proces():
    try:
        yield "Proces activ"
    except ValueError:
        yield "Eroare tratată"
generator = proces()
print(next(generator))
print(generator.throw(ValueError))
Proces activ
Eroare tratată

ValueError este trimisă în punctul în care generatorul era oprit. Blocul except o tratează și produce un nou mesaj.

throw() reia execuția generatorului

La fel ca next() și send(), throw() reia generatorul. Diferența este că reluarea se face prin ridicarea unei excepții.

def demonstratie():
    try:
        yield "Aștept"
    except RuntimeError:
        print("RuntimeError primită")
        yield "Continuare"
generator = demonstratie()
print(next(generator))
print(generator.throw(RuntimeError))
Aștept
RuntimeError primită
Continuare

Trimiterea unei instanțe de excepție

Poți trimite clasa excepției:

generator.throw(ValueError)

sau o instanță care conține un mesaj:

generator.throw(ValueError("Valoare invalidă"))

A doua variantă permite accesarea mesajului în blocul except.

Citirea mesajului excepției

def proces():
    try:
        yield "Pregătit"
    except ValueError as eroare:
        yield f"Problemă: {eroare}"
generator = proces()
print(next(generator))
print(generator.throw(ValueError("Date greșite")))
Pregătit
Problemă: Date greșite

Generatorul trebuie pornit

În majoritatea situațiilor, generatorul trebuie avansat până la primul yield înainte să folosești throw().

def proces():
    try:
        yield "Pornit"
    except ValueError:
        yield "Eroare"
generator = proces()
print(next(generator))
print(generator.throw(ValueError))

Primul next() poziționează generatorul la yield, iar throw() trimite excepția în acel punct.

Ce se întâmplă dacă excepția nu este tratată?

def proces():
    yield "Activ"
    yield "Continuare"
generator = proces()
print(next(generator))
generator.throw(ValueError("Problemă"))

Funcția nu conține un bloc except pentru ValueError. Excepția părăsește generatorul și programul se oprește dacă nu este tratată în exterior.

Reține

throw() nu garantează că generatorul va continua. Continuarea depinde de modul în care excepția este tratată.

Tratarea excepției în exterior

def proces():
    yield "Activ"
generator = proces()
print(next(generator))
try:
    generator.throw(ValueError("Problemă"))
except ValueError as eroare:
    print(f"Eroare externă: {eroare}")
Activ
Eroare externă: Problemă

Generatorul după o excepție netratată

Dacă excepția trimisă prin throw() nu este tratată în generator, acesta se închide.

def proces():
    yield "Activ"
    yield "Continuare"
generator = proces()
print(next(generator))
try:
    generator.throw(ValueError)
except ValueError:
    print("Eroare propagată")

După propagarea excepției, generatorul nu mai poate continua.

Continuarea după tratarea excepției

def proces():
    try:
        yield "Pasul 1"
    except ValueError:
        yield "Eroare tratată"
    yield "Pasul final"
generator = proces()
print(next(generator))
print(generator.throw(ValueError))
print(next(generator))
Pasul 1
Eroare tratată
Pasul final

După ce blocul except produce o valoare, generatorul poate continua cu instrucțiunile următoare.

throw() poate returna o valoare

Apelul throw() returnează valoarea produsă de următorul yield la care ajunge generatorul.

def proces():
    try:
        yield "Aștept"
    except KeyError:
        yield "Cheie lipsă"
generator = proces()
print(next(generator))
rezultat = generator.throw(KeyError)
print(rezultat)
Aștept
Cheie lipsă

Folosirea mai multor blocuri except

def proces():
    try:
        yield "Pregătit"
    except ValueError:
        yield "Valoare invalidă"
    except TypeError:
        yield "Tip invalid"
generator = proces()
print(next(generator))
print(generator.throw(TypeError))
Pregătit
Tip invalid

Generatorul poate reacționa diferit în funcție de tipul excepției trimise.

throw() într-un generator repetitiv

def receptor():
    while True:
        try:
            valoare = yield "Aștept valoare"
            print(f"Primit: {valoare}")
        except ValueError:
            print("Valoare ignorată")
generator = receptor()
print(next(generator))
print(generator.send(10))
print(generator.throw(ValueError))
Aștept valoare
Primit: 10
Aștept valoare
Valoare ignorată
Aștept valoare

Generatorul tratează excepția și revine la următoarea iterație a buclei.

throw() și finally

def proces():
    try:
        yield "Activ"
    finally:
        print("Curățare executată")
generator = proces()
print(next(generator))
try:
    generator.throw(ValueError)
except ValueError:
    print("Eroare propagată")
Activ
Curățare executată
Eroare propagată

Blocul finally este executat chiar dacă excepția nu este tratată în generator.

Diferența dintre send(), throw() și close()

send() trimite o valoare în generator.

throw() trimite o excepție în generator.

close() solicită oprirea definitivă a generatorului.

Exemplu practic: procesarea unei comenzi

def proceseaza_comanda():
    try:
        yield "Comandă primită"
        yield "Comandă procesată"
    except ValueError as eroare:
        yield f"Comandă anulată: {eroare}"
generator = proceseaza_comanda()
print(next(generator))
print(generator.throw(ValueError("Plată invalidă")))
Comandă primită
Comandă anulată: Plată invalidă

Când este util throw()?

throw() este util când un cod exterior trebuie să semnaleze generatorului că a apărut o problemă.

Generatorul poate decide dacă tratează problema, produce un mesaj alternativ, continuă sau se închide.

Greșeli frecvente

Trimiți o excepție care nu este tratată

Excepția se propagă în exterior și poate închide generatorul.

Uiți să pornești generatorul

Avansează generatorul până la primul yield înainte de throw().

Confunzi throw() cu raise

raise ridică o excepție în codul curent. throw() o introduce într-un generator suspendat.

Te aștepți ca throw() să returneze excepția

throw() returnează următoarea valoare produsă de generator, dacă excepția este tratată și se ajunge la un nou yield.

Rezumat

Excepție trimisă

throw() ridică o excepție în generatorul suspendat.

Tratare internă

Generatorul poate folosi try/except pentru a reacționa.

Continuare

După tratare, generatorul poate produce alte valori.

Propagare

O excepție netratată părăsește și închide generatorul.

Exercițiul lecției

Creează funcția generatoare verifica_plata(). În interiorul funcției folosește un bloc try. Creează variabila generator apelând exact verifica_plata().

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