1. Qu’est-ce qu’un paradigme ?
Un paradigme de programmation est une manière d’organiser et de structurer un programme. Il définit comment on écrit les instructions et comment on manipule les données.
2. Le paradigme impératif
Le programme est vu comme une suite d’instructions exécutées dans l’ordre. Les variables sont modifiées au cours du temps.
def somme(liste):
total = 0
for nbre in liste:
total = total + nbre
return total
- Modification d'une variable locale
- Évolution d'un état interne à la fonction
- Exécution séquentielle des instructions
3. Le paradigme fonctionnel
Le programme est vu comme une composition de fonctions. Chaque fonction transforme des données et renvoie un résultat.
def ajouter(stock, produit, quantite):
nouveau = stock.copy()
nouveau[produit] = nouveau.get(produit, 0) + quantite
return nouveau
- Transformation de données
- Fonctions sans modification globale
- Moins d’effets de bord
4. Effets de bord et paramètres par défaut
En Python, certains effets de bord peuvent être invisibles. Un cas classique concerne les paramètres ayant une valeur par défaut modifiable (liste, dictionnaire…).
Exemple problématique
def ajouter(valeur, liste=[]):
liste.append(valeur)
return liste
print(ajouter(1))
print(ajouter(2))
print(ajouter(3))
Résultat obtenu :
[1]
[1, 2]
[1, 2, 3]
[] est créée une seule fois
lors de la définition de la fonction.
Elle est ensuite réutilisée à chaque appel.
La fonction modifie donc toujours la même liste. Il s’agit d’un effet de bord caché.
Version correcte
def ajouter(valeur, liste=None):
if liste is None:
liste = []
liste.append(valeur)
return liste
print(ajouter(1))
print(ajouter(2))
print(ajouter(3))
Résultat :
[1]
[2]
[3]
None et créer la structure à l’intérieur de la fonction.
4. Le paradigme orienté objet
Le programme est organisé autour d’objets qui regroupent des données et des méthodes.
class Stock:
def __init__(self):
self.produits = {}
def ajouter(self, produit, quantite):
self.produits[produit] = self.produits.get(produit, 0) + quantite
- Encapsulation
- Organisation en classes
- Modélisation d’entités
5. Comment choisir ?
- Problème simple et séquentiel → Impératif
- Traitement de données → Fonctionnel
- Système complexe ou logiciel structuré → Orienté objet
6. Un même problème, trois paradigmes
Problème : on dispose d’une liste de notes.
On veut ajouter 1 point à chaque note sans dépasser 20.
[12, 18, 9] devient [13, 19, 10].
6.1. Version impérative (modification en place)
On décrit les étapes et on modifie directement la liste.
def bonus(notes):
for i in range(len(notes)):
notes[i] = min(notes[i] + 1, 20)
notes = [12, 18, 9]
bonus(notes)
print(notes) # [13, 19, 10]- Exécution séquentielle
- Variable d’index
- État interne (la liste) mis à jour
6.2. Version fonctionnelle (transformation)
On produit une nouvelle liste sans modifier l’originale.
def bonus(notes):
return [min(note + 1, 20) for note in notes]
notes = [12, 18, 9]
nouvelles_notes = bonus(notes)
print(notes) # [12, 18, 9]
print(nouvelles_notes) # [13, 19, 10]- Transformation de données
- Résultat renvoyé
- Pas de modification de la liste d’entrée
6.3. Version orientée objet (modélisation)
On regroupe les données et les actions dans une classe.
class Classe:
def __init__(self, notes):
self.notes = notes
def ajouter_bonus(self):
for i in range(len(self.notes)):
self.notes[i] = min(self.notes[i] + 1, 20)
def afficher(self):
return self.notes
classe = Classe([12, 18, 9])
classe.ajouter_bonus()
print(classe.afficher()) # [13, 19, 10]- Données + méthodes regroupées
- Encapsulation (attributs / méthodes)
- Structure adaptée aux projets plus grands