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

send() în generatoare Python

În această lecție vei învăța cum folosești metoda send() pentru a relua un generator și pentru a trimite o valoare în interiorul acestuia.

Recapitulare: next() reia generatorul

Un generator este pus pe pauză atunci când ajunge la yield. Apelul next() îl reia până la următoarea instrucțiune yield.

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

next() cere următoarea valoare, dar nu trimite o valoare nouă în generator.

Ce face send()?

Metoda send() reia generatorul și trimite în interiorul lui o valoare.

valoare_primita = yield "Generator pregătit"

Generatorul produce mai întâi textul "Generator pregătit" și se oprește temporar.

La apelul send(), valoarea trimisă devine rezultatul expresiei yield și este salvată în valoare_primita.

Primul exemplu cu send()

def primeste_mesaj():
    mesaj = yield "Pregătit"
    yield f"Am primit: {mesaj}"
generator = primeste_mesaj()
print(next(generator))
print(generator.send("Salut"))
Pregătit
Am primit: Salut

Apelul next(generator) pornește funcția și o aduce la primul yield. Apoi send("Salut") trimite textul în variabila mesaj.

Generatorul trebuie pornit înainte

Nu poți trimite direct o valoare diferită de None într-un generator care nu a început încă.

def primeste_valoare():
    valoare = yield "Start"
    yield valoare
generator = primeste_valoare()
generator.send("Python")

Acest cod produce o eroare deoarece generatorul nu a ajuns încă la primul yield.

Varianta corectă este:

generator = primeste_valoare()
next(generator)
print(generator.send("Python"))
Python

Pornirea cu send(None)

Un generator poate fi pornit și cu send(None).

def exemplu():
    valoare = yield "Pregătit"
    yield valoare
generator = exemplu()
print(generator.send(None))
print(generator.send(100))
Pregătit
100
next(generator) și generator.send(None)

Ambele pot porni un generator și îl pot avansa până la primul yield.

Valoarea trimisă devine rezultatul lui yield

def proceseaza_numar():
    numar = yield "Trimite un număr"
    rezultat = numar * 2
    yield rezultat
generator = proceseaza_numar()
print(next(generator))
print(generator.send(7))
Trimite un număr
14

Valoarea 7 este atribuită variabilei numar, apoi generatorul continuă și produce rezultatul 14.

send() returnează următoarea valoare produsă

Metoda send() nu doar trimite o valoare. Ea continuă execuția și returnează valoarea produsă de următorul yield.

def formateaza():
    text = yield "Aștept text"
    yield text.upper()
generator = formateaza()
mesaj_initial = next(generator)
mesaj_final = generator.send("python")
print(mesaj_initial)
print(mesaj_final)
Aștept text
PYTHON

Mai multe valori trimise succesiv

Un generator poate primi mai multe valori dacă revine în mod repetat la o expresie yield.

def primeste_numere():
    while True:
        numar = yield "Trimite"
        print(f"Primit: {numar}")
generator = primeste_numere()
print(next(generator))
print(generator.send(10))
print(generator.send(20))
Trimite
Primit: 10
Trimite
Primit: 20
Trimite

După fiecare valoare primită, bucla revine la yield și generatorul este pregătit pentru următorul send().

Generator care menține un total

def totalizator():
    total = 0
    while True:
        valoare = yield total
        total += valoare
generator = totalizator()
print(next(generator))
print(generator.send(5))
print(generator.send(3))
0
5
8

Generatorul păstrează variabila total între apelurile send().

Ordinea execuției

def demonstratie():
    print("Generator pornit")
    valoare = yield "Pauză"
    print(f"Valoare primită: {valoare}")
    yield "Final"
generator = demonstratie()
print(next(generator))
print(generator.send("Date"))
Generator pornit
Pauză
Valoare primită: Date
Final

send("Date") completează expresia yield aflată în pauză și continuă execuția de pe linia următoare.

send() și StopIteration

Dacă după reluare generatorul ajunge la final fără un alt yield, apelul send() produce StopIteration.

def primeste_o_valoare():
    valoare = yield "Pregătit"
    print(valoare)
generator = primeste_o_valoare()
print(next(generator))
generator.send("Salut")

Textul este afișat, apoi funcția se termină. Pentru ca send() să returneze normal o valoare, generatorul trebuie să ajungă la încă un yield.

Exemplu practic: aplicarea unei reduceri

def calculator_reducere():
    procent = yield "Calculator pregătit"
    pret = yield f"Reducere setată: {procent}%"
    yield pret - pret * procent / 100
generator = calculator_reducere()
print(next(generator))
print(generator.send(20))
print(generator.send(500))
Calculator pregătit
Reducere setată: 20%
400.0

Când este util send()?

send() este util când generatorul nu trebuie doar să producă valori, ci și să primească informații în timp ce este activ.

Poate fi folosit pentru procesoare de date, acumulatoare, fluxuri de evenimente și alte situații în care generatorul păstrează o stare între valori.

Greșeli frecvente

Trimiți o valoare înainte de primul yield

Pornește mai întâi generatorul cu next() sau send(None).

Uiți că send() avansează generatorul

send() trimite valoarea și continuă execuția până la următorul yield.

Nu mai există un yield după valoarea primită

Dacă funcția ajunge la final, send() produce StopIteration.

Confunzi valoarea produsă cu valoarea primită

Valoarea din dreapta lui yield este produsă de generator. Valoarea trimisă prin send() devine rezultatul expresiei yield.

Rezumat

Pornire

Generatorul trebuie pornit înainte de send(valoare).

Trimitere

send() introduce o valoare în expresia yield suspendată.

Reluare

Generatorul continuă până la următorul yield.

Stare

Variabilele locale sunt păstrate între apeluri.

Exercițiul lecției

Creează funcția generatoare calculeaza_bonus(). Creează variabila generator apelând exact calculeaza_bonus(). Folosește exact o definiție de funcție, două instrucțiuni yield, două atribuiri, două apeluri print(), un apel next() și un apel s…

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