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

itertools.chain() în Python

În această lecție vei învăța cum folosești itertools.chain() pentru a parcurge mai multe obiecte iterabile ca și cum ar forma o singură secvență.

Ce problemă rezolvă chain()?

Uneori ai mai multe liste, tuple sau alte obiecte iterabile și vrei să le parcurgi unul după altul.

prima_lista = [1, 2]
a_doua_lista = [3, 4]

Funcția chain() creează un singur iterator care produce mai întâi elementele primului iterabil, apoi elementele celui de-al doilea.

Importarea funcției chain

chain() face parte din modulul itertools.

from itertools import chain

După import, poți transmite funcției două sau mai multe obiecte iterabile.

Primul exemplu

from itertools import chain
numere = chain([1, 2], [3, 4])
print(next(numere))
print(next(numere))
print(next(numere))
print(next(numere))
1
2
3
4

Elementele sunt produse în ordinea iterabilelor primite.

chain() returnează un iterator

Funcția nu creează imediat o listă nouă. Ea returnează un iterator.

from itertools import chain
valori = chain(["A", "B"], ["C"])
print(next(valori))
print(next(valori))
print(next(valori))
A
B
C

Fiecare valoare este cerută pe rând cu next().

Parcurgerea cu for

from itertools import chain
culori = ["roșu", "verde"]
forme = ["cerc", "pătrat"]
for element in chain(culori, forme):
    print(element)
roșu
verde
cerc
pătrat

Bucla vede un singur iterator, chiar dacă valorile provin din colecții diferite.

Mai mult de două iterabile

from itertools import chain
valori = chain([1, 2], [3], [4, 5])
print(list(valori))
[1, 2, 3, 4, 5]

Poți transmite oricâte obiecte iterabile.

Combinarea tipurilor diferite

from itertools import chain
valori = chain([1, 2], (3, 4), "AB")
print(list(valori))
[1, 2, 3, 4, 'A', 'B']

Fiecare argument trebuie să fie iterabil, dar nu trebuie să aibă același tip.

Stringurile sunt parcurse caracter cu caracter

from itertools import chain
litere = chain("AB", "CD")
print(list(litere))
['A', 'B', 'C', 'D']

Un string este iterabil, iar chain() produce fiecare caracter separat.

Ordinea este păstrată

from itertools import chain
rezultat = chain(["primul", "al doilea"], ["al treilea"])
for valoare in rezultat:
    print(valoare)
primul
al doilea
al treilea

chain() nu sortează și nu amestecă valorile.

Iterabile goale

from itertools import chain
valori = chain([], [10, 20], [])
print(list(valori))
[10, 20]

Iterabilele goale sunt trecute fără să producă erori.

Când se oprește iteratorul?

chain() se oprește după ce toate iterabilele primite au fost consumate.

from itertools import chain
valori = chain([1], [2])
print(next(valori))
print(next(valori))
print(next(valori))

Al treilea next() produce StopIteration.

chain() consumă iteratoarele primite

from itertools import chain
iterator = iter([1, 2])
valori = chain(iterator, [3])
print(list(valori))
print(list(iterator))
[1, 2, 3]
[]

Primul iterator a fost consumat în timpul parcurgerii lui chain().

Evaluare pe măsură ce sunt cerute valorile

chain() nu trebuie să copieze toate elementele înainte de parcurgere.

El solicită valori din primul iterabil până când acesta se termină, apoi trece la următorul.

Avantaj

Acest comportament este eficient când lucrezi cu multe valori sau cu iteratoare care produc date treptat.

chain() față de operatorul +

lista_unita = [1, 2] + [3, 4]

Operatorul + creează o listă nouă.

iterator_unit = chain([1, 2], [3, 4])

chain() creează un iterator și produce elementele pe rând.

Operatorul + nu unește tipuri diferite

[1, 2] + (3, 4)

Această expresie produce TypeError deoarece lista și tuple-ul sunt tipuri diferite.

chain([1, 2], (3, 4))

chain() le poate parcurge fără să le transforme în același tip.

Unirea rezultatelor din mai multe surse

from itertools import chain
utilizatori_activi = ["Ana", "Mihai"]
utilizatori_noi = ["Ioana", "Radu"]
for utilizator in chain(utilizatori_activi, utilizatori_noi):
    print(utilizator)
Ana
Mihai
Ioana
Radu

Unirea mai multor intervale

from itertools import chain
numere = chain(range(1, 4), range(10, 13))
print(list(numere))
[1, 2, 3, 10, 11, 12]

Combinarea cu un generator

from itertools import chain
def genereaza():
    yield 100
    yield 200
valori = chain([10, 20], genereaza())
print(list(valori))
[10, 20, 100, 200]

chain() poate primi și obiecte generator.

chain.from_iterable()

Uneori iterabilele sunt deja grupate într-un singur obiect.

from itertools import chain
grupuri = [[1, 2], [3, 4], [5]]
valori = chain.from_iterable(grupuri)
print(list(valori))
[1, 2, 3, 4, 5]

chain.from_iterable() primește un iterabil care conține alte iterabile.

chain() și chain.from_iterable()

chain([1, 2], [3, 4])

Aici iterabilele sunt transmise ca argumente separate.

chain.from_iterable([[1, 2], [3, 4]])

Aici toate iterabilele sunt în interiorul unui singur obiect.

Când este util chain()?

chain() este util când ai mai multe surse de date și vrei să le procesezi printr-o singură parcurgere.

Îl poți folosi pentru liste de utilizatori, rezultate din fișiere, intervale, generatoare sau colecții de tipuri diferite.

Greșeli frecvente

Transmiți o valoare care nu este iterabilă

chain([1, 2], 3) nu funcționează deoarece numărul 3 nu poate fi parcurs.

Te aștepți la o listă

chain() returnează un iterator. Folosește list() doar când ai nevoie explicit de o listă.

Uiți că stringurile sunt separate în caractere

chain("AB", "CD") produce A, B, C și D.

Reutilizezi un iterator deja consumat

Iteratorii transmiși către chain() sunt consumați în timpul parcurgerii.

Rezumat

Un singur flux

chain() parcurge mai multe iterabile consecutiv.

Ordine păstrată

Elementele apar în ordinea argumentelor primite.

Iterator

Valorile sunt produse pe rând, fără o listă nouă.

Tipuri diferite

Poate combina orice obiecte iterabile.

Exercițiul lecției

Folosește exact un import, trei atribuiri, un singur apel chain(), patru apeluri print() și patru apeluri next(). Nu folosi for, while, range(), list(), operatorul +, funcții, comprehensions, cycle(), count() sau repeat().

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