Créer ses propres modules

Un module : un simple fichier Python

Créer un module en Python est extrêmement simple : il suffit de créer un fichier avec l'extension `.py` et d'y écrire du code Python (fonctions, classes, variables, etc.).

Ce fichier `.py` est alors un module que vous pouvez importer et utiliser dans d'autres fichiers Python.

Exemple :

Créez un fichier nommé `mon_module.py` (le nom du fichier est le nom du module) contenant le code suivant :

# mon_module.py

def dire_bonjour(nom):
    """Salue la personne dont le nom est passé en argument."""
    print(f"Bonjour, {nom} !")

PI = 3.14159

class MonObjet:
 def __init__(self):
  pass

Vous avez maintenant un module nommé `mon_module` qui contient une fonction (`dire_bonjour`), une variable (`PI`), et une classe (`MonObjet`).

Importer et utiliser votre module

Pour utiliser votre module, vous devez l'importer dans un autre fichier Python (ou dans l'interpréteur Python) en utilisant l'instruction `import`.

Créez un fichier `main.py` (dans le même répertoire que `mon_module.py`) contenant :

# main.py
import mon_module

mon_module.dire_bonjour("Alice")  # Utilisation de la fonction dire_bonjour
print(mon_module.PI)          # Utilisation de la variable PI

obj = mon_module.MonObjet()   # Utilisation de la classe MonObjet.

Lorsque vous exécutez `main.py`, Python recherche un fichier nommé `mon_module.py` dans les répertoires suivants (dans cet ordre) :

1. Le répertoire courant (le répertoire à partir duquel vous exécutez le script).
2. Les répertoires listés dans la variable d'environnement `PYTHONPATH` (si elle est définie).
3. Les répertoires d'installation par défaut de Python (où se trouvent les modules de la bibliothèque standard).

Si Python trouve le fichier `mon_module.py`, il l'exécute et crée un objet module correspondant. Vous pouvez ensuite accéder aux éléments définis dans `mon_module.py` en utilisant la notation `mon_module.element`.

Organiser votre module : bonnes pratiques

Voici quelques bonnes pratiques pour organiser votre module :

• Utilisez des noms de modules descriptifs : Le nom du module doit indiquer clairement son contenu ou son rôle. Utilisez des noms en minuscules, avec des mots séparés par des traits de soulignement (snake_case) si nécessaire.
• Documentez votre module : Ajoutez une docstring au début du fichier pour décrire le rôle du module. Documentez également les fonctions, classes et variables importantes à l'intérieur du module.
• Structurez votre module : Si votre module contient beaucoup de code, divisez-le en plusieurs fonctions et/ou classes pour le rendre plus lisible et plus facile à maintenir.
• Gérez les dépendances : Si votre module dépend d'autres modules, importez-les au début du fichier.
• Utilisez `if __name__ == "__main__":` : Ce bloc de code est exécuté uniquement si le fichier est exécuté directement (par exemple, avec `python mon_module.py`), mais pas s'il est importé comme module. Cela vous permet d'ajouter du code de test ou des exemples d'utilisation à votre module, sans que ce code ne soit exécuté lorsqu'il est importé.

Exemple de `mon_module.py` amélioré :

# mon_module.py

"""Ce module fournit des fonctions et des classes pour ... (description du module)."""

import math  # Importation des dépendances

PI = 3.14159

def dire_bonjour(nom):
    """Salue la personne dont le nom est passé en argument."""
    print(f"Bonjour, {nom} !")

def calculer_aire_cercle(rayon):
    """Calcule l'aire d'un cercle."""
    return PI * (rayon ** 2)

class MonObjet:
    """Description de la classe MonObjet."""
    def __init__(self):
        pass


if __name__ == "__main__":
    # Code de test (exécuté uniquement si le fichier est exécuté directement)
    dire_bonjour("Utilisateur")
    aire = calculer_aire_cercle(5)
    print(f"L'aire d'un cercle de rayon 5 est : {aire}")

Exécuter un module comme un script : if __name__ == '__main__'

Comme mentionné précédemment, le bloc `if __name__ == "__main__":` est un moyen de rendre un module exécutable comme un script (c'est-à-dire, exécutable directement avec `python mon_module.py`), tout en permettant qu'il soit importé comme un module sans que ce code ne soit exécuté.

• `__name__` est une variable spéciale en Python qui contient le nom du module courant.
• Si le module est exécuté directement, `__name__` est égal à `"__main__"`.
• Si le module est importé, `__name__` est égal au nom du module.

Le bloc `if __name__ == "__main__":` est donc un moyen de distinguer si le module est exécuté comme un script ou importé comme un module.

C'est une bonne pratique d'inclure ce bloc dans vos modules, même si vous ne prévoyez pas de les exécuter directement. Cela permet de :

• Ajouter du code de test qui ne sera exécuté que lorsque le module est exécuté directement.
• Fournir des exemples d'utilisation du module.
• Rendre le module utilisable à la fois comme un script et comme un module.

Importer des fonctions/classes spécifiques : from ... import

Comme avec les modules de la bibliothèque standard, vous pouvez utiliser `from mon_module import nom1, nom2` pour importer des fonctions, classes, ou variables spécifiques de votre module directement dans l'espace de noms courant.

Exemple (en utilisant le `mon_module.py` amélioré) :

# main.py
from mon_module import dire_bonjour, calculer_aire_cercle

dire_bonjour("Alice")
aire = calculer_aire_cercle(5)
print(f"L'aire est : {aire}")

Cela évite d'avoir à préfixer les noms par `mon_module.`.