💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici
Les listes imbriquées sont une structure de données courante en Python, mais parfois, vous devrez peut-être les aplatir en une seule liste linéaire. Dans ce tutoriel, nous explorerons la technique d'aplatissement récursif, qui vous permet de gérer efficacement les listes imbriquées de toute profondeur dans vos programmes Python.
Une liste imbriquée en Python est une liste qui contient d'autres listes comme éléments. Ces listes imbriquées peuvent avoir différents types de données, notamment des entiers, des chaînes de caractères et même d'autres listes imbriquées. Les listes imbriquées sont une structure de données puissante qui vous permet de représenter et de manipuler des structures de données complexes en Python.
Une liste imbriquée est une liste qui contient une ou plusieurs listes comme éléments. Par exemple, voici une liste imbriquée :
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]Dans cet exemple, la liste externe nested_list contient trois listes internes, chacune contenant trois entiers.
Pour accéder aux éléments d'une liste imbriquée, vous pouvez utiliser plusieurs indices. Le premier indice sélectionne la liste externe, et le deuxième indice sélectionne la liste interne. Par exemple, pour accéder à l'élément 5 dans la liste imbriquée ci-dessus, vous utiliseriez le code suivant :
print(nested_list[1][1]) ## Output: 5Vous pouvez également modifier les éléments d'une liste imbriquée en assignant une nouvelle valeur à l'élément spécifique. Par exemple, pour changer la valeur de l'élément 5 en 10, vous utiliseriez le code suivant :
nested_list[1][1] = 10
print(nested_list) ## Output: [[1, 2, 3], [4, 10, 6], [7, 8, 9]]Les listes imbriquées sont utiles dans diverses situations, telles que :
En comprenant les bases des listes imbriquées, vous pouvez exploiter cette structure de données puissante pour résoudre une grande variété de problèmes dans votre programmation Python.
Aplatir récursivement une liste imbriquée est une technique courante utilisée pour transformer une liste imbriquée en une liste plate à une dimension. Cette approche est particulièrement utile lorsque vous devez travailler avec des structures de données complexes qui contiennent des listes imbriquées.
La récursivité est une technique de programmation où une fonction s'appelle elle - même pour résoudre un problème. Dans le contexte de l'aplatissement d'une liste imbriquée, l'approche récursive consiste à décomposer le problème en sous - problèmes plus petits et plus gérables jusqu'à ce qu'un cas de base soit atteint.
L'idée de base derrière l'algorithme d'aplatissement récursif est d'itérer sur les éléments de la liste imbriquée et de vérifier si chaque élément est une liste. Si l'élément est une liste, l'algorithme aplatit récursivement cette liste et ajoute les éléments aplatis au résultat final. Si l'élément n'est pas une liste, il est simplement ajouté au résultat final.
Voici une implémentation Python de l'algorithme d'aplatissement récursif :
def flatten_nested_list(nested_list):
result = []
for element in nested_list:
if isinstance(element, list):
result.extend(flatten_nested_list(element))
else:
result.append(element)
return resultDécortiquons le code :
flatten_nested_list prend une liste imbriquée en entrée.result pour stocker les éléments aplatis.flatten_nested_list sur cet élément et ajoute les éléments aplatis à la liste result.result.result, qui contient les éléments aplatis.La technique d'aplatissement récursif peut être appliquée à une grande variété de problèmes impliquant des structures de données imbriquées. Par exemple, vous pouvez l'utiliser pour aplatir des données JSON imbriquées, traiter des structures de fichiers hiérarchiques ou simplifier la représentation de données complexes dans vos applications Python.
En comprenant et en maîtrisant la technique d'aplatissement récursif, vous pouvez améliorer vos compétences en programmation Python et aborder plus facilement des tâches de manipulation de données plus complexes.
La technique d'aplatissement récursif peut être appliquée à une grande variété de scénarios pratiques où vous devez travailler avec des structures de données imbriquées. Explorons quelques exemples pour illustrer l'utilité de cette technique.
Supposons que vous ayez une structure de données JSON imbriquée que vous devez traiter. Vous pouvez utiliser la technique d'aplatissement récursif pour transformer les données JSON imbriquées en une liste plate de paires clé - valeur. Cela peut être particulièrement utile lorsque vous devez rechercher, filtrer ou analyser les données plus efficacement.
Voici un exemple de comment vous pouvez aplatir une structure de données JSON imbriquée en utilisant la fonction flatten_nested_list de la section précédente :
import json
nested_json = {
"name": "John Doe",
"age": 30,
"address": {
"street": "123 Main St",
"city": "Anytown",
"state": "CA"
},
"hobbies": ["reading", "hiking", ["swimming", "cycling"]]
}
flattened_data = flatten_nested_list(list(nested_json.items()))
print(flattened_data)
## Output: [('name', 'John Doe'), ('age', 30), ('address', {'street': '123 Main St', 'city': 'Anytown', 'state': 'CA'}), ('hobbies', ['reading', 'hiking', ['swimming', 'cycling']])]Dans cet exemple, nous convertissons d'abord la structure de données JSON imbriquée en une liste de paires clé - valeur en utilisant la méthode items(). Ensuite, nous passons cette liste à la fonction flatten_nested_list, qui aplatit récursivement la liste imbriquée et retourne une liste plate de paires clé - valeur.
Un autre cas d'utilisation pratique de la technique d'aplatissement récursif est le traitement de structures de fichiers hiérarchiques, telles que les arborescences de répertoires. Vous pouvez utiliser cette technique pour transformer la structure de fichiers imbriquée en une liste plate de chemins de fichiers, ce qui peut être utile pour diverses tâches de gestion et d'analyse de fichiers.
Voici un exemple de comment vous pouvez aplatir une structure de fichiers hiérarchique en utilisant la fonction flatten_nested_list :
import os
def get_file_paths(directory):
file_paths = []
for root, dirs, files in os.walk(directory):
for file in files:
file_path = os.path.join(root, file)
file_paths.append(file_path)
return file_paths
directory = "/path/to/directory"
flattened_file_paths = flatten_nested_list([get_file_paths(directory)])
print(flattened_file_paths)Dans cet exemple, nous utilisons la fonction os.walk() pour parcourir l'arborescence de répertoires et collecter tous les chemins de fichiers. Nous passons ensuite la liste des chemins de fichiers à la fonction flatten_nested_list pour transformer la liste imbriquée en une liste plate de chemins de fichiers.
En comprenant et en appliquant la technique d'aplatissement récursif, vous pouvez simplifier le traitement de structures de données complexes et découvrir de nouvelles possibilités dans vos projets de programmation Python.
Maîtriser l'art d'aplatir récursivement les listes imbriquées est une compétence précieuse pour tout programmeur Python. En comprenant l'approche récursive et en explorant des exemples pratiques, vous pourrez rationaliser vos tâches de traitement de données et travailler facilement avec des structures de données complexes et hiérarchiques. Ce tutoriel vous fournit les connaissances et les techniques nécessaires pour gérer efficacement les listes imbriquées dans vos projets Python.
