Les procédures
Nous avons déjà rencontré et utilisé plusieurs procédures : init_tas et deplacer_sommet du module Cartes.
Définition :
Une procédure permet de créer une nouvelle action, ou encore d'abstraire et nommer une suite d'instructions. Une fois définie, une procédure peut être utilisée comme une nouvelle instruction du langage. Comme toute instruction, un appel à une procédure modifie l'état courant de l'environnement : c'est un effet de bord.
Spécification d'une procédure
Spécifier une procédure, c'est
choisir un identificateur pour la nommer;
préciser le nombre de paramètres, leur type, et les nommer ;
indiquer les conditions d'utilisation (CU) que doivent vérifier les paramètres lors d'un appel à la procédure ;
et indiquer l'action de la procédure sur l'environnement (effet de bord).
Exemple :
La procédure du module Cartes permettant de déplacer une carte d'un tas vers un autre se nomme deplacer_sommet, possède deux paramètres de type numero_tas désignant les tas de départ et d'arrivée, possède une contrainte d'utilisation qui est que le tas de départ ne doit pas être vide, et son action modifie les tas de cartes en déplaçant une carte du tas de départ vers le tas d'arrivée. Nous résumons tout cela par la notation :
deplacer_sommet : numero_tas * numero tas
depart,arrivee →déplace une carte du tas depart vers le tas arrivee
CU : le tas depart ne doit pas être vide
Syntaxe : Déclaration d'une procedure en Python
def nomDeLaProcedure(liste de paramètres):
...
bloc d'instructions
...
Syntaxe : Indentation
La structuration d'un programme Python est définie par son indentation. Le début d'un bloc est défini par un ‘:‘, la première ligne pouvant être considérée comme un en-tête (test, boucle, définition, etc.). Le corps du bloc est alors indenté de manière plus importante (mais régulière) que l'en-tête. Enfin, la fin du bloc est délimitée par le retour à l'indentation de l'en-tête. La convention en Python est d'utiliser quatre espaces pour chaque niveau d'indentation. Les blocs peuvent être imbriqués.
>>> def initialiser_a_vide(numero_tas):
... init_tas(numero_tas, "")
Cette structuration est utilisée aussi bien pour définir des fonctions, des boucles, des tests.
Syntaxe : Spécification
Une spécification doit préciser :
• l'action de la fonction
• la fonction des paramètres
• les contraintes d'utilisation (CU) que doivent vérifier les paramètres lors d'un appel à la fonction
>>> def deplacer_sommet(num_tas1, num_tas2) :
... """Déplace la carte au sommet du tas <num_tas1> vers le tas <num_tas2>.
...
... Contraintes d'utilisation: le tas <num_tas1> ne doit pas etre vide.
... """
>>> help(deplacer_sommet)
Help on function deplacer_sommet in module Cartes:
deplacer_sommet(num_tas1, num_tas2)
Déplace la carte au sommet du tas <num_tas1> vers le tas <num_tas2>
Contraintes d'utilisation: le tas <num_tas1> ne doit pas etre vide.
Exemple :
def toutMettreSurTas1():
... # vider le tas 2 sur le tas 1
... while tas_non_vide(2):
... deplacer_sommet(2,1)
... # vider le tas 3 sur le tas 1
... while tas_non_vide(3):
... deplacer_sommet(3,1)
... # vider le tas 4 sur le tas 1
... while tas_non_vide(4):
... deplacer_sommet(4,1)
Cette procedure a pour nom toutMettreSurTas1 déplace toutes les cartes sur le tas 1.
def viderTas(depart,arrivee):
... while tas_non_vide(depart):
... deplacer_sommet(depart,arrivee)
Cette procédure a pour nom viderTas et possède deux paramètres <depart> et <arrivee> qualifiés de formels, car lors de la conception (ou écriture) de cette procédure, ces paramètres n'ont aucune valeur. Ils servent à
nommer les (futures) valeurs qui seront passées lors d'un appel à la procédure.
Fondamental :
Un appel à une procédure est une instruction. Le résultat de son exécution est une modification de l'état courant de l'environnement.
Exemple :
Un nouvel exemple de définition d'instruction avec Python et les cartes : il faut ici répartir équitablement un tas de cartes sur 2 autres tas.
