Listes en compréhension et expressions dict / set / génératrices — Construire des collections en une ligne

Dans l'article précédent sur all() / any(), tu as vu comment juger une collection entière d'un coup. Cette fois, tu vas aller un cran plus loin et découvrir la syntaxe puissante pour construire la collection elle-même en une seule ligne — les compréhensions.

On commence par les listes en compréhension, on ajoute le filtrage avec if, on voit les variantes dict et set, et on termine avec l'expression génératrice qui économise la mémoire.

Les bases de la liste en compréhension — Une boucle for compressée en une ligne

Python a une syntaxe en une ligne pour construire des listes : [expression for variable in itérable]. C'est ce qu'on appelle une liste en compréhension.

C'est un raccourci pour le motif de boucle for où l'on part d'une liste vide et où l'on appelle append() à répétition, et il brille quand tu veux appliquer la même transformation à chaque élément pour produire une nouvelle liste.

# Avec une boucle for
result = []
for price in [100, 250, 480]:
    result.append(int(price * 1.1))
print(result)   # [110, 275, 528]

# La même chose en liste en compréhension
prices = [100, 250, 480]
tax_included = [int(p * 1.1) for p in prices]
print(tax_included)   # [110, 275, 528]

# Récupérer les longueurs de chaînes en une ligne aussi
names = ["Alice", "Bob", "Charlotte"]
lengths = [len(n) for n in names]
print(lengths)   # [5, 3, 9]

Construis une nouvelle liste de prix de produits avec 10 % de TVA ajoutée, en utilisant une liste en compréhension.

① Déclare prices = [100, 250, 480, 1200].

② Utilise la liste en compréhension [int(p * 1.1) for p in prices] pour construire la liste TTC et affecte-la à tax_included.

③ Affiche le résultat avec print(tax_included).

(Quand la réponse est correcte, l'explication apparaît.)

Filtrer avec if — Compréhensions conditionnelles

Ajoute if condition après le for et seuls les éléments qui satisfont la condition finissent dans la nouvelle liste. La forme est [expression for variable in itérable if condition].

Écrire la transformation et le filtre sur la même ligne, c'est ce qui rend les listes en compréhension concises — extraire « uniquement les éléments qui correspondent » devient une ligne courte et lisible.

# Extraire uniquement les articles >= 200
prices = [80, 250, 120, 480, 95]
premium = [p for p in prices if p >= 200]
print(premium)         # [250, 480]

# Filtrer et transformer en même temps
discounted = [int(p * 0.9) for p in prices if p >= 200]
print(discounted)      # [225, 432]   ← 10% de réduction, uniquement >= 200

# Filtrer et transformer sur des chaînes
names = ["Alice", "Bob", "Charlotte", "Ed"]
long_names = [n.upper() for n in names if len(n) >= 5]
print(long_names)      # ['ALICE', 'CHARLOTTE']

À partir de données d'inventaire, extrais les noms de produits avec un stock >= 1.

① Déclare stocks = [("pomme", 12), ("banane", 0), ("orange", 5), ("raisin", 0), ("kiwi", 3)].

② Utilise [name for name, count in stocks if count > 0] pour construire la liste des produits en stock et affecte-la à available (le dépaquetage de tuple permet de lier name et count en même temps).

③ Affiche le résultat avec print(available).

Compréhensions de dict et compréhensions d'ensemble

Échange les crochets [ ] d'une liste en compréhension contre des accolades { } et tu obtiens une compréhension d'ensemble.

Va un cran plus loin avec {key: value for ...} et le deux-points en fait une compréhension de dict. La syntaxe for ... in ... est identique — seule la forme de la collection en sortie change, et c'est cette flexibilité qui rend les compréhensions si pratiques.

# Compréhension de dict : construire une recherche name → price
pairs = [("pomme", 120), ("orange", 80), ("banane", 60)]
price_lookup = {name: price for name, price in pairs}
print(price_lookup)
# {'pomme': 120, 'orange': 80, 'banane': 60}

# Reconstruire un dict avec les prix TTC
tax_included = {name: int(price * 1.1) for name, price in pairs}
print(tax_included)
# {'pomme': 132, 'orange': 88, 'banane': 66}

# Compréhension d'ensemble : extraire les tags uniques (sans doublons)
tags = ["sale", "new", "sale", "limited", "new"]
unique = {t for t in tags}
print(unique)   # {'sale', 'new', 'limited'} (l'ordre dépend de l'implémentation)

Associe zip() aux compréhensions de dict

Quand tu as deux listes parallèles comme names et prices et que tu veux un dict, {n: p for n, p in zip(names, prices)} colle parfaitement. zip() parcourt les listes en parallèle pour que tu construises clés et valeurs en même temps.

À partir d'une liste de tuples (name, price), construis un dict produit → prix TTC en une ligne.

① Déclare pairs = [("pomme", 120), ("orange", 80), ("banane", 60), ("kiwi", 200)].

② Utilise la compréhension de dict {name: int(price * 1.1) for name, price in pairs} pour construire la table TTC et affecte-la à tax_lookup.

③ Affiche le résultat avec print(tax_lookup).

Expressions génératrices — Échanger les crochets contre des parenthèses

Échange les crochets [ ] d'une liste en compréhension contre des parenthèses ( ) et tu as une expression génératrice. Contrairement à une liste, elle ne matérialise pas tous les éléments en mémoire — elle calcule uniquement ce dont tu as besoin, quand tu en as besoin (évaluation paresseuse).

Tu peux la passer directement à sum() / max() / min() / any() etc., ce qui réduit l'usage mémoire pour agréger des données volumineuses. Le tour complet est dans l'article sur les fonctions génératrices plus tard.

# Les parenthèses créent une expression génératrice
prices = [100, 250, 480, 1200]
gen = (int(p * 1.1) for p in prices)
print(type(gen))   # <class 'generator'>

# La passer directement à sum() (les parenthèses extérieures peuvent être omises)
total_tax = sum(int(p * 1.1) for p in prices)
print(total_tax)   # 2233

# Même astuce avec max() / min()
max_tax = max(int(p * 1.1) for p in prices)
print(max_tax)     # 1320

Choisis selon l'usage : « tout d'un coup ? » ou « un par un ? »

Si tu veux avoir tout sous la main comme liste, utilise [ ] (liste en compréhension). Si tu passes juste à sum() / max() pour agréger, ( ) (expression génératrice) est le choix le plus économe en mémoire. À l'échelle du million d'éléments la différence est spectaculaire — l'expression génératrice n'utilise que quelques centaines d'octets.

Pour une liste de prix de produits, calcule le total TTC en combinant une expression génératrice avec sum().

① Déclare prices = [100, 250, 480, 1200].

② Calcule le total TTC avec sum(int(p * 1.1) for p in prices) et affecte-le à total (tu peux placer l'expression génératrice directement dans les parenthèses de sum()).

③ Affiche le résultat avec print(total).