En programmation, un module est une pièce d’un logiciel qui possède une fonctionnalité spécifique. Par exemple, lors de la création d’un jeu de ping-pong, un module serait responsable de la logique du jeu, et un autre module serait chargé de dessiner le jeu à l’écran. Chaque module est un fichier différent, qui peut être édité séparément.

Très souvent, c’est une personne qui définit une fonction et une autre qui l’utilise. Par exemple, avec la bibliothèque **matplotlib**, on peut utiliser la fonction plot() pour tracer des courbes sans avoir à écrire nous-mêmes cette fonction. Nous allons donc voir à présent comment définir des fonctions dans un **module** et faire en sorte qu’un utilisateur puisse appeler ces fonctions dans son programme.

Par exemple, nous allons créer un fichier nommé <span class="pre">puissance.py</span> qui va définir 2 fonctions : carre() et cube(). Un tel fichier est appelé un module et il va pouvoir être importé dans un autre fichier, et en particulier dans le fichier qui contient le programme principal.

1
2
3
4
5
6
7

def carre(valeur):
    resultat = valeur**2
    return resultat

def cube(valeur):
    resultat = valeur**3
    return resultat

Il est maintenant possible d’utiliser dans un programme principal les fonctions qui ont été définies dans le module <span class="pre">puissance.py</span>. Pour cela, il faut importer les fonctions à partir du module.

Exemple : on importe une seule fonction

Le fichier `puissance.py` doit être dans le même répertoire que le programme principal (ou bien se trouver dans le “path” de Python).
**Exemple : on importe explicitement les deux fonctions** 
1
2
3
4
5
6
7

from puissance import carre, cube

a = 5
u = carre(a)
print("le carre vaut", u)
v = cube(a)
print("le cube vaut", v)

Exemple : on importe toutes les fonctions

1
2
3
4
5
6
7

from puissance import *

a = 5
u = carre(a)
print("le carre vaut", u)
v = cube(a)
print("le cube vaut", v)

L’importation de toutes les fonctions avec <span class="pre">*</span> est fortement déconseillée. En effet, elle ne permet pas d’avoir une vision claire des fonctions qui ont été importées. Ceci est donc une source potentielle d’erreurs.

Exemple : on importe le module

1
2
3
4
5
6
7

import puissance

a = 5
u = puissance.carre(a)
print("le carre vaut", u)
v = puissance.cube(a)
print("le cube vaut", v)

Dans ce cas, il faut préciser le nom du module devant la fonction.

Exemple : on importe le module et on lui donne un alias

1
2
3
4
5
6

import puissance as pu
a = 5
u = pu.carre(a)
print("le carre vaut", u)
v = pu.cube(a)
print("le cube vaut", v)

Exemple : on importe une fonction d’un module et on lui donne un alias

Il est aussi possible de donner un alias à une fonction comme dans l’exemple suivant :

1
2
3
4
5

from puissance import carre as ca

a = 5
u = ca(a)
print("le carre vaut", u)
## Package

Quand on a un grand nombre de modules, il peut être intéressant de les organiser dans des dossiers. Un dossier qui rassemble des modules est appelé un package (paquetage en français). Le nom du package est le même que celui du dossier. Par exemple, on crée un dossier <span class="pre">package1</span> dans lequel on place le fichier <span class="pre">module1.py</span> suivant :

1
2

def fonction1(a):
    return a**2

On peut ensuite utiliser la fonction fonction1() définie dans <span class="pre">module1.py</span>, en important <span class="pre">package1.module1</span> comme dans l’exemple qui suit :

``` ```
Il est aussi possible d’avoir des dossiers imbriqués, c’est-à-dire des dossiers qui contiennent d’autres dossiers.
## Complément

Dans la documentation de Python, il est fait une distinction entre script et module. Voici quelques précisions sur cette distinction.

En Python, lorsqu’on crée un fichier qui rassemble des instructions au lieu de les taper une à une dans l’interpréteur, on appelle ce fichier un script et on le sauvegarde avec une extension <span class="pre">.py</span>, par exemple <span class="pre">essai.py</span>.

Quand on est amené à travailler sur un programme long, il est utile de séparer le programme en plusieurs fichiers. Certaines parties peuvent alors être réutilisées par d’autres programmes.

Il est par exemple possible d’effectuer la définition des fonctions dans un fichier séparé pour ensuite les utiliser dans un script ou dans l’interpréteur. Le fichier qui contient ces définitions a aussi une extension <span class="pre">.py</span>, mais on appelle ce fichier un module.

Les modalités pour importer un module sont expliquées plus haut dans cette page.

A l’intérieur d’un module, le nom du module (en tant que chaîne de caractères) peut être obtenu grâce à la variable globale <span class="pre">__name__</span>. Par exemple, si on utilise le module <span class="pre">puissance.py</span> défini précédemment, on a dans l’interpréteur :

``` >>> import puissance >>> puissance.__name__ 'puissance' ```
Un même fichier `.py` peut jouer le rôle de script ou de module suivant son utilisation.

Exécution d’un module en tant que script

Quand on utilise un fichier en tant que script, la variable globale <span class="pre">__name__</span> prend pour valeur <span class="pre">'__main__'</span>. Ceci permet d’avoir dans le fichier un bloc d’instructions qui sera exécuté uniquement lorsque le fichier est lancé en tant que script.

Par exemple, pour le fichier <span class="pre">puissance2.py</span> suivant :

1
2
3
4
5
6
7

def carre(valeur):
    resultat = valeur**2
    return resultat

if __name__ == "__main__":
    a = 3
    print("le carre vaut", carre(a))

On peut lancer une exécution directe en tant que script et on obtient alors :

``` le carre vaut 9 ```
Ou bien on peut importer `puissance2` en tant que module, par exemple dans le fichier suivant :
``` import puissance2 as pu2 b = 4 print("le carre vaut",pu2.carre(b)) ```
Si on exécute ce script, on obtient :
``` le carre vaut 16 ```