Débuter en Python avec lambda, map() et filter()

Difficulté

Facile

Les fonctions lambda, map() et filter() font partie des outils Python souvent présentés tôt, mais pas toujours expliqués simplement. Bien utilisées, elles permettent d’écrire des transformations courtes et lisibles sur des listes ou d’autres suites de valeurs.

Dans ce tutoriel, vous allez manipuler ces trois outils sur des exemples concrets : doubler des nombres, convertir du texte, puis garder seulement certains éléments. L’objectif n’est pas de mémoriser une syntaxe abstraite, mais de voir quand ces outils sont utiles et quand il vaut mieux rester sur une solution plus classique.

Prérequis

• Savoir lancer Python dans un terminal, un interpréteur interactif ou un éditeur.
• Connaître les bases des listes, des variables et des fonctions Python.
• Savoir lire un message d’erreur simple.

Matériel nécessaire

• Python 3 installé
• Un terminal, IDLE ou un éditeur de code
• Un fichier de test, par exemple <code>essai.py</code>

Étapes

1. 1

   Créer une première fonction classique

   Commencez par écrire une fonction normale pour transformer une valeur. Par exemple, créez un fichier Python avec le code suivant :

   def doubler(x):
       return x * 2
   
   print(doubler(4))

   Exécutez le fichier. Vous devez obtenir 8, ce qui servira de point de comparaison pour la suite.

2. 2

   Remplacer la fonction par une lambda

   

   Écrivez maintenant la même idée avec lambda :

   doubler = lambda x: x * 2
   print(doubler(4))

   Relancez le programme. Le résultat est encore 8, mais cette fois la fonction est écrite sur une seule ligne.

3. 3

   Tester plusieurs lambdas simples

   Ajoutez quelques exemples pour voir que lambda peut aussi comparer ou modifier du texte :

   carre = lambda x: x * x
   majuscules = lambda mot: mot.upper()
   est_pair = lambda x: x % 2 == 0
   
   print(carre(5))
   print(majuscules("python"))
   print(est_pair(6))

   Vous obtenez respectivement 25, PYTHON et True. Ces cas simples montrent qu’une lambda peut renvoyer un nombre, une chaîne ou un booléen.

4. 4

   Appliquer une transformation avec map()

   

   Créez une liste de nombres puis appliquez une fonction à chaque élément avec map() :

   nombres = [1, 2, 3, 4]
   resultat = map(lambda x: x * 2, nombres)
   print(list(resultat))

   Après conversion avec list(), vous obtenez [2, 4, 6, 8]. Chaque nombre a été doublé automatiquement.

5. 5

   Réécrire map() avec une fonction nommée

   Refaites le même exercice, mais avec une fonction classique pour comparer les deux styles :

   def doubler(x):
       return x * 2
   
   nombres = [1, 2, 3, 4]
   resultat = map(doubler, nombres)
   print(list(resultat))

   Le résultat reste identique. La différence est surtout une question de lisibilité et de taille du traitement.

6. 6

   Transformer du texte avec map()

   Passez maintenant à un cas utile sur des chaînes de caractères :

   prenoms = ["alice", "bruno", "chloe"]
   resultat = map(lambda nom: nom.capitalize(), prenoms)
   print(list(resultat))

   Vous obtenez ['Alice', 'Bruno', 'Chloe']. C’est un bon exemple de transformation simple appliquée à toute une liste.

7. 7

   Filtrer des valeurs avec filter()

   Utilisez ensuite filter() pour garder seulement certains éléments. Testez ce code :

   nombres = [1, 2, 3, 4, 5, 6]
   resultat = filter(lambda x: x % 2 == 0, nombres)
   print(list(resultat))

   Le programme affiche [2, 4, 6]. Cette fois, la fonction ne transforme pas les nombres : elle décide lesquels conserver.

8. 8

   Garder les mots utiles avec filter()

   Essayez maintenant un exemple simple sur du texte :

   mots = ["Python", "", "code", "", "test"]
   resultat = filter(lambda mot: mot != "", mots)
   print(list(resultat))

   Le résultat est ['Python', 'code', 'test']. Vous supprimez ainsi les chaînes vides d’une liste.

9. 9

   Enchaîner map() et filter() sur un même exemple

   

   Combinez maintenant les deux outils. Gardez d’abord les nombres pairs, puis multipliez-les par 10 :

   nombres = [1, 2, 3, 4, 5, 6]
   pairs = filter(lambda x: x % 2 == 0, nombres)
   resultat = map(lambda x: x * 10, pairs)
   print(list(resultat))

   Vous obtenez [20, 40, 60]. L’exemple montre bien la différence entre sélectionner des éléments et les transformer ensuite.

10. 10

    Comparer avec une boucle for

    Réécrivez le même traitement avec une boucle classique pour voir l’alternative :

    nombres = [1, 2, 3, 4, 5, 6]
    resultat = []
    
    for x in nombres:
        if x % 2 == 0:
            resultat.append(x * 10)
    
    print(resultat)

    Le résultat est le même : [20, 40, 60]. Cette version est souvent plus parlante pour un débutant, surtout quand la logique comporte plusieurs conditions.

11. 11

    Choisir la bonne approche selon le cas

    Utilisez lambda quand l’opération est très courte, par exemple doubler une valeur ou mettre un mot en majuscule. Utilisez map() pour appliquer une transformation répétée et filter() pour garder seulement les éléments qui passent un test.

    Si vous voyez que l’expression devient difficile à lire, revenez à une fonction avec def ou à une boucle for. Le but est d’écrire un code facile à comprendre, y compris pour vous-même plus tard.

Erreurs fréquentes & dépannage

• Oublier les deux-points dans une lambda : la forme correcte est lambda x: x * 2.
• Confondre transformation et filtrage : map() modifie chaque élément, filter() choisit quels éléments garder.
• Passer une fonction mal adaptée à filter() : la fonction doit renvoyer un résultat vrai ou faux.
• Écrire une lambda trop complexe : si elle devient difficile à lire, remplacez-la par def.
• Oublier de convertir le résultat pour l’afficher clairement : dans les exemples du tutoriel, list() permet de visualiser facilement le contenu produit par map() ou filter().

Astuces & pour aller plus loin

Commencez toujours par écrire une version simple avec une fonction classique ou une boucle, puis raccourcissez-la seulement si le résultat reste lisible. Pour vous entraîner, reprenez une petite liste de nombres ou de mots et testez séparément une lambda, puis map(), puis filter().

Une bonne habitude consiste aussi à nommer les variables intermédiaires, par exemple pairs ou resultat. Cela rend les enchaînements plus faciles à suivre qu’une seule expression trop compacte.

Questions fréquentes

Une fonction lambda remplace-t-elle toutes les fonctions classiques en Python ?

Non. Elle est surtout utile pour des traitements très courts écrits sur une seule ligne. Dès que la logique devient plus longue ou doit être réutilisée souvent, une fonction définie avec def est généralement plus claire.

Quelle est la différence la plus simple entre map() et filter() ?

map() transforme chaque élément d’une suite, alors que filter() garde seulement les éléments qui respectent une condition. On peut ensuite les enchaîner si l’on veut d’abord sélectionner puis transformer.

Faut-il toujours utiliser lambda avec map() et filter() ?

Non. Vous pouvez passer une fonction définie avec def à la place d’une lambda. C’est souvent un bon choix quand le traitement a un nom utile ou doit être réutilisé.

Pourquoi comparer aussi avec une boucle for ?

Parce qu’une boucle reste très lisible pour un débutant et convient parfaitement à beaucoup de cas. En Python, un code un peu plus long mais clair est souvent préférable à une écriture trop condensée.

Conclusion

Vous savez maintenant à quoi servent lambda, map() et filter() en Python. Ces outils permettent d’écrire des transformations courtes et des sélections simples sur des listes, à condition de garder la lisibilité comme priorité.

Pour progresser, reprenez vos propres petits exemples : doubler des prix, nettoyer une liste de mots ou garder seulement des valeurs positives. Plus vous comparerez ces outils avec une fonction classique ou une boucle, plus vous saurez choisir la forme la plus adaptée.