Mathématice, intégration des Tice dans l'enseignement des mathématiques  
Sommaire > N° 1 - Septembre 2006 > Comment faciliter la migration d’AlgoBox vers (...)

Comment faciliter la migration d’AlgoBox vers Python
Moteur de recherche
Mis en ligne le 23 novembre 2017, par Patrick Raffinat, Pascal Couvrechef

N.D.L.R Cet article est destiné au sommaire du n° 59 (mars 2018). Mais son thème, la migration d’AlgoBox vers Python, rendra service à ceux qui sont en train de convertir (merci aux virages sans préavis de l’Institution...) leurs anciens programmes AlgoBox en Python. Nous le mettons donc dans le domaine public dès maintenant.

S’il y a un problème temporaire d’accès à PluriAlgo, essayez cette solution de secours.

Dans l’annexe signalée dans la note 3, le lecteur fera connaissance avec le coauteur de l’article, Pascal Couvrechef.

A) Introduction

A l’occasion de la réforme de 2009, l’Education Nationale a encouragé l’utilisation d’AlgoBox en seconde, même si le programme officiel laisse aux enseignants toute liberté sur le choix des langages de programmation. Donc, de nombreuses ressources pédagogiques ont été développées pour AlgoBox.

En 2017, l’Education Nationale change de cap et encourage l’utilisation de Python, ce qui peut décourager de nombreux enseignants qui doivent non seulement apprendre un nouveau langage, mais aussi adapter les ressources pédagogiques qu’ils utilisaient. C’est pourquoi nous avons décidé d’écrire cet article dont l’objectif est de faciliter l’adaptation des ressources AlgoBox.

Pour y parvenir, nous nous appuierons sur le logiciel PluriAlgo, présenté dans plusieurs articles [1] : en effet, parmi ses nombreuses fonctionnalités, il y a un outil d’aide à la traduction qui peut être utilisé pour transformer un programme AlgoBox en un programme Python. Cet outil n’est pas un véritable traducteur car le code Python engendré n’est qu’approximatif si le code initial comprend des primitives graphiques, des listes ou des fonctions mathématiques prédéfinies : donc, l’article évoquera aussi ces points en Python.

Pour illustrer nos propos, nous utiliserons des programmes d’exemples accompagnant l’installation d’AlgoBox. Ils sont également disponibles en ligne sur le site officiel d’AlgoBox (voir http://www.xm1math.net/algobox/gallerie.html), et regroupés dans ce fichier zippé :

Zip - 3.7 ko
Les programmes AlgoBox de l’article

B) L’outil d’aide à la traduction de PluriAlgo

Exemple 1 : suite de Syracuse avec un copier-coller

L’outil est très simple à utiliser, comme l’illustre ce premier exemple (télécharger) :

Il suffit en effet de coller le code dans l’onglet « Editeur 1 » de PluriAlgo, puis de cliquer sur le bouton « Traduire » de l’onglet « Principal ». Le code obtenu, visible dans l’onglet « Editeur 2 », est un code Python car c’est le langage par défaut [2] :

  1. a = float(input("a : "))
  2. u=a
  3. print '0 -> '
  4. print "u : ", u
  5. for i in range(1, 100+1) :
  6. if (u%2==0) :
  7. u=u/2
  8. else :
  9. u=3*u+1
  10. print "i : ", i
  11. print ' -> '
  12. print "u : ", u

Télécharger

On peut constater que les instructions d’affichage sont écrites en Python 2.7 : il faudra donc les adapter pour les utilisateurs de Python 3.

Exemple 2 : méthode des trapèzes avec importation du fichier AlgoBox

Si on dispose de fichiers AlgoBox installés sur le poste utilisateur, on peut les télécharger dans l’onglet « Editeur 1 » avec le bouton « Ouvrir » : on voit alors apparaître non pas un code AlgoBox, mais un code Xml. Il ne faut pas s’en inquiéter : pour obtenir la traduction en AlgoBox, il suffit encore de cliquer sur le bouton « Traduire » dans l’onglet « Principal ».

Voici le résultat obtenu avec le fichier AlgoBox calculant l’aire d’une intégrale avec la méthode des trapèzes :

  1. def F1(x) :
  2. retour=x*x
  3. return retour
  4.  
  5. a = float(input("a : "))
  6. b = float(input("b : "))
  7. nbtrapezes = float(input("nbtrapezes : "))
  8. if (nbtrapezes>0 and b>a) :
  9. approxintegrale=0
  10. pas=(b-a)/nbtrapezes
  11. for i in range(0, nbtrapezes) :
  12. approxintegrale=approxintegrale+pas/2*(F1(a+i*pas)+F1(a+(i+1)*pas))
  13. print "approxintegrale : ", approxintegrale

Télécharger

Il y a un petit défaut, rédhibitoire pour certaines implémentations de Python : PluriAlgo n’a pas détecté que la variable nbtrapezes est un entier et pas un réel, ce qui peut poser un problème d’exécution de la boucle « Pour ». Il faut donc changer l’instruction de saisie de nbtrapezes : nbtrapezes = int(input("nbtrapezes : ")).

Un autre petit défaut, sans conséquence pour l’exécution, est l’introduction d’une variable nommée « retour » dans la fonction F1.

C) Courbes

Introduction

Dans la documentation d’AlgoBox, on trouve plusieurs exemples graphiques utilisant une primitive traçant un segment, dont celui-ci qui représente graphiquement la courbe de x³ – x² entre -2 et 4 :

Il est possible de coller ce code dans l’éditeur 1 de PluriAlgo pour en obtenir la traduction en Python, mais mieux vaut télécharger le fichier AlgoBox car il contient également l’expression mathématique définissant la fonction F1. Le code Python obtenu en cliquant sur le bouton « Traduire » est alors le suivant :

  1. def F1(x) :
  2. retour=pow(x,3)-3*pow(x,2)
  3. return retour
  4.  
  5. pas=0.1
  6. xdepart=-2
  7. while (xdepart<4) :
  8. xfin=xdepart+pas
  9. # TRACER_SEGMENT(xdepart,F1(xdepart),xfin,F1(xfin))
  10. xdepart=xfin

Télécharger

On voit que le TRACER_SEGMENT d’AlgoBox a été traduit sous forme de commentaire en Python, parce qu’il n’y a à notre connaissance pas d’équivalent dans la bibliothèque matplotlib. Pour obtenir un programme final opérationnel, deux options seront étudiées dans cet article :

  • utiliser des listes, technique utilisée dans les diverses documentations Python que nous avons examinées.
  • créer une procédure TRACER_SEGMENT en Python, ce qui permet de réutiliser au maximum la traduction proposée par PluriAlgo.

Solution 1 : utiliser des listes

Dans les diverses documentations Python que nous avons examinées, on introduit deux listes : une liste contenant l’abscisse de tous les points et une liste contenant toutes les ordonnées. La solution 1 est donc assez éloignée de la traduction fournie par PluriAlgo :

  1. def F1(x) :
  2. return x**3 - x**2
  3.  
  4. from matplotlib import pyplot
  5. pas=0.1
  6. xdepart=-2
  7. X = [] # liste des abscisses
  8. Y = [] # liste des ordonnees
  9. while (xdepart<=4) :
  10. X.append(xdepart)
  11. Y.append(F1(xdepart))
  12. xdepart=xdepart+pas
  13. pyplot.plot(X, Y)
  14. pyplot.show()

Télécharger

Que PluriAlgo n’ait pas été ici d’un très grand secours est anecdotique. Par contre, il faut s’interroger sur le bien fondé de proposer cette solution à des élèves de seconde sans faire d’enseignement spécifique (pas forcément très poussé) sur les listes, ce que revendique le document « Algorithmique et programmation » publié sur Eduscol pour tenir compte des nouveautés de la rentrée 2017-2018. Page 5, on y lit en effet :

Les listes ne font pas l’objet d’un enseignement spécifique en seconde, mais peuvent être utilisées comme objets simples et pratiques.

En tout cas, nous partageons pas du tout cet avis. C’est d’ailleurs ce qui nous a conduit à écrire un article sur les listes en Python dans le N°58 (voir lien).

Solution 2 : créer une procédure TRACER_SEGMENT

Cette solution cherche à réutiliser au maximum la traduction proposée par PluriAlgo en créant une procédure TRACER_SEGMENT en Python :

  1. from matplotlib import pyplot
  2.  
  3. def TRACER_SEGMENT(x1, y1, x2, y2) :
  4. pyplot.plot([x1,x2], [y1,y2])
  5. def F1(x) :
  6. return x**3 - x**2
  7.  
  8. xdepart=-2
  9. while (xdepart<4) :
  10. xfin=xdepart+pas
  11. TRACER_SEGMENT(xdepart,F1(xdepart),xfin,F1(xfin))
  12. xdepart=xfin
  13. pyplot.show()

Télécharger

La procédure utilise certes des listes de longueur 2, mais c’est « indolore » pour les lycéens : il n’est pas nécessaire ici qu’on leur explique ce qu’est une liste.

Une variante de cette solution est d’introduire une procédure TRACER_POINT, ce qui simplifie le programme puisqu’on n’a plus à gérer deux variables pour les abscisses (xdebut et xfin), mais une seule :

  1. from matplotlib import pyplot
  2.  
  3. def TRACER_POINT(x1, y1) :
  4. pyplot.plot([x1], [y1], color='blue', marker='+')
  5. def F1(x) :
  6. return x**3 - x**2
  7.  
  8. xdepart=-2
  9. while (xdepart<=4) :
  10. TRACER_POINT(xdepart,F1(xdepart))
  11. xdepart=xdepart+pas
  12. pyplot.show()

Télécharger

On peut trouver des informations complémentaires sur les graphiques en Python ici par exemple. Plus généralement, nous conseillons de parcourir le site http://www.python-simple.com/ dont fait partie cette rubrique consacrée à pyplot : c’est en effet un aide mémoire efficace qui fournit de nombreux exemples très simples.

D) Listes

Introduction

Dans la documentation d’AlgoBox, on trouve plusieurs exemples utilisant des listes, dont celui-ci qui simule 100000 répétitions du jet de 3 dés :

Le total d’un jet de 3 dés étant compris entre 3 et 18, les éléments d’indice 3 à 18 de la liste « issue » sont initialisés à 0. Ensuite, en fonction de chaque somme de 3 dés, l’élément correspondant de la liste est augmenté de 1. Voici la traduction en Python fournie par PluriAlgo :

  1. issue = [0]*10
  2. for i in range(3, 18+1) :
  3. issue[i]=0
  4. for i in range(1, 100000+1) :
  5. somme=floor(6*random()+1)+floor(6*random()+1)+floor(6*random()+1)
  6. issue[somme]=issue[somme]+1
  7. for i in range(3, 18+1) :
  8. propor=issue[i]/1000
  9. print "i : ", i
  10. print ' points -> '
  11. print "propor : ", propor
  12. print ' % des cas observés'
  13. # TRACER_SEGMENT(i,0,i,propor)

Télécharger

On peut constater que PluriAlgo a arbitrairement déclaré la liste « issue » comme étant de longueur 10, ce qui signifie que la numérotation des indices va de 0 à 9 : cela posera donc un problème à l’exécution, puisque le total des 3 jets peut aller jusqu’à 18. Il suffit donc de fixer la taille du tableau à 19 (issue = [0]*19) :

  1. from matplotlib import pyplot
  2. from random import random
  3. from math import floor
  4.  
  5. def TRACER_SEGMENT(x1, y1, x2, y2) :
  6. pyplot.plot([x1,x2], [y1,y2])
  7.  
  8. issue = [0]*19
  9. for i in range(1, 100000+1) :
  10. somme=floor(6*random()+1)+floor(6*random()+1)+floor(6*random()+1)
  11. somme = int(somme)
  12. issue[somme]=issue[somme]+1
  13. for i in range(3, 18+1) :
  14. propor = issue[i]/1000.0
  15. print "i : ", i
  16. print ' points -> '
  17. print "propor : ", propor
  18. print ' % des cas observés'
  19. TRACER_SEGMENT(i,0,i,propor)
  20. pyplot.show()

Télécharger

La boucle initialisant les éléments de la liste à 0 n’a pas été conservée : en effet, l’instruction « issue = [0]*19 » le fait déjà.

Fonctions AlgoBox sur les listes

Un reproche usuel et justifié concernant AlgoBox est la lourdeur de ses notations : en ce qui nous concerne, cela nous indiffère pour l’affectation (PREND_LA_VALEUR), mais nous exaspère pour un « si … sinon » qui crée de nombreuses lignes néfastes à la lisibilité du code (une pour DEBUT_SI, une pour FIN_SI et une pour DEBUT_SINON).

Mais les détracteurs les plus acharnés d’AlgoBox oublient de souligner qu’AlgoBox a en contre-partie quelques avantages dans un cadre mathématique en seconde : par exemple, pas besoin d’indiquer la taille de la liste « issue » en AlgoBox et tracé de courbes plus intuitif. Il y a aussi quelques fonctions mathématiques sur les listes, qui permettent par exemple d’obtenir facilement le maximum et le mode pour la somme de 3 dés :

Mais c’est moins direct quand on passe à Python :

  1. from random import random
  2. from math import floor
  3.  
  4. issue = [0]*19
  5. for i in range(1, 100000+1) :
  6. somme=floor(6*random()+1)+floor(6*random()+1)+floor(6*random()+1)
  7. somme = int(somme)
  8. issue[somme]=issue[somme]+1
  9. # maximum et mode
  10. maxi = max(issue[3:])
  11. print maxi
  12. for i in range(3, 18+1) :
  13. if (issue[i]==maxi) :
  14. print i

Télécharger

E) Conclusion

Nous ne sommes bien évidemment pas en train de faire le procès de Python : c’est un langage qui a fait ses preuves depuis longtemps [3] , et qui est bien plus universel et complet qu’AlgoBox.

Mais la richesse de Python peut aussi être un inconvénient pédagogique et perturber les lycéens. Par exemple, l’utilisation de listes est plus variée qu’avec AlgoBox : un enseignement spécifique (pas forcément très poussé) est donc nécessaire, sinon les élèves verront défiler des notations qu’ils ne comprendront pas vraiment, ce qui me dérange.

Par ailleurs, même si Python est adapté à l’enseignement des mathématiques, il est nécessaire de faciliter l’utilisation de ses librairies mathématiques et/ou d’introduire des fonctions spécifiques au lycée : c’est par exemple ce que fait la bibliothèque « lycee » définie dans le logiciel EduPython (en Python 3) et son alter ego AmiensPython (en Python 2). Et avec d’autres environnements Python, rien n’empêche d’y intégrer cette bibliothèque bien documentée dans le très pédagogique polycopié « Documentation pour l’enseignant », dont nous recommandons la lecture : il combine intelligemment présentation du langage et illustration avec des exemples mathématiques et, cerise sur le gâteau, propose 80 exercices corrigés.

Pour finir, nous espèrons que cet article ainsi que l’outil de traduction de PluriAlgo faciliteront le travail de nos collègues de lycée pour migrer d’AlgoBox vers Python.


notes

[1Le plus récent est dans le N°57 : voir http://revue.sesamath.net/spip.php?article1012

[2On pourrait changer de langage dans l’onglet « Principal », mais c’est Python qu’on étudie dans cet article !

[3D’ailleurs, Python avait déjà fait ses preuves avant 2009 : donc, pourquoi avoir encouragé AlgoBox en 2009 et encourager Python en 2017 ? Pour en savoir plus sur ce sujet, vous pouvez consulter cette annexe.

Documents associés à l'article
  Code AlgoBox pour la suite de Syracuse   |   (Texte - 417 octets)
  Annexe : pourquoi Python en 2017 seulement ?   |   (PDF - 235.7 ko)
Réagir à cet article
Vous souhaitez compléter cet article pour un numéro futur, réagir à son contenu, demander des précisions à l'auteur ou au comité de rédaction...
À lire aussi ici
MathémaTICE est un projet
en collaboration avec
Suivre la vie du site Flux RSS 2.0  |  Espace de rédaction  |  Nous contacter  |  Site réalisé avec: SPIP  |  N° ISSN 2109-9197