Fonctions Lambda en Python

Introduction

Dans ce laboratoire, vous apprendrez à utiliser les fonctions lambda en Python. Nous commencerons par comprendre le concept des fonctions anonymes et le mot-clé lambda, en les comparant aux définitions de fonctions traditionnelles. Vous créerez ensuite des fonctions lambda simples avec différents nombres de paramètres.

Le laboratoire explorera plus en détail comment utiliser efficacement les fonctions lambda avec des fonctions intégrées de Python telles que sorted. Enfin, nous discuterons des meilleures pratiques pour l'utilisation des fonctions lambda afin de garantir que votre code soit lisible et maintenable.

Comprendre les Fonctions Anonymes et Lambda

Dans cette étape, nous allons introduire le concept des fonctions anonymes en Python, en nous concentrant sur le mot-clé lambda. Les fonctions anonymes sont des fonctions sans nom, offrant une manière concise de définir des fonctions simples à expression unique.

En Python, nous définissons généralement des fonctions en utilisant le mot-clé def. Par exemple, une fonction qui double un nombre ressemble à ceci :

def double(x):
    return x * 2

print(double(10))

Pour de petites fonctions comme celle-ci, lambda fournit une syntaxe plus compacte. Créons la même fonction en utilisant lambda.

Dans l'explorateur de fichiers du WebIDE à gauche, trouvez et ouvrez le fichier ~/project/lambda_example1.py. Ajoutez-y le code suivant :

## Define a lambda function to double a number
double_lambda = lambda x: x * 2

## Call the lambda function and print the result
print(double_lambda(10))

La syntaxe est lambda arguments: expression. Les arguments sont les entrées, et l'expression est une opération unique qui est évaluée et retournée. Notez qu'il n'y a pas de mot-clé return ; le retour est implicite.

Enregistrez le fichier. Pour exécuter le script, ouvrez le terminal dans le WebIDE et exécutez la commande suivante :

python3 ~/project/lambda_example1.py

Vous devriez voir la sortie dans le terminal.

20

Ceci démontre comment une fonction lambda peut être assignée à une variable et appelée comme une fonction normale.

Créer des Fonctions Lambda avec des Paramètres Variés

Les fonctions lambda sont flexibles et peuvent être définies avec zéro, un ou plusieurs paramètres. Cependant, elles sont toujours limitées à une seule expression. Dans cette étape, nous allons explorer la création de lambdas avec différents nombres de paramètres.

Tout d'abord, créons une fonction lambda qui ne prend aucun argument. Ceci peut être utile pour définir une constante ou une action simple et répétable.

Ouvrez le fichier ~/project/lambda_example2.py depuis l'explorateur de fichiers. Ajoutez le code suivant :

## Define a lambda function with no arguments
get_greeting = lambda: "Hello, World!"

## Call the lambda function and print the result
print(get_greeting())

Ensuite, créons une fonction lambda qui accepte plusieurs arguments. Nous allons définir une lambda qui additionne deux nombres. Ajoutez ce code dans le même fichier lambda_example2.py :

## Define a lambda function that adds two numbers
add_numbers = lambda x, y: x + y

## Call the lambda function with two arguments and print the result
print(add_numbers(5, 3))

Enregistrez le fichier. Maintenant, exécutez le script depuis le terminal pour voir les deux sorties :

python3 ~/project/lambda_example2.py

Le terminal affichera les résultats des deux fonctions lambda.

Hello, World!
8

Ceci montre que les fonctions lambda peuvent gérer différentes configurations de paramètres, ce qui les rend polyvalentes pour diverses tâches simples.

Utiliser Lambda avec la Fonction sorted()

L'un des cas d'utilisation les plus courants pour les fonctions lambda est de servir de fonction rapide et en ligne pour les fonctions d'ordre supérieur (fonctions qui prennent d'autres fonctions comme arguments). Un excellent exemple est la fonction intégrée sorted() de Python, qui peut accepter un argument key. La key spécifie une fonction à appeler sur chaque élément avant d'effectuer les comparaisons de tri.

Imaginez que vous avez une liste de tuples, où chaque tuple représente un produit et son prix. Vous souhaitez trier cette liste en fonction du prix.

Ouvrez le fichier ~/project/lambda_sorted.py dans l'éditeur. Ajoutez le code suivant :

## A list of tuples (product, price)
products = [('Laptop', 1200), ('Mouse', 25), ('Keyboard', 75)]

## Sort the list by price (the second element of each tuple) using a lambda function
sorted_products = sorted(products, key=lambda item: item[1])

## Print the sorted list
print(sorted_products)

Dans ce code, key=lambda item: item[1] indique à sorted() d'utiliser le deuxième élément (item[1], qui est le prix) de chaque tuple comme valeur pour le tri. Ceci est beaucoup plus concis que de définir une fonction séparée avec def.

Enregistrez le fichier et exécutez-le depuis le terminal :

python3 ~/project/lambda_sorted.py

Vous verrez la liste des produits triée par prix par ordre croissant.

[('Mouse', 25), ('Keyboard', 75), ('Laptop', 1200)]

Ce modèle est extrêmement courant et utile pour trier des structures de données complexes d'une manière simple et lisible.

Techniques Lambda Avancées

Dans cette étape, nous allons explorer des manières légèrement plus avancées d'utiliser les fonctions lambda, notamment en définissant des valeurs de paramètres par défaut et en invoquant immédiatement une fonction lambda.

Comme les fonctions régulières, les fonctions lambda peuvent avoir des paramètres avec des valeurs par défaut. Cela fournit une valeur de secours si aucun argument n'est fourni lors de l'appel de la fonction.

Ouvrez le fichier ~/project/lambda_advanced.py dans l'éditeur. Ajoutez le code suivant :

## Define a lambda function with a default parameter value
power = lambda base, exponent=2: base ** exponent

## Call the lambda function without the optional argument (uses default)
print(power(3))

## Call the lambda function with both arguments
print(power(3, 3))

Une autre technique intéressante consiste à définir et à appeler immédiatement une fonction lambda. Ceci est connu sous le nom d'Expression de Fonction Immédiatement Invoquée (IIFE - Immediately Invoked Function Expression). Cela peut être utile pour créer une fonction temporaire à usage unique afin de calculer une valeur sans encombrer l'espace de noms (namespace).

Ajoutez le code suivant au fichier lambda_advanced.py :

## Define and immediately invoke a lambda function to calculate a discounted price
price = 100
discount_percentage = 20
final_price = (lambda p, d: p * (1 - d / 100))(price, discount_percentage)

print(final_price)

Enregistrez le fichier et exécutez-le depuis le terminal :

python3 ~/project/lambda_advanced.py

La sortie affichera les résultats des deux exemples.

9
27
80.0

Bien que ces techniques démontrent la flexibilité des lambdas, rappelez-vous que la lisibilité est essentielle. Si la logique devient complexe, une fonction standard def est souvent un meilleur choix.

Bonnes Pratiques et Lisibilité

Dans cette dernière étape, nous allons discuter des bonnes pratiques pour l'utilisation des fonctions lambda. Bien que les lambdas soient un outil puissant pour écrire du code concis, elles doivent être utilisées judicieusement pour maintenir la lisibilité et la maintenabilité.

Quand utiliser lambda :

• Comme arguments pour les fonctions d'ordre supérieur : C'est le cas d'utilisation principal. Des fonctions comme sorted(), map(), et filter() sont des candidats parfaits pour les lambdas.
• Opérations simples et courtes : Si la logique tient confortablement et clairement sur une seule ligne, une lambda est un bon choix.

Quand éviter lambda :

• Logique complexe : Si vous avez besoin de plusieurs instructions, d'une logique conditionnelle complexe ou de boucles, utilisez toujours une fonction def.
• Problèmes de lisibilité : Si une expression lambda est difficile à comprendre immédiatement, elle va à l'encontre de son objectif. Une fonction nommée avec un nom descriptif est préférable.
• Réutilisabilité : Si vous avez besoin de la même logique à plusieurs endroits, définissez-la une seule fois avec def pour suivre le principe DRY (Don't Repeat Yourself - Ne vous répétez pas).

Examinons un bon exemple, lisible, qui renforce le cas d'utilisation conforme aux bonnes pratiques. Ouvrez le fichier ~/project/lambda_best_practice.py et ajoutez le code suivant :

## A list of dictionaries
students = [
    {'name': 'Alice', 'grade': 88},
    {'name': 'Bob', 'grade': 95},
    {'name': 'Charlie', 'grade': 72}
]

## A good use of lambda: sorting a list of dictionaries by a value
sorted_by_grade = sorted(students, key=lambda student: student['grade'])

print("Sorted by grade:", sorted_by_grade)

## For comparison, a more complex task is better with a named function.
## For example, if you needed to apply a curve and check for a minimum score,
## a 'def' function would be much clearer than a complex lambda.
def process_grade(student):
    curved_grade = student['grade'] * 1.05
    return max(curved_grade, 75) ## Ensure a minimum score

processed_grades = [process_grade(s) for s in students]
print("Processed grades:", processed_grades)

Enregistrez le fichier et exécutez-le :

python3 ~/project/lambda_best_practice.py

Vous verrez la sortie :

Sorted by grade: [{'name': 'Charlie', 'grade': 72}, {'name': 'Alice', 'grade': 88}, {'name': 'Bob', 'grade': 95}]
Processed grades: [92.4, 99.75, 75.60000000000001]

La première partie montre une utilisation claire et appropriée de lambda. La seconde partie illustre un scénario où une fonction nommée est plus appropriée. Privilégiez toujours l'écriture d'un code facile à lire et à comprendre pour vous et pour les autres.

Résumé

Dans ce laboratoire, vous avez appris les fondamentaux des fonctions lambda de Python. Vous avez commencé par comprendre leur syntaxe et comment elles diffèrent des fonctions standard définies avec def. Vous vous êtes exercé à créer des lambdas avec zéro, un et plusieurs paramètres, et avez vu comment elles peuvent être assignées à des variables et appelées.

Un point clé à retenir a été l'application pratique des fonctions lambda comme arguments pour les fonctions d'ordre supérieur, notamment avec sorted() pour définir de manière concise une logique de tri personnalisée. Nous avons également exploré des techniques avancées telles que les paramètres par défaut et les expressions de fonction immédiatement invoquées (IIFE). Enfin, vous avez examiné les meilleures pratiques pour l'utilisation des lambdas, en soulignant que bien qu'elles soient puissantes pour des cas simples et à usage unique, la lisibilité et la maintenabilité doivent toujours être la priorité, favorisant les fonctions nommées pour une logique plus complexe.