Un guide pour aplatir la liste et la liste des listes en Python

Table des matières

Transformation d’un tableau 2D en 1D : exploration des méthodes

L’opération de conversion d’un tableau bidimensionnel en un tableau unidimensionnel est communément appelée « aplatissement » ou « nivellement ». Plusieurs approches existent pour accomplir cette tâche, et nous allons en détailler quelques-unes dans ce guide.

Considérons un exemple concret :

Entrée :

[[1, 2, 3], [4, 5], [6, 7, 8, 9, 10]]

Sortie attendue :

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#1. Utilisation des boucles traditionnelles

La technique la plus intuitive pour résoudre ce problème implique l’utilisation de boucles. La logique est assez simple, et la plupart d’entre vous la comprendront rapidement. Voici les étapes clés pour aplatir un tableau 2D avec des boucles :

On commence par initialiser un tableau de tableaux avec des valeurs de test, que l’on nomme par exemple « données ».
Ensuite, on crée une liste vide, qui sera notre tableau aplati, que l’on appelle « liste_aplatie ».
On parcourt alors le tableau « données » :
- Pour chaque sous-tableau, on extrait tous ses éléments.
- Ces éléments sont ajoutés à la « liste_aplatie » en utilisant la méthode d’ajout (append).
Enfin, on affiche le contenu de la « liste_aplatie ».

Le code correspondant est le suivant :

# Initialisation du tableau de tableaux et de la liste aplatie
data = [[1, 2, 3], [4, 5], [6, 7, 8, 9, 10]]
flat_list = []

# Parcours du tableau de tableaux
for item in data:
    # Ajout des éléments à la liste aplatie
    flat_list += item

# Affichage de la liste aplatie
print(flat_list)

Il est possible d’utiliser une autre boucle pour ajouter les éléments du sous-tableau à « flat_list » au lieu de la concaténation. On pourrait également utiliser des compréhensions de liste pour simplifier ce code. Ces alternatives réalisent le même objectif, nous allons donc explorer une autre approche.

#2. Recours au module Itertools : la méthode chain

Ici, nous allons employer la fonction « chain » du module « itertools » intégré de Python.

La fonction « chain » itère séquentiellement sur chaque sous-tableau et fournit tous les éléments qu’il contient, jusqu’à ce qu’il n’y ait plus de sous-tableaux. Elle retourne un itérable qu’il faut ensuite convertir en liste.

Voici la démarche à suivre :

On initialise le tableau de tableaux de test, toujours appelé « données ».
On utilise la fonction « itertools.chain(*data) » pour obtenir un itérable aplati.
On convertit cet itérable en une liste.
Enfin, on affiche la liste résultante.

Le code illustratif est ci-dessous :

# Import du module
import itertools

# Initialisation du tableau de tableaux
data = [[1, 2, 3], [4, 5], [6, 7, 8, 9, 10]]

# Aplatissement du tableau et stockage du résultat
flat_list = itertools.chain(*data)

# Conversion de l'itérable en liste et affichage
print(list(flat_list))

#3. Gestion des listes imbriquées à plusieurs niveaux

Les méthodes que nous avons vues jusqu’ici fonctionnent pour des listes à un niveau de profondeur. Cependant, elles ne sont pas adaptées pour des listes imbriquées sur plusieurs niveaux. Illustrons cela par un exemple :

Entrée :

[1, [2, 3, [4, 5]], 6, [[7], [8, 9]]]

Sortie attendue :

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Comme la profondeur de l’imbrication peut varier, nous devons utiliser la récursivité pour résoudre ce type de problème.

On initialise le tableau « données » comme dans l’exemple précédent.
On initialise une liste vide « liste_aplatie ».
On définit une fonction récursive « aplanir_liste » qui :
- Parcourt chaque élément du tableau donné.
- Si l’élément est une liste, on appelle récursivement la fonction « aplanir_liste » avec cet élément comme argument.
- Sinon, si l’élément n’est pas une liste, on l’ajoute à la « liste_aplatie ».
On appelle la fonction « aplanir_liste » avec le tableau « données » initial.
La fonction se chargera d’ajouter tous les éléments à « liste_aplatie ».
On affiche la « liste_aplatie » pour vérifier le résultat.

Bien que ce processus puisse paraître complexe, la traduction de ces étapes en code reste simple. Voici le résultat :

# Initialisation des données et de la liste vide
data = [1, [2, 3, [4, 5]], 6, [[7], [8, 9]]]
flat_list = []

# Fonction récursive
def flatten_list(data):
    # Parcours du tableau
    for element in data:
        # Vérification du type de l'élément
        if type(element) == list:
            # Appel récursif si c'est une liste
            flatten_list(element)
        else:
            flat_list.append(element)

# Aplatissement de la liste
flatten_list(data)

# Affichage de la liste aplatie
print(flat_list)

Il est important de noter que cette approche crée une nouvelle liste, et ne modifie pas la structure de la liste originale.

Conclusion

Nous avons exploré différentes méthodes pour aplatir une liste en Python. Bien qu’il puisse exister d’autres approches, celles présentées ici sont parmi les plus simples et efficaces pour la plupart des cas d’utilisation. J’espère que ce guide vous aura été utile.

Bon développement ! 🙂

0 Partages