Modularité

Introduction

Un programme sérieux ne tient pas dans un seul fichier. Au-delà de quelques centaines de lignes, il devient illisible et coûteux à maintenir. On découpe alors le code en unités cohérentes — les modules — chacune responsable d'un domaine, chacune documentée et réutilisable.

Cette discipline est l'objet de l'item [TD02]. Elle suppose deux compétences complémentaires : savoir consommer une bibliothèque (comprendre sa documentation, l'utiliser correctement) et savoir produire ses propres modules, documentés à un niveau tel qu'un tiers puisse les utiliser sans lire le code source.

Une bibliothèque, c'est un atelier d'outils prêts à l'emploi : vous n'allez pas refondre un marteau à chaque clou à planter. Documenter votre propre module, c'est laisser un mode d'emploi pour celui qui ouvrira la boîte après vous — souvent vous-même dans six mois.

Modules, packages, bibliothèques

Importer — quatre syntaxes utiles

import math                            # accès via math.sqrt(2)
from math import sqrt                  # accès direct sqrt(2)
from math import sqrt, pi              # plusieurs symboles
import numpy as np                     # alias court

Exploiter la documentation

Toute bibliothèque sérieuse expose trois niveaux de documentation :

1. help(objet) dans l'interpréteur — affiche la docstring de l'objet.
2. La documentation en ligne — référence officielle, tutoriels, exemples.
3. Le code source — pour les cas extrêmes, mais à éviter en première approche.

>>> import math
>>> help(math.sqrt)
Help on built-in function sqrt in module math:

sqrt(x, /)
    Return the square root of x.

Devant une fonction inconnue, le réflexe est help(...) ou ? dans Jupyter, avant Stack Overflow.

Créer son propre module — geom.py

Le meilleur moyen d'apprendre est d'en écrire un. Voici un module minimaliste de géométrie :

# fichier geom.py
"""Module geom — primitives géométriques pour figures simples.

Ce module fournit des fonctions pour calculer l'aire et le périmètre
de figures usuelles (cercle, rectangle, triangle).
"""

from math import pi


def aire_cercle(rayon: float) -> float:
    """Retourne l'aire d'un cercle de rayon donné.

    >>> round(aire_cercle(1), 4)
    3.1416
    """
    assert rayon >= 0, "le rayon doit être positif"
    return pi * rayon ** 2


def perimetre_cercle(rayon: float) -> float:
    """Retourne le périmètre (circonférence) d'un cercle.

    >>> round(perimetre_cercle(1), 4)
    6.2832
    """
    assert rayon >= 0, "le rayon doit être positif"
    return 2 * pi * rayon


def aire_rectangle(largeur: float, hauteur: float) -> float:
    """Retourne l'aire d'un rectangle.

    >>> aire_rectangle(3, 4)
    12
    """
    assert largeur >= 0 and hauteur >= 0, "dimensions positives"
    return largeur * hauteur

L'utiliser depuis un autre script :

# fichier main.py
import geom

print(geom.aire_cercle(2))             # 12.566370614359172
print(geom.aire_rectangle(3, 4))       # 12
help(geom)                             # affiche la docstring du module
help(geom.aire_cercle)                 # affiche la docstring de la fonction

Pour aller plus loin

Un module mature s'accompagne d'un __main__ qui permet de l'exécuter directement (python geom.py), de tests dans un fichier test_geom.py, et d'un README.md qui décrit le projet. Au-delà, on package le tout (pyproject.toml) pour le publier sur PyPI et le rendre installable par pip install.