L’aplatissement d’une liste, processus consistant à convertir une liste imbriquée en une liste à un seul niveau, est une tâche courante en Python. Cet article explore diverses techniques pour y parvenir, en les catégorisant selon leur profondeur d’aplatissement : superficiel et profond.
Table des matières
Aplatissement superficiel
L’aplatissement superficiel ne supprime qu’un niveau d’imbrication. Il est idéal lorsque vous avez une liste de listes, mais que ces listes internes ne contiennent pas d’autres structures imbriquées. Deux méthodes efficaces existent :
List Comprehension : Ceci fournit une solution concise et lisible :
nested_list = [[1, 2, 3], [4, 5], [6]]
flat_list = [item for sublist in nested_list for item in sublist]
print(flat_list) # Sortie : [1, 2, 3, 4, 5, 6]
itertools.chain.from_iterable : Pour les listes plus grandes, cette approche offre de meilleures performances grâce à son itération optimisée :
from itertools import chain
nested_list = [[1, 2, 3], [4, 5], [6]]
flat_list = list(chain.from_iterable(nested_list))
print(flat_list) # Sortie : [1, 2, 3, 4, 5, 6]
Limitations : L’aplatissement superficiel ne parvient pas à aplatir complètement les listes contenant des listes imbriquées à l’intérieur de listes imbriquées. Par exemple :
nested_list = [[1, 2, [3, 4]], [5, 6]]
flat_list = [item for sublist in nested_list for item in sublist]
print(flat_list) # Sortie : [1, 2, [3, 4], 5, 6]
La liste interne [3, 4] reste imbriquée.
Aplatissement profond
L’aplatissement profond gère récursivement les listes imbriquées de toute profondeur. Deux approches principales existent :
Fonction récursive : Cette solution élégante utilise la récursivité pour parcourir la structure imbriquée :
def flatten(nested_list):
flat_list = []
for item in nested_list:
if isinstance(item, list):
flat_list.extend(flatten(item))
else:
flat_list.append(item)
return flat_list
nested_list = [[1, 2, [3, 4]], [5, 6, [7, [8, 9]]]]
flat_list = flatten(nested_list)
print(flat_list) # Sortie : [1, 2, 3, 4, 5, 6, 7, 8, 9]
Approche itérative (utilisant une pile) : La récursivité peut entraîner des erreurs de dépassement de pile avec une imbrication extrêmement profonde. Une approche itérative utilisant une pile offre une robustesse :
def flatten_iterative(nested_list):
flat_list = []
stack = [nested_list]
while stack:
current = stack.pop()
if isinstance(current, list):
stack.extend(current)
else:
flat_list.append(current)
return flat_list
nested_list = [[1, 2, [3, 4]], [5, 6, [7, [8, 9]]]]
flat_list = flatten_iterative(nested_list)
print(flat_list) # Sortie : [1, 2, 3, 4, 5, 6, 7, 8, 9]
Conclusion
Le choix entre l’aplatissement superficiel et l’aplatissement profond dépend entièrement de la structure de vos listes imbriquées. L’aplatissement superficiel est suffisant pour l’imbrication à un seul niveau et offre des solutions concises et efficaces. Cependant, pour les listes arbitrairement imbriquées, l’aplatissement profond, de préférence en utilisant l’approche itérative basée sur la pile pour plus de robustesse, est nécessaire.