Les paradigmes de programmation

🌿 Chapitre : Paradigmes de programmation

1️⃣ Introduction : qu’est-ce qu’un paradigme de programmation ?

Un paradigme de programmation est une manière de concevoir et d’organiser un programme. Il correspond à une façon de penser la résolution d’un problème informatique.

Un même langage (comme Python) permet d’utiliser plusieurs paradigmes. Dans un même programme, on peut également mélanger différents paradigmes.

2️⃣ Le paradigme impératif

Le paradigme impératif décrit une suite d’instructions qui modifient l’état du programme.

Utilisation de variables modifiables
Suites d’instructions exécutées dans l’ordre
Boucles et structures conditionnelles

Exemple : calcul d’une somme

On veut calculer la somme des entiers de 1 à 9.


total = 0
for i in range(1, 10):
    total = total + i

print(total)   # affiche 45

La variable total est modifiée à chaque itération : c’est une approche typiquement impérative.

3️⃣ Le paradigme fonctionnel

Le paradigme fonctionnel repose sur l’idée que l’on manipule des fonctions produisant un résultat sans modifier l’extérieur.

Peu ou pas d’effets de bord
Fonctions réutilisables
Résultat dépend uniquement des paramètres

Exemple : version itérative réutilisable

On écrit une fonction qui retourne la somme des entiers pairs jusqu’à n.


def somme_pairs(n):
    total = 0    
    for i in range(n + 1):
        if i % 2 == 0:      # si i est pair
            total = total + i    
    return total

# Appels de la fonction
print(somme_pairs(10))   # affiche 30
print(somme_pairs(4))    # affiche 6

Avantage : la fonction somme_pairs peut être appelée à tout moment dans le programme avec des paramètres différents. Elle ne dépend que de son argument et ne modifie aucune variable globale.

4️⃣ Le paradigme objet (exemple avec les nombres pairs)

On regroupe maintenant les données et les comportements dans une classe.


class CalculateurPairs:    
    def __init__(self, n):
        self.n = n    

    def est_pair(self, nombre):
        return nombre % 2 == 0    

    def somme_pairs(self):
        total = 0        
        for i in range(self.n + 1):
            if self.est_pair(i):
                total = total + i        
        return total

# Instanciation de la classe
calcul = CalculateurPairs(10)

# Appel de la méthode
print(calcul.somme_pairs())   # affiche 30

Explication :

n devient un attribut de l’objet
est_pair et somme_pairs sont des méthodes
On crée un objet calcul grâce à l’instanciation
On appelle la méthode avec calcul.somme_pairs()

Ici, le calcul est encapsulé dans un objet. On pourrait créer plusieurs objets avec des valeurs différentes :


c1 = CalculateurPairs(10)
c2 = CalculateurPairs(20)

print(c1.somme_pairs())   # 30
print(c2.somme_pairs())   # 110

5️⃣ Mélange des paradigmes

Dans un même programme, on peut combiner plusieurs paradigmes.


class Rectangle:
    
    def __init__(self, largeur, hauteur):
        self.largeur = largeur
        self.hauteur = hauteur

def aire(rectangle):
    return rectangle.largeur * rectangle.hauteur

# Instanciation (objet)
r = Rectangle(4, 5)

# Appel d'une fonction (fonctionnel)
print(aire(r))   # affiche 20

Ici :

La classe Rectangle relève du paradigme objet
La fonction aire relève du paradigme fonctionnel
Les instructions d’exécution relèvent du paradigme impératif

6️⃣ Choisir un paradigme selon le problème

Calculs simples → impératif
Transformations de données → fonctionnel
Modélisation d’un système complexe → objet

Le choix dépend :

de la nature du problème
de la lisibilité recherchée
de la maintenance future du programme

7️⃣ À retenir

Un paradigme est une manière de concevoir un programme
Impératif : suite d’instructions modifiant des variables
Fonctionnel : fonctions réutilisables sans effet de bord
Objet : organisation autour d’objets et de classes
Un même langage peut supporter plusieurs paradigmes
On peut mélanger plusieurs paradigmes dans un même programme