Modules et packages — Importer depuis d'autres fichiers

Les applications Python sont généralement construites en répartissant le travail sur plusieurs fichiers et en les reliant. Cet article parcourt les unités appelées modules et packages, plus comment l'instruction import récupère des fonctionnalités depuis un autre fichier.

Module vs Package vs Bibliothèque

Python organise le code en trois tailles : module → package → bibliothèque. Un module est un seul fichier .py, un package est un dossier de modules, et une bibliothèque est l'échelon supérieur — un paquet distribuable.

Bibliothèque standard vs bibliothèque tierce

Python est livré avec une bibliothèque standard par défaut, et il existe des bibliothèques tierces que tu installes en plus. Les bibliothèques standard comme math, os et json fonctionnent avec un simple import. Les bibliothèques tierces comme pandas ou requests ont besoin de pip install nom_du_package au préalable.

Essaie la bibliothèque standard math.

① Affiche le plafond entier de 1.7 avec math.ceil(1.7).

② Affiche la racine carrée de 3 avec math.sqrt(3).

(Si tu l'exécutes correctement, l'explication apparaît en dessous.)

Importer tes propres modules

Tu peux importer tes propres fichiers .py exactement comme la bibliothèque standard. Quand tu exécutes Python en local, place main.py et le fichier que tu veux importer (math_utility.py) dans le même dossier — c'est tout. Les fichiers du même dossier se chargent avec un simple import math_utility depuis main.py (pas de suffixe .py dans l'instruction d'import).

math_utility.py est attaché à gauche (ouvre-le depuis 📂 Files pour l'inspecter).

① Charge-le avec import math_utility.

② Appelle volontairement add(10, 20) sans le préfixe du module et confirme avec try/except que tu obtiens un NameError — import math_utility ne fait entrer que le nom math_utility lui-même dans la portée de main, donc add n'est pas directement appelable.

③ Ensuite affiche math_utility.add(10, 20) et math_utility.multiply(5, 5) avec le préfixe du nom de module — la bonne façon de les appeler.

import exécute le fichier entier une seule fois

Quand tu écris import math_utility, Python exécute math_utility.py de haut en bas une seule fois. Les définitions de fonctions (def) sont enregistrées en mémoire à ce moment-là, donc tu peux ensuite les appeler comme math_utility.add(...). Les corps de ces fonctions ne s'exécutent pas au moment de l'import — seul le code en dehors de toute fonction (le niveau supérieur du module) s'exécute.

Ne lance pas de tâches lourdes au niveau supérieur du module

Le niveau supérieur désigne le code situé à l'indentation la plus extérieure — en dehors de toute fonction ou classe. Python l'exécute de haut en bas chaque fois que le module est importé. Y placer des tâches lourdes (connexions BD, chargement de fichiers énormes, boucles infinies) signifie que simplement importer le module prend une éternité. Garde la logique lourde à l'intérieur des fonctions et ne laisse au niveau supérieur que les définitions et l'initialisation minimale.

Distinguer exécution directe et import — __name__

Les fichiers Python existent en deux saveurs : les scripts exécutés directement (que tu lances avec python xxx.py) et les modules importés par autre chose. Le même fichier peut jouer l'un ou l'autre rôle, et tu as souvent besoin de savoir lequel se produit — par exemple, « ne lancer un test rapide que si le fichier est exécuté directement ».

Le test utilise la variable spéciale __name__ que Python définit automatiquement. Quand le fichier est exécuté directement, __name__ vaut "__main__". Quand le fichier est importé, __name__ vaut le nom du module (le nom de fichier). Le code à l'intérieur de if __name__ == "__main__": ne s'exécute que dans le premier cas.

# math_utility.py
def add(a, b):
    return a + b


# Test rapide uniquement à l'exécution directe
if __name__ == "__main__":
    print("check:", add(10, 20))   # 30

# Quand un autre fichier fait `import math_utility`,
# le bloc if ci-dessus ne s'exécute pas — seule la fonction add est exposée.

Le fichier joint math_utility_2.py définit une fonction show_name() qui affiche son propre __name__, plus un bloc if __name__ == "__main__": en bas (ouvre-le depuis 📂 Files pour regarder).

① Depuis le côté main, importe math_utility_2 et affiche le __name__ de main.

② Appelle math_utility_2.show_name() et vérifie ce à quoi ressemble __name__ du côté importé.

Combiner plusieurs de tes propres modules

Dans les vraies applications, tu répartis généralement les fonctions dans des fichiers séparés par responsabilité et tu les récupères toutes depuis main.py. Par exemple, les vérifications d'entrée vivent dans validator.py, le formatage d'affichage dans formatter.py. Avec les responsabilités réparties ainsi, les changements de formatage ne touchent que formatter.py — main.py et validator.py restent intacts.

Remplis les fichiers joints validator.py et formatter.py, puis importe-les tous les deux depuis main.py.

① Dans validator.py, implémente is_valid_price(price) — retourne True si price est un int positif, False sinon.

② Dans formatter.py, implémente format_price(price) — prends un int, ajoute une majoration de 5 % avec int(price + price * 0.05), et retourne une chaîne comme "with tax: $1575".

③ Dans main.py, importe les deux. Décide si price = 1500 est valide, formate-le et affiche le résultat.

Cet article a couvert la hiérarchie module / package / bibliothèque, comment import récupère des fonctions depuis d'autres fichiers, ce qui s'exécute au moment de l'import, le motif __name__ == "__main__" pour distinguer exécution directe et import, et la répartition multi-modules où chaque fichier porte une seule responsabilité. Le prochain article creuse les packages et le fichier __init__.py.