Qu'est-ce qu'un module en Python ?

Qu'est-ce qu'un module en Python ?

En Python, un module est un fichier contenant du code Python — des fonctions, des classes, des variables et des instructions exécutables — que vous pouvez réutiliser dans d'autres programmes. Un module porte l'extension .py et constitue l'une des briques fondamentales de l'organisation du code en Python. Si vous souhaitez maîtriser les modules et bien d'autres concepts essentiels, notre formation complète sur Python vous guidera pas à pas.

Le système de modules permet de découper un programme volumineux en fichiers plus petits, plus lisibles et plus faciles à maintenir. Au lieu de tout écrire dans un seul fichier, vous regroupez les fonctionnalités liées dans des modules distincts, puis vous les importez là où vous en avez besoin. C'est le cœur même de la modularité en programmation.

Définition détaillée d'un module

Un module est une unité logique de code qui encapsule des définitions et des instructions. Python distingue trois grandes catégories de modules :

Lorsque vous importez un module, Python exécute tout le code contenu dans ce fichier une seule fois, puis met le résultat en cache. Les importations suivantes du même module réutilisent ce cache, ce qui est à la fois efficace et performant.

Un module peut contenir :

• Des fonctions définies avec le mot-clé def
• Des classes définies avec le mot-clé class
• Des variables et des constantes
• Du code exécutable (qui s'exécute lors de l'importation)
• Des docstring pour documenter le module

Importer un module en Python

Python offre plusieurs syntaxes pour importer un module. Chacune a ses avantages et ses cas d'utilisation. Voyons-les en détail.

L'instruction import

La façon la plus simple d'importer un module est d'utiliser le mot-clé import suivi du nom du module :

import math

# Utilisation avec le préfixe du module
resultat = math.sqrt(144)
print(resultat)  # 12.0

pi = math.pi
print(pi)  # 3.141592653589793

Avec cette syntaxe, vous devez toujours préfixer les éléments du module par son nom (ici math.). C'est la méthode la plus explicite et celle qui évite les conflits de noms.

L'instruction from ... import

Si vous n'avez besoin que de certains éléments d'un module, vous pouvez les importer directement :

from math import sqrt, pi

# Utilisation directe, sans préfixe
resultat = sqrt(144)
print(resultat)  # 12.0
print(pi)  # 3.141592653589793

Cette syntaxe est plus concise, mais peut entraîner des conflits si deux modules exportent des noms identiques.

Importer avec un alias

Vous pouvez renommer un module lors de l'importation grâce au mot-clé as :

import numpy as np
import pandas as pd

tableau = np.array([1, 2, 3, 4, 5])
print(tableau.mean())  # 3.0

Les alias comme np pour NumPy ou pd pour Pandas sont des conventions très répandues dans la communauté Python.

Importer tous les éléments avec *

from math import *

# Tous les éléments de math sont accessibles directement
print(sqrt(25))  # 5.0
print(cos(0))    # 1.0

Notez que la variable __all__ permet de contrôler quels éléments sont exportés lorsqu'un utilisateur utilise from module import *.

Créer son propre module

Créer un module en Python est extrêmement simple : il suffit de créer un fichier .py et d'y écrire du code. Voyons un exemple concret.

Étape 1 : Créer le fichier du module

Créez un fichier nommé calculatrice.py :

"""Module calculatrice - Opérations mathématiques de base."""

PI = 3.14159265358979

def additionner(a, b):
    """Retourne la somme de a et b."""
    return a + b

def soustraire(a, b):
    """Retourne la différence entre a et b."""
    return a - b

def multiplier(a, b):
    """Retourne le produit de a et b."""
    return a * b

def diviser(a, b):
    """Retourne le quotient de a par b."""
    if b == 0:
        raise ValueError("Division par zéro impossible")
    return a / b

Étape 2 : Utiliser le module

Dans un autre fichier Python situé dans le même répertoire, vous pouvez maintenant importer et utiliser votre module :

import calculatrice

resultat = calculatrice.additionner(10, 5)
print(resultat)  # 15

quotient = calculatrice.diviser(20, 4)
print(quotient)  # 5.0

print(calculatrice.PI)  # 3.14159265358979

Vous pouvez également utiliser from ... import :

from calculatrice import additionner, diviser

print(additionner(7, 3))  # 10
print(diviser(15, 3))     # 5.0

La variable __name__ et le pattern main

La variable spéciale __name__ joue un rôle essentiel dans les modules. Lorsque Python exécute un fichier directement, il attribue la valeur "__main__" à __name__. Lorsque le fichier est importé comme module, __name__ prend la valeur du nom du module.

Ce mécanisme permet de créer du code qui ne s'exécute que lorsque le fichier est lancé directement :

# calculatrice.py

def additionner(a, b):
    return a + b

def soustraire(a, b):
    return a - b

if __name__ == "__main__":
    # Ce bloc ne s'exécute que si le fichier est lancé directement
    print("Tests de la calculatrice :")
    print(additionner(2, 3))   # 5
    print(soustraire(10, 4))   # 6
    print("Tous les tests passent !")

Les packages : des modules dans des dossiers

Lorsque votre projet grandit, vous aurez besoin d'organiser vos modules dans des dossiers. En Python, un dossier contenant un fichier __init__ est appelé un package.

Voici une structure de package typique :

mon_projet/
│
├── main.py
└── utils/
    ├── __init__.py
    ├── texte.py
    ├── math_utils.py
    └── fichiers.py

Le fichier __init__.py peut être vide ou contenir du code d'initialisation du package. Il indique à Python que le dossier doit être traité comme un package :

# utils/__init__.py
from .texte import nettoyer_texte
from .math_utils import calculer_moyenne

__all__ = ["nettoyer_texte", "calculer_moyenne"]

Vous pouvez ensuite importer depuis le package :

# main.py
from utils import nettoyer_texte, calculer_moyenne
from utils.fichiers import lire_fichier

texte_propre = nettoyer_texte("  Bonjour le monde  ")
moyenne = calculer_moyenne([10, 20, 30])

Les modules intégrés les plus utiles

Python est livré avec une bibliothèque standard extrêmement riche. Voici les modules intégrés les plus couramment utilisés :

Voyons un exemple concret avec plusieurs modules intégrés :

import os
import json
import datetime

# Vérifier si un fichier existe
if os.path.exists("config.json"):
    # Lire et parser le fichier JSON
    with open("config.json", "r") as f:
        config = json.load(f)
    print(f"Configuration chargée : {config}")
else:
    # Créer une configuration par défaut
    config = {
        "app_name": "MonApp",
        "version": "1.0",
        "date_creation": str(datetime.datetime.now())
    }
    with open("config.json", "w") as f:
        json.dump(config, f, indent=4)
    print("Configuration par défaut créée")

Installer et utiliser des modules tiers

Au-delà de la bibliothèque standard, l'écosystème Python dispose de centaines de milliers de modules tiers disponibles sur PyPI (Python Package Index). Vous les installez avec pip :

# Installation depuis le terminal
pip install requests
pip install numpy pandas
pip install flask

Une fois installé, un module tiers s'utilise exactement comme un module intégré :

import requests

reponse = requests.get("https://api.github.com")
if reponse.status_code == 200:
    donnees = reponse.json()
    print(f"API GitHub accessible")
else:
    print(f"Erreur : {reponse.status_code}")

Comment Python trouve les modules

Lorsque vous écrivez import mon_module, Python cherche le module dans un ordre précis :

1. Le cache des modules : si le module a déjà été importé, Python le récupère depuis sys.modules.
2. Les modules intégrés : Python vérifie s'il s'agit d'un module built-in (comme sys ou math).
3. Le chemin de recherche sys.path : Python parcourt les répertoires listés dans sys.path, qui inclut :
   • Le répertoire du script en cours d'exécution
   • Les répertoires définis par la variable d'environnement PYTHONPATH
   • Les répertoires d'installation par défaut (site-packages)

Vous pouvez inspecter le chemin de recherche :

import sys

for chemin in sys.path:
    print(chemin)

Et même ajouter un répertoire personnalisé :

import sys
sys.path.append("/chemin/vers/mes/modules")

import mon_module_personnalise

Bonnes pratiques pour les modules

Pour écrire du code Python propre et maintenable, voici les bonnes pratiques à suivre concernant les modules :

• Placez tous vos imports en haut du fichier : c'est la convention PEP 8. Les imports doivent être regroupés dans cet ordre : modules standard, modules tiers, modules locaux, avec une ligne vide entre chaque groupe.
• Évitez from module import * : cette syntaxe rend le code difficile à comprendre et peut provoquer des conflits de noms.
• Utilisez toujours le pattern if __name__ == "__main__" : cela rend vos modules à la fois importables et exécutables.
• Définissez __all__ : dans vos modules publics, utilisez la variable __all__ pour contrôler explicitement ce qui est exporté.
• Documentez vos modules : ajoutez une docstring en tout début de fichier pour expliquer le rôle du module.
• Nommez vos modules en minuscules : selon PEP 8, les noms de modules doivent être courts, en minuscules, et les underscores sont acceptés si cela améliore la lisibilité.
• Évitez les imports circulaires : si le module A importe le module B et que B importe A, vous obtiendrez des erreurs. Restructurez votre code pour éliminer ces dépendances cycliques.

Voici un exemple de fichier respectant toutes ces conventions :

"""Module de gestion des utilisateurs.

Ce module fournit des fonctions pour créer, lire,
mettre à jour et supprimer des utilisateurs.
"""

# Modules standard
import os
import json
from datetime import datetime

# Modules tiers
import requests

# Modules locaux
from .base_de_donnees import connexion

__all__ = ["creer_utilisateur", "obtenir_utilisateur"]


def creer_utilisateur(nom, email):
    """Crée un nouvel utilisateur.
    
    Args:
        nom: Le nom de l'utilisateur.
        email: L'adresse email de l'utilisateur.
    
    Returns:
        dict: Les informations de l'utilisateur créé.
    """
    utilisateur = {
        "nom": nom,
        "email": email,
        "date_creation": str(datetime.now())
    }
    return utilisateur


def obtenir_utilisateur(identifiant):
    """Récupère un utilisateur par son identifiant."""
    # Logique de récupération...
    pass


if __name__ == "__main__":
    # Tests rapides
    user = creer_utilisateur("Alice", "alice@example.com")
    print(user)

Recharger un module

Lorsque vous travaillez en mode interactif (dans un terminal Python ou un notebook Jupyter), un module n'est importé qu'une seule fois. Si vous modifiez le fichier source, les changements ne seront pas pris en compte automatiquement. Pour forcer le rechargement, utilisez importlib.reload() :

import importlib
import mon_module

# Après modification du fichier mon_module.py
importlib.reload(mon_module)

# Les changements sont maintenant pris en compte
mon_module.ma_fonction()

Exploration dynamique d'un module

Python offre plusieurs outils pour explorer le contenu d'un module à l'exécution :

import math

# Lister tous les attributs du module
print(dir(math))

# Obtenir de l'aide sur le module
help(math)

# Obtenir de l'aide sur une fonction spécifique
help(math.sqrt)

# Vérifier le chemin du fichier du module
print(math.__file__)

# Lire la docstring du module
print(math.__doc__)

La fonction print combinée avec dir() est un excellent moyen de découvrir rapidement ce qu'un module a à offrir.

Questions fréquentes

Un module est un fichier unique .py contenant du code Python. Un package est un dossier contenant un fichier __init__ et un ou plusieurs modules. Le package permet d'organiser les modules de manière hiérarchique. Par exemple, utils/texte.py est un module à l'intérieur du package utils. Vous pouvez voir le package comme un dossier de modules, et le module comme un fichier individuel.

Cette erreur signifie que Python ne parvient pas à trouver le module que vous tentez d'importer. Vérifiez d'abord que le module est bien installé (avec pip list pour les modules tiers). Ensuite, assurez-vous que votre fichier se trouve dans un répertoire listé dans sys.path. Si vous utilisez un environnement virtuel, vérifiez qu'il est bien activé. Enfin, vérifiez que le nom du module est correctement orthographié — Python est sensible à la casse.

Oui, vous avez plusieurs options. Vous pouvez ajouter le répertoire au sys.path, définir la variable d'environnement PYTHONPATH, ou utiliser des imports relatifs au sein d'un package. La solution la plus propre est de structurer votre projet en package avec des fichiers __init__.py appropriés et d'installer votre package localement avec pip install -e ..

La maîtrise des modules et de l'architecture d'un projet Python s'acquiert par la pratique et l'apprentissage structuré. Nous vous recommandons de suivre notre formation dédiée à Python sur Believemy, qui couvre en profondeur les modules, les packages, les bonnes pratiques d'organisation du code et bien plus encore. Vous y trouverez des exercices concrets pour progresser rapidement.