formations/algo/algorithmique/cours/modules.txt

315 lines
8.7 KiB
Plaintext
Raw Permalink Normal View History

2017-08-28 17:36:36 +02:00
La programmation modulaire
===========================
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 demploi du module, avec en plus un principe de masquage
des informations (partie publique, partie secrète)
2018-08-20 21:01:30 +02:00
Signatures, type abstrait et langage de modules : la programmation modulaire
2017-08-28 17:36:36 +02:00
permet d'aller très loin dans la programmation structurée.
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 dabord 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 dautres 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 dimporter 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 :
2018-08-20 21:01:30 +02:00
2017-08-28 17:36:36 +02:00
.. 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 dacces 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]
Lexécution directe du premier fichier de programme::
python prog max list.py
Lexé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 dune fonction ou dune
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 dune 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 dun 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 louverture dune 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.
Dautres modules internes sont string, math, random
Dans une session de travail sous linterpréteur Python, la première importation dun mo-
dule qui, à part des fonctions quelle 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
Le langages des modules
-------------------------
.. code-block:: ocaml
module type PILE = (* signature (interface) du module *)
sig
type a t
val create : unit -> a t
val push : a -> a t -> unit
val pop : a t -> a
end
(* implémentation du module *)
module Pile : PILE = (* le module est restreint
par la signature PILE *)
struct
type a t = a list ref
let create () = ref []
let push x p = p := x::!p
let pop p = match !p with [...]
let rec print p = match p with [...]
end
- `struct .. end` introduit une collection de définitions, valeurs, types ou modules.
C'est une **structure**.
- `module Nom = struct .. end` permet de donner un nom à cette structure et
c'est ça un module. C'est une structure nommée.
- `sig ... end` introduit une signature de module : une interface pour un module.
On restreint souvent une structure par une signature pour "cacher" certaines
définitions. Une signature de module fournit une **interface** entre l'extérieur
et l'intérieur d'un module.
En dehors du module, on accède à ses composants grâce à la notation pointée
.. code-block:: ocaml
let p = Pile.create()
Pile.push 45 p
Les foncteurs
--------------
Si un langage possède un langage de modules, on peut aller plus loin : on peut
considérer un module comme étant une expression de base du langage.
- La signature d'un module peut être considérée comme le type du module
- La structure du module peut être considéré comme sa valeur
Quel est l'intérêt ? On peut alors définir des **foncteurs**.
foncteur
"fonction" d'une structure vers une autre structure.
On peut ainsi paramétrer un module par un autre module.
.. code-block:: ocaml
module Nom (M1 :S1 ) (M2 :S2 ) (M3 :S3 ) ... =
struct
...
end
On applique un foncteur à des paramètres modules, pour
obtenir un nouveau module :
.. code-block:: ocaml
module M = F (Titi) (Toto)
Contrainte de type par signature
------------------------------------
::
module M =
struct
type t = int * int * int ;;
let make d m y = d, m, y ;;
end ;;
let d = M.make 8 5 8 ;;
module type S =
sig
type t ;;
val make : int -> int -> int -> t ;;
end ;;
module MS = (M:S) ;;
MS.make 5 1 2 ;;
Type et signature
------------------
::
# module type A = sig
val a: int -> int
end ;;
module type A = sig val a : int -> int end
# module B = struct
let a x = x + 1 ;;
end;;
module B : sig val a : int -> int end
# module C = (B:A) ;;
module C : A
# C.a 2 ;;
- : int = 3
#
Module auquel on impose une signature
-----------------------------------------
::
module type DATE = sig
type t
val make: int -> t
val get_year: t -> int
val get_month: t -> int
end ;;
module MR = struct
type t = int * int
let make x y = (x, y)
let get_month (x, y) = x
let get_year (x, y) = y
end ;;
module date = (MR:DATE) ;;