Langage et 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