Python Fonctions Lambda avec EXEMPLES

Qu'est-ce que la fonction Lambda dans Python?

A Fonction Lambda dans Python la programmation est une fonction anonyme ou une fonction n'ayant pas de nom. Il s'agit d'une fonction petite et restreinte ne comportant pas plus d'une ligne. Tout comme une fonction normale, une fonction Lambda peut avoir plusieurs arguments avec une seule expression.

In Python, les expressions lambda (ou formes lambda) sont utilisées pour construire des fonctions anonymes. Pour ce faire, vous utiliserez le lambda mot-clé (tout comme vous utilisez def pour définir les fonctions normales). Chaque fonction anonyme que vous définissez dans Python comportera 3 parties essentielles :

• Le mot-clé lambda.
• Les paramètres (ou variables liées), et
• Le corps fonctionnel.

Une fonction lambda peut avoir n'importe quel nombre de paramètres, mais le corps de la fonction ne peut contenir que UN expression. De plus, un lambda est écrit sur une seule ligne de code et peut également être invoqué immédiatement. Vous verrez tout cela en action dans les exemples à venir.

Syntaxe et exemples

La syntaxe formelle pour écrire une fonction lambda est la suivante :

lambda p1, p2: expression

Ici, p1 et p2 sont les paramètres qui sont transmis à la fonction lambda. Vous pouvez ajouter autant ou peu de paramètres que nécessaire.

Notez cependant que nous n'utilisons pas de parenthèses autour des paramètres, contrairement aux fonctions classiques. La dernière partie (expression) peut être n'importe quelle expression valide. Python expression qui agit sur les paramètres que vous fournissez à la fonction.

Exemple 1

Maintenant que vous connaissez les lambdas, essayons avec un exemple. Alors, ouvrez votre IDLE et saisissez ce qui suit :

adder = lambda x, y: x + y
print (adder (1, 2))

Code Explication

Ici, nous définissons une variable qui contiendra le résultat renvoyé par la fonction lambda.

1. Le mot-clé lambda utilisé pour définir une fonction anonyme.

2. x et y sont les paramètres que nous transmettons à la fonction lambda.

3. C'est le corps de la fonction, qui ajoute les 2 paramètres que nous avons passés. Notez qu'il s'agit d'une seule expression. Vous ne pouvez pas écrire plusieurs instructions dans le corps d'une fonction lambda.

4. Nous appelons la fonction et imprimons la valeur renvoyée.

Exemple 2

C'était un exemple simple pour comprendre les principes fondamentaux et la syntaxe des fonctions lambda. Essayons maintenant d'afficher une fonction lambda et d'observer le résultat. Ouvrez à nouveau votre IDLE et saisissez ce qui suit :

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Enregistrez maintenant votre fichier et appuyez sur F5 pour exécuter le programme. C'est le résultat que vous devriez obtenir.

Sortie :

<function <lambda> at 0x00000185C3BF81E0>

Que se passe-t-il ici ? Examinons le code pour mieux comprendre.

Code Explication:

1. Ici, nous définissons un string que vous transmettrez en tant que paramètre à la fonction lambda.

2. Nous déclarons une lambda qui appelle une instruction d'impression et affiche le résultat.

Mais pourquoi le programme n'affiche-t-il pas la chaîne de caractères que nous lui transmettons ? C'est parce que la lambda elle-même renvoie un objet fonction. Dans cet exemple, la lambda n'est pas exécutée. appelé par la fonction d'impression mais est simplement retour L'objet fonction et son adresse mémoire sont affichés dans la console.

Exemple 3

Cependant, si vous écrivez un programme comme celui-ci :

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

Exécutez-le en appuyant sur F5, vous verrez un résultat comme celui-ci.

Sortie :

some kind of a useless lambda

L'expression lambda est maintenant appelée et la chaîne de caractères transmise s'affiche dans la console. Mais que signifie cette syntaxe étrange et pourquoi la définition de l'expression lambda est-elle encadrée par des crochets ? Essayons de comprendre cela.

Code Explication:

1. Voici la même chaîne de caractères que celle définie dans l'exemple précédent.

2. Dans cette partie, nous définissons une fonction lambda et l'appelons immédiatement en lui passant la chaîne de caractères comme argument. Il s'agit d'une fonction IIFE (Integrated IIFE), dont vous apprendrez davantage dans les sections suivantes de ce tutoriel.

Exemple 4

Prenons un dernier exemple pour comprendre comment les lambdas et les fonctions classiques sont exécutées. Ouvrez donc votre IDLE et dans un nouveau fichier, saisissez ce qui suit :

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Enregistrez le fichier et appuyez sur F5 pour exécuter le programme. Si vous n'avez commis aucune erreur, le résultat devrait ressembler à ceci.

Sortie :

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Explication:

1. Une fonction appelée guru qui prend une autre fonction comme premier paramètre et tous les autres arguments qui suivent.

2. printer_one est une fonction simple qui imprime le paramètre qui lui est passé et le renvoie.

3. printer_two est similaire à printer_one mais sans l'instruction return.

4. Dans cette partie, nous appelons la fonction guru et passons les fonctions d'impression et une chaîne de caractères comme paramètres.

5. Voici la syntaxe pour réaliser la quatrième étape (c'est-à-dire appeler la fonction guru) mais en utilisant des lambdas.

Dans la section suivante, vous apprendrez à utiliser les fonctions lambda avec map (), réduire() et filtre() in Python.

Utiliser des lambdas avec Python intégrés

Les fonctions Lambda offrent un moyen élégant et puissant d'effectuer des opérations à l'aide de méthodes intégrées dans Python. C'est possible car les lambdas peuvent être invoqués immédiatement et passés en argument à ces fonctions.

IIFE en Python Lambda

IIFE qui veut dire exécution de la fonction immédiatement invoquée. Cela signifie qu'une fonction lambda est appelable dès sa définition. Prenons un exemple pour mieux comprendre ; lancez votre IDLE et saisissez ce qui suit :

 (lambda x: x + x)(2)

Voici le résultat et l'explication du code :

Cette capacité des lambdas à être invoquées immédiatement vous permet de les utiliser dans des fonctions comme map() et réduire(). C'est utile car vous ne souhaiterez peut-être plus utiliser ces fonctions.

lambdas dans le filtre()

La fonction de filtre est utilisée pour sélectionner certains éléments particuliers dans une séquence d'éléments. La séquence peut être n'importe quel itérateur comme des listes, des ensembles, des tuples, etc.

Les éléments sélectionnés sont déterminés par une contrainte prédéfinie. Cette fonction prend deux paramètres :

• Une fonction qui définit la contrainte de filtrage
• Une séquence (tout itérateur comme des listes, des tuples, etc.)

Par exemple,

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Voici la sortie:

[10, 8, 7, 5, 11]

Code Explication:

1. Dans la première instruction, nous définissons une liste appelée séquences qui contient des nombres.

2. Ici, nous déclarons une variable appelée filtered_result, qui stockera les valeurs filtrées renvoyées par la fonction filter().

3. Une fonction lambda qui s'exécute sur chaque élément de la liste et renvoie vrai s'il est supérieur à 4.

4. Imprime le résultat renvoyé par la fonction de filtre.

lambdas dans la carte()

La fonction map permet d'appliquer une opération particulière à chaque élément d'une séquence. Comme filter(), elle prend également deux paramètres :

1. Une fonction qui définit l'opération à effectuer sur les éléments
2. Une ou plusieurs séquences

Par exemple, voici un programme qui imprime les carrés des nombres dans une liste donnée :

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Sortie :

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

Code Explication:

1. Ici, nous définissons une liste appelée séquences qui contient certains nombres.

2. Nous déclarons une variable appelée filtered_result qui stockera les valeurs mappées.

3. Une fonction lambda qui s'exécute sur chaque élément de la liste et renvoie le carré de ce nombre.

4. Imprimez le résultat renvoyé par la fonction map.

lambdas dans réduire()

La fonction de réduction, comme map(), est utilisée pour appliquer une opération à chaque élément d'une séquence. Cependant, elle diffère de la carte dans son fonctionnement. Voici les étapes suivies par la fonction réduire() pour calculer une sortie :

Étape 1) Effectuez l'opération définie sur les 2 premiers éléments de la séquence.

Étape 2) Enregistrer ce résultat.

Étape 3) Effectuez l'opération avec le résultat enregistré et l'élément suivant dans la séquence.

Étape 4) Répétez jusqu’à ce qu’il ne reste plus d’éléments.

Il faut également deux paramètres :

1. Une fonction qui définit l'opération à effectuer
2. Une séquence (tout itérateur comme des listes, des tuples, etc.)

Par exemple, voici un programme qui renvoie le produit de tous les éléments d'une liste :

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Voici la sortie:

120

Code Explication:

1. Importez reduce depuis le module functools.

2. Ici, nous définissons une liste appelée séquences qui contient certains nombres.

3. Nous déclarons une variable appelée produit qui stockera la valeur réduite.

4. Une fonction lambda qui s'exécute sur chaque élément de la liste. Elle renverra le produit de ce nombre, conformément au résultat précédent.

5. Imprimez le résultat renvoyé par la fonction reduce.

Pourquoi (et pourquoi pas) utiliser les fonctions lambda ?

Comme vous le verrez dans la section suivante, les lambdas sont traitées de la même manière que les fonctions normales au niveau de l'interprète. D'une certaine manière, on pourrait dire que les lambdas fournissent une syntaxe compacte pour écrire des fonctions qui renvoient une seule expression.

Cependant, il est important de savoir quand utiliser les lambdas et quand les éviter. Dans cette section, vous découvrirez certains des principes de conception utilisés par Python développeurs lors de l'écriture de lambdas.

L'un des cas d'utilisation les plus courants des lambdas se trouve dans la programmation fonctionnelle, comme Python prend en charge un paradigme (ou un style) de programmation appelé programmation fonctionnelle.

Elle permet de passer une fonction en paramètre à une autre (par exemple, dans `map`, `filter`, etc.). Dans ce cas, l'utilisation des lambdas offre une manière élégante de créer une fonction ponctuelle et de la transmettre comme paramètre.

Quand ne faut-il pas utiliser Lambda ?

Vous ne devriez jamais écrire de fonctions lambda compliquées dans un environnement de production. Il sera très difficile pour les codeurs qui maintiennent votre code de le décrypter. Si vous vous retrouvez à créer des expressions complexes sur une seule ligne, ce serait une pratique bien supérieure de définir une fonction appropriée. En tant que bonne pratique, vous devez vous rappeler qu’un code simple est toujours meilleur qu’un code complexe.

Fonctions Lambdas et fonctions régulières

Comme indiqué précédemment, les lambdas sont simplement des fonctions sans identifiant. Autrement dit, ce sont des fonctions anonymes. Voici un tableau illustrant la différence entre les lambdas et les fonctions classiques. Python.

lambda x : x + x

def (x) :
return x + x 

Explication des différences

La principale différence entre une fonction lambda et une fonction régulière est que la fonction lambda n'évalue qu'une seule expression et génère un objet fonction. Par conséquent, nous pouvons nommer le résultat de la fonction lambda et l'utiliser dans notre programme comme nous l'avons fait dans l'exemple précédent.

Une fonction régulière pour l'exemple ci-dessus ressemblerait à ceci :

def adder (x, y):
return x + y 
print (adder (1, 2))

Ici, nous devons définir un Le nom pour la fonction qui Retours le résultat quand nous nous appeler Une fonction lambda ne contient pas d'instruction de retour, car elle ne comporte qu'une seule expression, toujours retournée par défaut. Il n'est même pas nécessaire d'assigner une lambda, car elle peut être appelée immédiatement (voir la section précédente). Comme vous le verrez, les lambdas deviennent particulièrement puissantes lorsqu'on les utilise avec… Pythonles fonctions intégrées de.

Cependant, vous vous demandez peut-être encore en quoi les lambdas sont différents d'une fonction qui renvoie une seule expression (comme celle ci-dessus). Au niveau des interprètes, il n’y a pas beaucoup de différence. Cela peut paraître surprenant, mais toute fonction lambda que vous définissez dans Python est traitée comme une fonction normale par l'interprète.

Au niveau du bytecode, les deux définitions sont traitées de la même manière par le Python interpréteur. Désormais, vous ne pouvez plus nommer une fonction lambda car il est réservé par Pythonmais tout autre nom de fonction produira le même bytecode.

FAQ