Qu'est-ce que la fonction Lambda en Python?
Une fonction Lambda en programmation Python 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 mot clé lambda (tout comme vous utilisez def pour définir des 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 contenir qu'une seule expression. De plus, un lambda est écrit dans une seule ligne de code et peut également être appelé 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 des composants intégrés Python
- lambdas dans le filtre ()
- lambdas dans la carte ()
- lambdas dans réduire ()
- Pourquoi (et pourquoi pas) utiliser les fonctions lambda?
- Lambdas vs 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 ou peu 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 opère sur les paramètres que vous fournissez à la fonction.
Exemple 1
Maintenant que vous connaissez les lambdas, essayons-le avec un exemple. Alors, ouvrez votre IDLE et tapez ce qui suit:
adder = lambda x, y: x + yprint (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 passons à la fonction lambda.
3. Ceci 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 de voir le résultat. Encore une fois, ouvrez votre IDLE et tapez ce qui suit:
#What a lambda returnsstring='some kind of a useless lambda'print(lambda string : print(string))
Maintenant, enregistrez votre fichier et appuyez sur F5 pour exécuter le programme. C'est la sortie que vous devriez obtenir.
Production:
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 print et imprime le résultat.
Mais pourquoi le programme n'imprime-t-il pas la chaîne que nous transmettons? C'est parce que le lambda lui-même renvoie un objet fonction. Dans cet exemple, le lambda n'est pas appelé par la fonction d'impression mais renvoie simplement 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 #2x="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.
Production:
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 crochets? 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 FUNCTIONdef guru( funct, *args ):funct( *args )def printer_one( arg ):return print (arg)def printer_two( arg ):print(arg)#CALL A REGULAR FUNCTIONguru( printer_one, 'printer 1 REGULAR CALL' )guru( printer_two, 'printer 2 REGULAR CALL \n' )#CALL A REGULAR FUNCTION THRU A LAMBDAguru(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, la sortie devrait être quelque chose comme ça.
Production:
imprimante 1 APPEL RÉGULIER
imprimante 2 APPEL RÉGULIER
imprimante 1 LAMBDA CALL
imprimante 2 LAMBDA CALL
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 passons les fonctions d'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 guru) mais en utilisant des lambdas.
Dans la section suivante, vous apprendrez à utiliser les fonctions lambda avec map (), Reduce () et filter () en Python.
Utilisation de lambdas avec des composants intégrés Python
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ées immédiatement et passées en argument à ces fonctions.
IIFE en Python Lambda
IIFE signifie exécution de 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; lancez votre IDLE et saisissez ce qui suit:
(lambda x: x + x)(2)
Voici l'explication de la sortie et du code:
Cette capacité d'invocation immédiate des lambdas vous permet de les utiliser dans des fonctions telles que map () et reduction (). C'est utile car vous ne voudrez peut-être plus utiliser ces fonctions à nouveau.
lambdas dans le filtre ()
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 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 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 true si elle est supérieure à 4.
4. Imprimez 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:
- 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 de 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))
Production:
[100, 4, 64, 49, 25, 16, 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.
- Imprimez le résultat renvoyé par la fonction de carte.
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, il diffère de la carte dans son fonctionnement. Voici les étapes suivies par la fonction reduction () 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 de 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 reducesequences = [1,2,3,4,5]product = reduce (lambda x, y: x*y, sequences)print(product)
Voici la sortie:
120
Explication du code:
- Importer réduire 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 product 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.
- Imprimez 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 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 des lambdas et quand les éviter est une bonne idée. 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 connu sous le nom de 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 passer en paramètre.
Quand ne devriez-vous 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échiffrer. Si vous vous retrouvez à créer des expressions complexes à une seule ligne, il serait bien plus pratique de définir une fonction appropriée. En tant que meilleure 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 sont [vV4] [J5] juste des fonctions qui n'ont pas d'identifiant lié à elles. 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 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 évalue 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 régulière pour l'exemple ci-dessus ressemblerait à ceci:
def adder (x, y):return x + yprint (adder (1, 2))
Ici, nous devons définir un nom pour la fonction qui renvoie le résultat lorsque nous l' appelons . Une fonction lambda ne contient pas d'instruction return car elle n'aura qu'une seule expression qui est toujours retournée par défaut. Vous n'avez même pas besoin d'attribuer un lambda car il peut être immédiatement appelé (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 en quoi les lambdas sont différentes 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 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 elle est réservée 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 d'un nom (c'est-à-dire d'un 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 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 composants intégrés Python suivants:
- Filtre: filtre (paramètre lambda: expression, séquence itérative)
- Map: map (paramètre lambda: expression, iterable-séquences)
- Réduire: réduire (paramètre lambda1, paramètre2: expression, séquence itérative)
- 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.