Chapitre 1 - Partie 3 : Modularité et paradigmes de programmation

Programme officiel (B.O.)

B.O. spécial n° 8 du 25 juillet 2019 - NSI Terminale

Contenus	Capacités attendues	Commentaires
Modularité.	Utiliser des API (Application Programming Interface) ou des bibliothèques. Exploiter leur documentation. Créer des modules simples et les documenter.
Paradigmes de programmation.	Distinguer sur des exemples les paradigmes impératif, fonctionnel et objet. Choisir le paradigme de programmation selon le champ d'application d'un programme.	Avec un même langage de programmation, on peut utiliser des paradigmes différents. Dans un même programme, on peut utiliser des paradigmes différents.

---

1. La modularité

1.1 Pourquoi découper en modules ?

Un programme de grande taille, écrit dans un seul fichier, devient vite illisible et difficile à maintenir. La modularité consiste à découper le code en modules indépendants, chacun responsable d'une fonctionnalité précise.

Avantage	Description
Lisibilité	Chaque module a un rôle clair et limité
Réutilisabilité	Un module peut être utilisé dans plusieurs projets
Maintenance	On peut modifier un module sans toucher aux autres
Travail en équipe	Chaque développeur travaille sur des modules différents
Tests	Chaque module peut être testé indépendamment

1.2 Les modules en Python

Un module Python est simplement un fichier .py contenant des fonctions, des classes et des variables.

Créer un module geometrie.py :

"""Module de calculs géométriques."""

import math

def aire_cercle(rayon):
    """Calcule l'aire d'un cercle de rayon donné."""
    return math.pi * rayon ** 2

def perimetre_cercle(rayon):
    """Calcule le périmètre d'un cercle de rayon donné."""
    return 2 * math.pi * rayon

def aire_rectangle(longueur, largeur):
    """Calcule l'aire d'un rectangle."""
    return longueur * largeur

Utiliser le module dans un autre fichier :

import geometrie

print(geometrie.aire_cercle(5))        # 78.53981633974483
print(geometrie.perimetre_cercle(5))   # 31.41592653589793

Ou en important des fonctions spécifiques :

from geometrie import aire_cercle, aire_rectangle

print(aire_cercle(5))
print(aire_rectangle(4, 3))

1.3 Le mécanisme __name__

Pour qu'un module puisse être à la fois importé et exécuté directement :

geometrie.py

def aire_cercle(rayon):
    import math
    return math.pi * rayon ** 2

if __name__ == "__main__":
    # Ce code ne s'exécute que si le fichier est lancé directement
    print("Test :", aire_cercle(5))

---

2. Les API et bibliothèques

2.1 Qu'est-ce qu'une API ?

Une API (Application Programming Interface) est un ensemble de fonctions, classes et constantes mises à disposition par une bibliothèque ou un service. L'API définit ce que l'on peut faire (l'interface) sans révéler comment c'est fait (l'implémentation).

2.2 La bibliothèque standard de Python

Python possède une riche bibliothèque standard (modules inclus par défaut) :

Module	Fonctionnalité
math	Fonctions mathématiques (sqrt, cos, pi, etc.)
random	Génération de nombres aléatoires
os	Interaction avec le système d'exploitation
csv	Lecture/écriture de fichiers CSV
sqlite3	Interface avec les bases de données SQLite
json	Manipulation de données JSON
datetime	Gestion des dates et heures
turtle	Dessin graphique (tortue Logo)

2.3 Exploiter la documentation

Pour utiliser une API, on consulte sa documentation :

help(math.sqrt)          # aide intégrée
dir(math)                # liste des fonctions disponibles
math.sqrt.__doc__        # docstring de la fonction

La documentation en ligne de Python (docs.python.org) est la référence officielle.

2.4 Bibliothèques tierces

Au-delà de la bibliothèque standard, des milliers de bibliothèques sont disponibles via pip :

Bibliothèque	Usage
matplotlib	Graphiques et visualisation
numpy	Calcul numérique
flask	Applications Web
pillow	Traitement d'images
requests	Requêtes HTTP

---

3. Les paradigmes de programmation

3.1 Qu'est-ce qu'un paradigme ?

Un paradigme de programmation est une manière de concevoir et d'organiser un programme. C'est un style, une philosophie de programmation. Python est un langage multi-paradigme : il permet d'utiliser différents styles dans un même programme.

3.2 Le paradigme impératif

Le programme est une séquence d'instructions qui modifient l'état du système (variables, mémoire). On décrit comment faire, étape par étape.

# Calculer la somme des carrés de 1 à n (style impératif)
def somme_carres_imperatif(n):
    resultat = 0
    for i in range(1, n + 1):
        resultat += i ** 2
    return resultat

Caractéristiques :

• Variables qui changent de valeur (affectation) ;
• Structures de contrôle (if, for, while) ;
• Instructions exécutées dans l'ordre.

3.3 Le paradigme fonctionnel

Le programme est une composition de fonctions pures, sans effet de bord. On décrit quoi calculer plutôt que comment.

# Calculer la somme des carrés de 1 à n (style fonctionnel)
def somme_carres_fonctionnel(n):
    return sum(map(lambda x: x ** 2, range(1, n + 1)))

Ou avec une compréhension :

def somme_carres_fonctionnel(n):
    return sum(x ** 2 for x in range(1, n + 1))

Caractéristiques :

• Fonctions pures : le résultat ne dépend que des arguments, pas d'état extérieur ;
• Pas d'effets de bord : la fonction ne modifie rien en dehors d'elle ;
• Fonctions d'ordre supérieur : map, filter, reduce, fonctions en arguments ;
• Immutabilité : on évite de modifier les variables.

Outils fonctionnels en Python :

Fonction	Description	Exemple
map(f, iterable)	Applique f à chaque élément	list(map(str, [1, 2, 3])) → ['1', '2', '3']
filter(f, iterable)	Garde les éléments où f renvoie True	list(filter(lambda x: x > 0, [-1, 2, -3, 4])) → [2, 4]
lambda	Fonction anonyme	carre = lambda x: x ** 2

3.4 Le paradigme objet

Le programme est organisé en objets qui encapsulent des données (attributs) et des comportements (méthodes). On modélise le monde réel.

# Calculer avec des objets (style objet)
class Statistiques:
    def __init__(self, donnees):
        self.donnees = donnees

    def somme_carres(self):
        return sum(x ** 2 for x in self.donnees)

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

stats = Statistiques([1, 2, 3, 4, 5])
print(stats.somme_carres())    # 55
print(stats.moyenne())         # 3.0

Caractéristiques :

• Encapsulation : données et traitements regroupés dans des objets ;
• Abstraction : l'utilisateur n'a pas besoin de connaître le fonctionnement interne ;
• Classes et instances : la classe est le modèle, l'objet est l'exemplaire.

3.5 Comparaison des trois paradigmes

Le même problème (filtrer les nombres pairs et les mettre au carré) résolu dans les trois styles :

Impératif

def carres_pairs_imperatif(nombres):
    resultat = []
    for n in nombres:
        if n % 2 == 0:
            resultat.append(n ** 2)
    return resultat

Fonctionnel

def carres_pairs_fonctionnel(nombres):
    return list(map(lambda x: x ** 2,
                    filter(lambda x: x % 2 == 0, nombres)))

Objet

class TraitementNombres:
    def __init__(self, nombres):
        self.nombres = nombres

    def carres_pairs(self):
        return [n ** 2 for n in self.nombres if n % 2 == 0]

t = TraitementNombres([1, 2, 3, 4, 5, 6])
print(t.carres_pairs())    # [4, 16, 36]

3.6 Choisir le bon paradigme

Paradigme	Adapté à
Impératif	Scripts simples, automatisation, calcul séquentiel
Fonctionnel	Traitement de données, transformations, calcul scientifique
Objet	Applications complexes, modélisation du monde réel, interfaces graphiques

En pratique

Un bon programme Python mélange souvent les paradigmes : des classes (objet) dont les méthodes utilisent des boucles (impératif) et des compréhensions de liste (fonctionnel).

---

À retenir

Concept	Description
Module	Fichier Python contenant des fonctions/classes réutilisables
API	Interface publique d'une bibliothèque (fonctions, classes disponibles)
__name__	Vaut "__main__" si le fichier est exécuté directement
Impératif	Séquence d'instructions modifiant l'état (for, while, affectation)
Fonctionnel	Composition de fonctions pures, sans effet de bord (map, filter, lambda)
Objet	Objets encapsulant données et comportements (classes, méthodes)
Multi-paradigme	Python permet de mélanger les paradigmes dans un même programme