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

itertools.accumulate() în Python

În această lecție vei învăța cum folosești itertools.accumulate() pentru a calcula rezultate cumulative după fiecare element al unui iterabil.

Ce înseamnă rezultat cumulativ?

Un rezultat cumulativ păstrează efectul valorilor procesate până la poziția curentă.

Valori:   10   20   30   40
Totaluri: 10   30   60   100

Primul total este 10. Al doilea total este 10 + 20. Al treilea total este 10 + 20 + 30.

Ce face accumulate()?

Funcția accumulate() aplică în mod repetat o operație și produce rezultatul după fiecare pas.

from itertools import accumulate
numere = [10, 20, 30, 40]
totaluri = accumulate(numere)
print(list(totaluri))
[10, 30, 60, 100]

Dacă nu specifici o altă operație, accumulate() folosește adunarea.

Importarea funcției accumulate

from itertools import accumulate

accumulate() face parte din modulul itertools și returnează un iterator.

Sintaxa de bază

accumulate(iterable)

Această formă calculează sumele cumulative ale valorilor.

Cum se calculează fiecare rezultat?

numere = [5, 3, 2]
Primul rezultat:  5
Al doilea:        5 + 3 = 8
Al treilea:       8 + 2 = 10
from itertools import accumulate
print(list(accumulate([5, 3, 2])))
[5, 8, 10]

Rezultatul este un iterator

from itertools import accumulate
totaluri = accumulate([10, 20, 30])
print(next(totaluri))
print(next(totaluri))
print(next(totaluri))
10
30
60

Diferența față de sum()

sum() produce doar totalul final.

numere = [10, 20, 30]
print(sum(numere))
60

accumulate() produce și rezultatele intermediare.

from itertools import accumulate
print(list(accumulate(numere)))
[10, 30, 60]

Folosirea unei operații personalizate

Al doilea argument poate fi o funcție care primește rezultatul acumulat și următoarea valoare.

from itertools import accumulate
rezultate = accumulate(
    [2, 3, 4],
    lambda acumulat, valoare: acumulat * valoare
)
print(list(rezultate))
[2, 6, 24]

Înmulțiri cumulative

from itertools import accumulate
from operator import mul
numere = [2, 3, 4]
print(list(accumulate(numere, mul)))
[2, 6, 24]

Funcția mul() înmulțește rezultatul anterior cu următoarea valoare.

Valorile maxime întâlnite

from itertools import accumulate
valori = [4, 2, 8, 5, 10, 7]
maxime = accumulate(valori, max)
print(list(maxime))
[4, 4, 8, 8, 10, 10]

Fiecare rezultat reprezintă cea mai mare valoare întâlnită până în acel moment.

Valorile minime întâlnite

from itertools import accumulate
valori = [9, 7, 8, 3, 5]
minime = accumulate(valori, min)
print(list(minime))
[9, 7, 7, 3, 3]

Scăderi cumulative

from itertools import accumulate
valori = [100, 10, 20, 5]
rezultate = accumulate(
    valori,
    lambda acumulat, valoare: acumulat - valoare
)
print(list(rezultate))
[100, 90, 70, 65]

Ordinea parametrilor funcției

lambda acumulat, valoare: acumulat + valoare

Primul parametru primește rezultatul calculat anterior. Al doilea parametru primește următorul element din iterabil.

Argumentul initial

Poți stabili o valoare inițială folosind argumentul initial.

from itertools import accumulate
numere = [10, 20, 30]
totaluri = accumulate(numere, initial=100)
print(list(totaluri))
[100, 110, 130, 160]

Valoarea inițială este produsă prima și participă la toate calculele următoare.

Numărul rezultatelor cu initial

Fără initial, numărul rezultatelor este egal cu numărul elementelor.

Cu initial, iteratorul produce cu un rezultat mai mult.

from itertools import accumulate
print(list(accumulate([1, 2, 3], initial=0)))
[0, 1, 3, 6]

O listă goală

from itertools import accumulate
print(list(accumulate([])))
[]

Fără initial, un iterabil gol nu produce rezultate.

O listă goală cu initial

from itertools import accumulate
print(list(accumulate([], initial=100)))
[100]

Parcurgerea cu for

from itertools import accumulate
incasari = [100, 250, 150]
for total in accumulate(incasari):
    print(total)
100
350
500

Urmărirea soldului

from itertools import accumulate
tranzactii = [1000, -200, 500, -100]
solduri = accumulate(tranzactii)
print(list(solduri))
[1000, 800, 1300, 1200]

Urmărirea progresului

from itertools import accumulate
puncte_castigate = [10, 15, 20, 5]
progres = accumulate(puncte_castigate)
print(list(progres))
[10, 25, 45, 50]

Folosirea cu stringuri

from itertools import accumulate
litere = ["P", "Y", "T", "H", "O", "N"]
cuvinte_partiale = accumulate(
    litere,
    lambda text, litera: text + litera
)
print(list(cuvinte_partiale))
['P', 'PY', 'PYT', 'PYTH', 'PYTHO', 'PYTHON']

Iteratorul sursă este consumat

from itertools import accumulate
sursa = iter([1, 2, 3])
totaluri = accumulate(sursa)
print(next(totaluri))
print(list(sursa))

Valorile sunt preluate din sursă pe măsură ce sunt cerute.

Iteratorul accumulate este consumabil

from itertools import accumulate
totaluri = accumulate([1, 2, 3])
print(list(totaluri))
print(list(totaluri))
[1, 3, 6]
[]

Datele originale nu sunt modificate

from itertools import accumulate
numere = [1, 2, 3]
totaluri = list(accumulate(numere))
print(numere)
print(totaluri)
[1, 2, 3]
[1, 3, 6]

Când este util accumulate()?

accumulate() este util când ai nevoie de evoluția unui rezultat, nu doar de valoarea finală.

Îl poți folosi pentru solduri, progres, totaluri de vânzări, produse cumulative, valori maxime, valori minime și serii de rezultate intermediare.

Greșeli frecvente

Te aștepți la un singur rezultat

accumulate() produce rezultatul după fiecare pas.

Confunzi accumulate() cu sum()

sum() produce doar totalul final.

Uiți că initial este produs primul

Cu initial, numărul rezultatelor crește cu unu.

Reutilizezi iteratorul consumat

Creează un iterator nou pentru o altă parcurgere.

Rezumat

Rezultate cumulative

Fiecare rezultat include valorile procesate anterior.

Adunare implicită

Fără funcție, sunt calculate sumele cumulative.

Operație personalizată

Poți folosi lambda, min, max sau alte funcții.

Valoare inițială

initial stabilește punctul de pornire al acumulării.

Exercițiul lecției

Folosește exact un import, două atribuiri, un singur apel accumulate(), patru apeluri print() și patru apeluri next(). Nu folosi for, while, sum(), list(), lambda, comprehensions, funcții definite cu def, argumentul initial sau alte apeluri…

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