Un guide des fonctions Python Lambda, avec des exemples

Cet article présente les fonctions Python lambda et comment les écrire et les utiliser.

Bien que Python soit un langage de programmation orienté objet, les fonctions lambda sont pratiques lorsque vous effectuez différents types de programmation fonctionnelle.

Remarque : cet article suppose que vous comprenez déjà la programmation Python et comment utiliser une fonction standard. Il est également supposé que Python 3.8 ou supérieur est installé sur votre appareil.

Expliquer les fonctions Python Lambda

En Python, les fonctions peuvent prendre un ou plusieurs arguments de position ou de mots-clés, une liste variable d’arguments, une liste variable d’arguments de mots-clés, etc. Ils peuvent être transmis à une fonction d’ordre supérieur et renvoyés en sortie. Les fonctions régulières peuvent avoir plusieurs expressions et plusieurs instructions. Ils ont aussi toujours un nom.

Un python fonction lambda est simplement une fonction anonyme. On pourrait aussi l’appeler un sans nom fonction. Les fonctions Python normales sont définies par le def mot-clé. Les fonctions Lambda en Python sont généralement composées des lambda mot-clé, n’importe quel nombre d’arguments et une expression.

Attention : les termes fonctions lambda, expressions lambdaet formes lambda peuvent être utilisés de manière interchangeable, selon le langage de programmation ou le programmeur.

Les fonctions lambda sont principalement utilisées comme une seule ligne. Ils sont très souvent utilisés dans des fonctions d’ordre supérieur telles que map() et filter(). En effet, les fonctions anonymes sont transmises en tant qu’arguments aux fonctions d’ordre supérieur, ce qui n’est pas le cas uniquement dans la programmation Python.

Une fonction lambda est également très utile pour gérer la compréhension de liste en Python – avec diverses options pour utiliser les expressions Python lambda à cette fin.

Les lambdas sont parfaits lorsqu’ils sont utilisés pour le rendu conditionnel dans des frameworks d’interface utilisateur tels que Tkinter, wxPython, Kivy, etc. Bien que le fonctionnement des frameworks d’interface graphique Python ne soit pas couvert dans cet article, certains extraits de code révèlent une utilisation intensive des fonctions lambda pour rendre l’interface utilisateur basée sur l’interaction d’un utilisateur.

Choses à comprendre avant de se plonger dans les fonctions Python Lambda

Parce que Python est un langage de programmation orienté objet, tout est un objet. Les classes Python, les instances de classe, les modules et les fonctions sont tous traités comme des objets.

Un objet fonction peut être affecté à une variable.

Il n’est pas rare d’affecter des variables à des fonctions régulières en Python. Ce comportement peut également être appliqué aux fonctions lambda. C’est parce qu’il s’agit d’objets fonctionnels, même s’ils n’ont pas de nom :

def greet(name):
    return f'Hello {name}'

greetings = greet
greetings('Clint')
>>>>
Hello Clint

Fonctions d’ordre supérieur telles que map(), filter() et reduce()

Il est probable que vous deviez utiliser une fonction lambda dans des fonctions intégrées telles que filter() et map()et aussi avec reduce() — qui est importé du module functions en Python, car ce n’est pas une fonction intégrée. Par défaut, fonctions d’ordre supérieur sont des fonctions qui reçoivent d’autres fonctions comme arguments.

Comme on le voit dans les exemples de code ci-dessous, les fonctions normales peuvent être remplacées par des lambdas, passés en arguments dans l’une de ces fonctions d’ordre supérieur :


names = ['Clint', 'Lisa', 'Asake', 'Ada']

greet_all = list(map(greet, names))
print(greet_all)
>>>>
['Hello Clint', 'Hello Lisa', 'Hello Asake', 'Hello Ada']

numbers = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
def multiples_of_three(x):
        return x % 3 == 0

print(list(filter(multiples_of_three, numbers)))
>>>>
[12, 15, 18]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def add_numbers(x, y):
        return x * y

print(reduce(add_numbers, numbers))
>>>>
55

La différence entre un énoncé et une expression

Un point commun de confusion parmi les développeurs est de faire la différence entre une instruction et une expression en programmation.

UN déclaration est n’importe quel morceau de code qui fait quelque chose ou exécute une action – comme if ou while les conditions.

Un expression est composé d’une combinaison de variables, de valeurs et d’opérateurs et évalue à une nouvelle valeur.

Cette distinction est importante alors que nous explorons le sujet des fonctions lambda en Python. Une expression comme celle ci-dessous renvoie une valeur :

square_of_three = 3 ** 2
print(square_of_three)
>>>>
9

Une déclaration ressemble à ceci :

for i in range(len(numbers), 0, -1):
        if i % 2 == 1:
                print(i)
        else:
                print('even')
>>>>
even 9 even 7 even 5 even 3 even 1

Comment utiliser les fonctions Python Lambda

Le guide de style Python stipule que chaque fonction lambda doit commencer par le mot-clé lambda (contrairement aux fonctions normales, qui commencent par le def mot-clé). La syntaxe d’une fonction lambda ressemble généralement à ceci :

lambda arguments : expression

Les fonctions lambda peuvent prendre n’importe quel nombre d’arguments de position, d’arguments de mots clés, ou les deux, suivis de deux-points et d’une seule expression. Il ne peut y avoir plus d’une expression, car elle est syntaxiquement restreinte. Examinons un exemple d’expression lambda ci-dessous :

add_number = lambda x, y : x + y
print(add_number(10, 4))
>>>>
14

Dans l’exemple ci-dessus, l’expression lambda est affectée à la variable add_number. Un appel de fonction est effectué en passant des arguments, ce qui donne 14.

Prenons un autre exemple ci-dessous :

discounted_price = lambda price, discount = 0.1, vat = 0.02 : price * (1 - discount) * (1 + vat)

print(discounted_price(1000, vat=0.04, discount=0.3))
>>>>
728.0

Comme vu ci-dessus, la fonction lambda est évaluée à 728,0. Une combinaison d’arguments positionnels et de mots-clés est utilisée dans la fonction Python lambda. Lors de l’utilisation d’arguments de position, nous ne pouvons pas modifier l’ordre indiqué dans la définition de la fonction. Cependant, nous pouvons placer des arguments de mots-clés à n’importe quelle position uniquement après les arguments de position.

Les fonctions Lambda sont toujours exécutées comme des expressions de fonction immédiatement appelées (IIFE) en JavaScript. Ceci est principalement utilisé avec un interpréteur Python, comme illustré dans l’exemple suivant :

print((lambda x, y: x - y)(45, 18))
>>>>
27

L’objet de la fonction lambda est entouré de parenthèses, et une autre paire de parenthèses suit de près avec les arguments passés. En tant qu’IIFE, l’expression est évaluée et la fonction renvoie une valeur affectée à la variable.

Les fonctions Python lambda peuvent également être exécutées dans une compréhension de liste. Une compréhension de liste a toujours une expression de sortie, qui est remplacée par une fonction lambda. Voici quelques exemples:

my_list = [(lambda x: x * 2)(x) for x in range(10) if x % 2 == 0]
print(my_list)
>>>>
[0, 4, 8, 12, 16]
value = [(lambda x: x % 2 and 'odd' or 'even')(x) for x in my_list] 
print(value)
>>>>
['even', 'even', 'even', 'even', 'even']

Les fonctions Lambda peuvent être utilisées lors de l’écriture d’expressions ternaires en Python. UN expression ternaire produit un résultat basé sur une condition donnée. Découvrez les exemples ci-dessous :

test_condition1 = lambda x: x / 5 if x > 10 else x + 5
print(test_condition1(9))
>>>>
14
test_condition2 = lambda x: f'{x} is even' if x % 2 == 0 else (lambda x: f'{x} is odd')(x)

print(test_condition2(9))
>>>>
9 is odd

Fonctions Lambda dans les fonctions d’ordre supérieur

Le concept de fonctions d’ordre supérieur est populaire en Python, tout comme dans d’autres langages. Ce sont des fonctions qui acceptent d’autres fonctions en tant qu’arguments et renvoient également des fonctions en sortie.

En Python, une fonction d’ordre supérieur prend deux arguments : une fonction et un itérable. L’argument de la fonction est appliqué à chaque élément de l’objet itérable. Puisque nous pouvons passer une fonction en argument à une fonction d’ordre supérieur, nous pouvons également passer une fonction lambda.

Voici quelques exemples d’une fonction lambda utilisée avec le map() fonction:

square_of_numbers = list(map(lambda x: x ** 2, range(10)))

print(square_of_numbers)
>>>>
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
strings = ['Nigeria', 'Ghana', 'Niger', 'Kenya', 'Ethiopia', 'South Africa', 'Tanzania', 'Egypt', 'Morocco', 'Uganda']

length_of_strings = list(map(lambda x: len(x), strings))

print(length_of_strings)
>>>>
[7, 5, 5, 5, 8, 12, 8, 5, 7, 6]

Voici quelques fonctions lambda utilisées avec le filter() fonction:

length_of_strings_above_five = list(filter(lambda x: len(x) > 5, strings))

print(length_of_strings_above_five)
>>>>
['Nigeria', 'Ethiopia', 'South Africa', 'Tanzania', 'Morocco', 'Uganda']
fruits_numbers_alphanumerics = ['apple', '123', 'python3', '4567', 'mango', 'orange', 'web3', 'banana', '890']

fruits = list(filter(lambda x: x.isalpha(), fruits_numbers_alphanumerics))

numbers = list(filter(lambda x: x.isnumeric(), fruits_numbers_alphanumerics))

print(fruits)
print(numbers)
>>>>
['apple', 'mango', 'orange', 'banana']
['123', '4567', '890']

Voici quelques fonctions lambda utilisées avec le reduce() fonction:

values = [13, 6, 12, 23, 15, 31, 16, 21]
max_value = reduce(lambda x,y: x if (x > y) else y, values)
print(max_value)
>>>>
31
nums = [1, 2, 3, 4, 5, 6]
multiplication_of_nums = reduce(lambda x,y: x*y, nums)

print(multiplication_of_nums)
>>>>
720

Conclusion

Bien que les lambdas Python puissent réduire considérablement le nombre de lignes de code que vous écrivez, ils doivent être utilisés avec parcimonie et uniquement lorsque cela est nécessaire. La lisibilité de votre code doit être privilégiée par rapport à la concision. Pour un code plus lisible, utilisez toujours une fonction normale lorsqu’elle convient aux fonctions lambda, comme recommandé par le Python Style Guide.

Les lambdas peuvent être très pratiques avec les expressions ternaires Python, mais encore une fois, essayez de ne pas sacrifier la lisibilité. Les fonctions Lambda prennent tout leur sens lorsque des fonctions d’ordre supérieur sont utilisées.

En résumé:

  • Les lambdas Python sont bons pour écrire des fonctions à une ligne.
  • Ils sont également utilisés pour les IIFE (expression de fonction immédiatement invoquée).
  • Les lambdas ne doivent pas être utilisés lorsqu’il existe plusieurs expressions, car cela rend le code illisible.
  • Python est un langage de programmation orienté objet, mais les lambdas sont un bon moyen d’explorer la programmation fonctionnelle en Python.

Contenu connexe :

Leave a Comment

Your email address will not be published. Required fields are marked *