Python Fonctions Lambda avec EXEMPLES

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.

Cependant, notez que nous n’utilisons pas de crochets autour des paramètres comme nous le faisons avec les fonctions normales. La dernière partie (expression) est toute expression Python valide qui opère 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))

Voici la sortie:

3

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. 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 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 le résultat 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

1. Ici, nous définissons un string que vous passerez en paramètre au lambda.
2. Nous déclarons un lambda qui appelle une instruction print et imprime le résultat.

Mais pourquoi le programme n'imprime-t-il pas la chaîne que nous transmettons ? 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 retour 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 mise entre parenthèses ? Comprenons cela maintenant.

Explication du code

1. Voici la même chaîne que nous avons définie dans l'exemple précédent.
2. 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, 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'))

Maintenant, 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

Explication du code

1. Une fonction appelée gourou qui prend une autre fonction comme premier paramètre et tout autre argument qui la suit.
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 gourou et passons les fonctions d'imprimante et une chaîne comme paramètres.
5. 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 carte(), 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 qu'elle est définie. Comprenons cela avec un exemple ; allumez 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 qui seront sélectionnés sont basés sur une contrainte prédéfinie. 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 la sortie:

[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. Imprime le résultat renvoyé par la fonction de filtre.

lambdas dans la carte()

la fonction map est utilisée pour appliquer une opération particulière à chaque élément d'une séquence. Comme filter(), il prend également 2 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]

[KR1]

Explication du code :

1. Ici, nous définissons une liste appelée séquences qui contient quelques 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. Imprime 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) Enregistrez 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

Explication du code :

1. Importer réduire depuis le module functools
2. Ici, nous définissons une liste appelée séquences qui contient quelques nombres.
3. On déclare une variable appelée product qui stockera la valeur réduite
4. 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.
5. Imprime le résultat renvoyé par la fonction de réduction.

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, vous devez savoir quand c'est une bonne idée d'utiliser des 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 concerne la programmation fonctionnelle. Python prend en charge un paradigme (ou un style) de programmation appelé programmation fonctionnelle.

Il permet de fournir une fonction en paramètre à une autre fonction (par exemple, dans une carte, un 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 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 ne sont que des fonctions auxquelles aucun identifiant n'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.

Lambda

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 ne sont pas associés à un nom. 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 return.

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 n'aura qu'une seule expression qui est toujours renvoyée par défaut. Vous n'avez même pas besoin d'assigner une fonction lambda car elle peut être immédiatement invoquée (voir la section suivante). Comme vous le verrez dans l'exemple suivant, les fonctions lambda deviennent particulièrement puissantes lorsque nous les utilisons 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.

Comme vous pouvez le voir sur le diagramme, les deux définitions sont traité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 connues sous le nom de fonctions anonymes, sont de petites fonctions restreintes qui n'ont pas besoin de nom (c'est-à-dire d'identifiant).
• Chaque fonction lambda dans Python comporte 3 parties essentielles :
• Le mot-clé lambda.
• Les paramètres (ou variables liées), et
• Le corps fonctionnel.
• 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 entourés d'accolades
• Un lambda ne peut avoir qu'une seule expression dans son corps de fonction, qui est renvoyée 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 Python intégrés suivants :
• Filtre : filtre (paramètre lambda : expression, séquence itérable)
• Map : map (paramètre lambda : expression, séquences itérables)
• Réduire : réduire (paramètre lambda 1, paramètre 2 : 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 du code.

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

Ce code est modifiable. Cliquez sur Exécuter pour exécuter