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

itertools.zip_longest() în Python

În această lecție vei învăța cum folosești itertools.zip_longest() pentru a combina elementele aflate pe aceleași poziții, fără să pierzi valorile din iterabilul mai lung.

Problema funcției zip()

Funcția zip() combină elementele aflate pe aceleași poziții. Totuși, ea se oprește când se termină cel mai scurt iterabil.

nume = ["Ana", "Mihai", "Ioana"]
punctaje = [90, 80]
print(list(zip(nume, punctaje)))
[('Ana', 90), ('Mihai', 80)]

Valoarea Ioana nu mai apare în rezultat.

Ce face zip_longest()?

Funcția zip_longest() continuă până când se termină cel mai lung iterabil.

from itertools import zip_longest
nume = ["Ana", "Mihai", "Ioana"]
punctaje = [90, 80]
rezultat = zip_longest(nume, punctaje)
print(list(rezultat))
[('Ana', 90), ('Mihai', 80), ('Ioana', None)]

Pentru poziția lipsă este folosită implicit valoarea None.

Importarea funcției

from itertools import zip_longest

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

Sintaxa

zip_longest(iterabil_1, iterabil_2, fillvalue=None)

Poți transmite două sau mai multe obiecte iterabile.

fillvalue stabilește valoarea folosită pentru pozițiile care lipsesc.

Valoarea implicită este None

from itertools import zip_longest
litere = ["A", "B", "C"]
numere = [1, 2]
print(list(zip_longest(litere, numere)))
[('A', 1), ('B', 2), ('C', None)]

Folosirea argumentului fillvalue

from itertools import zip_longest
litere = ["A", "B", "C"]
numere = [1, 2]
rezultat = zip_longest(
    litere,
    numere,
    fillvalue="Lipsă"
)
print(list(rezultat))
[('A', 1), ('B', 2), ('C', 'Lipsă')]

Rezultatul este un iterator

from itertools import zip_longest
perechi = zip_longest(["A", "B"], [1])
print(next(perechi))
print(next(perechi))
('A', 1)
('B', None)

Ordinea argumentelor contează

from itertools import zip_longest
print(list(zip_longest(["A", "B"], [1])))
print(list(zip_longest([1], ["A", "B"])))
[('A', 1), ('B', None)]
[(1, 'A'), (None, 'B')]

Elementele tuplelor rezultate păstrează ordinea iterabilelor transmise.

Mai mult de două iterabile

from itertools import zip_longest
nume = ["Ana", "Mihai", "Ioana"]
varste = [25, 30]
orase = ["București"]
rezultat = zip_longest(
    nume,
    varste,
    orase,
    fillvalue="-"
)
print(list(rezultat))
[('Ana', 25, 'București'), ('Mihai', 30, '-'), ('Ioana', '-', '-')]

Iterabile de aceeași lungime

from itertools import zip_longest
print(list(
    zip_longest(
        ["A", "B"],
        [1, 2],
        fillvalue="Lipsă"
    )
))
[('A', 1), ('B', 2)]

fillvalue nu este folosită dacă toate pozițiile există.

Un iterabil gol

from itertools import zip_longest
print(list(
    zip_longest(
        ["A", "B"],
        [],
        fillvalue=0
    )
))
[('A', 0), ('B', 0)]

Toate iterabilele sunt goale

from itertools import zip_longest
print(list(zip_longest([], [])))
[]

Parcurgerea cu for

from itertools import zip_longest
nume = ["Ana", "Mihai", "Ioana"]
emailuri = ["ana@example.com", "mihai@example.com"]
for nume, email in zip_longest(
    nume,
    emailuri,
    fillvalue="Fără email"
):
    print(nume, email)
Ana ana@example.com
Mihai mihai@example.com
Ioana Fără email

Combinarea listelor și tuplelor

from itertools import zip_longest
limbaje = ["Python", "Java", "SQL"]
niveluri = ("Junior", "Senior")
print(list(
    zip_longest(
        limbaje,
        niveluri,
        fillvalue="Nespecificat"
    )
))
[('Python', 'Junior'), ('Java', 'Senior'), ('SQL', 'Nespecificat')]

Folosirea cu stringuri

from itertools import zip_longest
print(list(
    zip_longest(
        "ABC",
        "12",
        fillvalue="-"
    )
))
[('A', '1'), ('B', '2'), ('C', '-')]

Folosirea cu range()

from itertools import zip_longest
print(list(
    zip_longest(
        range(3),
        range(10, 12),
        fillvalue=-1
    )
))
[(0, 10), (1, 11), (2, -1)]

Folosirea cu generatoare

from itertools import zip_longest
def genereaza():
    yield "A"
    yield "B"
    yield "C"
rezultat = zip_longest(
    genereaza(),
    [1, 2],
    fillvalue=0
)
print(list(rezultat))
[('A', 1), ('B', 2), ('C', 0)]

zip() și zip_longest()

zip() se oprește la cel mai scurt iterabil.

print(list(zip(["A", "B", "C"], [1, 2])))
[('A', 1), ('B', 2)]

zip_longest() se oprește la cel mai lung iterabil.

from itertools import zip_longest
print(list(
    zip_longest(
        ["A", "B", "C"],
        [1, 2],
        fillvalue=0
    )
))
[('A', 1), ('B', 2), ('C', 0)]

Completarea datelor lipsă

from itertools import zip_longest
produse = ["Laptop", "Monitor", "Tastatură"]
preturi = [3500, 1200]
for produs, pret in zip_longest(
    produse,
    preturi,
    fillvalue="Preț lipsă"
):
    print(produs, pret)
Laptop 3500
Monitor 1200
Tastatură Preț lipsă

Crearea rândurilor unui raport

from itertools import zip_longest
luni = ["Ianuarie", "Februarie", "Martie"]
vanzari = [1000, 1500]
randuri = zip_longest(
    luni,
    vanzari,
    fillvalue=0
)
print(list(randuri))
[('Ianuarie', 1000), ('Februarie', 1500), ('Martie', 0)]

Iteratorii sursă sunt consumați

from itertools import zip_longest
prima = iter(["A", "B"])
a_doua = iter([1])
rezultat = zip_longest(prima, a_doua)
print(next(rezultat))

Valorile sunt preluate din surse pe măsură ce iteratorul rezultat este consumat.

Iteratorul rezultat este consumabil

from itertools import zip_longest
rezultat = zip_longest(["A", "B"], [1])
print(list(rezultat))
print(list(rezultat))
[('A', 1), ('B', None)]
[]

Datele originale nu sunt modificate

from itertools import zip_longest
litere = ["A", "B"]
numere = [1]
rezultat = list(
    zip_longest(litere, numere)
)
print(litere)
print(numere)
['A', 'B']
[1]

Atenție la iteratoarele infinite

Dacă unul dintre iterabile este infinit, zip_longest() nu se va opri singur.

Atenție

Limitează rezultatul cu islice() sau folosește un mecanism clar de oprire când lucrezi cu iteratoare infinite.

Când este util zip_longest()?

zip_longest() este util când trebuie să păstrezi toate valorile, chiar dacă sursele au lungimi diferite.

Îl poți folosi pentru rapoarte, tabele, importuri de date, completarea valorilor lipsă, compararea colecțiilor și asocierea informațiilor provenite din surse diferite.

Greșeli frecvente

Te aștepți să se oprească la cel mai scurt iterabil

Acesta este comportamentul lui zip(), nu al lui zip_longest().

Uiți să alegi o valoare fillvalue potrivită

Valoarea implicită este None, dar poți folosi un text, un număr sau altă valoare relevantă.

Confunzi valorile lipsă cu valorile reale

Alege un fillvalue care poate fi recunoscut clar.

Folosești un iterator infinit fără limită

În acest caz, iteratorul rezultat poate continua la infinit.

Rezumat

Poziții comune

Elementele de pe aceleași poziții sunt grupate.

Cel mai lung iterabil

Procesarea continuă până la terminarea sursei mai lungi.

fillvalue

Completează pozițiile care nu au o valoare reală.

Iterator

Tuplele sunt produse pe rând.

Exercițiul lecției

Pentru următoarele rezultate folosește numele: nume_2, punctaj_2, nume_3 și punctaj_3. Folosește exact un import, șase instrucțiuni de atribuire, un singur apel zip_longest(), trei apeluri next() și trei apeluri print(). Nu folosi zip(), fo…

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