2017-04-13 10:50:18 +02:00
|
|
|
|
Les modules
|
|
|
|
|
============
|
|
|
|
|
|
|
|
|
|
Il s'agit de décomposer un grand programme en
|
|
|
|
|
morceaux (**modules**) connectés entre eux par des **interfaces** bien
|
|
|
|
|
définies.
|
|
|
|
|
|
|
|
|
|
Ces modules doivent être aussi indépendants que possible.
|
|
|
|
|
|
|
|
|
|
module
|
|
|
|
|
|
|
|
|
|
ensemble de ressources liées sémantiquement
|
|
|
|
|
|
|
|
|
|
interface
|
|
|
|
|
|
|
|
|
|
mode d’emploi du module, avec en plus un principe de masquage
|
|
|
|
|
des informations (partie publique, partie secrète)
|
|
|
|
|
|
2017-04-29 20:24:46 +02:00
|
|
|
|
Définir des fonctions dans un fichier séparé
|
|
|
|
|
--------------------------------------------
|
|
|
|
|
|
|
|
|
|
Les fonctions peuvent être définies dans un fichier et le programme dans un
|
|
|
|
|
autre fichier séparé. Dans ce cas, pour pouvoir être exécuté directement avec
|
|
|
|
|
la commande python `nomfichierprogramme.py`, le fichier du programme doit
|
|
|
|
|
importer d’abord les fonctions du fichier dans lequel les fonctions sont
|
|
|
|
|
définies.
|
|
|
|
|
|
|
|
|
|
1. Fichier de fonctions
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
|
|
|
|
|
# Fichier foncmaxliste.py
|
|
|
|
|
# Recherche le premier élément maximal dans une liste ou
|
|
|
|
|
#dans une chaine de caractères
|
|
|
|
|
def max_list(L) :
|
|
|
|
|
k = len(L)
|
|
|
|
|
max, x = L[0], 0
|
|
|
|
|
i = 1
|
|
|
|
|
while i < k :
|
|
|
|
|
if max < L[i]:
|
|
|
|
|
max = L[i]
|
|
|
|
|
x = i
|
|
|
|
|
i = i + 1
|
|
|
|
|
return max, x
|
|
|
|
|
|
|
|
|
|
2. Fichier de programme
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
Pour utilser les fonctions définies dans d’autres fichiers, le fichier de
|
|
|
|
|
programme doit commencer par les instructions qui importent ces fichiers de
|
|
|
|
|
fonctions ou directement les fonctions de ces fichiers. Dans la syntaxe
|
|
|
|
|
ci-dessous, on importe une ou toutes les fonctions du fichier `foncmaxlist.py`.
|
|
|
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
|
|
|
|
|
# Fichier progmaxlist.py
|
|
|
|
|
from foncmaxliste import max_list
|
|
|
|
|
# ou plus simple:
|
|
|
|
|
# from foncmaxliste import *
|
|
|
|
|
print max_list([4,5,6,9,12,5,10,3,18,5,6,7])
|
|
|
|
|
couple = max_list([4,5,6,9,12,5,10,3,18,5,6,7])
|
|
|
|
|
print ’Max de L est ’, couple[0]
|
|
|
|
|
print ’et se trouve à la position ’, couple[1]
|
|
|
|
|
print max_list(’totovaaumarche’)
|
|
|
|
|
couple = max_list(’totovaaumarche’)
|
|
|
|
|
print ’Max de L est ’, couple[0]
|
|
|
|
|
print ’et se trouve à la position ’, couple[1]
|
|
|
|
|
|
|
|
|
|
Au lieu d’importer les fonctions, on peut importer le fichier qui définit les
|
|
|
|
|
fonctions avec la syntaxe qui suit. Dans ce cas, le fichier de programme sera
|
|
|
|
|
changé comme suit :
|
|
|
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
|
|
|
|
|
# Fichier prog2maxlist
|
|
|
|
|
import foncmaxliste
|
|
|
|
|
print foncmaxliste.max_list([4,5,6,9,12,5,10,3,18,5,6,7])
|
|
|
|
|
# la syntaxe indiquant le chemin d’acces a la fonction max_list utiliser ‘‘.’’
|
|
|
|
|
couple = foncmaxliste.max_list([4,5,6,9,12,5,10,3,18,5,6,7])
|
|
|
|
|
print ’Max de L est ’, couple[0]
|
|
|
|
|
print ’et se trouve à la position ’, couple[1]
|
|
|
|
|
print foncmaxliste.max_list(’totovaaumarche’)
|
|
|
|
|
couple = foncmaxliste.max_list(’totovaaumarche’)
|
|
|
|
|
print ’Max de L est ’, couple[0]
|
|
|
|
|
print ’et se trouve à la position ’, couple[1]
|
|
|
|
|
|
|
|
|
|
L’exécution directe du premier fichier de programme::
|
|
|
|
|
|
|
|
|
|
python prog max list.py
|
|
|
|
|
|
|
|
|
|
L’exécution directe du seconde fichier de programme::
|
|
|
|
|
|
|
|
|
|
python prog2 max list.py
|
|
|
|
|
|
|
|
|
|
Définition de l'implémentation d'un module
|
|
|
|
|
-------------------------------------------
|
|
|
|
|
|
|
|
|
|
Tout fichier qui contient au moins une définition d’une fonction ou d’une
|
|
|
|
|
variable est appelé un module (une bibliothèque). Le nom du module est le nom
|
|
|
|
|
du fichier enlevé le suffixe `.py`. Ainsi, un fichier de programme qui contient
|
|
|
|
|
au moins une définition d’une fonction ou un fichier qui ne contient que des
|
|
|
|
|
définition de fonctions sont des modules. On peut importer un module ou des
|
|
|
|
|
fonctions ou variables d’un module dans un programme, comme nous avons vu dans
|
|
|
|
|
les exemples ci-dessus.
|
|
|
|
|
|
|
|
|
|
.. important:: on peut importer un module, ou bien lancer un module en tant que
|
|
|
|
|
programme executable
|
|
|
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
|
main()
|
|
|
|
|
|
|
|
|
|
Pour faciliter la programmation, Python définit un certain nombre de **modules internes**,
|
|
|
|
|
appelés les builtins (la librairie standard).
|
|
|
|
|
|
|
|
|
|
Par exemple :
|
|
|
|
|
|
|
|
|
|
– Lors de l’ouverture d’une session interactive, on est dans un module interne nommé
|
|
|
|
|
main . Toutes les variables définies par affectation au niveau de ce module sont valides
|
|
|
|
|
globalement dans la session.
|
|
|
|
|
|
|
|
|
|
– D’autres modules internes sont string, math, random
|
|
|
|
|
|
|
|
|
|
Dans une session de travail sous l’interpréteur Python, la première importation d’un mo-
|
|
|
|
|
dule qui, à part des fonctions qu’elle définit, contient des instruction de programme fait
|
|
|
|
|
exécuter ces instructions. Dans la même session, les importations suivantes ne font pas
|
|
|
|
|
exécuter ces instructions. Pour les exécuter, on utilise la fonction reload(nomdumodule)
|
|
|
|
|
(sans sufffixe .py).
|
|
|
|
|
|
2017-04-13 10:50:18 +02:00
|
|
|
|
Exemples d'interface
|
|
|
|
|
--------------------
|
|
|
|
|
|
|
|
|
|
::
|
|
|
|
|
|
|
|
|
|
type: son type
|
|
|
|
|
arguments
|
|
|
|
|
arg1 : description de l'argument 1
|
|
|
|
|
arg2 : description de l'argument 2
|
|
|
|
|
préconditions:
|
|
|
|
|
arg1 > 10
|
|
|
|
|
postconditions:
|
|
|
|
|
result < 19
|
|
|
|
|
raises: TypeError, AssertionError, SystemError...
|
|
|
|
|
test: tests nominaux pour chaque cas spécifié
|
|
|
|
|
|
|
|
|
|
- L'interface racine carrée
|
|
|
|
|
|
|
|
|
|
::
|
|
|
|
|
|
|
|
|
|
racine:
|
|
|
|
|
type: float -> float
|
|
|
|
|
arguments x: float, flottant dont on veut calculer la racine
|
|
|
|
|
pré: x >= 0
|
|
|
|
|
test: racine 25.0 -> 5.0 ; racine (-25) -> raises TypeError
|
|
|
|
|
|
|
|
|
|
- L'interface `lendemain`
|
|
|
|
|
|
|
|
|
|
Il faut définir auparavant un type spécifique appelé `date`
|
|
|
|
|
|
|
|
|
|
::
|
|
|
|
|
|
|
|
|
|
lendemain: le lendemain est la date qui désigne
|
|
|
|
|
le jour suivant de la date passée en argument
|
|
|
|
|
type: date -> date
|
|
|
|
|
arguments :
|
|
|
|
|
d: date
|
|
|
|
|
description: la date dont on veut calculer le lendemain
|