ISET-Sousse Préparation à la certification PYTHON 2

----------------------------------------------------------------------------------

CH2 : Les modules et packages

Un programme Python est généralement composé de plusieurs fichiers sources, appelés
modules.
S’ils sont correctement codés les modules doivent être indépendants les uns des autres pour
être réutilisés à la demande dans d’autres programmes.
Ce chapitre explique comment coder des modules et comment les importer dans un autre.
Nous verrons également la notion de package qui permet de grouper plusieurs modules.

I. Les modules
1. Définition
Module : fichier script Python permettant de définir des éléments de programme réutilisables.
Ce mécanisme permet d’élaborer efficacement des bibliothèques de fonctions ou de classes.
Avantages des modules :
- réutilisation du code ;
- la documentation et les tests peuvent être intégrés au module ;
- réalisation de services ou de données partagés ;
- partition de l’espace de noms du système.
Remarque
Lorsqu’on parle du module, on néglige l’extension : le module machin est dans le fichier
machin.py.

2. L’instruction import
L’instruction import charge et exécute le module indiqué s’il n’est pas déjà chargé.
L’ensemble des définitions contenues dans ce module deviennent alors disponibles : variables
globales, fonctions, classes.
Suivant la syntaxe utilisée, on accède aux définitions du module de différentes façons :
- l’instruction import <nom_module> donne accès à l’ensemble des définitions du module
importé en utilisant le nom du module comme espace de nom.

>>> import nom_module

- l’instruction
from <nom_module> import nom1, nom2…donne accès directement
à une sélection choisie de noms définis dans le module.

>>> from math import pi, sin

>>> print(”Valeur de Pi :”, pi, ”sinus(pi/4) :”, sin(pi/4))
Valeur de Pi : 3.14159265359 sinus(pi/4) : 0.707106781187

Dans les deux cas, le module et ses définitions existent dans leur espace mémoire propre, et
on duplique simplement dans le module courant les noms que l’on a choisi, comme si on avait
fait les affectations :

>>> sin = math.sin

>>> pi = math.pi

Remarque
Il est conseillé d’importer dans l’ordre :
------------------------------------------------------------------------------------

Page 1 sur 6 Enseignante : Emna Bouzid – AU : 2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
- les modules de la bibliothèque standard ;
- les modules des bibliothèques tierces ;
- Les modules personnels.

Attention
Pour tout ce qui est fonction et classe, ainsi que pour les « constantes » (variables globales
définies et affectée une fois pour toute à une valeur), l’import direct du nom ne pose pas de
problème.
Par contre, pour les variables globales que l’on désire pouvoir modifier, il est préconisé de
passer systématiquement par l’espace de nom du module afin de s’assurer de l’existence de
cette variable en un unique exemplaire ayant la même valeur dans tout le programme.

Exemples
Notion d’« auto-test »
Le module principal est celui qui est donné en argument sur la ligne de commande ou qui est
lancé en premier lors de l’exécution d’un script. Son nom est contenu dans la variable globale
__name__. Sa valeur dépend du contexte de l’exécution.
Soit le module :
# je_me_nomme.py
print(”Je me nomme :”, __name__)

Premier contexte exécution sur la ligne de commande (ou dans un EDI), on obtient la valeur
de la variable prédéfinie __main__ :

$ python3 je_me_nomme.py
Je me nomme : __name__

Second contexte import de ce module (ce n’est donc plus le module principal), on obtient
l’identificateur du module :
>>> import je_me_nomme
Je me nomme : je_me_nomme

3. Importer des fonctions d'autres fichiers

Les fonctions vont se multiplier et il faudra les enregistrer dans des fichiers distincts pour plus
de flexibilité.
Créons un fichier que nous nommerons func.py dans le même dossier qu’un fichier fiche.py
func.py

------------------------------------------------------------------------------------

Page 2 sur 6 Enseignante : Emna Bouzid – AU : 2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------

# coding: utf-8

def ajoute_un(v):

return v + 1

fiche.py

from func import *

age = input("Quel est votre age? : ")

print("Vous avez %d ans" % age)

age_plus_un = ajoute_un(age)

print("Dans un an vous aurez %d ans" % age_plus_un)

4. Modules courants
Il existe une série de modules qu’on aura probablement amené à utiliser si on programme en
Python. En voici une liste non exhaustive :
— math : fonctions et constantes mathématiques de base (sin, cos, exp, pi. . . ).
— sys : passage d’arguments, gestion de l’entrée/sortie standard. . .
— os : dialogue avec le système d’exploitation (permet de sortir de Python, lancer une
commande en shell. . . ).
— random : génération de nombres aléatoires.
— time : permet d’accéder a l’heure de l’ordinateur et aux fonctions gérant le temps.
— calendar : fonctions de calendrier.
— profile : permet d’évaluer le temps d’exécution de chaque fonction dans un programme
— urllib : permet de récupérer des données sur internet depuis Python.
— tkinter : interface python avec Tk (permet de créer des objets graphiques
— re : gestion des expressions régulières.
— pickle : écriture et lecture de structures Python (comme les dictionnaires par exemple).

4.1 Module sys : passage d’arguments

Le sys contient (comme son nom l’indique) des fonctions et des variables spécifiques au
système, ou plus exactement a l’interpréteur lui-même. Par exemple, il permet de gérer
l’entrée (stdin) et la sortie standard (stdout). Ce module est particulièrement intéressant pour
récupérer les arguments passés à un script Python lorsque celui-ci est appelé en ligne de
commande. Dans cet exemple, écrivons le court script suivant :test.py :

1 #!/usr/bin/env python3
2
3 import sys
4 print(sys.argv)

Ensuite lancez test.py suivi de plusieurs arguments. Par exemple :

1$ python3 test.py salut girafe 42
2 ['test.py', 'salut', 'girafe', '42']

Dans l’exemple précédent, salut, girafe et 42 sont les arguments passés au script.

------------------------------------------------------------------------------------

Page 3 sur 6 Enseignante : Emna Bouzid – AU : 2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
La variable sys.argv est une liste qui représente tous les arguments de la ligne de commande,
y compris le nom du script lui même qu’on peut retrouver dans sys.argv[0]. On peut donc
accéder à chacun de ces arguments avec sys.argv[1], sys.argv[2]. . .
On peut aussi utiliser la fonction sys.exit() pour quitter un script Python. On peut donner un
argument à cette fonction (en général une chaine de caractères) qui sera renvoyé au moment
ou Python quittera le script. Par exemple, si on attend au moins un argument en ligne de
commande, on peut renvoyer un message pour indiquer à l’utilisateur ce que le script attend
comme argument :

1 #!/usr/bin/env python3
23 import sys
4
5 if len(sys.argv) != 2:
6 sys.exit("ERREUR : il faut exactement un argument.")
78 #

Puis on l’exécute sans argument :

1 $ python3 test.py
2 ERREUR : il faut exactement un argument.

Notez qu’ici on vérifie que le script possède deux arguments car le nom du script lui-même
est le premier argument.

4.2 Module os
Le module os gère l’interface avec le système d’exploitation.
os.path.exists() est une fonction pratique de ce module qui vérifie la présence d’un fichier sur
le disque.

1 >>> import sys

2 >>> import os
3 >>> if os.path.exists("toto.pdb"):
4 ... print("le fichier est présent")
5 ... else:
6 ... sys.exit("le fichier est absent")

7 ...
8 le fichier est absent

Dans cet exemple, si le fichier n’est pas présent sur le disque, on quitte le programme avec la fonction
exit() du module sys.
La fonction system() permet d’appeler n’importe quelle commande externe.
✄􀀀
1 >>> import os
2 >>> os.system("ls -al")
3 total 5416
4 drwxr-xr-x 2 iset sousse 4096 2010-07-21 14:33 .
5 drwxr-xr-x 6 iset sousse 4096 2010-07-21 14:26 ..
6 -rw-r--r-- 1 iset sousse 124335 2010-07-21 14:31 1BTA.pdb
7 -rw-r--r-- 1 iset sousse 4706057 2010-07-21 14:31 NC_000913.fna
8 -rw-r--r-- 1 iset sousse 233585 2010-07-21 14:30 NC_001133.fna
9 -rw-r--r-- 1 iset sousse 463559 2010-07-21 14:33 NC_001133.gbk
10 0

------------------------------------------------------------------------------------

Page 4 sur 6 Enseignante : Emna Bouzid – AU : 2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------

La commande externe ls -al est introduite comme une chaine de caractères à la fonction
system(). La valeur 0 sur la dernière ligne correspondant au code de sortie de la commande ls
-al et indique ici qu’il n’y a pas eu d’erreur.

II. Les packages

Nous avons donc vu que lorsque l'on regroupe des fonctions dans un fichier on crée un
ensemble de fonctions que l'on nomme " module ".
Lorsque l'on cherche à regrouper des modules, on parle de package.

1. Créer un package
Pour créer un package, on commence par créer dans le même dossier du programme - un
dossier portant le nom du package. Dans notre exemple, nous le nommerons " utils ".
Dans ce dossier, créons le fichier suivant: __init__.py , cela indique à python qu'il s'agit
d'un package . Ce fichier peut être vide, seule sa présence est importante.
Ensuite créons un fichier toujours dans ce répertoire utils que nous nommerons par exemple
" operations.py "
Contenu du dossier du projet:

Contenu du dossier utils:

Maintenant éditons le fichier operations.py et créons une nouvelle fonction

# coding: utf-8

def ajoute_deux(v):

return v + 2

Puis ajoutons un appel vers cette fonction dans le fichier fiche.py

------------------------------------------------------------------------------------

Page 5 sur 6 Enseignante : Emna Bouzid – AU : 2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------

# coding: utf-8

from func import *

from utils.operations import ajoute_deux

age = input("Quel est votre age? : ")

print("Vous avez %d ans" % age)

age_plus_un = ajoute_un(age)

print("Dans un an vous aurez %d ans" % age_plus_un)

age_plus_deux = ajoute_deux(age)

print("Dans un an vous aurez %d ans" % age_plus_deux)

Alors que remarque-t-on? Tout d'abord on importe un package avec les mots
clé from et import , ensuite pour appeler une fonction précise, on passe par la hiérarchie
suivante:
from package.module import fonction

Si on veut importer toutes les fonctions d'un module, on indique une étoile * qui signifie
souvent en informatique "TOUS".

4.2 Les extensions des fichiers python

Il existe plusieurs extensions de fichier qui tournent autour de python:

.py -> script modifiable

.pyc -> script compilé

.pyw -> script exécuté sans lancement de

terminal (sous windows)

------------------------------------------------------------------------------------

Page 6 sur 6 Enseignante : Emna Bouzid – AU : 2020/2021