logo oujood
🔍

L'expressions lambda en Python

Parfois, vous devez écrire une fonction simple qui contient une seule expression. Cependant, vous ne devez utiliser cette fonction qu'une seule fois. Et il sera inutile de définir cette fonction avec le mot-clé def.
C'est là que les expressions lambda de Python entrent en jeu.

OUJOOD.COM

Qu'est-ce que les expressions lambda Python ?

Les expressions lambda Python vous permettent de définir des fonctions anonymes.
Les fonctions anonymes sont des fonctions sans nom. Les fonctions anonymes sont utiles lorsque vous n'avez besoin de les utiliser qu'une seule fois.
Une expression lambda contient généralement un ou plusieurs arguments, mais elle ne peut avoir qu'une seule expression.
Ce qui suit montre la syntaxe des expressions lambda :

lambda paramètres : expression


C'est l'équivalent de la fonction suivante sans le nom "anonymous" :

📋 Copier le code 

def anonymous(paramètres) :
    return expression

Exemples d'expressions lambda en Python

En Python, vous pouvez passer une fonction à une autre fonction ou retourner une fonction depuis une autre fonction.

1) Exemples de fonctions qui acceptent une fonction

Ce qui suit définit une fonction appelée get_nom_complet() qui formate le nom complet à partir du prénom et du nom :

📋 Copier le code 

def get_nom_complet(prenom, nom, formateur):
    return formater(prenom, nom)
La fonction get_nom_complet accepte 3 arguments

le prénom (prenom)
Nom de famille (nom)
Une fonction qui formatera le nom complet (formateur).

À son tour, la fonction formateur accepte deux arguments : (prenom) et (nom).
mais avant de pouvoir utiliser la fonction get_nom_complet , il faut définir la fonction formateur.
Ce qui suit définit deux fonctions formateur qui renvoient un nom complet à partir du prénom et du nom de famille dans deux formats différents et on peut utiliser l'une de ces ceux fonctions pour formater lke nom complet :

📋 Copier le code 

def prenom_nom(prenom, nom):
    return f"{prenom} {nom}"

def nom_prenom(prenom, nom):
    return f"{nom}, {prenom}"
Et voilà comment appeler la fonction get_nom_complet() en passant le prénom, le nom et les fonctions prenom_nom / nom_prenom :

📋 Copier le code 

nom_complet = get_nom_complet('John', 'Doe', prenom_nom)
print(nom_complet) #retourne John Doe

nom_complet = get_nom_complet('John', 'Doe', nom_prenom)
print(nom_complet) #retourne  Doe, John
Au lieu de définir les fonctions prenom_nom et nom_prenom, vous pouvez utiliser des expressions lambda.
Par exemple, vous pouvez exprimer la fonction prenom_nom à l'aide de l'expression lambda suivante :

📋 Copier le code 

lambda prenom,nom: f"{prenom} {nom}"
Cette expression lambda accepte deux arguments et les concatène en une chaîne formatée dans l'ordre suivant : prénom, espace et nom.
Et ce qui suit convertit la fonction nom_prenom en utilisant une expression lambda qui renvoie le nom complet dans le format : nom de famille, espace, et prénom :

📋 Copier le code 

lambda nom, prenom: f"{prenom} {nom}";
A l'aide d'expressions lambda, vous pouvez appeler la fonction get_nom_complet() comme suit :

📋 Copier le code 

def get_nom_complet(prenom, nom, formateur):
    return formateur(prenom, nom)

nom_complet = get_nom_complet('John','Doe',lambda prenom, nom: f"{prenom} {nom}")
print(nom_complet)

nom_complet = get_nom_complet('John','Doe',lambda prenom, nom: f"{nom} {prenom}")
print(nom_complet)
Ce qui donne une fonction plus précise et moins longue.

2) Exemple de fonctions qui renvoient une fonction

La fonction fois() suivante renvoie une fonction qui est une expression lambda :

📋 Copier le code 

def fois(n):
    return lambda x: x * n
Cet exemple montre comment appeler la fonction times() :

📋 Copier le code 

def fois(n):
    return lambda x: x * n
triple = fois(3)
print(triple(3))
print(triple(8))
Comme la fonction fois() renvoie une fonction, le triple est également une fonction. Pour l'appeler, vous placez des parenthèses comme ceci :

📋 Copier le code 

def fois(n):
    return lambda x: x * n
triple = fois(3)
print(triple(3))
#on peut aussi stcker dans une varible
x=triple(8)
print(x)

Lambda Python dans une boucle

Voir l'exemple suivant :

📋 Copier le code 

appellables = []
for i in (1, 2, 3):
    appellables.append(lambda: i)

for f in appellables:
    print(f())
Comment cela fonctionne?
  1. définissez une liste avec le nom appellables.
  2. itérer de 1 à 3, créer une nouvelle expression lambda à chaque itération, et l'ajouter à la liste des appelables.
  3. bouclez sur les appelables et appelez chaque fonction.
Le résultat attendu sera :
1
2
3
Cependant, le programme affiche la sortie suivante :
3
3
3
Le problème est que toutes ces expressions lambda font référence à la variable i, et non à la valeur actuelle de i.
Lorsque vous appelez les expressions lambda, la valeur de la variable i est 3.
Pour résoudre ce problème, vous devez lier la variable i à chaque expression lambda au moment où celle-ci est créée. Une façon de le faire est d'utiliser l'argument par défaut :

📋 Copier le code 

appellables = []
for i in (1, 2, 3):
    appellables.append(lambda a=i: a)

for f in appellables:
    print(f())
En effet, dans cet exemple, la valeur de a est évaluée au moment où l'expression lambda est créée. Par conséquent, le programme renvoie la valeur attendue.
Cours precedent    Sommaire     Cours suivant