Modules, paquets et visite de la bibliothèque standard Python

Tout fichier Python intéressant que vous lirez commence par des instructions import, que vous avez jusqu'ici tapées en toute confiance. Cette leçon lève le voile. Vous apprendrez ce qu'est réellement un module, comment répartir votre propre code sur plusieurs fichiers, ce que sont les packages et pip, puis vous suivrez une visite guidée de la bibliothèque standard, l'immense collection de modules livrée avec Python. Le célèbre slogan du langage est « batteries incluses », et cette leçon est celle où vous ouvrez le compartiment à piles.

La visite est délibérément pratique. Plutôt que de cataloguer des centaines de modules, nous en visitons sept que vous utiliserez chaque semaine : math et random, datetime, collections, pathlib, os, et un aperçu de json en prévision de la partie 11, chacun avec les trois ou quatre fonctions qui concentrent l'essentiel de leur valeur. L'objectif n'est pas la mémorisation, mais la géographie : savoir ce qui existe et où, pour que le mois prochain, face à un vrai problème, vous utilisiez l'outil intégré au lieu de le réinventer maladroitement.

1. Ce que fait réellement import

Un module est simplement un fichier Python. Quand vous écrivez import math, Python trouve le fichier, l'exécute une fois, du début à la fin, et lie l'espace de noms résultant au nom math ; chaque fonction et variable définie dans ce fichier est désormais accessible via le point. Exécutez à nouveau import math et rien ne se réexécute, car Python met en cache les modules chargés. C'est tout le mécanisme, et cela explique les trois styles d'importation que vous rencontrerez : importer le module et utiliser des noms qualifiés, importer des noms spécifiques depuis celui-ci, ou les renommer à l'arrivée avec as.

import math                      # qualified: clearest for readers
print(math.sqrt(225))            # 15.0

from math import pi, ceil        # direct names: fine for a few favorites
print(ceil(pi))                  # 4

import datetime as dt            # rename: common for long module names
print(dt.date.today().year)

Un conseil de style fiable pour le reste de votre carrière : préférez la forme qualifiée pour tout ce qui est ambigu, importez directement une poignée de noms quand ils sont sans équivoque, et n'écrivez jamais from module import *, qui déverse des noms inconnus dans votre fichier et oblige le prochain lecteur à deviner d'où vient chaque chose. Les imports se placent en haut du fichier, bibliothèque standard d'abord, packages installés ensuite, vos propres modules en dernier, avec une ligne vide entre les groupes ; c'est la première chose que les relecteurs regardent, par pure habitude.

2. Vos propres modules et la garde principale

Répartir votre code sur plusieurs fichiers est le même mécanisme à l'envers. Placez les fonctions connexes dans helpers.py, et tout fichier dans le même dossier peut importer helpers et utiliser helpers.tax_due(). Le piège que tout apprenant rencontre : importer un fichier l'exécute, y compris ses impressions de test. La solution est l'idiome le plus célèbre de Python. L'interpréteur définit la variable spéciale __name__ à "__main__" uniquement dans le fichier que vous avez réellement exécuté ; dans les fichiers importés, elle contient le nom du module. Protéger votre code réservé au script derrière cette vérification rend chaque fichier à la fois importable et exécutable en toute sécurité.

# helpers.py
def tax_due(income):
    return income * 0.12

def main():
    print(f"demo: {tax_due(1_000_000):,.0f}")

if __name__ == "__main__":
    main()        # runs only via: python3 helpers.py
                  # silent when another file does: import helpers

Un package est l'échelon supérieur : un dossier de modules. Là où les modules organisent les fonctions, les packages organisent les modules, et la syntaxe d'importation ajoute simplement des points : from myproject.billing import tax. Le monde des bibliothèques tierces fonctionne de manière identique ; pip install requests télécharge un package depuis le Python Package Index dans votre environnement, et à partir de là, import requests fonctionne comme n'importe quel autre import. L'habitude professionnelle qui accompagne pip est l'environnement virtuel, un dossier de packages installés par projet créé avec python3 -m venv .venv, afin que les projets ne puissent pas se battre pour les versions. Quand vous aurez terminé ce parcours, le guide moderne de configuration Python avec uv dans notre série avancée montre l'état de l'art actuel pour l'outillage de projet.

3. La visite, premier arrêt : math, random et datetime

math contient les fonctions que l'arithmétique a oubliées : racines carrées, logarithmes, trigonométrie, constantes pi et e, ainsi que floor et ceil. random fournit du hasard contrôlé : random() pour un flottant entre 0 et 1, randint pour les dés, choice pour piocher dans une séquence, shuffle et sample pour les loteries et les quiz ; le mini-projet Générateur de mot de passe de l'application Learn Python est construit presque entièrement avec random.choice sur des jeux de caractères. datetime gère le domaine vraiment ardu du temps : la date du jour, des instants précis et l'arithmétique avec timedelta, si bien que des questions comme « combien de jours avant l'examen » deviennent une soustraction.

import math, random
from datetime import date, timedelta

print(math.sqrt(2) * math.pi)            # numbers beyond arithmetic
print(random.randint(1, 6))              # a die roll
print(random.choice(["red", "green", "blue"]))

today = date(2026, 6, 13)
exam = date(2026, 7, 20)
print((exam - today).days, "days left")  # 37 days left
print(today + timedelta(weeks=2))        # 2026-06-27

4. Deuxième arrêt : collections, les évolutions de dict

Vous souvenez-vous de la boucle de comptage de mots que vous avez construite à la main dans la Partie 5 ? La bibliothèque standard attendait que vous appreniez d'abord le principe. collections.Counter compte n'importe quel itérable en un seul appel et répond à la question évidente qui suit avec most_common. Son cousin defaultdict supprime complètement la gymnastique des clés manquantes : dites-lui quoi créer au premier accès, et le regroupement d'enregistrements devient une boucle de deux lignes. Ces deux-là couvrent une part absurde du traitement quotidien des données, et reconnaître leurs cas d'usage au premier coup d'œil est un petit super-pouvoir professionnel.

from collections import Counter, defaultdict

words = "learn python by doing then doing more python".split()
counts = Counter(words)
print(counts.most_common(2))     # [('python', 2), ('doing', 2)]

students = [("A", "Amina"), ("B", "Zane"), ("A", "Ruwan")]
by_grade = defaultdict(list)
for grade, name in students:
    by_grade[grade].append(name)  # no key check needed, ever
print(dict(by_grade))             # {'A': ['Amina', 'Ruwan'], 'B': ['Zane']}

5. Troisième arrêt : pathlib et os, votre passeport pour le système de fichiers

La Partie 7 ouvrait des fichiers par leur simple nom ; les vrais programmes ont besoin de construire des chemins, de créer des dossiers, de vérifier l'existence et de parcourir des arborescences, sous Windows comme sous Unix, où même le sens de la barre oblique diffère. pathlib résout tout cela avec un seul objet élégant. Un Path accepte l'opérateur slash pour la concaténation, connaît son propre nom, son stem et son suffixe, peut se lire et s'écrire lui-même en un seul appel, et peut utiliser glob pour trouver des fichiers correspondants. Son compagnon plus ancien os détient encore les variables d'environnement et quelques informations système, mais pour tout ce qui touche aux chemins, pathlib est la réponse moderne et la seule que ce cours utilise.

from pathlib import Path

base = Path("project")
(base / "data").mkdir(parents=True, exist_ok=True)

report = base / "data" / "report.txt"     # / joins paths on every OS
report.write_text("quarterly numbers\n")  # open/write/close in one call

print(report.exists())                    # True
print(report.suffix, report.stem)         # .txt report
for p in base.rglob("*.txt"):             # walk the whole tree
    print(p, p.stat().st_size, "bytes")

Cette ligne avec rglob mérite une pause : elle visite récursivement chaque fichier correspondant sous un dossier, paresseusement, un par un, quelle que soit la taille de l'arborescence. Le mécanisme qui rend cela possible, les itérateurs, est précisément le sujet de la Partie 9, et pathlib sera votre premier bénéficiaire quotidien de sa compréhension. En attendant, os.environ, une vue de type dict des variables d'environnement, est la façon dont les vrais programmes reçoivent des secrets et des paramètres sans les coder en dur, une pratique qui devient cruciale dans les leçons de déploiement de notre série avancée.

Un dernier module du quotidien complète ce tour d'horizon : sys, et plus précisément sys.argv, la liste des arguments de ligne de commande avec lesquels votre script a été lancé. python3 rapport.py notes.txt 2026 place ces chaînes dans argv[1] et argv[2], et soudain vos scripts acceptent des entrées sans modifier le code, la différence entre un programme que l'on réutilise et un que l'on ne cesse de réécrire. Pour tout ce qui dépasse deux arguments positionnels, argparse de la bibliothèque standard construit des interfaces correctes avec des options et un texte d'aide, et c'est exactement l'amélioration à adopter quand argv commence à sembler étriqué.

gradebook.py   (180 lines, everything)

gradebook/
  parsing.py     # read_grades(), clean_row()
  reporting.py   # averages(), render_table()

gradebook/
  __init__.py
  parsing.py
  reporting.py

# main.py
from gradebook.parsing import read_grades
from gradebook.reporting import render_table

if __name__ == "__main__":
    render_table(read_grades("grades.txt"))

python3 main.py
Amina   87
Zane    91
average: 85.0

6. Pratique : un organiseur de fichiers

Le bac à sable ci-dessous construit une version miniature d'un script vraiment utile : il crée un dossier en désordre rempli de fichiers, puis les organise dans des sous-dossiers par extension, en comptant au fur et à mesure avec Counter. C'est de l'automatisation réelle, du genre de celles que les gens écrivent pour dompter leur dossier de téléchargements, adaptée à l'environnement sandbox du navigateur. Les exercices l'enrichissent avec des horodatages datetime et un mode dry-run, la fonction de sécurité que tout script de déplacement de fichiers devrait avoir.

7. Récapitulatif et suite

Les imports n'ont plus de secret : les modules sont des fichiers exécutés une fois et mis en cache, les packages sont des dossiers, pip et les environnements virtuels gèrent le monde extérieur, et votre propre code peut être proprement découpé avec la garde main qui protège le comportement du script. La visite guidée vous a donné une géographie pratique de math, random, datetime, Counter, defaultdict, pathlib et os.environ, les modules qui gagnent leur vie chaque semaine dans le travail réel.

La suite est la leçon la plus satisfaisante intellectuellement du parcours intermédiaire : Partie 9, itérateurs et générateurs, qui explique les rouages derrière chaque boucle for que vous avez écrite et vous apprend à traiter des données illimitées en mémoire constante avec yield. Les leçons Modules et Collections dans l'application Learn Python ci-dessous ajoutent des quiz de répétition espacée, et le parcours complet se trouve sur le hub de la série.

Pratiquez en mobilité

Learn Python, l'application Android gratuite

Chaque sujet de cette série est aussi dans l'application : leçons courtes, exemples exécutables, quiz, mini-projets et un environnement Python hors ligne qui fonctionne sur votre téléphone.

Disponible sur Google Play Voir la page de l'application