Fonctions Python Lambda avec EXEMPLES

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

Une fonction Lambda en Python la programmation est une fonction anonyme ou une fonction sans nom. C'est une fonction petite et restreinte n'ayant pas plus d'une ligne. Tout comme une fonction normale, une fonction Lambda peut avoir plusieurs arguments avec une seule expression.

En 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 en Python aura 3 parties essentielles :

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

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

Dans ce didacticiel Lambda en Python, vous apprendrez :

Syntaxe et exemples
Utilisation de lambdas avec les composants Python intégrés
lambdas dans filter()
lambdas dans map()
lambdas dans reduce()
Pourquoi (et pourquoi pas) utiliser les fonctions lambda ?
Lambdas et fonctions régulières

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 passés à la fonction lambda. Vous pouvez ajouter autant de paramètres que vous le souhaitez.

Cependant, notez que nous n'utilisons pas de parenthèses autour des paramètres comme nous le faisons avec les fonctions régulières. La dernière partie (expression) est toute expression python valide qui fonctionne 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 tapez ce qui suit :

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

Voici le résultat :

Explication du code

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. Remarquez 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 de base pour comprendre les principes fondamentaux et la syntaxe de lambda. Essayons maintenant d'imprimer un lambda et voyons le résultat. Encore une fois, ouvrez 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 la sortie que vous devriez obtenir.

Sortie :

<function <lambda> at 0x00000185C3BF81E0>

Qu'est-ce qu'il se passe ici? Regardons le code pour mieux comprendre.

Explication du code

Ici, nous définissons une chaîne que vous passerez en paramètre au lambda.
Nous déclarons un lambda qui appelle une instruction d'impression et imprime le résultat.

Mais pourquoi le programme n'imprime-t-il pas la chaîne que nous passons ? En effet, le lambda lui-même renvoie un objet fonction. Dans cet exemple, le lambda n'est pas appelé par la fonction d'impression mais simplement retournant l'objet fonction et l'emplacement mémoire où il est stocké. C'est ce qui est imprimé sur 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)

Et exécutez-le en appuyant sur F5, vous verrez une sortie comme celle-ci.

Sortie :

some kind of a useless lambda

Maintenant, le lambda est appelé et la chaîne que nous transmettons est imprimée sur la console. Mais quelle est cette syntaxe étrange, et pourquoi la définition lambda est-elle couverte entre parenthèses ? Comprenons cela maintenant.

Explication du code

Voici la même chaîne que nous avons définie dans l'exemple précédent.
Dans cette partie, nous définissons un lambda et l'appelons immédiatement en passant la chaîne comme argument. C'est ce qu'on appelle un IIFE, et vous en apprendrez plus à ce sujet dans les prochaines sections de ce didacticiel.

Exemple 4

Regardons un dernier exemple pour comprendre comment les lambdas et les fonctions régulières sont exécutées. Alors, ouvrez votre IDLE et dans un nouveau fichier, tapez 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'))

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

Sortie :

imprimante 1 APPEL REGULIER

imprimante 2 APPEL REGULIER

imprimante 1 APPEL LAMBDA

imprimante 2 APPEL LAMBDA

Explication du code

Une fonction appelée guru qui prend une autre fonction comme premier paramètre et tout autre argument qui la suit.
printer_one est une fonction simple qui imprime le paramètre qui lui est passé et le renvoie.
printer_two est similaire à printer_one mais sans l'instruction return.
Dans cette partie, nous appelons la fonction guru et transmettons les fonctions de l'imprimante et une chaîne en tant que paramètres.
C'est la syntaxe pour réaliser la quatrième étape (c'est-à-dire appeler la fonction gourou) mais en utilisant des lambdas.

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

Utilisation de 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 représente l'exécution de la fonction appelée immédiatement. Cela signifie qu'une fonction lambda est appelable dès qu'elle est définie. Comprenons cela avec un exemple; lancez votre IDLE et tapez ce qui suit :

 (lambda x: x + x)(2)

Voici la sortie et l'explication du code :

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

lambdas dans filter()

La fonction de filtre est utilisée pour sélectionner certains éléments particuliers à partir d'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 qui seront sélectionnés sont basés sur des contraintes prédéfinies. Il faut 2 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 le résultat :

[10, 8, 7, 5, 11]

Explication du code :

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. Imprimer le résultat renvoyé par la fonction de filtrage.

lambdas dans map()

la fonction map est utilisée pour appliquer une opération particulière à chaque élément d'une séquence. Comme filter(), il prend aussi 2 paramètres :

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

Par exemple, voici un programme qui imprime les carrés des nombres d'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]

[KR1]

Explication du code :

Ici, nous définissons une liste appelée séquences qui contient des nombres.
Nous déclarons une variable appelée filtered_result qui stockera les valeurs mappées
Une fonction lambda qui s'exécute sur chaque élément de la liste et renvoie le carré de ce nombre.
Imprime le résultat renvoyé par la fonction map.

lambdas dans reduce()

La fonction reduce, comme map(), est utilisée pour appliquer une opération à chaque élément d'une séquence. Cependant, il diffère de la carte dans son fonctionnement. Voici les étapes suivies par la fonction reduce() 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 prend également deux paramètres :

Une fonction qui définit l'opération à effectuer
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 le résultat :

Explication du code :

Importer la réduction depuis le module functools
Ici, nous définissons une liste appelée séquences qui contient des nombres.
Nous déclarons une variable appelée produit qui stockera la valeur réduite
Une fonction lambda qui s'exécute sur chaque élément de la liste. Il renverra le produit de ce nombre selon le résultat précédent.
Imprime 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és de la même manière que les fonctions régulières au niveau de l'interpréteur. 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, vous devez savoir quand utiliser les lambdas et quand les éviter. Dans cette section, vous apprendrez certains des principes de conception utilisés par les développeurs Python lors de l'écriture de lambdas.

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

Il vous permet de fournir une fonction en tant que paramètre à une autre fonction (par exemple, dans la carte, le filtre, etc.). Dans de tels cas, l'utilisation de lambdas offre un moyen élégant de créer une fonction unique et de la transmettre en tant que paramètre.

Quand ne pas utiliser Lambda ?

Vous ne devez 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 à faire des expressions complexes d'une seule ligne, ce serait une pratique bien supérieure de définir une fonction appropriée. Comme bonne pratique, vous devez vous rappeler qu'un code simple est toujours meilleur qu'un code complexe.

Lambdas vs fonctions régulières

Comme indiqué précédemment, les lambdas ne sont [vV4][J5] que des fonctions qui n'ont pas d'identifiant qui leur est lié. En termes plus simples, ce sont des fonctions sans nom (donc anonymes). Voici un tableau pour illustrer la différence entre les lambdas et les fonctions régulières en python.

Lambdas

Fonctions régulières

Syntaxe :

lambda x : x + x

Syntaxe :

def (x) :
return x + x

Les fonctions Lambda ne peuvent avoir qu'une seule expression dans leur corps.

Les fonctions régulières peuvent avoir plusieurs expressions et instructions dans leur corps.

Les lambdas n'ont pas de nom qui leur est associé. C'est pourquoi elles sont également appelées fonctions anonymes.

Les fonctions régulières doivent avoir un nom et une signature.

Les lambdas ne contiennent pas d'instruction return car le corps est automatiquement renvoyé.

Les fonctions qui doivent renvoyer une valeur doivent inclure une instruction de retour.

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 produit 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 normale pour l'exemple ci-dessus ressemblerait à ceci :

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

Ici, nous devons définir un nom pour la fonction qui retourne le résultat lorsque nous appelons ce. Une fonction lambda ne contient pas d'instruction de retour car elle n'aura qu'une seule expression qui est toujours renvoyée par défaut. Vous n'avez même pas besoin d'attribuer un lambda non plus car il peut être immédiatement invoqué (voir la section suivante). Comme vous le verrez dans l'exemple suivant, les lambdas deviennent particulièrement puissants lorsque nous les utilisons avec les fonctions intégrées de Python.

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 sembler surprenant, mais toute fonction lambda que vous définissez en Python est traitée comme une fonction normale par l'interpréteur.

Comme vous pouvez le voir dans le diagramme, les deux définitions sont gérées de la même manière par l'interpréteur python lorsqu'elles sont converties en bytecode. Maintenant, vous ne pouvez pas nommer une fonction lambda car il est réservé par Python, mais tout autre nom de fonction donnera le même bytecode[KR6].

Résumé

Les lambdas, également appelées fonctions anonymes, sont de petites fonctions restreintes qui n'ont pas besoin de nom (c'est-à-dire d'identifiant).
Chaque fonction lambda en Python comporte 3 parties essentielles :
Le mot-clé lambda.
Les paramètres (ou variables liées), et
Le corps de la fonction.
La syntaxe pour écrire un lambda est :paramètre lambda :expression
Les lambdas peuvent avoir n'importe quel nombre de paramètres, mais ils ne sont pas entre accolades
Un lambda ne peut avoir qu'une seule expression dans son corps de fonction, qui est renvoyé par défaut.
Au niveau du bytecode, il n'y a pas beaucoup de différence entre la façon dont les lambdas et les fonctions régulières sont gérées par l'interpréteur.
Lambdas prend en charge IIFE via cette syntaxe :(paramètre lambda :expression)(argument)
Les lambdas sont couramment utilisés avec les éléments intégrés Python suivants :
Filtre :filtre (paramètre lambda :expression, iterable-sequence)
Map :map (paramètre lambda :expression, iterable-sequences)
Réduire :réduire (paramètre 1 lambda, paramètre2 :expression, séquence itérable)
N'écrivez pas de fonctions lambda compliquées dans un environnement de production, car cela sera difficile pour les responsables de la maintenance du code.

[J5]J'ai ajouté un tableau, mais l'explication est nécessaire pour comprendre les différences.

Exemples de fonctions Python :appel, indentation, arguments et valeurs de retour Fonction Python abs() :Exemples de valeurs absolues

Python