Nous étions nombreux à attendre un outil qui autoriserait une programmation simple en Python de constructions géométriques. Les développeurs de GeoGebra s’en sont chargé. Le mariage tant attendu entre Python et GeoGebra est devenu réalité
par Jean-Yves Labouche
Il y a quelque temps, Patrick Raffinat nous présentait son formidable ScratchGGB (ici et ici ou encore ici avec Juliette Hernando, trois articles de MathémaTICE), qui nous permet de programmer par blocs une construction géométrique tout en bénéficiant de la simplicité de Scratch et de l’ergonomie de GeoGeobra. L’outil est génial, facile à prendre en main et très utile au collège avec ses banques d’exercices prêts à l’emploi.
Nous étions nombreux à attendre un outil similaire qui autoriserait une programmation simple en Python de constructions géométriques. Et cette fois, ce sont les développeurs de GeoGebra qui s’en chargent. Le mariage tant attendu entre Python et GeoGebra est devenu une réalité, certes en version bêta, mais qui nous promet déjà de très belles choses. Pour être tout à fait précis, il y a quelques années une tentative avait déjà été faite. Malheureusement, le projet avait rapidement été enterré par l’équipe de GeoGebra. À l’époque, le langage Python n’était pas dans les programmes du lycée en France et, certainement, peu de collègues de l’hexagone s’étaient sentis concernés. Espérons que cette nouvelle version soit pérenne et qu’elle ne subisse pas le même sort.
Pour la tester, une seule adresse : https://www.geogebra.org/python/
Une IDE Python comme une autre, ou presque…
PyGgb n’est rien d’autre qu’un IDE (Environnement de Travail Intégré) Python qui intègre une bibliothèque Python qui permet d’interagir avec les commandes et les objets de GeoGebra. L’interface est minimaliste et classique : à gauche, une fenêtre de programmation (éditeur Python, donc) et à droite, l’interface graphique (GeoGebra). En dessous de celle-ci, la console qui pourra afficher des résultats non graphiques, mais qui ne permet pas de saisir des instructions.
Ces fenêtres ne sont pas redimensionnables ce qui est un peu dommage : sur un écran large, on aimerait bien agrandir la fenêtre graphique. Celle-ci est dynamique, mais ne possède aucun menu (il n’est pas possible, par exemple, de cacher les axes ou la grille d’un simple clic) et le clic droit sur les objets n’est pas possible (on peut juste les sélectionner pour les déplacer). Nous avons juste 3 boutons : zoom avant, zoom arrière et un retour à la vue de départ (origine centrée dans la fenêtre).
On le comprend vite, il s’agit ici avant tout de programmer, pas (ou peu) d’interagir manuellement avec les objets. Mais contrairement aux IDE auxquels nous sommes habitués, la fenêtre graphique est intégrée : elle n’aura pas besoin d’être appelée via une bibliothèque spécifique.
L’apport de Python à GeoGebra
Connaitre les commandes et fonctions qui permettent de créer et d’interagir avec les objets graphiques est une chose importante pour commencer, j’y reviendrai dans la suite de l’article. Mais, bien évidemment, le plus important ici, la puissance de Pyggb, c’est de pouvoir utiliser le langage Python dans la création d’une construction : les boucles, les tests conditionnels, l’utilisation de fonctions… les possibilités sont infinies.
Pour commencer, il ne faut pas perdre de vue que nous sommes dans un environnement Python : des fonctions comme sqrt(), floor() ou randint() devront être appelées dans leurs bibliothèques respectives pour pouvoir être utilisées.
Voici un exemple de programme (obtention du triangle de Sierpinski avec la méthode du jeu du chaos) accessible dès la classe de seconde (tester) :
- from random import randint
- from time import sleep
- xA,yA,xB,yB,xC,yC = -8,0,8,0,0,14
- A = Point(xA,yA)
- B = Point(xB,yB)
- C = Point(xC,yC)
- xM = randint(-8,8)
- yM = randint(0,14)
- def nouveaupoint(x,y):
- n=randint(1,3)
- if n==1:
- xnew = (xA+x)/2
- ynew = (yA+y)/2
- elif n==2:
- xnew = (xB+x)/2
- ynew = (yB+y)/2
- else:
- xnew = (xC+x)/2
- ynew = (yC+y)/2
- return (xnew,ynew)
- for i in range(1000) :
- xM,yM = nouveaupoint(xM,yM)
- M = Point(xM,yM,size=2)
- sleep(0.1)
Et voici la figure ainsi obtenue :
On se rend très vite compte de ce que l’outil apporte en simplicité d’utilisation. On peut parfaitement réaliser cette construction en utilisant Python dans un IDE classique et la bibliothèque Matplotlib par exemple. Mais dans ce cas, le programme devient très vite plus complexe pour des élèves qui découvrent Python. PyGgb permet de s’affranchir de la lourdeur des bibliothèques de visualisation disponibles dans Python.
Pour les programmeurs avertis, PyGgb permet, évidemment, l’utilisation d’un grand nombre de bibliothèques Python. Les principales sont : Array, Bisect, Collections, Copy, Dateline, Functools, Image, Itertools, Math, Numbers, Platform, Sys, Random, RE, Signal, String, Textwrap, Time, Webbrowser.
Un excellent livret GeoGebra en espagnol donne de nombreuses utilisations possibles de ces bibliothèques et de leurs fonctions : https://www.geogebra.org/m/mvcy7r23
La prise en main de PyGgb
La difficulté, pour prendre en main ce qui promet d’être un très bel outil pour aborder la programmation au lycée son un angle nouveau, est de savoir quelles sont les fonctions ou commandes que nous allons pouvoir utiliser.
À commencer par le plus simple : comment créer un point ? Avec GeoGebra, pour placer un point de coordonnées données, on utilisera la commande A = (3,1). Cela ne fonctionne pas ici puisque cette même commande, dans Python, permet de définir un tuple. Il y a donc un conflit entre le langage de programmation et certaines commandes de GeoGebra. Pour ce cas précis, une fonction spécifique permet la création d’un point : A = Point(3,1). C’est simple, mais le problème est qu’il n’y a, pour le moment, aucune documentation qui listerait les commandes GeoGebra utilisables dans PyGgb ou les fonctions disponibles dans cette bibliothèque PyGgb.
Mais il y a des exemples de programmes, dont certains sont assez impressionnants. Pour y accéder, aller dans le menu « File » puis « Open ».
Dans « Examples », nous avons accès à une douzaine de fichiers, certains assez complexes, d’autres, plus élémentaires et certains, qui ne fonctionnent pas…
En passant ces programmes en revue, on peut se faire une idée de ce qu’il est possible de faire et de se créer un petit lexique de fonctions. C’est ce que j’ai fait. J’ai également testé un certain nombre de commandes GeoGebra pour voir si elles étaient acceptées comme fonctions dans PyGgb. Je vous propose ici les résultats de ces quelques tests qui, s’ils sont loin d’être exhaustifs, pourront permettre de gagner du temps à tous ceux qui veulent se lancer. Je précise que je n’ai testé pour cet article que les commandes qui interagissent avec la fenêtre graphique (2D). D’autres fonctions, non graphiques, sont aussi répertoriées : ce sont celles trouvées sur les exemples de programmes, disponibles sur PyGgb.
Certains des exemples qui sont proposés sont impressionnants comme le fichier ci-dessus nommé « Juggling animation »
Des commandes qui fonctionnent
Pour commencer, voici quelques commandes GeoGebra que les habitués du logiciel seront heureux de retrouver. Encore une fois, il ne s’agit pas ici de dresser un tableau complet des fonctionnalités disponibles de PyGgb, mais d’en avoir un aperçu pour pouvoir se lancer dans son utilisation. Ce sont les commandes en anglais et je n’en détaille pas ici l’utilisation : le site https://wiki.geogebra.org/en/Commands les recense et explique toutes (dans leur utilisation dans GeoGebra : il peut y avoir des différence dans PyGgb).
– p=Polygon((A,B,C)) #A, B et C sont des points
– p=Polygon([A,B,C])
– p=Polygon(A,B,5) #pentagone régulier
– Segment(A,B)
– Vector(A,B)
– Line(A,B)
– Line(a,b) #coeff directeur et ordonnée à l’origine
– Circle(A, 3) #centre et rayon
– Circle(A, 3,color=’green’,line_thickness=10)
– Ellipse(A,B,2)
– Parabola(a, b, c) # trace la parabole d’équation y=ax²+bx+c
– Vector(B, C)
– D = Rotate(A, pi/6).with_properties(color=’green’)
# le centre de la rotation est l’origine
# pi doit être importé de la bibliothèque math
# with_properties() permet de modifier les attributs du point
– Intersect(parabola, line,2) # 2 objets ggb et le n° pt intersection
– z = complex(2, -4)
– abs(z) # argument de z
– a=Slider(0, 4, increment=0.1)
– Distance(A,B)
Quelques commandes qui ne fonctionnent pas
Parmi les quelques déceptions, les commandes suivantes sont absentes dans PyGgb sous leur forme connue dans GeoGebra :
– Ray()
– Midpoint()
– Hyperbola()
– Angle()
– CircularArc()
Il y en a très certainement beaucoup d’autres. Mais s’agissant d’une version bêta, on peut aussi espérer que ces fonctions seront activées par la suite.
Quelques fonctions propres à PyGgb
PyGgb intégre une bibliothèque propre à GeoGebra et qui possède ses propres fonctions avec des arguments qui permettent de modifier certains attributs des objets créés.
J’ai déjà mentionné la fonction Point() qui est forcément indispensable. Nous avons la possibilité de changer quelques attributs du point :
- A = Point(1,2, color=’green’, size=9 , is_visible=False)
# Size entre 1 et 9
# Color ‘mot’ ou RVB en hexadecimal ’#00FF00’ ou ‘#F08’ ou [0.5,0.2,0.8]
De même, pour les fonction Circle(), line() ou Segment() il est possible de changer les attributs de l’objet. Par exemple :
- Segment(A,B,line_thickness=10, color=’green’)
Il est également possible de modifier ou de récupérer un attribut d’un objet :
- A.x = 3 permet de fixer l’abscisse du point A à 3 ou de la récupérer. Par exemple : print(A.x)
- A.color = « red » permet de fixer la couleur du point A à rouge ou de la récupérer. Par exemple : print(A.color)
- A.is_visible = False permet de cacher le point A.
L’instruction @A.when_moved permet d’attendre que le point A soit déplacé pour exécuter la partie du programme qui la suit. Les fonctions utilisées après cette instruction doivent être définies également après celle-ci.
Par exemple ce court programme place un point A et son symétrique par rapport à l’axe des ordonnées. Le déplacement (manuel) de A « dessine » le déplacement de B.
Un développement à suivre
On peut penser que nous serons nombreux à nous emparer de ce nouvel outil de programmation qui est à notre disposition. Il n’est pas parfait, il manque notamment une véritable documentation et une interface graphique plus élaborée. Mais il s’agit d’une version bêta : si PyGgb rencontre un certain succès, alors on peut espérer que des améliorations arriveront et que certaines commandes GeoGebra manquantes seront intégrées.
Suivons donc de près le développent de PyGgb ; en attendant, il y a déjà de quoi se faire plaisir et initier nos élèves à la programmation avec Python dans un environnement familier.