for]]>def carre(x): return x * x.def ajoute_a_liste(L, x): L.append(x)map, filter, sorted avec key), quilambda vient du lambda-calcul de Church. Enlambda sont limitées à une seuledef.]]>lambda x: x x est une fonctionx et renvoie son carré.def f(x): return x x mais sansmap(f, L) en Python ?]]>map et filter sont deux fonctions d'ordre supérieurfilter, pas map.]]>map produit une valeur pour chaque élémentL, elle ne les combine pas en une seule.]]>f à chaque élément de L]]>list(map(f, L)). Par exemple,list(map(lambda x: x * 2, [1, 2, 3])) renvoie[2, 4, 6].]]>L en y appliquant f directement]]>map ne modifie pas la liste d'origine. ElleL intacte.]]>filter(p, L) en Python ?]]>[x for x in L if p(x)]. Souvent plus lisible quefilter en Python.]]>L]]>len ou sum.]]>L où p est vrai]]>list(filter(lambda x: x > 0, [-1, 0, 1, 2]))[1, 2]. Les éléments pour lesquels pTrue sont conservés.]]>L]]>map.]]>filter renvoie un itérateur des élémentsdef depasse_dix(x):
return x > 10Que vaut list(map(depasse_dix, [4, 15, 10, 23])) ?
map(f, L) renvoie un résultat f(x) pour chaque élément x deL, tandis que filter(f, L) ne garde que les éléments pourf(x) vaut True. Avec une fonction qui renvoie unmap donne donc des booléens.]]>[15, 23] : les éléments qui dépassent $10$]]>filter, qui ne garde que les élémentsTrue. map renvoie, pour chaque[False, True, False, True] : un booléen par élément]]>map applique depasse_dix à chaque élément et4 > 10 donne False, 15 > 10 donneTrue, 10 > 10 donne False et 23 > 10 donne True.]]>[False, True, True, True] : un booléen par élément]]>10 > 10 vaut False, car $10$ n'est pas strictement10 >= 10 vaudrait True.]]>[4, 10] : les éléments qui ne dépassent pas $10$]]>map ne retirefor i in range(n) modifiei à chaque tour, ce qui contreditdef f1(x): return x + 1
def f2(x): print(x); return x
def f3(L, x): L.append(x); return L
def f4(): return random.random()print,f1 et f4]]>f4 n'est pas pure. Pour les mêmesf1 et f2]]>f2 appelle print, ce qui est un effetf1 seule]]>f1 ne modifie rien et retournef2print), f3 modifie sonf4 retourne un résultat différent àf1 respecte les deux conditions delist(map(lambda x: x ** 2, [1, 2, 3, 4]))[x ** 2 for x in [1, 2, 3, 4]], qui est[1, 4, 9, 16]]]>map[1, 2, 3, 4]]]>map applique la fonction à chaque[1, 16]]]>map applique à chaque élément, on[2, 4, 6, 8]]]>lambda x: x * 2, pas x 2.list(filter(lambda x: x % 2 == 0, range(10)))[x for x in range(10) if x % 2 == 0]. Les deux[]]]>range(10).]]>[1, 3, 5, 7, 9]]]>x % 2 == 0 teste si x est pair.[0, 1, 2, ..., 9]]]>range(10) complet, sans filtre.]]>[0, 2, 4, 6, 8]]]>filter conserve les éléments pourrange(10) produitlist(map(lambda x: x * 2, filter(lambda x: x > 0, L))) ?]]>map et filter ensum, max, min, etc.]]>[x > 0 * 2 for x in L]]]>[x for x in L * 2]]]>[L if x > 0 for x in L]]]>[x * 2 for x in L if x > 0]]]>sorted(L, key=f)map, filter et sorted (avec key)resultat après l'exécution de ce programme ?
def ajouter(a, b):
return a + b
def multiplier(a, b):
return a * b
operations = {"+": ajouter, "*": multiplier}
resultat = operations["*"](4, 5)operations["*"](4, 5) revient à multiplier(4, 5), soit $20$.]]>9]]>ajouter(4, 5), rangée sous la"+". La clé "*" désigne multiplier.]]>20]]>operations["*"] désigne la fonction multiplier,(4, 5) l'appellent aussitôt : multiplier(4, 5)multiplier elle-même, sans l'appeler]]>operations["*"] seul serait la fonction, mais il est(4, 5), qui provoque son appel. resultat reçoit donc lataux = 0.1
def remise(prix):
return prix - prix * taux
a = remise(200)
taux = 0.5
b = remise(200)a et b, et que peut-on en conclure ?]]>taux, remise renvoie des valeurs différentestaux change. Pour la rendre pure, onremise(prix, taux).]]>180.0 et 100.0 : remise n'est pas une fonction pure]]>taux est lue à chaque appel, $0.1$180.0 et 180.0 : taux est lu une fois, à la définition]]>taux au moment de chaque appel, pas lors de laremise. Le second appel utilise donc $0.5$ et100.0.]]>180.0 et 100.0 : remise est pure, elle ne modifie rien]]>remise(200) vaut 180.0 puis 100.0.]]>taux n'est pas défini à l'intérieur de remise]]>global. Le mot-clé global n'est nécessaire que pour latotal = 0
for x in L:
if x > 0:
total += x ** 2sum(x ** 2 if x > 0 for x in L)]]>x ** 2 if x > 0 sans elsefor, sous la forme for x in L if x > 0.]]>sum(x ** 2 for x in L if x > 0)]]>if x > 0 écarte les valeursx ** 2 transforme chaque valeursum additionne le tout. Pas de variablelist(map(lambda x: x ** 2, filter(lambda x: x > 0, L)))]]>L = [2, -1, 3], elle donne [4, 9]for x in L: total += x ** 2]]>total. On veut s'en abstraire.]]>L, l'appel somme(L, 0) devant renvoyer lai + 1. En Python, le nombre d'appels imbriquéssum.]]>def somme(L, i):
return L[i] + somme(L, i + 1)]]>i atteint len(L),L[i] n'existe pas : somme([1, 2, 3], 0) lève IndexError.]]>def somme(L, i):
total = 0
for j in range(i, len(L)):
total = total + L[j]
return total]]>total modifiée à chaque tour. C'est l'écrituredef somme(L, i):
if i == len(L):
return 0
return L[i] + somme(L, i + 1)]]>L[i] à la somme desdef somme(L, i):
if i == len(L) - 1:
return 0
return L[i] + somme(L, i + 1)]]>L[i], si bien que le dernier élément est oublié :somme([1, 2, 3], 0) renvoie $3$ au lieu de $6$.]]>for poursorted avec unemap,for est bien impérative,sorted avec une lambda relèvenombres. Quel code suit le style fonctionnel ?]]>sum, map, filtertotal = 0
for n in nombres:
total = total + n * n]]>total à chaque itération.]]>class Sommateur:
def __init__(self):
self.total = 0
def ajouter(self, n):
self.total += n * n]]>total = nombres]]>total = sum(n * n for n in nombres)]]>sum. Pas d'effet de bord.]]>map sur une lambda]]>[p * 0.9 for p in prix] est concise etRemiseur et une méthode appliquer]]>goto]]>goto en Python, etdouble est-elle pure ?def double(x):
print(x)
return 2 * xx, mais lax]]>print en est un.]]>print ne modifie aucune variable]]>def ajoute(t, x): return t + (x,), avec t un tuple]]>t + (x,) construit un nouveau tuple ; tdef ajoute(l, x): l.append(x), avec l une liste]]>append modifie la liste reçue, visible depuisdef ajoute(l, x): l += [x], avec l une liste]]>+= modifie l'objet existant, commeappend.]]>def ajoute(l, x): l.insert(len(l), x), avec l une liste]]>insert modifie la liste en place.]]>l, laquelle nesum(l), qui renvoie la somme sans rien changer]]>sum reçoit la liste et renvoie une valeur, sansfor accumulant dans total, réaffecté à chaque tour]]>total est réaffecté à chaque tour, c'est le stylel[0] par l[0] + l[1] et retirant l[1]]]>l.append(sum(l)) suivi de la lecture de l[-1]]]>sans_tete est-elle pure ?def sans_tete(l):
l.pop(0)
return l
a = [1, 2, 3]
b = sans_tete(a)
print(a)l[1:], sans[2, 3], et la fonction n'est pas pure, elle modifie a]]>pop(0) retire le premier élément de la listea elle-même. Un appel a changé une valeur[1, 2, 3], et la fonction est pure, elle renvoie une liste]]>a et l désignent la même liste, modifiée parpop.]]>[2, 3], et la fonction est pure, le résultat étant renvoyé]]>a.]]>[1, 2, 3], et la fonction n'est pas pure, elle utilise pop]]>a a# Version A
p.deplace(2, 3)
# Version B
q = deplace(p, 2, 3)p]]>deplace reçoit p et renvoie un pointp reste disponible tel quel. La version A modifiep.]]>deplace]]>p]]>def multiplieur(k):
return lambda x: k * x
f = multiplieur(3)
print(f(5))15]]>multiplieur(3) renvoie une fonction quif(5) vaut8]]>3]]>f n'est pas la valeur 3, c'est une fonction qui3.]]>k ayant disparu]]>k, c'estsorted(['pomme', 'kiwi', 'banane'], key=len) ?]]>key de sorted reçoit une fonction : c'est un['kiwi', 'pomme', 'banane']]]>key=len indique de comparer les mots par leurlen est passée en argument, sans être['banane', 'kiwi', 'pomme']]]>key.]]>['banane', 'pomme', 'kiwi']]]>len devant être appelée]]>def enchaine(fonctions, x):
for f in fonctions:
x = f(x)
return x
print(enchaine([lambda x: x + 1, lambda x: x * 2], 3))8]]>7]]>4]]>