Modules et imports Python : import, from-import, pip et packages

Un fichier, c'est un module

Une fois que ton code Python dépasse un seul script, tu voudras le découper en plusieurs fichiers. Le système de modules de Python est simple : n'importe quel fichier .py est automatiquement un module, importable par son nom.

Disons que tu as un fichier util.py :

# util.py
def greet(name):
    return f"Hello, {name}"

PI = 3.14159

Depuis un autre fichier dans le même répertoire — main.py — tu peux l'utiliser :

# main.py
import util

print(util.greet("Ada"))
print(util.PI)

Lance python3 main.py et Python trouve util.py, l'exécute une fois, et expose tout ce qui est défini au niveau racine (fonctions, variables, classes) comme attributs du module util.

Les trois formes d'import

Importer le module entier. Les choses à l'intérieur sont accessibles via le nom du module :

Importer des noms spécifiques. Ils deviennent directement disponibles :

Importer avec un alias. Utile quand le nom du module est long ou quand deux modules partagent un nom :

import numpy as np
import pandas as pd

# Maintenant utilise np.array(...), pd.DataFrame(...), etc.

Il y a une quatrième forme, from math import *, qui déverse tout dans ton espace de noms. Évite-la en dehors de l'expérimentation en REPL — ça rend impossible de dire d'où vient un nom, et ça crée des collisions de noms silencieuses.

Quand les imports s'exécutent

Python exécute le code racine d'un module importé une fois, la première fois qu'il est importé dans un programme donné. Les imports suivants du même module renvoient la version déjà chargée. Donc ceci :

# setup.py
print("setup module loading...")
VALUE = 42

# main.py
import setup
import setup  # importé deux fois — mais "loading" ne s'affiche qu'une fois
print(setup.VALUE)

Affiche "setup module loading..." une seule fois. Ça compte : si tu mets des effets de bord (comme ouvrir un fichier ou afficher) au niveau racine du module, ils arrivent au moment de l'import, ce qui n'est généralement pas ce que tu veux. Mets-les dans des fonctions.

La bibliothèque standard

Python est livré avec une grande bibliothèque standard de modules. Tu en as déjà vu quelques-uns. Certains que tu utiliseras sans arrêt :

• math — sqrt, sin, log, constantes comme pi et e.
• random — nombres aléatoires, choix, mélange.
• datetime — dates et heures.
• json — lire/écrire du JSON.
• os, os.path — chemins et opérations sur le système de fichiers.
• pathlib — gestion moderne des chemins, souvent plus sympa que os.path.
• re — expressions régulières.
• collections — types de collections spécialisés (Counter, defaultdict, deque, etc.).
• itertools, functools — helpers d'itérateurs et de fonctions.
• csv — lire et écrire des fichiers CSV.

La bibliothèque standard est déjà installée — rien à pip installer.

Packages tiers et pip

Pour tout ce que la bibliothèque standard ne couvre pas, le Python Package Index (PyPI) héberge des centaines de milliers de packages. Installe-les avec pip :

pip install requests
pip install pandas
pip install --upgrade requests
pip uninstall requests

Une fois installés, ils s'importent comme n'importe quoi d'autre :

import requests

response = requests.get("https://api.example.com/data")
print(response.status_code)

Quelques conseils pour gérer ça sainement :

Utilise des environnements virtuels

Tout installer globalement mène à la douleur. Différents projets ont besoin de différentes versions ; certains packages dépendent de versions Python spécifiques ; les installations globales demandent des droits admin sur certains systèmes. Un environnement virtuel est une installation Python isolée juste pour un projet :

python3 -m venv .venv
source .venv/bin/activate    # macOS/Linux
.venv\Scripts\activate       # Windows

pip install requests

Tant que le venv est activé, pip installe dans le dossier du projet, pas sur ton système. Désactive avec deactivate quand tu as fini.

Épingle tes dépendances

Enregistre la liste des packages installés pour que d'autres (y compris toi plus tard) puissent recréer le même environnement :

pip freeze > requirements.txt

Puis plus tard :

pip install -r requirements.txt

Des outils comme Poetry, pipenv et uv gèrent ça plus ergonomiquement, mais le workflow simple pip + requirements.txt est toujours bien pour apprendre.

Écrire tes propres modules

Une fois que tu as des fonctions à réutiliser à travers plusieurs fichiers, mets-les dans leur propre module. Conventions de nommage :

• Les noms de fichiers devraient être en lower_snake_case.py.
• Les fonctions et variables au niveau module aussi en lower_snake_case.
• Les classes utilisent PascalCase.

# shopping.py
PRICES = {"apple": 0.50, "bread": 2.00}

def total(items):
    return sum(PRICES[item] for item in items)

# main.py
from shopping import total, PRICES

print(total(["apple", "bread"]))
print(PRICES)

Si deux fichiers du même dossier s'importent l'un l'autre, tu peux accidentellement créer un import circulaire. Le correctif habituel, c'est de déplacer le code partagé dans un troisième fichier importé par les deux.

Packages : dossiers de modules

Une fois que tu as plus d'une poignée de modules, regroupe-les dans un package — un dossier avec un fichier __init__.py dedans :

myproject/
├── main.py
└── utils/
    ├── __init__.py
    ├── text.py
    └── numbers.py

Puis :

from utils.text import slugify
from utils import numbers

print(slugify("Hello, World"))
print(numbers.mean([1, 2, 3]))

Le __init__.py peut être vide ; c'est sa présence qui fait d'utils un package. Python moderne supporte aussi les « namespace packages » sans __init__.py, mais pour débuter, la version explicite est plus claire.

Une petite checklist quand les imports cassent

• « ModuleNotFoundError: No module named X ». Soit le package n'est pas installé, soit tu lances Python depuis un interpréteur différent de celui contre lequel tu as fait pip install. Dans un venv, assure-toi que le venv est activé.
• « ImportError: cannot import name Y from X ». Le module existe, mais le nom que tu as demandé n'y est pas. Vérifie les fautes de frappe et regarde le contenu réel du module.
• « Circular import ». Deux modules s'importent l'un l'autre. Déplace le code partagé dans un troisième module.

Ensuite : installer des packages tiers

Tes propres modules te mènent loin, mais la plupart des vrais projets tirent aussi des bibliothèques de PyPI — requests, pandas, un framework de test. La prochaine page couvre pip, comment installer des packages proprement, et comment enregistrer les dépendances de ton projet.