Fonctions Lambda en Python

Que sont les fonctions Lambda ?

En Python, les fonctions sont des objets : elles peuvent être affectées à des variables, peuvent être renvoyées par d'autres fonctions, stockées dans des listes ou des dictionnaires et transmises en tant que paramètres pour d'autres fonctions. Considérez, par exemple, la map() fonction intégrée. Sa syntaxe est map(function, iterable) et il est utilisé pour appliquer facilement function à chaque élément de iterable.

map() renvoie en fait un iterator chose. En pratique, nous présentons le résultat sous la forme d'un list, tuple, set, dict, etc., selon ce qui est le plus pratique.

Supposons que vous vouliez mettre au carré chaque terme d'une liste en utilisant la map() fonction. Pour ce faire, nous définirons un square() fonction et l'utiliser comme paramètre pour map():

my_list = [1,2,3,4,5]
def square(x):
    return x**2

my_modified_list = list(map(square, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

Cependant, si la seule utilisation de notre square() fonction est de créer cette liste, il est plus propre d'utiliser un lambda fonction:

my_list = [1,2,3,4,5]
my_modified_list = list(map(lambda x: x**2, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

En Python, lambda les fonctions sont des fonctions anonymes qui tirent leur nom et leur syntaxe de celui d'Alonzo Church. Calcul lambda. Leur syntaxe est :

lambda x_1,..., x_n : expression(x_1, ..., x_n)

Cela crée une fonction anonyme qui reçoit en entrée les variables x_1, ..., x_n et renvoie l'évalué expression(x_1, ..., x_n).

À notre humble avis, lambda functions doit être utilisé comme paramètre pour les fonctions qui acceptent des fonctions comme paramètre, comme nous l'avons fait avec map() au dessus. Python vous permet d'attribuer un lambda fonction à une variable, mais la Guide de style PEP 8 le déconseille. Si vous souhaitez affecter une fonction simple à une variable, il est préférable de le faire sous la forme d'une définition sur une ligne. Cela garantit que l'objet résultant est correctement nommé, ce qui améliore la lisibilité de la trace :

anonymous_square = lambda x : x**2
​
def named_square(x): return x**2
​
print(anonymous_square.__name__)
print(named_square.__name__)


a = anonymous_square
b = named_square
print(a.__name__)
print(b.__name__)

Pourquoi utiliser les fonctions Lambda ?

Après le dernier paragraphe, vous vous demandez peut-être pourquoi voudriez-vous utiliser un lambda une fonction. Après tout, tout ce qui peut être fait avec un lambda fonction pourrait être fait avec une fonction nommée.

La réponse à cela est que lambda les fonctions but est de vivre à l'intérieur d'expressions plus grandes représentant un calcul. Une façon de penser à cela est par analogie avec les variables et les valeurs. Considérez le code suivant :

x = 2

La variable x est un espace réservé (ou un nom) pour l'entier 2. Par exemple, appeler print(x) ainsi que le print(2) donne exactement le même résultat. Dans le cas des fonctions :

def square(x): return x**2

La fonction square() est un espace réservé pour le calcul de la quadrature d'un nombre. Ce calcul peut être écrit d'une manière sans nom comme lambda x: x**2.

Suite à cette digression philosophique, voyons quelques exemples d’applications pour lambda fonctions.

Utilisation de Lambda avec la fonction triée()

Les sorted() la fonction trie un itérable. Il accepte une fonction comme son key argument, et le résultat de la fonction appliquée à chaque élément de l'itérable est utilisé pour ordonner les éléments.

Ceci est parfaitement adapté à un lambda fonction : en réglant la key paramètre avec un lambda fonction, nous pouvons trier par n'importe quel type d'attribut des éléments. Par exemple, nous pouvons trier une liste de noms par nom de famille :

name_list = ['Grace Hopper', 'Ada Lovelace', 'Emmy Noether', 'Marie Curie']
​
sorted_by_surname = sorted(name_list, key = lambda x: x.split()[1])
​
print(sorted_by_surname)

['Marie Curie', 'Grace Hopper', 'Ada Lovelace', 'Emmy Noether']

Utilisation de Lambda avec la fonction 'filter()'

Les filter() fonction a la syntaxe suivante : filter(function, iterable) et il sort les éléments de iterable qui évaluent function(element) comme vrai (il est similaire à un WHERE clause en SQL). On peut utiliser lambda fonctionne comme paramètres pour filter() pour sélectionner des éléments d'un itérable.

Prenons l'exemple suivant:

num_list = list(range(0,100))
​
multiples_of_15= filter(lambda x: (x % 3 == 0) and (x % 5 == 0), num_list)
​
print(list(multiples_of_15))

[0, 15, 30, 45, 60, 75, 90]

filter() applique le lambda fonction lambda x: (x % 3 == 0) and (x % 5 == 0) à chaque élément de range(0,100), et renvoie un filter chose. Nous accédons aux éléments en les jetant comme list.

Utilisation de Lambda avec la fonction map()

Notre dernier exemple est quelque chose que nous avons vu dans l’introduction : le map() fonction. le map() la syntaxe de la fonction est : map(function, iterable)et la map() s'applique function à chaque élément de iterable, retour d'un map objet accessible par diffusion vers un list.

Nous avons vu comment cela peut être appliqué aux listes, mais cela pourrait être appliqué aux dictionnaires utilisant le dict.items() méthode:

my_data = {'Mary':1, 'Alice':2, 'Bob':0}
map_obj = map(lambda x: f'{x[0]} had {x[1]} little lamb', my_data.items())
print(', '.join((map_obj)))

Mary had 1 little lamb, Alice had 2 little lamb, Bob had 0 little lamb

ou à une chaîne :

my_string = 'abcdefg'
''.join(map(lambda x: chr(ord(x)+2),my_string))

'cdefghi'

Nous pouvons utiliser map() fonctionner de manière ingénieuse – un exemple consiste à appliquer de nombreuses fonctions à la même entrée.

Par exemple, supposons que vous créez une API qui reçoit une chaîne de texte et que vous souhaitez lui appliquer une liste de fonctions.

Chaque fonction extrait une caractéristique du texte. Les caractéristiques que nous voulons extraire sont le nombre de mots, le deuxième mot et la quatrième lettre du quatrième mot :

def number_of_words(text):
  return len(text.split())
​
def second_word(text):
  return text.split()[1]
​
def fourth_letter_of_fourth_word(text):
  return text.split()[3][3]
​
function_list = [number_of_words, second_word, fourth_letter_of_fourth_word]
​
my_text = 'Mary had a little lamb'
map_obj = map(lambda f: f(my_text), function_list)
​
feature_list = list(map_obj)
​
print(feature_list)

[5, 'had', 't']

Conclusion

Dans ce guide, nous avons exploré les fonctionnalités de lambda fonctions en Python. Nous avons vu ça lambda les fonctions sont des fonctions anonymes à utiliser comme paramètre de fonction en ligne pour d'autres fonctions. Nous avons vu quelques cas d’utilisation ainsi que les moments où il ne faut pas les utiliser.

Lors de la programmation, il est important de garder à l’esprit la citation de Donald Knuth : « Les programmes sont destinés à être lus par des humains et seulement accessoirement à être exécutés par des ordinateurs. » Avec ça en tête, lambda Les fonctions sont un outil utile pour simplifier notre code, mais doivent être utilisées à bon escient.