Exercices : programmation fonctionnelle

C. Le paradigme fonctionnel repose sur la composition de fonctions pures (sans effets de bord). A et D sont des caractéristiques du paradigme impératif. B est propre au paradigme objet.

D. map applique lambda x: x ** 2 à chaque élément : $1^2 = 1$, $2^2 = 4$, $3^2 = 9$. A correspond à 2 * x. B correspond à x ** 3. C correspond à la fonction identité.

A. Par exemple, map, filter et sorted sont des fonctions d’ordre supérieur car elles prennent une fonction en paramètre. B décrit la récursivité. C décrit une fonction imbriquée (closure). D décrit un effet de bord.

C. Cette expression compose sum, filter et lambda sans modifier de variable. A et B utilisent des boucles et des affectations (impératif). D utilise une méthode sur un objet (paradigme objet).

a) Impératif. Utilisation d’une variable modifiable total, d’une boucle for et d’une affectation +=.

b) Fonctionnel. Pas de variable modifiable, pas de boucle : seulement une expression conditionnelle et un appel récursif.

c) Objet. Les données (L) sont encapsulées dans un attribut de l’objet, et le traitement est une méthode (somme).

d) Fonctionnel. Utilisation de reduce (fonction d’ordre supérieur) et de lambda (fonctions anonymes), sans variable ni boucle.

a) Compléments :

list(map(lambda x: 2 * x, L))          # doubler
list(filter(lambda x: x % 2 != 0, L))  # impairs
list(map(str, L))                        # convertir en chaînes

Pour le dernier, str est déjà une fonction : pas besoin de lambda.

b)

1. Carrés :

list(map(lambda x: x ** 2, L))    # avec map
[x ** 2 for x in L]               # en compréhension

2. Éléments pairs :

list(filter(lambda x: x % 2 == 0, L))
[x for x in L if x % 2 == 0]

3. Éléments supérieurs à 5 :

list(filter(lambda x: x > 5, L))
[x for x in L if x > 5]

c)

list(map(len, mots))
# ou [len(m) for m in mots]

d)

list(map(abs, filter(lambda x: x < 0, L)))
# ou [-x for x in L if x < 0]

On filtre d’abord les négatifs, puis on applique la valeur absolue.

a)

sorted(mots, key=len)
# ['un', 'est', 'Python', 'langage', 'multiparadigme']

len est directement passée comme fonction clé.

b)

sorted(eleves, key=lambda e: e[1], reverse=True)
# [('Clara', 18), ('Alice', 15), ('David', 14), ('Bob', 12)]

La clé extrait la note (indice 1). reverse=True inverse l’ordre.

c)

from math import sqrt
sorted(points, key=lambda p: sqrt(p[0]**2 + p[1]**2))
# [(0, 0), (3, 2), (4, 1), (1, 5)]

On peut aussi utiliser p[0]**2 + p[1]**2 (le carré suffit pour comparer les distances).

a)

def longueur(L):
    return 0 if L == [] else 1 + longueur(L[1:])

Cas de base : la liste vide a une longueur de 0. Appel récursif : 1 plus la longueur du reste.

b)

def appartient(x, L):
    return False if L == [] else (L[0] == x) or appartient(x, L[1:])

Cas de base : x n’est pas dans la liste vide. Sinon, soit le premier élément est x, soit x appartient au reste.

c)

def nb_occurrences(x, L):
    return 0 if L == [] else (1 if L[0] == x else 0) + nb_occurrences(x, L[1:])

On ajoute 1 si le premier élément est x, puis on compte dans le reste.

a) Pure. double(3) renvoie toujours 6, sans modifier quoi que ce soit en dehors de la valeur de retour.

b) Impure. La fonction modifie la variable globale compteur (effet de bord). Deux appels successifs ne renvoient pas la même valeur.

c) Impure. append modifie la liste L en place (effet de bord). Après l’appel, la liste passée en argument a changé.

d) Pure. L’opérateur + crée une nouvelle liste sans modifier L. La liste originale reste intacte.

La différence entre c) et d) est fondamentale : en programmation fonctionnelle, on crée de nouvelles structures plutôt que de modifier les existantes.

a) Avec une boucle (impératif) :

def forall(pred, L):
    for x in L:
        if not pred(x):
            return False
    return True

On parcourt la liste ; dès qu’un élément ne vérifie pas, on renvoie False. Si la boucle se termine, tous vérifient.

b) Récursif pur (fonctionnel) :

def forall(pred, L):
    return True if L == [] else pred(L[0]) and forall(pred, L[1:])

Cas de base : la liste vide → True (tous les éléments d’un ensemble vide vérifient toute propriété). Appel récursif : le premier élément doit vérifier le prédicat et tous les suivants aussi.

c) Avec map et all :

def forall(pred, L):
    return all(map(pred, L))

map(pred, L) applique pred à chaque élément, produisant une séquence de booléens. all renvoie True si tous les booléens sont True.

d) Avec compréhension et all :

def forall(pred, L):
    return all(pred(x) for x in L)

Équivalent à la version map, avec un générateur au lieu de map.

e) Avec filter et len :

def forall(pred, L):
    return len(list(filter(pred, L))) == len(L)

On filtre les éléments vérifiant le prédicat. Si la liste filtrée a la même longueur que l’originale, tous vérifient.

a) Impératif :

def bons_eleves(eleves):
    resultat = []
    for e in eleves:
        somme = 0
        for n in e["notes"]:
            somme += n
        moyenne = somme / len(e["notes"])
        if moyenne >= 14:
            resultat.append(e["nom"])
    return resultat

Variables modifiables (resultat, somme), boucles for, affectations.

b) Fonctionnel :

moyenne = lambda e: sum(e["notes"]) / len(e["notes"])
bons = list(map(lambda e: e["nom"],
                filter(lambda e: moyenne(e) >= 14, eleves)))

Composition de filter (sélectionner) et map (transformer). Pas de variable modifiable.

En compréhension :

bons = [e["nom"] for e in eleves
        if sum(e["notes"]) / len(e["notes"]) >= 14]

c) Objet :

class Eleve:
    def __init__(self, nom, notes):
        self.nom = nom
        self.notes = notes

    def moyenne(self):
        return sum(self.notes) / len(self.notes)

    def est_bon(self, seuil=14):
        return self.moyenne() >= seuil

objets = [Eleve(e["nom"], e["notes"]) for e in eleves]
bons = [e.nom for e in objets if e.est_bon()]

Données et traitements encapsulés dans la classe.

d) La compréhension de liste (fonctionnel pythonique) est la plus courte et souvent la plus lisible en Python. L’approche objet est la plus facilement testable (on peut tester Eleve.moyenne() et Eleve.est_bon() indépendamment). L’approche impérative est la plus explicite pas à pas, mais la plus verbeuse. Les trois paradigmes produisent le même résultat ; le choix dépend du contexte et de la lisibilité recherchée.