Mathématice, intégration des Tice dans l'enseignement des mathématiques  
Sommaire > Articles à paraître dans les numéros à venir > SofusPyScratch : un logiciel pour passer de (...)

SofusPyScratch : un logiciel pour passer de Scratch à Python en mathématiques
Moteur de recherche

A) Introduction : de SofusPy à SofusPyScratch

J’ai publié plusieurs articles consacrés à SofusPy, un logiciel en ligne permettant de programmer par blocs (au collège) et en Python (au lycée) :

  • au collège, son extension Blockly est plus adaptée à un contexte mathématique que Scratch : calcul formel, blocs spécifiques (augmenter/diminuer/multiplier/diviser une variable, augmenter/diminuer d’un pourcentage une variable)…
  • au lycée (lien), on peut programmer en Python en s’appuyant facultativement sur la programmation par blocs : insertion de la traduction de bloc(s) dans le code Python en cours d’écriture (lorsque les élèves ont des difficultés syntaxiques), blocs d’entrées-sorties adaptés aux préconisations Python (saisie et affichage par une fonction dont les paramètres sont les entrées de l’algorithme)...

SofusPy est donc une passerelle entre la programmation par blocs et Python, mais pas vraiment une passerelle entre Scratch et Python, même s’il permet partiellement l’importation de fichiers Scratch (Scratch 2) : ceux-ci sont alors transformés en programmes Blockly à leur ouverture, puis il suffit ensuite d’en demander la traduction en Python à l’aide d’un bouton spécifique.

Comment faire pour que SofusPy devienne une véritable passerelle entre Scratch et Python et, par conséquent, devienne plus attractif pour les enseignants de mathématiques du secondaire (compte-tenu de leurs contraintes horaires et des « recommandations » de leur hiérarchie) ? Pendant longtemps, je n’ai trouvé aucune solution, avant de me pencher de plus près sur la nouvelle version de Scratch (Scratch 3) : en effet, celle-ci a été programmée en Javascript (comme SofusPy) et, cerise sur le gâteau, son éditeur de blocs est une adaptation de celui de Blockly. Cela m’a permis de faire évoluer l’interface de SofusPy, ce qui rend un utilisateur de Scratch immédiatement opérationnel pour programmer par blocs avec SofusPyScratch.

B) SofusPyScratch au collège

L’apport principal de SofusPyScratch se situe au lycée, en facilitant la programmation Python à l’aide de blocs. Néanmoins, il peut y avoir ponctuellement un intérêt pratique à privilégier SofusPyScratch au collège.

Exemple 1 : programmes de calcul et calcul formel

Par exemple, on peut introduire des blocs (multiplier/diviser une variable par) pour rendre un programme de calcul plus compréhensible :

Une autre possibilité est de construire le programme de gauche dans Scratch, puis de l’importer dans SofusPyScratch (bouton « Ouvrir ») afin d’en faire une généralisation formelle en remplaçant « mettre n à 7 » à « mettre n à x ». Il faut alors utiliser l’extension « symbolique » de SofusPyScratch, comme cela est expliqué dans l’exemple 2 du menu « Démos » :

Exemple 2 : fonctions mathématiques et fonctions informatiques

Les programmes de calcul, outre leur intérêt algorithmique, sont aussi utilisés au collège pour introduire la notion de fonction mathématique. Hélas, la notion de fonction informatique n’est pas implantée en Scratch : en effet, il n’y a pas d’équivalent au « return » de Python, si bien qu’il faut « bricoler » pour par exemple calculer la différence de deux fonctions mathématiques. Avec SofusPyScratch, au contraire, on peut utiliser les mêmes notations (ici f(x) – g(x)) qu’en mathématiques :

Si on ne veut pas dévoiler aux élèves l’expression algébrique correspondant au programme de calcul (3x+5), on peut utiliser la tortue de SofusPyScratch pour voir que la courbe représentative de la fonction f semble être une droite et que sa pente semble valoir 3 :

C) SofusPyScratch au lycée

Introduction

Lorsqu’on tape « scratch python » sur un moteur de recherche, on trouve de nombreuses ressources pédagogiques où, sur le papier, on part d’un programme Scratch pour aboutir à un programme Python (qu’on demande parfois d’adapter). Cela serait encore plus profitable si l’on proposait aussi aux élèves un logiciel capable de gérer ce processus (traduction en Python et exécution d’un programme Python), ce que sait faire SofusPyScratch. On peut le vérifier en téléchargeant les programmes par blocs du menu « Démos », puis en cliquant sur le bouton « Traduire Blocs » et le bouton « Exécuter » (de l’éditeur Python).

Ces ressources sont proposées en début de Seconde, pour une transition « en douceur » entre le collège et le lycée. Il semblerait qu’ensuite la programmation par blocs ne soit plus utilisée pour faire progresser les élèves en Python, ce que je trouve dommage, ne serait-ce que pour des raisons syntaxiques. C’est pourquoi, en plus du bouton « Traduire blocs », il y a un bouton « Insérer blocs » :

  • « Traduire blocs » efface le contenu de l’éditeur Python avant la traduction des blocs.
  • « Insérer blocs » insère la traduction dans le code Python en cours d’écriture, ce qui permet de combiner écriture directe en Python (l’objectif prioritaire est de faire progresser les élèves en Python) et programmation par blocs (une aide syntaxique n’est toutefois pas à négliger).

L’introduction de blocs d’entrées et de sorties dans SofusPyScratch, sur laquelle je reviendrai en détail, est un autre apport possible de la programmation par blocs. Elle établit clairement un lien entre les programmes de collège (entrée=saisie, sortie=affichage) et ceux du lycée (entrée=paramètre de fonction, sortie=valeur renvoyée). Outre cet apport méthodologique, il y a aussi un apport opérationnel : il n’est pas nécessaire de définir une fonction dans le programme par bloc pour obtenir un programme Python avec fonction, donc pas nécessaire de maîtriser le concept (pas évident [1]) de fonction informatique. Je note, ce qui me conforte dans cette approche, qu’elle est clairement revendiquée dans la fiche « Premiers pas en Python » sur le site web de la calculatrice NumWorks (lien) :

Exemple 1 : minimum (maximum) de deux nombres et entrées-sorties

Supposons qu’on ait créé le programme Scratch suivant :

Après l’avoir enregistré (de préférence au format « Scratch 3 » [2]), on peut le récupérer dans SofusPyScratch (bouton « Ouvrir ») puis en en demander la traduction en Python (bouton « Traduire blocs »). On récupère alors un code Python qui n’est clairement pas optimal, puisque la variable « reponse » peut être enlevée, ce qu’on peut demander ensuite comme exercice aux élèves. Il est à noter qu’on aurait pu éviter d’introduire artificiellement cette variable « réponse » en écrivant le programme par blocs directement dans SofusPyScratch :

Mais le véritable intérêt de ces deux blocs « entrée » est de migrer « en douceur » vers les préconisations du lycée (saisies remplacées par des paramètres d’une fonction, affichage remplacé par un « return »). Dans ce but, il faut changer l’option « demander un nombre » par « tester », ce qui permet d’obtenir une procédure paramétrée en Python :

Une dernière étape est de faire disparaître les deux « print », ce qui est d’autant plus délicat à expliquer formellement qu’on va introduire le t-uple « mini,maxi » dans le bloc « sortie ». Evidemment, mieux vaut une pseudo-justification du style « on sépare les résultats par une virgule », plus intuitive :

Pour être complet dans l’article sur les entrées-sorties, j’ai choisi un exemple avec plusieurs variables en sortie. Mais dans le cas présent, mieux vaut à mon avis traiter séparément le cas du minimum et du maximum pour aboutir à deux fonctions renvoyant une seule valeur. Et, après avoir traité le minimum via la programmation par blocs, on peut s’en passer pour le maximum en adaptant le code Python préalablement obtenu pour le minimum.

Exemple 2 : moyenne et listes

Dans un article du N°69 (lien), Matthieu Brabant propose deux petits exemples s’intégrant dans le programme de mathématiques en bac pro, dont un consacré au calcul d’une moyenne :

Il me semble que la programmation par blocs apporterait un plus concernant la seconde version de la moyenne, en la rendant plus intelligible avec son pseudo-code :

Le code Python produit par SofusPyScratch est ensuite à adapter légèrement pour obtenir le programme Python de Matthieu Brabant, qui conclut par une analyse à laquelle je souscris totalement : « Cette proposition est assez simple, mais elle permet d’engager les élèves concrètement sur un programme qu’elles et ils peuvent maîtriser et les encourager à un trouver un autre ».

Dans la même optique, je vais prolonger cet exemple pour introduire « en douceur » les listes. Je ne sais pas si c’est compatible avec une filière pro, mais cela figure au programme des filières générales. Une liste de test, fournie dans le bloc « entrée », permet de créer une fonction (nommée « algo ») calculant la moyenne dans le code Python engendré par le traducteur de SofusPyScratch.

Le renommage de la fonction « algo » en « MoyenneListe » peut être le point de départ d’une activité Python sur la calcul de la variance. On peut aussi chercher à tout faire en programmation par blocs, mais c’est un peu fastidieux même si on peut faire des copier-coller de blocs pour calculer la seconde somme :

Exemple 3 : polynômes de Lagrange et calcul formel

Pour montrer que la programmation par blocs peut être utile au-delà de la phase d’introduction de Python en Seconde, je vais reprendre brièvement une activité de Terminale S présentée dans MathémaTICE (lien), en commençant par rappeler la formule mathématique à programmer :

Voici un programme par blocs testant cette formule :

Voici la traduction Python fournie par SofusPyScratch :

  1. from sympy import *
  2. x, y, z, t = symbols('x y z t')
  3. def algo(X,Y) :
  4. n = len(X)
  5. P = 0
  6. for j in range(1,int(n + 1)):
  7. L = 1
  8. for j in range(1,int(n + 1)):
  9. if ((not (i == j))) :
  10. L = L * ((x-X[i-1])/(X[j-1]-X[i-1]))
  11. P = P + Y[i-1]*L
  12. return P
  13.  
  14. print(algo([1,-3,8],[6,-8,-4]))

Télécharger

Avant d’exécuter le programme (bouton « Exécuter » de l’éditeur Python), il faut veiller à choisir l’extension symbolique (dans la zone de liste déroulante jaune). Le polynôme n’étant pas simplifié, il faut le demander dans la console Python de Sympy Live (fonction « simplify ») :

Exemple 4 : illustration graphique de la loi des grands nombres

Les listes sont utilisées à diverses occasions au lycée, en particulier pour faire des simulations. Je reprends ici un exemple d’un document (lien, pages 14-15) publié sur Eduscol. On jette un dé truqué (une face 1, trois faces 2 et deux faces 4) un grand nombre de fois afin d’observer graphiquement la convergence vers la moyenne (ici 2.5) de la variable aléatoire associée au dé.

Le programme Python me semble « plutôt ardu » (listes, fonction sans paramètre pour un lancer et syntaxe de la librairie matplotlib), d’autant que le contexte mathématique (variable aléatoire) n’est pas évident. Donc un programme par blocs préalable peut contribuer à rendre l’algorithme plus intelligible (ou moins obscur ?).

Voici le code Python fourni par SofusPyScratch :

  1. import random
  2. import matplotlib.pyplot
  3.  
  4. def math_plot(xListe,yListe,titre) :
  5. matplotlib.pyplot.plot(xListe,yListe)
  6. matplotlib.pyplot.title(titre)
  7. matplotlib.pyplot.show()
  8.  
  9. def lancer() :
  10. de = random.randint(1, 6)
  11. if (de < 2) :
  12. de = 1
  13. else :
  14. if (de < 5) :
  15. de = 2
  16. else :
  17. de = 4
  18. return de
  19.  
  20. def algo(n) :
  21. Y = []
  22. X = []
  23. total = 0
  24. for k in range(1,int(n + 1)):
  25. total = total + lancer()
  26. X.append(k)
  27. Y.append(total/k)
  28. math_plot(X,Y,'grands nombres')
  29.  
  30. algo(500)

Télécharger

Et voici le graphique obtenu, après que j’aie complété le sous-programme « math_plot » avec une instruction ( « matplotlib.pyplot.plot([1,len(xListe)],[2.5, 2.5],’r-’) » ) permettant de visualiser la moyenne avec un trait rouge :

D) Conclusion

SofusPyScratch fait au moins aussi bien que Scratch pour la « programmation classique », c’est à dire hors programmation événementielle et parallèle. Et puisque son éditeur de blocs fonctionne comme celui de Scratch 3, les élèves seront immédiatement opérationnels avec SofusPyScratch, ce qui est important compte-tenu des contraintes horaires des enseignants de mathématiques du secondaire.

Au collège, il peut y avoir ponctuellement un intérêt pratique à privilégier SofusPyScratch. J’en ai donné deux exemples (programmes de calcul et calcul formel, fonctions mathématiques).

Au lycée, l’outil de traduction de SofusPyScratch permet une transition « en douceur » de la programmation par blocs vers Python en Seconde. Mais la programmation par blocs peut aussi rendre des services tout au long du lycée, comme le montre l’activité de Terminale S sur les polynômes de Lagrange.

Le logiciel est encore en cours de développement (graphiques notamment), mais les différents exemples présentés dans cet article fonctionnent d’ores et déja et sont disponibles dans le menu « Démos ». Il peut être testé sur mes pages professionnelles (lien).


notes

[1Je n’ai évidemment rien contre l’utilisation de fonctions, mais mon expérience d’enseignant d’informatique (en IUT) me rend dubitatif sur l’efficacité d’une introduction prématurée du concept (hors du cas particulier « f(x) ») dont les élèves sont familiers en mathématiques).

[2Pour cet exemple, il est indifférent d’importer un fichier « Scratch 2 » ou un fichier « Scratch 3 ». Si, pour un autre exemple, on rencontre un problème pour l’importation d’un fichier Scratch 2 (moins bien gérée par SofusPyScratch), une parade est d’ouvrir ce fichier (de format « sb2 ») dans Scratch 3 pour l’enregistrer (au format « sb3 »).

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