LES LISTES

Lambda, Map, Filter, Reduce Functions

Lambda
• Fonction Lambda
• Fonction simple avec une seule ligne
• Ne pas utiliser def où valeur de return, ils sont implicite
 Lambda

#double x

def double(x): Lambda x : x*2

return(x*2) Parametre(s) Return

 Lambda

# somme de x et y

def somme(x,y):
return(x+y)
Lambda x,y : x+y

Parametre(s) Return
 Lambda

# max de x, y
Max=Lambda x,y : x if x>y else y
def Max(x,y):
if x>y:

return(x)
else:
return y print(Max(8,5))
print(Max(8,5))
 map
• Appliquer la même fonction à chaque élément d'une
séquence.
• Retourner la liste modifier

Liste,[m,n,p] map Nouvelle liste,[f(m),f(n),f(p)]

Fonction, f()
 filter
• Filtrer les éléments d’une séquence.
• Retourner la liste filtrer

Liste,[m,n,p]
Condition, c()
filter Nouvelle liste,[m,n]

If m==Condition
 filter

# affiche [4,3]
L=[4,3,2,1]
Def sup_deux(L1):
L2=[x for x in L1 if Print(list(filter(Lambda x : x>2, L)))
x>2]
condition liste
return L2
print(sup_deux([4,3,2,1])) Liste de compréhension

Print([x for x in L if x>2])

 Reduce
• applique la même opération aux éléments d'une séquence.

• utilise le résultat de l'opération comme premier paramètre de l'opération

suivante.

• renvoie un élément, pas une liste

Liste,[m,n,p]
Reduce f(f(m,n),p)
Fonction, f()
 Reduce
L=[4,3,2,1]
# affichage 24
Print(reduce(Lambda x,y : x *y,L)))
def Mult(L1):
liste
p=L1[0] fonction
for i in 4*3=12
range(1,len(L1)) 12*2=24
p*=L1[i] 24*1=24
return p
print(Mult([4,3,2,1]))