DESCRIPTION.

Crée une fonction anonyme. 

SYNTAXE.

lambda  variable1 = valeur , ... , variablen = valeur : expression 

lambda ⇨ appel de l’instruction [ OBLIGATOIRE ]

variable = valeur ⇨ variables utilisées dans expression  [ optionnel ]

: ⇨ séparateur script à exécuter [ OBLIGATOIRE ]

expression  ⇨ script à exécuter [ OBLIGATOIRE ]

REMARQUES.

L'instruction lambda créer une expression qui pointe sur un objet fonction, comme ceux créer par l'instruction def.

On pourra donc appeler une fonction, dans une expression définie avec lambda, pour passer des paramètres à cette fonction.

Le terme anonyme signifie bien que l'expression n'as pas de nom propre.

Les fonctions définies avec l'instruction lambda sont aussi appelées indifféremment : fonctions, expressions, formes, abstractions et/ou littérales suivies de lambda.

Une fonction lambda est tout à fait équivalent à une fonction standard qui n'aurait qu'une seule est unique ligne de code.

LMD_Ajouter = lambda Q : Q + 1

Suivant = LMD_Ajouter ( 5 )

équivaut à :

def FNC_Ajouter ( Q ) :

    return Q + 1

Suivant = FNC_Ajouter ( 5 )

On utilisera donc les fonctions lambda, principalement, pour plus de lisibilité et maintenance du code.

EXEMPLES.

lambda permet de créer des fonctions sur une seule ligne de code.

Pour effectuer un traitement qui comporte une ou des inconnues avec appel immédiat de la fonction. Notez l'emplacement des parenthèses entourant d'une part, la fonction anonyme elle-même, et d'autre part, les arguments attendus par la fonction.

( lambda x : x ** 7 ) ( 3 )

retourne 2187

c'est à dire 3 à la puissance 7

( lambda x : ( 28 * ( x ** 3 ) ) - ( 6 * ( x ** 2 ) ) - ( 43 *  x )  + 1536 ) ( 12 )

retourne 48540

c'est à dire (28 x 12³) - (6 x 12²) - (43 x 12)  + 1536

Mais aussi parfois plus complexe, par exemple les 4 thermes d'un polynôme du second degré ( ax² + bx + c),

( lambda a , b , c , x : ( a * ( x ** 2 ) ) + ( b * x ) + c ) ( 4 , -2 , 17 , 6 )

retourne 149

c'est à dire (4 x 6²) +(-26 x 6) + 17

Si cette syntaxe, et usage, sera apprécié dans l'interpréteur, son intérêt sera des plus rares dans un script traditionnel.

Avec un argument unique.

LMD_Carre = lambda  Q : Q * Q

LMD_Carre ( 7 )

kchoix = input ( "Quel carré ?" ) 

print ( f"le carré de { kchoix } est { LMD_Carre ( int ( kchoix ) ) } )

retourne 

49

Quel carré ?   4

le carré de 4 est 16

Avec un nombre connu d'arguments.

Dans ce cas il doit y avoir le même nombre d'arguments que de paramètres dans la définition de la fonction. Les valeurs des arguments doivent être passées dans le même ordre que ceux de la définition.

LMD_Quotient = lambda Qdividende , Qdiviseur  : Qdividende / Qdiviseur 

print ( LMD_Quotient ( 102 , 31 ) )

kdividende = input ( "Entrez votre dividende ..." )

kdiviseur = input ( "Entrez votre diviseur, différent de 0 ..." )

print ( f"{ kdividende } / { kdiviseur } = { LMD_Quotient ( int ( kdividende ) , int ( kdiviseur ) ) }" )

retourne

3.2903225806451615

Entrez votre dividende ... 100

Entrez votre diviseur, différent de 0 ... 7

100 / 7 = 14.285714285714286

Ou passées indifféremment si l'on nomme les arguments avec leur valeur.

LMD_Quotient = lambda Qdividende , Qdiviseur  : Qdividende / Qdiviseur 

print ( LMD_Quotient ( Qdiviseur = 27 , Qdividende = 1296 ) )

kdividende = input ( "Entrez un premier nombre (différent de 0) ..." )

kdiviseur = input ( "Entrez un second nombre  (différent de 0) ..." )

print ( f"{ kdividende } / { kdiviseur } = { LMD_Quotient ( int ( kdividende ) , int ( kdiviseur ) ) }" )

print ( f"{ kdiviseur } / { kdividende } = { LMD_Quotient ( Qdiviseur = int ( kdividende ) , Qdividende = int ( kdiviseur ) ) }" )

retourne

48.0

Entrez votre dividende ... 127

Entrez votre diviseur, différent de 0 ... 31

127 / 31 = 4.096774193548387

31 / 127 = 0.2440944881889764

D'une façon générale, paramètres et arguments suivent les mêmes règles que celles développées pour les définitions de fonctions ordinaires avec l'instruction def.

- ordonnées :

( lambda Qa , Qb , Qc : Qa + Qb + Qc ) ( ka , kb , kc ) ou

( lambda Qa , Qb , Qc : Qa + Qb + Qc ) ( Qb = kb , Qc = kc , Qa = ka )

- nommées :

( lambda Qa = 10 , Qb = 127 : Qa * Qb ) ( Qa = 47 , Qb = 14 ) ou

( lambda Qa = 10 , Qb = 127 : Qa * Qb ) ( Qb = 84 )

- étoilées :

( lambda *Qtpl : sum ( Qtpl ) ) ( 12 , 45 , 7 , 15 , 7 , 65 , 7 , 138 )

- doubles étoilées :

( lambda **Qdct : list ( Qdct ) ) (  Population = 21679 , Ville  = "peighuig"  , Precipitations = ( 1.82 , 1.56 , 0.23 ) ) 

Voir l'instruction def et les définitions de fonctions personnalisées pour plus de détails ...

Avec un nombre connu d'arguments qui sont passés comme arguments à une fonction native.

LMD_Polynome = lambda Qa , Qb , Qc , Qx : print ( f"ax² + bx + c = { ( Qa * ( Qx * Qx ) ) + ( Qb * Qx ) + Qc }" )

LMD_Polynome ( 17 , 4 , 29 , 3 )

retourne ax² + bx + c = 194

LMD_Polynome  ( 8 , 3 , 128 , 5 )

retourne ax² + bx + c = 343

Avec un nombre connu d'arguments qui sont passés comme arguments à une fonction standard.

def FNC_Polynome ( Qa , Qb , Qc , Qx ) :

print ( f"ax² + bx + c = { ( Qa * ( Qx * Qx ) ) + ( Qb * Qx ) + Qc }" )

LMD_Polynome = lambda Qa , Qb , Qc , Qx : FNC_Polynome ( Qa , Qb , Qc , Qx )

LMD_Polynome ( 17 , 4 , 29 , 3 )

retourne ax² + bx + c = 194

LMD_Polynome ( 8 , 3 , 128 , 5 )

retourne ax² + bx + c = 343

Avec un nombre inconnu d'arguments qui sont passés comme arguments à une fonction native.

LMD_Somme = lambda *Qa : sum ( Qa )

LMD_Somme ( 1 , 2 , 3 , 4 )

retourne 10

LMD_Somme ( 2 , 3 ,  5 , 7 , 11 ,  13 , 17 )

retourne 58

Une fonction lambda pourra être utile pour créer une list ( ) à passer comme argument à une fonction, sans avoir définie cette fonction lambda préalablement.

kdebut = int ( input ( "Début de la suite à sommer ? " ) )

kfin = int (input ( "fin de la suite à sommer ? " ) )

kpas = int (input ( "écart entre les nombres à sommer ? " ) )

print ( sum ( ( lambda Qdebut , Qfin , Qpas : [ kvaleur for kvaleur in range ( Qdebut , Qfin , Qpas ) ] ) ( kdebut , kfin , kpas ) ) )

retourne

Début de la suite à sommer ? 10

fin de la suite à sommer ? 20

écart entre les nombres à sommer ? 3

58

Affectation d'une variable (entre 2 possibilités) selon une saisie de l'utilisateur (expression conditionnelle).

LMD_Choix = lambda Qchoix : print ( "Au revoir et à bientôt ..." ) if Qchoix.lower ( ) == "n" else print ( "Alors commençons une nouvelle partie ..." )

LMD_Choix ( input ( "Souhaitez vous recommencer ( n pour non ) ? " ) )

o retourne Alors commençons une nouvelle partie ...

LMD_Choix ( input ( "Souhaitez vous recommencer ( n pour non ) ? " ) )

n retourne Au revoir et à bientôt ...

Auto-appel de la fonction selon un test conditionnel (récursivité et expression conditionnelle).

LMD_Fibonacci = lambda Qnombre : Qnombre if Qnombre < 2 else LMD_Fibonacci ( Qnombre - 1 ) + LMD_Fibonacci ( Qnombre - 2 )

for i in range ( 20 , 26 ) :

print ( "La valeur du rang" , i  ,"de la suite de Fabonacci est :" , LMD_Fibonacci ( i ) )

retourne

La valeur du rang 20 de la suite de Fabonacci est : 6765

La valeur du rang 21 de la suite de Fabonacci est : 10946

La valeur du rang 22 de la suite de Fabonacci est : 17711

La valeur du rang 23 de la suite de Fabonacci est : 28657

La valeur du rang 24 de la suite de Fabonacci est : 46368

La valeur du rang 25 de la suite de Fabonacci est : 75025

Créer ou modifier un objet-ensemble grâce à la compréhension de liste. 

Notez que la seconde fonction (LMD_TTC) n'attends pas d'argument à son appel.

LMD_TVA = lambda Qtaux : [ kprix * ( Qtaux / 100 ) for kprix in LST_HT ]

LMD_TTC = lambda : [ int  ( LST_HT [ karticle ] + LST_TVA [ karticle] ) + 1 for karticle in range ( len ( LST_HT ) )  ]

LST_HT = [ .5 , 1.25 , 2.69 , 5.17 , 12.31 , 169.81 ]

ktaux = int ( input ( "Donnez le taux de la TVA (ex. :entrez 33 pour un taux de 33 %) ... " ) )

LST_TVA = LMD_TVA ( ktaux ) [ : ]

LST_TTC = LMD_TTC ( )

print ( "Liste des prix HT : " , LST_HT )

print ( "Montant de la TVA : " , LST_TVA )

print ( "Prix TTC arrondis : " , LST_TTC )

retourne :

Donnez le taux de la TVA (ex. :entrez 20 pour un taux de 20 %) ... 20

Liste des prix HT :  [0.5, 1.25, 2.69, 5.17, 12.31, 169.81]

Montant de la TVA :  [0.1, 0.25, 0.538, 1.034, 2.462, 33.962]

Prix TTC arrondis :  [1, 2, 4, 7, 15, 204]

PARTICULARITÉ AVEC LE MODULE TKINTER.

Lambda permet d’appeler une fonction en lui passant des arguments, dans un gestionnaire d'événements (méthode .bind  ( )) du module tkinter, ou comme valeur de l'attribut command des divers widgets qui accepte cette attribut.

Par exemple 1 :

TKI_Principal.bind  ( "<KeyPress-KP_0>" , lambda event : FNC_Ajouter ( 0 ) )

TKI_Principal.bind  ( "<KeyPress-KP_1>" , lambda event : FNC_Ajouter ( 1 ) )

TKI_Principal.bind  ( "<KeyPress-KP_2>" , lambda event : FNC_Ajouter ( 2 ) )

où la fonction FNC_Ajouter peut utiliser directement la valeur passée comme argument, sans avoir à analyser ce paramètre pour connaitre la touche utilisée pour l'invoquer.

à la place de :

TKI_Principal.bind  ( "<KeyPress-KP_0>" , FNC_Ajouter )

TKI_Principal.bind  ( "<KeyPress-KP_1>" , FNC_Ajouter )

TKI_Principal.bind  ( "<KeyPress-KP_2>" , FNC_Ajouter )

où la fonction FNC_Ajouter devra analyser l'attribut event pour déterminer, par une partie de son script, quelque touche à été utilisée.

Par exemple 2 : 

BUT_Suivant = tkinter.Button ( TKI_Principal , text = "Suivant" , command = lambda : FNC_Direction ( "après" ) )

BUT_Precedant = tkinter.Button ( TKI_Principal , text = "Suivant" , command = lambda : FNC_Direction ( "avant" ) )

BUT_Premier = tkinter.Button ( TKI_Principal , text = "Suivant" , command = lambda : FNC_Direction ( "premier" ) )

BUT_Dernier = tkinter.Button ( TKI_Principal , text = "Suivant" , command = lambda : FNC_Direction ( "dernier" ) )

Permet de passer une valeur différente,, selon l'action de l'utilisateur comme argument lors de l'appel de la fonction  FNC_Direction ( ), à la place de l'objet event, qui serait normalement passé comme unique argument à la fonction. La fonction pourra ainsi partager une partie de son script quelque soit le choix de l'utilisateur.

à la place de :

BUT_Suivant = tkinter.Button ( TKI_Principal , text = "Suivant" , command = FNC_Avant )

BUT_Precedant = tkinter.Button ( TKI_Principal , text = "Suivant" , command = FNC_Precedant )

BUT_Premier = tkinter.Button ( TKI_Principal , text = "Suivant" , command = FNC_Premier )

BUT_Dernier = tkinter.Button ( TKI_Principal , text = "Suivant" , command = FNC_Dernier )

Qui nécessite la création de 4 fonctions indépendantes, qui devront soit avoir une copie d'une partie du script ou renvoyée une gestion en commun vers une cinquième fonction.