fonction - expression lambda

01 Définir les expressions lambda

Les expressions Lambda, également appelées fonctions anonymes, sont souvent utilisées pour représenter des fonctions qui ne contiennent qu'une seule ligne d'expressions. Si le corps d'une fonction n'a qu'une seule ligne d'expression, la fonction peut être remplacée par une expression lambda.

La syntaxe d'une expression lambda est la suivante :

func = lambda [arg1[, arg2, ... argN]] : expression

Pour définir une expression lambda, il faut utiliser le mot-clé lambda ; [arg1[, arg2, … argN]] est un paramètre facultatif, qui équivaut à la liste de paramètres à spécifier lors de la définition d'une fonction. expression représente une ligne d'expression et le résultat de son opération est la valeur de retour de la fonction. func est une variable qui fait référence à l'objet fonction défini par lambda.

Ce format de syntaxe est transformé sous la forme d'une fonction ordinaire, comme suit :

def func([arg1[, arg2, ... argN]]):
    return expression

Clairement, définir cette fonction de manière normale nécessite 3 lignes de code, mais utiliser une expression lambda ne nécessite qu'une seule ligne.

Par exemple, si vous concevez une fonction qui calcule la somme de 2 nombres, à l’aide de fonctions ordinaires, la définition est la suivante :

def add(x, y):
    return x+ y
    
print(add(3,4))    # 打印 7

Dans le programme ci-dessus, il n'y a qu'une seule ligne d'expression à l'intérieur de la fonction add(), cette fonction peut donc être exprimée directement par expression lambda :

add = lambda x,y:x+y
print(add(3,4))    # 打印 7

02 Différence entre l'expression lambda et la fonction def

L'utilisation de base de lambda et def est similaire, les paramètres sont facultatifs et les deux définiront des objets fonction. Les différences sont les suivantes :
lambda peut définir une fonction anonyme, et la fonction définie par def doit avoir un nom. Cela devrait être la plus grande différence entre lambda et def.
lambda est une expression, pas une déclaration. Par conséquent, les lambdas peuvent apparaître à des endroits où def n'est pas autorisé par la syntaxe Python. Par exemple, dans une constante de liste ou comme argument d’un appel de fonction.
Le corps d'un lambda est une expression unique, pas un bloc de code. Le code contenu dans lambda est équivalent au code après la clause return dans def. Il ne peut s'agir que d'une expression simple, donc la capacité de lambda est inférieure à celle de def. Seule une syntaxe simple peut être utilisée dans lambda, et des instructions telles que if else while return ne peuvent pas être utilisées.
La philosophie de conception est également différente : lambda est conçu pour écrire des fonctions simples, tandis que def est utilisé pour gérer des tâches complexes.

Par rapport à la fonction def, l'expression lamba présente les deux avantages suivants :

Pour les fonctions sur une seule ligne, l'utilisation d'expressions lambda peut économiser le processus de définition des fonctions et rendre le code plus concis.
Pour les fonctions qui n'ont pas besoin d'être réutilisées plusieurs fois, l'utilisation d'expressions lambda peut être publiée immédiatement après utilisation, améliorant ainsi les performances d'exécution du programme.

Pourquoi utiliser des lambdas ?

La fonction lambda est principalement utilisée pour écrire quelques petites fonctions ponctuelles afin d'éviter de polluer l'environnement et de simplifier le code.
Lambda agit comme une sorte de raccourci de fonction, permettant d'intégrer la définition d'une fonction dans le code utilisé. Si vous n'avez besoin d'intégrer qu'un petit morceau de code exécutable, l'utilisation d'expressions lambda apportera une structure de code plus concise.

03 candidature

filtre()

Filtrez les éléments de la séquence, et obtenez enfin la séquence qualifiée.

#示例1
l = list(filter(lambda x:True if x % 3 == 0 else False, range(100)))
print(l)
'''
输出结果：
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]
'''

Comme indiqué ci-dessus, une expression lambda est utilisée pour définir une fonction anonyme permettant de filtrer les multiples de 3 sur 100 et de générer une liste. L'utilisation de la fonction def s'exprime comme suit :

#示例2
def f(x):
    if x % 3 == 0 :
        return True
    else:
        return False

l = list( filter(f, range(100) ))
print(l)

filter() est simplement compris comme un filtre, qui nécessite deux paramètres, une fonction et une séquence (les chaînes, les listes et les tuples sont tous des séquences), et le filtre transmettra à son tour la valeur de la séquence à la fonction, si elle renvoie True , qui régénère une liste.

carte()

map() peut parcourir la séquence, opérer sur chaque élément de la séquence et enfin obtenir une nouvelle séquence.

#示例3 
li = [11, 22, 33]
sl = [1, 2, 3]
new_list = map(lambda a, b: a + b, li, sl)
print(list(new_list))

# 输出结果为：
[12,24,36]

map() signifie mappage, filter() signifie filtrage, l'utilisation de map() est similaire à filter(), et il place également la séquence dans la fonction pour l'opération, mais quel que soit le résultat de l'opération, map( ) sera renvoyé un par un, c'est map La principale différence entre () et filter(). Notez que les fonctions filter() et map() doivent avoir une valeur de retour.

#示例4
l = list(map(lambda x:True if x % 3 == 0 else False, range(100)))
print(l)

'''
输出结果为：
[True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True, False, False, True]
'''

réduire()

Accumule tous les éléments de la séquence.

#示例5            
from functools import reduce

li = [11,22,33]
result = reduce(lambda a,b:a+b,li)
# reduce的第一个参数，函数必须要有两个参数
# reduce的第二个参数，要循环的序列
# reduce的第三个参数，初始值
print(result)

'''
输出结果：
66
'''

Trouvez la factorielle de n à l'aide d'une expression lambda.

#示例6 
from functools import reduce

n = 5
print( reduce(lambda x,y:x*y,range(1,n+1)) )
 
'''
输出结果：
120
'''

fonction imbriquée

#示例7 
def f(a):
    return lambda b : a + b

a = f(10)
print( a(20))     # 30

Lambda peut également être imbriqué dans une fonction, dans l'exemple ci-dessus, une expression lambda est imbriquée dans la fonction. La variable a fait référence à l'objet fonction défini par l'expression lambda.

#示例8 
#上面示例可以使用两个lambda表示：

x = lambda a: lambda b: a+b
y= x(10)
print(y(20))     # 30

trier()

#示例9 
# 根据每个元祖的第一个元素进行排序
a = [(1, 2), (4, 1), (9, 10), (13, -3)]
a.sort(key=lambda x: x[1])
print(a)

04 Résumé

lambda n'est qu'une expression et le corps de la fonction est beaucoup plus simple que def.
Le corps d'un lambda est une expression, pas un bloc de code. Seules des opérations logiques limitées peuvent être encapsulées dans des expressions lambda.
Une fonction lambda possède son propre espace de noms et ne peut pas accéder aux paramètres en dehors de sa propre liste de paramètres ou dans l'espace de noms global.
De simples lignes simples ou des fonctions ponctuelles peuvent être écrites sous forme de fonctions lambda, ce qui peut rendre le code plus concis.
Pour les fonctions complexes ou les fonctions avec des corps de fonctions volumineux, il est préférable de ne pas utiliser lambda, ce qui augmenterait la difficulté de lecture du code et rendrait le code obscur.
Dans le cas de fonctions qui ne sont pas appelées plusieurs fois, les expressions lambda peuvent être utilisées immédiatement, améliorant ainsi les performances.

Fonction Python - expression lambda