– dérouler le programme, comme expliqué dans le paragraphe précédent, avec 5 comme entrée, remplir et rendre le tableau ci-dessous ;
TP no3 LES FONCTIONS
– coder la suite de FIBONACCI dans le fichierTP3_3.py et vérifier les résultats obtenus (pour la saisie, utilisez uneintegerboxentre 2 et 20).
Fonction Appels Valeur de retour
fib(n) fib(n-1)+fib(n-2) fib(n-1)+fib(n-2) = fib(5) fib(4) + fib(3) ↓
fib(4) fib(3) + fib(2) ↓ ↑
fib(3) fib(2) + fib(1) ↓ ↑
fib(2) fib(1) + fib(0) ↓ ↑
fib(1) sans appel ↑
fib(0) sans appel ↑
C
QF
R+ apprendre à utiliser une fonction ou une méthode ; + apprendre à définir une fonction ;
+ bien comprendre la structure d’un script : fonctions-programme principal ;
+ enfin comprendre la notion de récursivité.
F
C
QF
PH les modules ;
H les espaces de nom.
BC v1.3 - 27 - 2007 - 2008
Chapitre 4
Mise au point et modules
Lorsque vous avez éliminé l’impossible, ce qui reste, même si c’est improbable, doit être la vérité.
A. Conan DOYLE(Le signe des quatre)
Objectifs :
– coder et utiliser un module ; – les espaces de nom ;
– apprendre àdéboguer.
Fichier(s) à produire :TP4_1.py TP4_2.py TP4_3.py
4.1 Manip
Durant cette partie, nous allons expérimenter quelques techniques du génie logiciel.
4.1.1 La portée des variables, les espaces de nom
Quand on utilise unnomdans un script, l’interpréteur Python le crée, le modifie ou le re-cherche dans une zone mémoire particulière : « l’espace de nom ». On sait qu’en Python les noms existent dès qu’on leur affecte une valeur : Python utilise l’affectation d’un nom pour l’associer à un espace de noms particulier correspondant à son type. Ce mécanisme se re-trouve à tous les niveaux, fonctions, classes, modules, packages.
Si, par exemple dans une fonction, on a besoin d’une variable de portée globale, on utilise l’instructionglobal.
MISE AU POINT & MODULES TP no4
Testez et commentez les instructions suivantes : x = "valeur globale"
def f1():
print "dans f1 :", x def f2():
x = "valeur locale"
print "dans f2 :", x def f3():
global x
x = "valeur modifiée"
print "dans f3 :", x print "au niveau global :", x f1()print "au niveau global :", x f2()print "au niveau global :", x f3()print "au niveau global :", x
Pour compléter l’exemple précédent, utilisez et expliquez la primitivedir().
4.1.2 Les modules
Jusqu’à maintenant, tous les scripts que nous avons écrits n’étaient constitués que d’un seul fichier. Or quasiment tous les langages proposent et préconisent le développement multi-fichiers. Quel en est l’intérêt ? En fait ils sont multiples :
– les sources sont plus petits, donc plus faciles à concevoir et à mettre au point ;
– on peut ainsi écrire des fonctionnalités qui seront réutilisables dans plusieurs programmes, c’est donc une bonne économie de moyens (on évite de réinventer la roue !) ;
– on peut aller plus loin et regrouper les différentes fonctionnalités dans des éléments sou-vent appelés bibliothèques.
Chaque langage possède ses propres outils, plus ou moins compliqués. Python propose une technique particulièrement simple : lemodule. L’étape suivante que nous n’explorerons pas est le regroupement de modules enpackagesformés d’arborescences de modules.
Comment faire un module ?
Créons par exemple un moduleaff_m.pycontenant une fonctionafficheur(). C’est tout simplement un fichier1Python contenant cette fonction :
#!/bin/env python
# coding: Latin-1
-*-"""Module d'affichage."""
__file__ = "aff_m.py"
1par convention, on choisit de suffixer les modules Python par_m
TP no4 MISE AU POINT & MODULES
__author__ = "Bob Cordeau"
# fonctions def afficheur(x):
print x
Comment utiliser un module ?
Vous savez déjà le faire depuis le deuxième TP ! En effet, le module que vous venez d’écrire s’utilise de la même façon de ceux de la bibliothèque standard Python. Donc, si dans un script, j’ai besoin de la fonctionafficheur(), il me suffit de l’importer au préalable.
Plus précisément, Python propose deux techniques d’importations :
import aff_m Les objets du module devront êtrepleinement qualifiés, c’est-à-dire qu’il fau-dra écrire le nom du module suivi d’un point suivi du nom de l’objet. Par exemple :
#!/bin/env python
from aff_m import afficheur Les objets du modules sont directement accessibles (mais peuvent générer des conflits dans l’espace de nom local. . .) :
#!/bin/env python
La seconde technique possède une variante utile pour certains cas : from aff_m import *
Pour la suite des TP, nous aurons besoin d’afficher des graphes de courbes. Un module GnuPlotnous permet de le fairedepuis un script. Afin d’améliorer la facilité d’utilisation,
BC v1.3 - 31 - 2007 - 2008
MISE AU POINT & MODULES TP no4
deux procédures utiles ont été incluses dans le module suivant qui vous sera utile dans les deux prochains TP. Ce module est présent dans le répertoireC:\python25.
#!/bin/env python
"""Plot de fonction(s) décrite(s) dans le string <msg>.
"""
g = Gnuplot.Gnuplot() g('set grid')
g.plot(Gnuplot.Func(msg))
raw_input(u"Tapez 'Entrée' pour continuer... ") def plot_Fic(msg):
"""Plot de fichier(s) nommé(s) dans le string <msg>.
"""
g = Gnuplot.Gnuplot() g('set grid')
g("plot " + msg)
raw_input(u"Tapez 'Entrée' pour continuer... ")
# Auto-test ---if __name__ == '__main__':
# test de la fonction plot_Fct() fct = '[-5:10] sin(20*x)*atan(x), 0' plot_Fct(fct)
# test de la fonction plot_Fic() f = open("data.dat", "w")
Vous remarquerez la dernière partie qui commence par : if __name__ == '__main__':
Elle permet, si le module est exécuté, d’évaluer les lignes qui suivent. Cette construction est très utilisée pour mettre au point les modules et fournir ainsi des modules « auto-testables ».
Mais si on importe ce module cette partie est ignorée.
Un second module vous sera utile (à enregistrer également pour les futurs TP). Il ne
com-TP no4 MISE AU POINT & MODULES
porte qu’une seule fonctionverif(), dont vous ferez un usage fréquent pour tester vos fonc-tions. Ce module est lui-même auto-testé, ce qui vous en donne la syntaxe :
#!/bin/env python
def verif(entree, reference, precision=0, comment=""):
"""Vérifie que l'entrée est égale à la référence, à la précision près."""
print "%s[%s, %s]" % (comment, entree, reference), if abs(entree - reference) <= precision:
print ": ok"
else:
print "### ERREUR ! ###"
exit(1)
# Auto-test ---if __name__=='__main__':
verif(abs(-6/2), 3, comment="Teste la fonction 'abs' : ") pi = 3.142
verif(pi, 3.14, 1e-2, comment="à 1e-2 : ")
verif(pi, 3.14, 1e-3, comment="à 1e-3 : ") ### ERREUR ! ###
4.1.3 Apprendre à déboguer
La recherche d’erreurs (ledébogage) est une activité parfois difficile et toujours importante pour un programmeur. Plusieurs outils et techniques existent en Python.
Nous vous proposons d’expérimenter la technique de débogage avecPyScripter.
Utilisez ce petit script qui va nous servir d’exemple (à prendre dansC:\python25) :
#!/bin/env python
# coding: Latin-1
-*-"""Exercice de debug.
- Mettre le curseur sur la ligne 24
- Faire Run/Run To Cursor (Vous êtes alors sous l'enviromment debug) - Examiner les valeurs des variable en positionnant le curseur dessus - Avancer pas à pas par F8
Mettre fin au debug : Ctrl+Alt+F9
Recommencer en ayant mis en commentaire la ligne 24.
"""
__file__ = "debug.py"
__author__ = "Bob Cordeau"
BC v1.3 - 33 - 2007 - 2008
MISE AU POINT & MODULES TP no4
# programme principal ---max = int(raw_input(u"Somme des entiers de 1 à :"))
n, cptB = 1, 0 while n <= max:
cptB = cptB+1 # nombre de passages dans la boucle s = (n * (n+1))/2
print "Somme des", cptB, "premiers entiers =", s n = n+1
Il vous suffit de suivre les instructions données dans ledocstring.
N’oubliez pas, bien sûr, de fournir descommentaires!
4.2 Programmation
4.2.1 Programme TP4_1.py
Réécrivez le programme de calcul de la suite de Syracuse en utilisant la technique des mo-dules.
Le premier fichier (le moduleTP4_1_m.py) ne contiendra que les fonctionsetapeSuivante() etaltMaxi().
Le programme principal (fichierTP4_1.py) importera ces fonctions et calculera : – le vol de l’étape initiale ;
– l’altitude maximale du vol ;
– la plus grande altitude maximale des vols de 1 à l’étape initiale.
Les résultats sont affichés dans desmsgbox(voir figure 4.1).