Comprendre les compréhensions Python simplement

Difficulté

Facile

Les compréhensions de liste et de dictionnaire sont une façon compacte d'écrire des créations de collections en Python. Elles servent souvent à remplacer une boucle courte quand vous voulez produire une nouvelle liste ou un nouveau dictionnaire à partir de données existantes.

Dans ce tutoriel, vous allez manipuler des exemples simples pour transformer des valeurs, filtrer des éléments, puis combiner les deux. L'objectif n'est pas d'aller vite, mais de voir clairement la forme de chaque compréhension et de savoir quand l'utiliser.

Prérequis

Il vaut mieux connaître les bases suivantes : variables, listes, dictionnaires, boucles for et conditions if. Si vous savez déjà parcourir une liste et afficher le résultat avec print(), vous avez le niveau nécessaire.

Matériel nécessaire

• Python 3 installé sur votre ordinateur
• Un éditeur de texte ou un environnement interactif Python
• Un terminal ou une console Python pour exécuter les exemples

Étapes

1. 1

   Créer une première liste avec une compréhension

   

   Commencez avec une liste de nombres, puis fabriquez une nouvelle liste qui contient leurs doubles. Tapez cet exemple : nombres = [1, 2, 3, 4] puis doubles = [n * 2 for n in nombres].

   Affichez ensuite le résultat avec print(doubles). Vous devez obtenir [2, 4, 6, 8].

2. 2

   Réécrire la même logique avec une boucle classique

   Écrivez maintenant la version longue pour comparer les deux styles. Par exemple : doubles = [], puis une boucle for qui ajoute n * 2 avec append().

   Comparez mentalement les deux écritures. La compréhension fait la même chose, mais en une seule expression quand le traitement reste simple.

3. 3

   Transformer du texte dans une liste

   Prenez une liste de mots comme mots = ["python", "liste", "code"]. Créez ensuite une nouvelle liste en majuscules avec majuscules = [mot.upper() for mot in mots].

   Affichez le résultat pour vérifier : ["PYTHON", "LISTE", "CODE"]. Le principe est le même que pour les nombres : seule l'opération de transformation change.

4. 4

   Filtrer des valeurs avec une condition

   

   Créez une liste de nombres, par exemple nombres = [1, 2, 3, 4, 5, 6]. Gardez seulement les nombres pairs avec pairs = [n for n in nombres if n % 2 == 0].

   Affichez le résultat avec print(pairs). Vous devez obtenir [2, 4, 6].

5. 5

   Combiner transformation et filtrage

   Prenez la même liste de nombres et créez les carrés des nombres pairs seulement. Écrivez : carres_pairs = [n ** 2 for n in nombres if n % 2 == 0].

   Affichez le résultat. Avec [1, 2, 3, 4, 5, 6], vous obtenez [4, 16, 36].

6. 6

   Construire un dictionnaire avec une compréhension

   

   Passez maintenant aux dictionnaires avec une liste de nombres comme nombres = [1, 2, 3, 4]. Créez un dictionnaire qui associe chaque nombre à son carré : carres = {n: n ** 2 for n in nombres}.

   Affichez le résultat avec print(carres). Vous obtenez un dictionnaire du type {1: 1, 2: 4, 3: 9, 4: 16}.

7. 7

   Filtrer des éléments pendant la création d'un dictionnaire

   Reprenez la même idée, mais ne gardez que certains éléments. Par exemple : carres_pairs = {n: n ** 2 for n in nombres if n % 2 == 0}.

   Affichez le résultat pour vérifier que seuls les nombres pairs deviennent des clés du dictionnaire. Avec [1, 2, 3, 4], vous obtenez {2: 4, 4: 16}.

8. 8

   Tester vos compréhensions avec de petits jeux de données

   Essayez maintenant plusieurs variantes très courtes. Par exemple, créez une liste de longueurs avec mots = ["un", "trois", "python"] puis longueurs = [len(mot) for mot in mots].

   Testez aussi un dictionnaire simple comme resultat = {mot: len(mot) for mot in mots}. Plus vos jeux de test sont petits, plus il est facile de vérifier si votre compréhension fait exactement ce que vous attendez.

9. 9

   Choisir entre compréhension et boucle classique

   Prenez une compréhension que vous avez écrite et demandez-vous si elle reste lisible en quelques secondes. Si vous devez la relire plusieurs fois pour la comprendre, réécrivez-la avec une boucle classique.

   Gardez les compréhensions pour les cas simples : une source claire, une transformation courte, et éventuellement un filtrage simple. Cette discipline rend votre code plus agréable à lire pour vous et pour les autres.

Erreurs fréquentes & dépannage

L'erreur la plus courante est d'inverser l'ordre des morceaux et d'écrire une expression difficile à relire. Retenez la forme générale : valeur produite, puis for, puis la source, puis éventuellement if.

Une autre erreur fréquente est d'essayer de faire trop de choses d'un coup. Si vous avez besoin de plusieurs conditions ou d'une logique compliquée, revenez à une boucle classique pour garder un code clair.

Astuces & pour aller plus loin

Pour apprendre plus vite, écrivez d'abord la version avec une boucle, puis transformez-la en compréhension. Cette comparaison rend la structure beaucoup plus naturelle.

Vous pouvez aussi prononcer la compréhension à voix haute. Par exemple : « pour chaque nombre dans la liste, garder les pairs et produire leur carré ».

Questions fréquentes

À quoi sert une compréhension de liste en Python ?

Elle sert à créer une nouvelle liste à partir d'une séquence existante, souvent avec une transformation, un filtrage, ou les deux.

Quelle est la différence entre une compréhension de liste et une compréhension de dictionnaire ?

La compréhension de liste produit une liste. La compréhension de dictionnaire produit un dictionnaire avec une clé et une valeur pour chaque élément parcouru.

Faut-il toujours préférer une compréhension à une boucle for ?

Non. Une compréhension est utile quand le traitement est court et facile à lire. Si la logique devient trop complexe, une boucle classique est souvent plus claire.

Où place-t-on la condition dans une compréhension simple ?

Dans les exemples de filtrage de ce tutoriel, la condition se place à la fin, après la partie for.

Conclusion

Vous savez maintenant lire et écrire des compréhensions de liste et de dictionnaire pour transformer et filtrer des données simples en Python. En partant de petits exemples, vous avez vu la structure générale, les cas de filtrage, et le moment où une boucle classique reste préférable.

Le bon réflexe pour progresser est simple : écrire d'abord une boucle, puis vérifier si une compréhension plus courte reste parfaitement lisible. Avec un peu de pratique, vous reconnaîtrez vite les situations où cet outil rend votre code plus net.