170 lines
5.4 KiB
Plaintext
170 lines
5.4 KiB
Plaintext
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)
|
||
|
||
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).
|
||
|
||
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
|