Les modules et les imports

Qu'est-ce qu'un module ?

Définition : Un module est un fichier Python (.py) contenant du code (fonctions, variables, classes…) qu'on peut importer dans d'autres scripts pour le réutiliser. Les classes, qui regroupent des données et les fonctions qui les concernent, sont présentées au chapitre sur les classes et les objets.

Fichier maths_utils.py :

def carre(x):
    return x * x

Fichier programme.py :

import maths_utils
print(maths_utils.carre(5))   # 25

Ce qu'un import charge vraiment

Un import n'est pas une déclaration décorative en tête de fichier : c'est une instruction qui s'exécute, et qui range le contenu du module dans un objet portant son nom.

Le contenu de cette commode se consulte : dir() liste les noms qu'un module met à disposition.

Le bloc suivant est faux exprès : il oublie d'ouvrir le tiroir.

NameError: name 'sqrt' is not defined. L'import a bien réussi : math existe, mais sqrt n'existe que dedans. La correction tient au préfixe : math.sqrt(25).

Où Python va chercher un module

import outils ne dit pas où se trouve outils. Python le cherche, dans un ordre fixe, et s'arrête au premier fichier trouvé. Cet ordre est une liste, visible depuis le programme :

La liste commence toujours par le dossier du fichier lancé, puis vient la bibliothèque standard, puis les paquets installés. Trois conséquences pratiques en découlent :

La première ligne explique l'erreur la plus déroutante du débutant, et l'encadré plus bas la décrit. Le mécanisme n'a rien de mystérieux : ce n'est qu'une liste parcourue dans l'ordre.

Ce que l'import exécute

Un import ne copie pas du texte : il exécute le fichier, de haut en bas, une seule fois. Tout ce qui s'y trouve au niveau du fichier, en dehors des def, tourne à ce moment-là.

C'est ce cache qui rend le second import gratuit, et c'est lui aussi qui fait que modifier un module déjà importé n'a aucun effet tant que l'interpréteur tourne. Dans un carnet Jupyter, où l'interpréteur survit à l'édition, c'est la cause d'une heure perdue à corriger un fichier dont la version chargée ne change pas.

C'est enfin la raison d'être du bloc if __name__ == "__main__": : sans lui, importer un module pour y prendre une fonction exécuterait aussi ses lignes de démonstration.

Les façons d'importer

Python offre plusieurs syntaxes selon ce dont on a besoin. Ces exemples utilisent des modules standards (déjà installés) : on peut donc les exécuter ici même.

Importer tout le module :

Importer un seul élément :

Renommer avec as :

Importer plusieurs éléments :

Les modules standards les plus utiles

Python est « livré piles incluses » : des centaines de modules prêts à l'emploi.

La liste complète est dans la documentation officielle.

Créer ses propres modules

On peut répartir le code dans plusieurs fichiers pour le rendre plus lisible.

Fichier outils.py :

def saluer(nom):
    print(f"Bonjour {nom} !")

def aire_carre(cote):
    return cote ** 2

Fichier main.py :

import outils

outils.saluer("Alice")
print("Aire :", outils.aire_carre(5))

Organiser un projet

La règle tient en une phrase : un fichier par rôle, et un point d'entrée unique.

main.py importe outils et enchaîne les appels. outils.py ne sait pas qu'il existe un main.py et ne l'importe jamais : la dépendance va dans un seul sens, sinon les deux fichiers s'importent l'un l'autre et Python s'y perd.

Quand outils.py devient trop gros, on le coupe en plusieurs fichiers rangés dans un dossier, et l'import prend un point de plus : from calculs.statistiques import moyenne. Le parcours Outils de développement traite en détail de la structure d'un projet, des dépendances et des environnements.

Quand un dossier devient un module : les paquets

Un fichier unique finit par gonfler. Le découpage suivant consiste à ranger plusieurs modules dans un dossier, qui devient lui-même importable : c'est un paquet.

L'import suit alors le chemin, un point par niveau :

from calculs.statistiques import moyenne
from donnees.lecture import charger_csv

import calculs.geometrie as geo
print(geo.aire_cercle(3))

Le fichier __init__.py peut rester vide : sa seule présence suffit à déclarer le dossier comme paquet. Quand il contient quelque chose, c'est en général une poignée d'imports qui raccourcissent l'écriture pour celui qui se sert du paquet, de sorte que from calculs import moyenne fonctionne sans connaître le découpage interne.

La dépendance va dans un seul sens. main.py importe calculs, et calculs n'importe jamais main. Si deux modules s'importent l'un l'autre, le premier chargé s'interrompt au milieu pour charger le second, lequel réclame un nom que le premier n'a pas encore défini. L'erreur, cannot import name ... (most likely due to a circular import), désigne le symptôme et pas la cause. La sortie consiste presque toujours à extraire dans un troisième module ce dont les deux ont besoin.

Au-delà de la bibliothèque standard

Les modules vus jusqu'ici arrivent avec Python. Des dizaines de milliers d'autres se téléchargent, et c'est là que se trouvent les outils du métier :

L'installation passe par pip, depuis le terminal et non depuis le programme :

pip install numpy pandas

Une fois installé, le paquet s'importe comme n'importe quel module. La différence de statut est invisible dans le code, et c'est précisément ce qui piège : un programme qui fonctionne sur une machine échoue sur une autre par ModuleNotFoundError, non parce que le code diffère, mais parce que l'installation diffère.

C'est pourquoi un projet déclare ses dépendances dans un fichier, requirements.txt, et les installe dans un environnement qui lui est propre. Le parcours Outils de développement traite ces deux points, qui deviennent indispensables dès qu'un programme quitte la machine où il est né.

Mettre en pratique

Exercice : le lancer de dés. À l'aide du module random, simuler le lancer de deux dés à six faces, puis afficher les deux résultats et leur somme.