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

Aplatizarea colecțiilor în Python

În această lecție vei învăța cum folosești itertools.chain.from_iterable() pentru a parcurge succesiv elementele mai multor colecții aflate într-un singur iterabil.

Ce înseamnă aplatizare?

Aplatizarea înseamnă transformarea unei colecții de colecții într-o singură succesiune de elemente.

Colecții:
[1, 2]
[3, 4]
[5]

Succesiunea aplatizată este:

1, 2, 3, 4, 5

Ce face chain.from_iterable()?

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

Ea parcurge fiecare colecție interioară și produce elementele acestora în ordine.

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

Importarea clasei chain

from itertools import chain

from_iterable() este o metodă a clasei chain din modulul itertools.

Sintaxa

chain.from_iterable(iterable)

Argumentul exterior trebuie să conțină obiecte iterabile: liste, tuple, stringuri, range-uri, seturi sau generatoare.

Rezultatul este un iterator

from itertools import chain
valori = chain.from_iterable(
    [[10, 20], [30, 40]]
)
print(next(valori))
print(next(valori))
print(next(valori))
10
20
30

Elementele sunt produse pe rând, doar când sunt cerute.

Ordinea colecțiilor este păstrată

from itertools import chain
grupuri = [
    ["C", "A"],
    ["D", "B"]
]
print(list(
    chain.from_iterable(grupuri)
))
['C', 'A', 'D', 'B']

Funcția nu sortează și nu rearanjează valorile.

Folosirea cu liste

from itertools import chain
liste = [
    ["Python", "Java"],
    ["SQL", "Git"]
]
print(list(
    chain.from_iterable(liste)
))
['Python', 'Java', 'SQL', 'Git']

Folosirea cu tuple

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

Amestecarea tipurilor de colecții

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

Folosirea cu stringuri

from itertools import chain
cuvinte = ["PY", "THON"]
print(list(
    chain.from_iterable(cuvinte)
))
['P', 'Y', 'T', 'H', 'O', 'N']

Fiecare string este parcurs caracter cu caracter.

Un iterabil exterior gol

from itertools import chain
print(list(
    chain.from_iterable([])
))
[]

Colecții interioare goale

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

Colecțiile goale nu produc valori și sunt pur și simplu sărite.

Parcurgerea cu for

from itertools import chain
module = [
    ["Variabile", "Condiții"],
    ["Bucle", "Funcții"]
]
for lectie in chain.from_iterable(module):
    print(lectie)
Variabile
Condiții
Bucle
Funcții

Folosirea cu un generator exterior

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

Evaluare întârziată

chain.from_iterable() nu trebuie să construiască imediat o listă mare cu toate valorile.

from itertools import chain
valori = chain.from_iterable(
    range(start, start + 3)
    for start in range(0, 1000000, 3)
)
print(next(valori))
print(next(valori))
0
1

Diferența față de chain()

chain() primește colecțiile ca argumente separate.

from itertools import chain
rezultat = chain(
    [1, 2],
    [3, 4],
    [5]
)

chain.from_iterable() primește o singură colecție care le conține pe toate.

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

Când este preferată metoda from_iterable()?

Metoda este utilă când numărul colecțiilor nu este cunoscut dinainte sau când acestea sunt deja stocate într-o altă colecție.

grupuri = obtine_grupurile()
rezultat = chain.from_iterable(grupuri)

Diferența față de concatenarea listelor

prima = [1, 2]
a_doua = [3, 4]
rezultat = prima + a_doua

Operatorul + creează o listă nouă și este potrivit când ai câteva liste mici.

chain.from_iterable() returnează un iterator și poate procesa datele treptat.

Nu elimină duplicatele

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

Toate valorile sunt păstrate, inclusiv duplicatele.

Nu aplatizează recursiv

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

Este eliminat un singur nivel exterior. Lista [2, 3] rămâne un element separat.

Elementele interioare trebuie să fie iterabile

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

Când funcția ajunge la numărul 3, apare TypeError deoarece un număr întreg nu poate fi parcurs.

Aplatizarea loturilor create cu batched()

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

Valorile sunt grupate și apoi parcurse din nou într-o singură succesiune.

Unirea rezultatelor din mai multe pagini

from itertools import chain
pagini = [
    ["Rezultat 1", "Rezultat 2"],
    ["Rezultat 3"],
    ["Rezultat 4", "Rezultat 5"]
]
toate_rezultatele = chain.from_iterable(
    pagini
)
print(list(toate_rezultatele))

Unirea lecțiilor din mai multe module

from itertools import chain
module = [
    ["Variabile", "Tipuri de date"],
    ["Condiții", "Bucle"],
    ["Funcții", "Fișiere"]
]
lectii = chain.from_iterable(module)
for lectie in lectii:
    print(lectie)

Unirea liniilor din mai multe fișiere

from itertools import chain
continuturi = [
    ["Linia 1", "Linia 2"],
    ["Linia 3"],
    ["Linia 4", "Linia 5"]
]
toate_liniile = chain.from_iterable(
    continuturi
)

Fiecare colecție poate reprezenta liniile unui fișier diferit.

Iteratorul exterior este consumat treptat

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

Funcția cere următoarea colecție doar atunci când are nevoie de ea.

Iteratorul rezultat este consumabil

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

Datele originale nu sunt modificate

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

Când este util chain.from_iterable()?

Este util când ai o colecție de colecții și vrei să procesezi toate elementele ca pe o singură succesiune.

Îl poți folosi pentru pagini de rezultate, module și lecții, loturi de date, linii din fișiere, răspunsuri API și generatoare care produc alte iterabile.

Greșeli frecvente

Transmiți mai multe argumente separate

from_iterable() primește un singur iterabil exterior.

Te aștepți la aplatizare recursivă

Funcția elimină un singur nivel de imbricare.

Incluzi elemente care nu sunt iterabile

Fiecare element exterior trebuie să poată fi parcurs.

Reutilizezi iteratorul consumat

Creează un iterator nou pentru o altă parcurgere.

Rezumat

Un singur argument

Primește un iterabil care conține alte iterabile.

Un nivel eliminat

Colecțiile interioare sunt parcurse succesiv.

Ordine păstrată

Valorile apar în ordinea surselor.

Iterator

Elementele sunt produse pe rând.

Exercițiul lecției

Folosește exact un import, șapte instrucțiuni de atribuire, un singur apel chain.from_iterable(), cinci apeluri next() și cinci apeluri print(). Nu folosi chain() direct, for, while, list(), tuple(), sum(), comprehensions, funcții definite…

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