Come appiattire una lista in Python

1. Elenco Python appiattimento superficiale
2. Python list appiattimento profondo della lista Python

L’appiattimento è un’operazione in cui prendiamo una lista di liste annidate e la convertiamo in una diversa struttura di dati che non contiene liste annidate.
Al contrario, essa include tutti gli elementi di tutte le liste, che inizialmente erano annidate.
Tale struttura di dati si chiama flat o lista flattened.

La lista originale può contenere liste annidate solo nel primo livello di nidificazione, per
esempio [[1, 2], [3, 4]].
Altrimenti, contiene liste sul secondo, terzo e ulteriori livelli di nidificazione,
per esempio [[[1], [2]]], [3, 4]].
Si dice che una lista di questo tipo contenga liste annidate profondamente.

Se vogliamo innescare un solo livello di nidificazione, lo chiamiamo abbassamento.
Se vogliamo innescare tutti i livelli di nidificazione, lo chiamiamo appiattimento profondo.

Elenco Python appiattimento superficiale

Un approccio semplice da comprendere e visualizzare è quello di utilizzare un doppio for loop.

Il primo cicli for attraversa liste annidate. Il secondo for loop itera su elementi di ogni lista annidata e li aggiunge ad una lista piatta di risultati uno per uno.

>>> flat_list = []
>>> original_list = [[1, 2], [3, 4]]
>>> for l in original_list:
...   for item in l:
...     flat_list.append(item)
...
>>> flat_list
[1, 2, 3, 4]

Il metodo di cui sopra è chiaro e leggibile, ma l’espressività di Python permette di
ci ha permesso di raggiungere lo stesso obiettivo in un’unica linea.
Qui Python list comprehensions viene in aiuto.

>>> original_list = [[1, 2], [3, 4]]
>>> flat_list = [item for l in original_list for item in l]
>>> flat_list
[1, 2, 3, 4]

Se non avete bisogno di una lista piatta di per sé, ma volete essere in grado di iterare su tutti gli elementi
di tutte le sottoelencate come se provenissero da un’unica struttura di dati piatta, si può usare itertools.chain().

>>> import itertools
>>> original_list = [[1, 2], [3, 4]] 
>>> iterator = itertools.chain(*original_list)
>>> for item in iterator:
...   print(item)
...
1
2
3
4

Se si usa Pandas - un pacchetto open-source per l’analisi dei dati in Python - c’è anche un modo integrato.

>>> from pandas.core.common import flatten
>>> original_list = [[1, 2], [3, 4]]  
>>> flat_list = list(flatten(original_list))
>>> flat_list
[1, 2, 3, 4]

Python list appiattimento profondo della lista Python

Come detto sopra, l’appiattimento superficiale non funzionerà, se abbiamo liste annidate in profondità.
Sarà unnest solo il primo livello di nidificazione, come mostrato nell’esempio qui sotto.

>>> deeply_nested_list = [[[1, 2], 3], [4, 5, 6]]
>>> flat_list = [item for l in deeply_nested_list for item in l]
>>> flat_list
[[1, 2], 3, 4, 5, 6]

Per fare l’appiattimento profondo, usare iteration_utilities.deepflatten() dal pacchetto iteration-utilities PyPI.

Per prima cosa, installare il pacchetto PyPI stesso.

$ pip install iteration-utilities

Poi appiattite le vostre liste profondamente annidate.

>>> from iteration_utilities import deepflatten
>>> deeply_nested_list = [[[1, 2], 3], [4, 5, 6]]
>>> flat_list = list(deepflatten(deeply_nested_list))
>>> flat_list
[1, 2, 3, 4, 5, 6]