Composer deux fonctions

En mathematiques, la composition de fonctions c'est appliquer une fonction au résultat d'une autre. Si tu as f et g, la composee f apres g applique d'abord g puis f au résultat.

En programmation fonctionnelle, c'est un outil tres puissant. Plutot que d'écrire :
résultat = f(g(x))

Tu créés une nouvelle fonction composee :
fg = composer(f, g)
résultat = fg(x)

L'avantage ? Tu peux stocker cette composee, la passer en argument, la reutiliser.

def composer(f, g):
return lambda x: f(g(x))

ajouter_un = lambda x: x + 1
doubler = lambda x: x * 2

ajouter_puis_doubler = composer(doubler, ajouter_un)
ajouter_puis_doubler(3) # d'abord 3+1=4, puis 4*2=8 -> renvoie 8

Écris une fonction composer(f, g) qui renvoie une nouvelle fonction. Cette nouvelle fonction applique d'abord g, puis f au résultat.

Ensuite, ecris une fonction pipeline(fonctions) qui prend une liste de fonctions et les compose toutes, de gauche a droite. pipeline([f, g, h]) doit d'abord appliquer f, puis g, puis h.

Exemple :
doubler = lambda x: x * 2
ajouter_un = lambda x: x + 1

h = composer(ajouter_un, doubler)
h(5) renvoie 11 (d'abord 5*2=10, puis 10+1=11)

p = pipeline([doubler, ajouter_un])
p(5) renvoie 11 (d'abord 5*2=10, puis 10+1=11)

Tests (4/5)

Composer doubler + 1

h = composer(lambda x: x + 1, lambda x: x * 2)
assert h(5) == 11

Composer str + len

h = composer(len, str)
assert h(1234) == 4

Pipeline doubler + 1

p = pipeline([lambda x: x * 2, lambda x: x + 1])
assert p(5) == 11

Pipeline vide

p = pipeline([])
assert p(42) == 42

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

def composer(f, g):
    return lambda x: f(g(x))

def pipeline(fonctions):
    def resultat(x):
        for func in fonctions:
            x = func(x)
        return x
    return résultat

← Convertisseur de devises currie Créer un decorateur simple →

solution.py

Bravo!

Composer deux fonctions

Tests (4/5)

Indices (3 disponibles)

Solution officielle