Paradigmes de programmation

Introduction

Un paradigme de programmation est une manière de concevoir un programme. Ce n'est pas un langage : un même langage (comme Python) permet d'écrire en plusieurs paradigmes — souvent dans le même fichier. C'est l'objet de l'item [TD04].

Trois paradigmes structurent l'enseignement de la Terminale : impératif, fonctionnel et orienté objet. Connaître les trois ne vous transformera pas en philosophe du code — mais cela vous donnera, devant un problème, plusieurs angles d'attaque, et la capacité de lire des bases de code écrites par d'autres dans leur style natif.

Une analogie culinaire éclaire la distinction. L'impératif ressemble à une recette de cuisine : « prendre une casserole, verser l'eau, allumer le feu, attendre, ajouter le sel… » — une suite d'instructions sur un état qui évolue. Le fonctionnel ressemble à la description du plat fini : « un risotto = un riz arrondi, lié au bouillon, parfumé au safran » — une composition, pas une marche à suivre. L'objet ressemble à un cuisinier qui dispose de méthodes (saler, goûter, flamber) et qui maintient en mémoire l'état de sa préparation.

Trois paradigmes en une phrase

Le même problème, trois fois — la somme d'une liste

Prenons une tâche élémentaire : calculer la somme d'une liste d'entiers.

Style impératif

On parcourt la liste, on accumule dans une variable.

def somme_imperative(liste):
    """Somme par accumulation dans une variable mutable."""
    total = 0                      # état initial
    for x in liste:                # boucle
        total = total + x          # mise à jour de l'état
    return total

print(somme_imperative([1, 2, 3, 4]))   # 10

Clés : variable total qui mute, boucle for explicite, séquence d'instructions qui décrivent comment calculer.

Style fonctionnel

On exprime la somme comme l'application d'une opération de réduction sur la liste.

from functools import reduce
from operator import add

def somme_fonctionnelle(liste):
    """Somme par réduction — pas de variable mutable."""
    return reduce(add, liste, 0)

print(somme_fonctionnelle([1, 2, 3, 4]))   # 10

# Variante encore plus directe :
print(sum([1, 2, 3, 4]))                   # 10 — sum est une fonction native

Clés : aucune affectation, aucune boucle visible, on décrit le résultat comme la réduction de la liste par l'addition à partir de 0. La fonction est pure : pas d'effet de bord, le même argument donne toujours le même résultat.

Style orienté objet

On modélise un objet somme qui porte un état (le total courant) et expose des méthodes pour le faire évoluer.

class Somme:
    """Objet qui accumule une somme par ajouts successifs."""

    def __init__(self):
        self._total = 0

    def ajouter(self, x):
        self._total += x

    def valeur(self):
        return self._total


s = Somme()
for x in [1, 2, 3, 4]:
    s.ajouter(x)
print(s.valeur())              # 10

Clés : la classe Somme encapsule l'état (self._total) et expose un contrat (ajouter, valeur). L'utilisateur ne manipule plus une variable locale, mais un objet qu'on instancie et avec lequel on dialogue.

Comment choisir ?

Pour aller plus loin

D'autres paradigmes existent : logique (Prolog), concurrent (acteurs, Erlang), réactif (flux d'événements). Le programme officiel limite l'étude aux trois principaux. Mais retenez l'idée : un langage n'est qu'un véhicule ; le style que vous y adoptez dépend du paradigme — et de votre maturité de concepteur.