Que sont les compréhensions de liste ?
La compréhension de liste est un moyen compact de créer une nouvelle liste basée sur une séquence existante ou un objet itérable. Au lieu d'écrire plusieurs lignes avec des boucles, vous pouvez exprimer la même logique en une seule ligne.
Syntaxe de base
La structure de base de la compréhension de la liste ressemble à ceci :
новый_список = [выражение for элемент in последовательность]Exemple : approche traditionnelle vs compréhension de liste
Créons une liste de carrés de nombres de 0 à 9.
Approche traditionnelle :
squares = []
for i in range(10):
squares.append(i ** 2)
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]Avec list comprehension :
squares = [i ** 2 for i in range(10)]
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]Le résultat est le même, mais la deuxième option est plus courte et se lit presque comme une phrase normale : « créer une liste de carrés i pour chaque i dans la plage de 0 à 9 ».
Ajout de conditions
Vous pouvez filtrer les éléments en ajoutant une condition à la fin :
новый_список = [выражение for элемент in последовательность if условие]Exemples avec conditions
Seulement les nombres pairs :
evens = [i for i in range(20) if i % 2 == 0]
print(evens)
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]Carrés de nombres impairs uniquement :
odd_squares = [i ** 2 for i in range(10) if i % 2 != 0]
print(odd_squares)
# [1, 9, 25, 49, 81]Filtration des lignes :
words = ["apple", "banana", "cherry", "date", "elderberry"]
long_words = [word for word in words if len(word) > 5]
print(long_words)
# ['banana', 'cherry', 'elderberry']Travail avec des lignes
Les compréhensions de liste sont parfaites pour le traitement des chaînes.
Conversion en majuscules :
names = ["anna", "bob", "charlie"]
upper_names = [name.upper() for name in names]
print(upper_names)
# ['ANNA', 'BOB', 'CHARLIE']Extraction des premières lettres :
words = ["Python", "is", "awesome"]
first_letters = [word[0] for word in words]
print(first_letters)
# ['P', 'i', 'a']Cycles imbriqués
Les compréhensions de liste prennent en charge les boucles imbriquées pour travailler avec des données multidimensionnelles.
Création de paires de coordonnées :
coordinates = [(x, y) for x in range(3) for y in range(3)]
print(coordinates)
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]Multiplication des éléments de deux listes :
list1 = [1, 2, 3]
list2 = [10, 20, 30]
products = [x * y for x in list1 for y in list2]
print(products)
# [10, 20, 30, 20, 40, 60, 30, 60, 90]
Opérateur conditionnel if-else
Vous pouvez utiliser l'opérateur ternaire pour une logique plus complexe :
новый_список = [выражение_if if условие else выражение_else for элемент in последовательность]Exemple : les paires sont remplacées par « paire », les impaires sont laissées telles quelles :
numbers = [1, 2, 3, 4, 5, 6]
result = ["even" if n % 2 == 0 else n for n in numbers]
print(result)
# [1, 'pair', 3, 'pair', 5, 'pair']Exemples pratiques
Utilisation des dictionnaires
Extraction de valeurs :
prices = {"apple": 50, "banana": 30, "cherry": 80}
expensive = [fruit for fruit, price in prices.items() if price > 40]
print(expensive)
# ['apple', 'cherry']Traitement des fichiers
Lecture et filtrage des lignes :
# Supposons que nous avons un fichier texte
lines = [" hello ", "world", " Python ", ""]
cleaned = [line.strip() for line in lines if line.strip()]
print(cleaned)
# ['hello', 'world', 'Python']Opérations mathématiques
Application de la fonction à tous les éléments :
import math
numbers = [4, 9, 16, 25]
roots = [math.sqrt(n) for n in numbers]
print(roots)
# [2.0, 3.0, 4.0, 5.0]Quand ne faut-il PAS utiliser les compréhensions de liste
Malgré l'élégance, il existe des situations où les cycles traditionnels sont préférables :
Logique complexe : si l'expression devient trop longue et difficile à lire
Effets secondaires : les compréhensions de liste sont conçues pour créer des listes, pas pour effectuer des actions
Imbrication profonde : plus de deux boucles imbriquées rendent le code illisible
Mauvais exemple (trop compliqué) :
# Ne faites pas ça !
result = [x * y if x % 2 == 0 else x + y for x in range(10) if x > 5 for y in range(10) if y % 3 == 0]Il est préférable de diviser en plusieurs lignes avec des cycles réguliers.
Autres types de compréhension
Python ne prend pas seulement en charge les compréhensions de liste :
Dictionary comprehension:
squares_dict = {x: x ** 2 for x in range(5)}
print(squares_dict)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}Set comprehension:
unique_squares = {x ** 2 for x in [1, 2, 2, 3, 3, 4]}
print(unique_squares)
# {1, 4, 9, 16}Expression de générateur (pour économiser de la mémoire) :
squares_gen = (x ** 2 for x in range(1000000))
# Crée un générateur, pas une liste, économisant de la mémoireProductivité
Les compréhensions de liste fonctionnent généralement plus rapidement que les boucles équivalentes avec append(), car elles sont optimisées au niveau de l'interpréteur Python.
Conclusion
Les compréhensions de liste sont un outil puissant qui rend votre code Python plus élégant et lisible. Commencez par des exemples simples, entraînez-vous sur des tâches réelles et, au fil du temps, vous les utiliserez naturellement et efficacement.
Points clés à retenir :
Les compréhensions de liste rendent le code plus court et plus expressif
Vous pouvez ajouter des conditions de filtrage
Les boucles imbriquées sont prises en charge
N'abusez pas de la complexité : la lisibilité est plus importante que la brièveté
Il existe également dict, set comprehensions et generator expressions
Entraînez-vous, expérimentez et les compréhensions de liste deviendront une partie naturelle de votre style de programmation Python !
Rejoignez Code - notre application de formation pour les développeurs ! Nous avons communauté amicale sur la chaîne Telegram, où les programmeurs débutants et expérimentés partagent leurs connaissances, s'entraident dans leurs tâches et discutent des nouvelles technologies. Apprenez avec nous !