La fonction la plus mystérieuse couramment utilisée en Python ! Résumé détaillé de la fonction lambda !

Qu'est-ce qu'une fonction Lambda en Python

Une fonction lambda est une fonction anonyme (c'est-à-dire sans nom défini) qui peut accepter n'importe quel nombre d'arguments, mais contrairement à une fonction normale, elle évalue et renvoie uniquement une expression.

La fonction lambda en Python est exprimée en utilisant la syntaxe suivante :

Paramètre lambda : expression

La fonction lambda comprend trois éléments :

• Mot-clé lambda : similaire à def dans une fonction normale
• Paramètre : prend en charge la position et la clé de passage Les paramètres Word sont les mêmes que les fonctions ordinaires
• Texte : Traitement des expressions avec des paramètres fixes

Il convient de noter que, contrairement aux fonctions ordinaires, il n'est pas nécessaire d'utiliser des parenthèses pour délimiter les paramètres de la fonction lambda. a deux paramètres multiples ou plus, nous les listons avec des virgules

Nous utilisons la fonction lambda pour évaluer uniquement une expression courte (idéalement, une seule ligne) et une seule fois, ce qui signifie que nous ne réutiliserons plus cette fonction à l'avenir. De manière générale, nous passerons la fonction lambda en paramètre à une fonction d'ordre supérieur (une fonction qui accepte d'autres fonctions comme paramètres), telle que les fonctions intégrées de Python, telles que filter(), map() ou réduire(). , etc.

Fonction Lambda en Python Comment ça marche

Voyons un exemple simple de fonction lambda :

lambda x: x + 1

Sortie :

<function __main__.<lambda>(x)>

La fonction lambda ci-dessus prend un paramètre, l'incrémente de 1 et renvoie le résultat

C'est ce qui suit avec les mots-clés def et return Une version plus simple d'une fonction normale :

def increment_by_one(x):
 return x + 1

Jusqu'à présent, notre fonction lambda lambda x : x + 1 crée uniquement un objet fonction et ne renvoie rien, c'est parce que nous n'avons fourni aucune valeur (argument) pour son paramètre x. Attribuons d'abord une variable, passons-la à la fonction lambda et voyons ce que nous obtenons cette fois :

a = 2
print(lambda x: a + 1)

Sortie :

<function <lambda> at 0x00000250CB0A5820>

Notre fonction lambda ne renvoie pas 3 comme prévu, mais renvoie à la place l'objet fonction lui-même et son emplacement mémoire, on peut voir que ce n'est pas la bonne façon d'appeler la fonction lambda. Pour passer des paramètres à une fonction lambda, l'exécuter et renvoyer le résultat, nous devons utiliser la syntaxe suivante :

(lambda x: x + 1)(2)

Sortie :

3

Bien que les paramètres de notre fonction lambda ne soient pas mis entre parenthèses, lorsque nous l'appelons, nous ajoutons des parenthèses autour de toute la construction de la fonction lambda et des paramètres que nous lui transmettons

Une autre chose à noter dans le code ci-dessus est qu'avec les fonctions lambda, nous pouvons exécuter la fonction et recevoir le résultat dès sa création. C'est ce qu'on appelle l'invocation immédiate d'exécution de fonction (ou IIFE)

Nous pouvons créer une fonction lambda avec plusieurs paramètres, auquel cas nous séparons les paramètres dans la définition de la fonction par des virgules. Lorsque nous exécutons une telle fonction lambda, nous listons les paramètres correspondants dans le même ordre et les séparons par des virgules :

(lambda x, y, z: x + y + z)(3, 8, 1)

Sortie :

12

Vous pouvez également utiliser les fonctions lambda pour effectuer des opérations conditionnelles. Voici une simulation lambda d'une simple fonction if-else :

print((lambda x: x if(x > 10) else 10)(5))
print((lambda x: x if(x > 10) else 10)(12))

Output:

10
12

S'il y a plusieurs conditions (if-elif-...-else), nous devons les imbriquer :

(lambda x: x * 10 if x > 10 else (x * 5 if x < 5 else x))(11)

Output:

110

Mais la méthode d'écriture ci-dessus rend le code difficile à lire

Dans ce cas, une fonction ordinaire avec if-elif-...-else définie sera un meilleur choix que la fonction lambda. En fait, nous pouvons écrire la fonction lambda dans l'exemple ci-dessus par :

def check_conditions(x):
 if x > 10:
 return x * 10
 elif x < 5:
 return x * 5
 else:
 return x
check_conditions(11)

Sortie :

110

Bien que la fonction ci-dessus ajoute plus de lignes que la fonction lambda correspondante, elle est plus facile à lire

Nous pouvons convertir la fonction lambda A est affecté à une variable, puis cette variable est appelée comme une fonction normale :

increment = lambda x: x + 1
increment(2)

Sortie :

3

Mais selon les règles de style PEP 8 pour le code Python, c'est une mauvaise pratique

• L'utilisation d'instructions d'affectation élimine le seul avantage offert par une expression lambda par rapport à une instruction def explicite (c'est-à-dire qu'elle peut être intégrée dans une expression plus grande)

Donc, si nous avons besoin de stocker une fonction pour une utilisation ultérieure, nous ferions mieux d'en définir une équivalente à une fonction normale, au lieu d'attribuer la fonction lambda à une variable

Application de la fonction Lambda en Python

Lambda avec la fonction filter()

La fonction filter() en Python nécessite deux paramètres :

• Fonction qui définit les conditions du filtre
• Objet itérable sur lequel la fonction opère

En exécutant la fonction, nous obtenons un objet filtre :

lst = [33, 3, 22, 2, 11, 1]
filter(lambda x: x > 10, lst)

Sortie :

<filter at 0x250cb090520>

Pour obtenir un nouvel itérateur à partir de l'objet filtre et que tous les éléments de l'itérateur d'origine répondent aux conditions prédéfinies, nous avons besoin pour passer l'objet filtre à la fonction correspondante de la bibliothèque standard Python : list(), tuple(), set(), Frozenset() ou sorted() (Renvoie une liste triée)

Filtrons une liste de nombres, sélectionnez uniquement les nombres supérieurs à 10 et renvoie une liste triée par ordre croissant :

lst = [33, 3, 22, 2, 11, 1]
sorted(filter(lambda x: x > 10, lst))

Sortie :

[11, 22, 33]

Nous n'avons pas besoin de créer un nouvel objet itérable du même type que l'objet d'origine, nous pouvons en outre stocker le résultat de celui-ci opération dans une variable :

lst = [33, 3, 22, 2, 11, 1]
tpl = tuple(filter(lambda x: x > 10, lst))
tpl

Output:

(33, 22, 11)

带有 map() 函数的 Lambda

我们使用 Python 中的 map() 函数对可迭代的每个项目执行特定操作。它的语法与 filter() 相同：一个要执行的函数和一个该函数适用的可迭代对象。

map() 函数返回一个 map 对象，我们可以通过将该对象传递给相应的 Python 函数来从中获取一个新的迭代：list()、tuple()、set()、frozenset() 或 sorted()

与 filter() 函数一样，我们可以从 map 对象中提取与原始类型不同类型的可迭代对象，并将其分配给变量。

下面是使用 map() 函数将列表中的每个项目乘以 10 并将映射值作为分配给变量 tpl 的元组输出的示例：

lst = [1, 2, 3, 4, 5]
print(map(lambda x: x * 10, lst))
tpl = tuple(map(lambda x: x * 10, lst))
tpl

Output:

<map object at 0x00000250CB0D5F40>
(10, 20, 30, 40, 50)

map() 和 filter() 函数之间的一个重要区别是第一个函数总是返回与原始函数相同长度的迭代。因此由于 pandas Series 对象也是可迭代的，我们可以在 DataFrame 列上应用 map() 函数来创建一个新列：

import pandas as pd
df = pd.DataFrame({'col1': [1, 2, 3, 4, 5], 'col2': [0, 0, 0, 0, 0]})
print(df)
df['col3'] = df['col1'].map(lambda x: x * 10)
df

Output:

col1col2
0 1 0
1 2 0
2 3 0
3 4 0
4 5 0
col1col2col3
0 1 010
1 2 020
2 3 030
3 4 040
4 5 050

当然要在上述情况下获得相同的结果，也可以使用 apply() 函数：

df['col3'] = df['col1'].apply(lambda x: x * 10)
df

Output:

col1col2col3
0 1 010
1 2 020
2 3 030
3 4 040
4 5 050

我们还可以根据某些条件为另一列创建一个新的 DataFrame 列，对于下面的代码，我们可以互换使用 map() 或 apply() 函数：

df['col4'] = df['col3'].map(lambda x: 30 if x < 30 else x)
df

Output:

col1col2col3col4
0 1 01030
1 2 02030
2 3 03030
3 4 04040
4 5 05050

带有 reduce() 函数的 Lambda

reduce() 函数与 functools Python 模块相关，它的工作方式如下：

• 对可迭代对象的前两项进行操作并保存结果
• 对保存的结果和可迭代的下一项进行操作
• 以这种方式在值对上进行，直到所有项目使用可迭代的

该函数与前两个函数具有相同的两个参数：一个函数和一个可迭代对象。但是与前面的函数不同的是，这个函数不需要传递给任何其他函数，直接返回结果标量值：

from functools import reduce
lst = [1, 2, 3, 4, 5]
reduce(lambda x, y: x + y, lst)

Output:

15

上面的代码展示了我们使用 reduce() 函数计算列表总和时的作用

需要注意的是，reduce() 函数总是需要一个带有两个参数的 lambda 函数，而且我们必须首先从 functools Python 模块中导入它

Python 中 Lambda 函数的优缺点

优点

• 评估单个表达式的理想选择，应该只评估一次
• 它可以在定义后立即调用
• 与相应的普通语法相比，它的语法更紧凑
• 它可以作为参数传递给高阶函数，例如 filter()、map() 和 reduce()

缺点

• 它不能执行多个表达式
• 它很容易变得麻烦，可读性差，例如当它包括一个 if-elif-...-else 循环
• 它不能包含任何变量赋值（例如，lambda x: x=0 将抛出一个语法错误）
• 我们不能为 lambda 函数提供文档字符串

总结

总而言之，我们已经详细讨论了在 Python 中定义和使用 lambda 函数的许多方面：

• lambda 函数与普通 Python 函数有何不同
• Python 中 lambda 函数的语法和剖析
• 何时使用 lambda 函数
• lambda 函数的工作原理
• 如何调用 lambda 函数
• 调用函数执行（IIFE）的定义
• 如何使用 lambda 函数执行条件操作，如何嵌套多个条件，以及为什么我们应该避免它
• 为什么我们应该避免将 lambda 函数分配给变量
• 如何将 lambda 函数与 filter() 函数一起使用
• 如何将 lambda 函数与 map() 函数一起使用
• 我们如何在 pandas DataFrame 中使用
• 带有传递给它的 lambda 函数的 map() 函数 - 以及在这种情况下使用的替代功能
• 如何将 lambda 函数与 reduce() 函数一起使用
• 普通 Python 上使用 lambda 函数的优缺点

希望今天的讨论可以使 Python 中看似令人生畏的 lambda 函数概念更清晰、更易于应用，更希望小伙伴们能够喜欢，喜欢就点个赞吧！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!