Fonction Lambda, la reine de tous en Python

Introduction à la fonction Lambda

La fonction Lambda est également connue sous le nom de fonction anonyme (sans nom), qui accepte directement le nombre de paramètres et la condition ou l'opération à effectuer à l'aide des paramètres, qui sont séparés par deux points, et renvoie le résultat final. Afin d'effectuer une petite tâche tout en écrivant du code sur une grande base de code, ou d'effectuer une petite tâche dans une fonction, les fonctions lambda sont utilisées dans le processus normal.

lambda argument_list:expersion

argument_list est une liste de paramètres. Sa structure est la même que la liste de paramètres d'une fonction en Python.

a,b
a=1,b=2
*args
**kwargs
a,b=1,*args
空
....

expression est une expression sur les paramètres. Les paramètres apparaissant dans l'expression doivent être définis dans argument_list, et les expressions peuvent. être uniquement sur une seule ligne.

1
None
a+b
sum(a)
1 if a >10 else 0
[i for i in range(10)]
...

La différence entre les fonctions ordinaires et les fonctions Lambda

• Aucun nom Les fonctions Lambda n'ont pas de nom, tandis que les opérations ordinaires ont un nom approprié.
• La fonction Lambda n'a pas de valeur de retour. Une fonction normale construite à l'aide du mot-clé def renvoie un type de données valeur ou séquence, mais dans une fonction Lambda, un processus complet est renvoyé. Supposons que nous voulions vérifier si un nombre est pair ou impair, en utilisant une syntaxe de fonction lambda similaire à l'extrait de code ci-dessous.

b = lambda x: "Even" if x%2==0 else "Odd"
b(9)

• Les fonctions ne sont écrites et créées que sur une seule ligne. Les fonctions Lambda sont écrites et créées sur une seule ligne, tandis que l'indentation est utilisée dans les fonctions normales.
• Pas pour la réutilisation du code. ou pas dans un autre fichier. Importez cette fonction. En revanche, les fonctions normales sont utilisées pour la réutilisation du code et peuvent être utilisées dans des fichiers externes.

Pourquoi utiliser la fonction Lambda ?

Généralement, nous n'utilisons pas la fonction Lambda, mais l'utilisons avec des fonctions d'ordre supérieur. Une fonction d'ordre supérieur est une fonction qui nécessite plusieurs fonctions pour accomplir une tâche, ou lorsqu'une fonction renvoie une autre fonction, une fonction Lambda peut éventuellement être utilisée.

Qu'est-ce qu'une fonction d'ordre supérieur ?

Comprenez les fonctions d'ordre supérieur à travers un exemple. Supposons que vous ayez une liste d’entiers et que trois sorties doivent être renvoyées.

• La somme de tous les nombres pairs dans une liste
• La somme de tous les nombres impairs dans une liste
• La somme de tous les nombres divisibles par trois

Supposons d'abord qu'une fonction ordinaire est utilisée pour résoudre ce problème. Dans ce cas, trois variables différentes sont déclarées pour stocker les tâches individuelles et une boucle for est utilisée pour traiter et renvoyer les trois variables résultantes. Cette méthode fonctionne normalement.

Utilisez maintenant la fonction Lambda pour résoudre ce problème. Vous pouvez ensuite utiliser trois fonctions Lambda différentes pour vérifier si un nombre à tester est pair, impair ou divisible par trois, puis ajouter un nombre au résultat.

def return_sum(func, lst):
 result = 0
 for i in lst:
 #if val satisfies func
 if func(i):
 result = result + i
 return result
lst = [11,14,21,56,78,45,29,28]
x = lambda a: a%2 == 0
y = lambda a: a%2 != 0
z = lambda a: a%3 == 0
print(return_sum(x, lst))
print(return_sum(y, lst))
print(return_sum(z, lst))

Ici, une fonction d'ordre supérieur est créée où une fonction Lambda est transmise en tant que partie d'une fonction normale. En fait, ce type de code peut être trouvé partout sur Internet. Cependant, de nombreuses personnes ignorent cette fonction lorsqu'elles utilisent Python, ou ne l'utilisent qu'occasionnellement, mais en fait, ces fonctions sont vraiment pratiques et peuvent économiser plus de lignes de code. Jetons ensuite un coup d'œil à ces fonctions d'ordre supérieur.

La fonction d'ordre supérieur intégrée de Python

Fonction Map

map() mappera la séquence spécifiée en fonction de la fonction fournie.

La fonction Map est une fonction qui accepte deux paramètres. La première fonction paramètre appelle la fonction fonction avec chaque élément de la séquence de paramètres, et le deuxième paramètre est n'importe quel type de données de séquence itérable. Renvoie une nouvelle liste contenant la valeur renvoyée par chaque fonction. La fonction

map(function, iterable, ...)

Map définira un certain type d'opération dans l'objet itérateur. Supposons que nous voulions mettre au carré les éléments d'un tableau, c'est-à-dire mapper le carré de chaque élément d'un tableau à un autre tableau qui produit le résultat souhaité.

arr = [2,4,6,8]
arr = list(map(lambda x: x*x, arr))
print(arr)

Nous pouvons utiliser la fonction Carte de différentes manières. Supposons qu'il existe une liste de dictionnaires contenant des détails tels que des noms, des adresses, etc. et que l'objectif soit de générer une nouvelle liste contenant tous les noms.

students = [
 {"name": "John Doe",
"father name": "Robert Doe",
"Address": "123 Hall street"
},
 {
 "name": "Rahul Garg",
 "father name": "Kamal Garg",
 "Address": "3-Upper-Street corner"
 },
 {
 "name": "Angela Steven",
"father name": "Jabob steven",
"Address": "Unknown"
 }
]
print(list(map(lambda student: student['name'], students)))
>>> ['John Doe', 'Rahul Garg', 'Angela Steven']

Les opérations ci-dessus se produisent généralement dans des scénarios tels que l'obtention de données à partir d'une base de données ou l'exploration du Web.

Fonction Filtre

La fonction Filtre filtre les données en fonction de conditions spécifiques données. Autrement dit, définissez les conditions de filtre dans la fonction, itérez les éléments et conservez les éléments avec une valeur de retour True. La fonction map opère sur chaque élément, tandis que la fonction filtre ne génère que les éléments qui répondent à des exigences spécifiques.

Supposons qu'il existe une liste de noms de fruits et que la tâche consiste à afficher uniquement les noms qui contiennent le caractère « g » dans leur nom.

fruits = ['mango', 'apple', 'orange', 'cherry', 'grapes']
print(list(filter(lambda fruit: 'g' in fruit, fruits)))

filter(function ou None, iterable) --> filter object

Renvoie un itérateur pour les éléments itérables où la fonction ou l'élément est vrai. Si la fonction est Aucune, renvoie vrai.

Fonction de réduction

Cette fonction est assez spéciale. Ce n'est pas une fonction intégrée de Python et doit être importée via functools import reduction. Réduire renvoie une valeur de sortie unique à partir d’une structure de données de séquence en appliquant une fonction donnée pour réduire les éléments.

reduce(function, sequence[, initial]) -> value

Appliquez une fonction à deux arguments de manière cumulative aux éléments d'une séquence, de gauche à droite, réduisant ainsi la séquence à une seule valeur.

Si initial est présent, il est placé dans la séquence avant l'élément et sert de valeur par défaut lorsque la séquence est vide.

假设有一个整数列表，并求得所有元素的总和。且使用reduce函数而不是使用for循环来处理此问题。

from functools import reduce
lst = [2,4,6,8,10]
print(reduce(lambda x, y: x+y, lst))
>>> 30

还可以使用 reduce 函数而不是for循环从列表中找到最大或最小的元素。

lst = [2,4,6,8]
# 找到最大元素
print(reduce(lambda x, y: x if x>y else y, lst))
# 找到最小元素
print(reduce(lambda x, y: x if x<y else y, lst))

高阶函数的替代方法

列表推导式

其实列表推导式只是一个for循环，用于添加新列表中的每一项，以从现有索引或一组元素创建一个新列表。之前使用map、filter和reduce完成的工作也可以使用列表推导式完成。然而，相比于使用Map和filter函数，很多人更喜欢使用列表推导式，也许是因为它更容易应用和记忆。

同样使用列表推导式将数组中每个元素进行平方运算，水果的例子也可以使用列表推导式来解决。

arr = [2,4,6,8]
arr = [i**2 for i in arr]
print(arr)
fruit_result = [fruit for fruit in fruits if 'g' in fruit]
print(fruit_result)

字典推导式

与列表推导式一样，使用字典推导式从现有的字典创建一个新字典。还可以从列表创建字典。

假设有一个整数列表，需要创建一个字典，其中键是列表中的每个元素，值是列表中的每个元素的平方。

lst = [2,4,6,8]
D1 = {item:item**2 for item in lst}
print(D1)
>>> {2: 4, 4: 16, 6: 36, 8: 64}
# 创建一个只包含奇数元素的字典
arr = [1,2,3,4,5,6,7,8]
D2 = {item: item**2 for item in arr if item %2 != 0}
print(D2)
>>> {1: 1, 3: 9, 5: 25, 7: 49}

一个简单应用

如何快速找到多个字典的公共键

方法一

dl = [d1, d2, d3] # d1, d2, d3为字典，目标找到所有字典的公共键
[k for k in dl[0] if all(map(lambda d: k in d, dl[1:]))]

例

dl = [{1:'life', 2: 'is'},
{1:'short', 3: 'i'},
 {1: 'use', 4: 'python'}]
[k for k in dl[0] if all(map(lambda d: k in d, dl[1:]))]
# 1

解析

# 列表表达式遍历dl中第一个字典中的键
[k for k in dl[0]]
# [1, 2]
# lambda 匿名函数判断字典中的键，即k值是否在其余字典中
list(map(lambda d: 1 in d, dl[1:]))
# [True, True]
list(map(lambda d: 2 in d, dl[1:]))
#[False, False]
# 列表表达式条件为上述结果([True, True])全为True,则输出对应的k值
#1

方法二

# 利用集合（set）的交集操作
from functools import reduce
# reduce(lambda a, b: a*b, range(1,11)) # 10!
reduce(lambda a, b: a & b, map(dict.keys, dl))

写在最后

目前已经学习了Lambda函数是什么，以及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!