Fonctions d'ordre supérieur en programmation fonctionnelle

Définition des fonctions d'ordre supérieur

Une fonction d'ordre supérieur est une fonction qui :

• Prend une ou plusieurs fonctions en argument, et/ou
• Retourne une fonction comme résultat.

Les fonctions d'ordre supérieur sont un outil puissant pour l'abstraction et la réutilisation de code en programmation fonctionnelle. Elles permettent de créer des fonctions génériques qui peuvent être utilisées avec différentes fonctions spécifiques.

Exemples en Python

Python supporte les fonctions d'ordre supérieur de manière native. Voici quelques exemples:

1. map(): Applique une fonction à chaque élément d'un itérable (liste, tuple, etc.) et retourne un itérateur contenant les résultats.
2. filter(): Filtre les éléments d'un itérable en fonction d'une fonction de test (qui retourne True ou False) et retourne un itérateur contenant les éléments qui passent le test.
3. reduce(): (Nécessite from functools import reduce) Applique une fonction cumulativement aux éléments d'un itérable, de gauche à droite, afin de réduire l'itérable à une seule valeur.

Exemples de code:

# map()
def carre(x):
    return x * x

liste_nombres = [1, 2, 3, 4, 5]
carres = list(map(carre, liste_nombres))
print(carres)  # Affiche [1, 4, 9, 16, 25]

# filter()
def est_pair(x):
    return x % 2 == 0

liste_nombres = [1, 2, 3, 4, 5, 6]
pairs = list(filter(est_pair, liste_nombres))
print(pairs)  # Affiche [2, 4, 6]

# reduce()
from functools import reduce

def addition(x, y):
    return x + y

liste_nombres = [1, 2, 3, 4, 5]
somme = reduce(addition, liste_nombres)
print(somme)  # Affiche 15

Création de fonctions d'ordre supérieur personnalisées

Vous pouvez également créer vos propres fonctions d'ordre supérieur. Voici un exemple:

def appliquer_plusieurs_fois(fonction, n, argument):
    resultat = argument
    for _ in range(n):
        resultat = fonction(resultat)
    return resultat

def incrementer(x):
    return x + 1

resultat = appliquer_plusieurs_fois(incrementer, 3, 5)
print(resultat)  # Affiche 8 (5 + 1 + 1 + 1)

Dans cet exemple, appliquer_plusieurs_fois est une fonction d'ordre supérieur qui prend une fonction (incrementer), un nombre n, et un argument initial en entrée. Elle applique la fonction n fois à l'argument et retourne le résultat final.

Currying (Curryfication)

Le currying, ou curryfication, est une technique qui consiste à transformer une fonction qui prend plusieurs arguments en une série de fonctions qui prennent chacune un seul argument.

Exemple en Python:

def multiplier(x):
    def par(y):
        return x * y
    return par

# Créer une fonction qui multiplie par 5
multiplier_par_5 = multiplier(5)

# Utiliser la fonction créée
resultat = multiplier_par_5(3)
print(resultat)  # Affiche 15

resultat2 = multiplier(2)(4) # Affiche 8
print(resultat2)

Dans cet exemple, multiplier est une fonction qui prend un argument x et retourne une nouvelle fonction par. La fonction par prend un argument y et retourne le produit de x et y. Ainsi, on a transformé une fonction à deux arguments en une série de fonctions à un seul argument.

Composition de fonctions

La composition de fonctions consiste à combiner deux ou plusieurs fonctions pour créer une nouvelle fonction. Le résultat de la première fonction est utilisé comme argument pour la deuxième fonction, et ainsi de suite.

Exemple en Python :

def carre(x):
    return x * x

def incrementer(x):
    return x + 1

# Composer les fonctions carre et incrementer
def compose(f, g):
    def h(x):
        return f(g(x))
    return h

# Créer une fonction qui incrémente et ensuite calcule le carré
carre_apres_incrementer = compose(carre, incrementer)

# Utiliser la fonction composée
resultat = carre_apres_incrementer(2)
print(resultat)  # Affiche 9 ((2 + 1)^2 = 3^2 = 9)

Dans cet exemple, compose est une fonction qui prend deux fonctions f et g en argument et retourne une nouvelle fonction h. La fonction h prend un argument x et retourne f(g(x)). Ainsi, on a combiné les fonctions carre et incrementer pour créer une nouvelle fonction carre_apres_incrementer.

Avantages des fonctions d'ordre supérieur

L'utilisation de fonctions d'ordre supérieur présente plusieurs avantages :

• Réutilisation du code: Elles permettent de créer des fonctions génériques qui peuvent être utilisées avec différentes fonctions spécifiques.
• Abstraction: Elles permettent de masquer les détails d'implémentation et de se concentrer sur la logique de haut niveau.
• Modularité: Elles permettent de diviser un problème complexe en sous-problèmes plus simples et de les résoudre en combinant des fonctions de base.
• Lisibilité: Elles peuvent rendre le code plus clair et plus facile à comprendre, en particulier lorsqu'elles sont utilisées avec des fonctions anonymes (lambda expressions).

Ce qu'il faut retenir

• Une fonction d'ordre supérieur prend une ou plusieurs fonctions en argument et/ou retourne une fonction.
• map(), filter(), et reduce() sont des exemples de fonctions d'ordre supérieur en Python.
• Vous pouvez créer vos propres fonctions d'ordre supérieur pour l'abstraction et la réutilisation du code.
• Le currying est une technique pour transformer une fonction à plusieurs arguments en une série de fonctions à un seul argument.
• La composition de fonctions consiste à combiner deux ou plusieurs fonctions pour créer une nouvelle fonction.
• Les fonctions d'ordre supérieur améliorent la réutilisation, l'abstraction, la modularité et la lisibilité du code.