Aller au contenu

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 :

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

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

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