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 argumentPrimește un iterabil care conține alte iterabile.
Un nivel eliminatColecțiile interioare sunt parcurse succesiv.
Ordine păstratăValorile apar în ordinea surselor.
IteratorElementele sunt produse pe rând.
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.

Alex Cristian
Iulian Pahom
Catalina Ioana Dan