Référence:Jython

De GeoGebra Manual
Aller à : navigation, rechercher

Scripts Python dans GeoGebra 5

La fenêtre Python

La fenêtre Python contient trois volets :

• Interactive : Ici vous pouvez entrer des expressions Python et voir immédiatement leur effet. Avec les touches Alt+Haut / Alt+Bas vous pouvez naviguer dans l’historique des commandes que vous avez entrées.

• Script : Ici vous pouvez écrire le script qui sera exécuté au chargement du fichier .ggb. Vous pouvez aussi exécuter le script à tout moment.

• Events : Ici vous pouvez sélectionner un objet GeoGebra quelconque et lui lier un script Python qui sera exécuté si on clique sur l’objet ou on modifie sa valeur. Dans ce script, l’objet lié à l’événement peut être référencé par self.


Démo

Copiez et collez ce script dans le volet interactive

geo.A = (1,2)
# Créer quelques points au hasard
import random
xcoords = [random.uniform(-2, 5) for i in range(8)]
ycoords = [random.uniform(-2, 5) for i in range(8)]
points = [Point(x, y) for x, y in zip(xcoords, ycoords)]
# Les relier tous à A
segments = [Segment(p, geo.A) for p in points]
# Définir une fonction affichant uniquement le plus court segment
def show_shortest(moved_point):
for s in segments: s.visible = False
shortest = min(segments, key=float)
shortest.visible = True
# L’appeler chaque fois que A est modifié
geo.A.onupdate = show_shortest

# Maintenant déplacer A dans la fenêtre Graphique !

Les noms Python et GeoGebra

Comme Python et GeoGebra travaillent tous deux avec des objets qui ont des noms, il est important de pouvoir accéder facilement aux objets GeoGebra depuis Python sans confondre deux types d’objets. Les objets GeoGebra peuvent être atteints (et créés) dans Python en préfixant leur nom avec $ ou geo. Ainsi s’il existe un point nommé A, il peut être référencé par $A ou geo.A depuis Python. Tous les autres noms ne sont pas accessibles depuis Python.

Comme ce qui précède autorise seulement des noms en ASCII, il y a une syntaxe pour avoir accès au nom en non-ASCII qui peut être pratique dans d'autres langues. L’écriture suivante retournera tout objet GeoGebra nommé A :

$A
geo.A
$['A']


Il y a aussi une syntaxe pour accéder ou modifier aux cellules du tableur :

$['B', 2] = 12 # Affecte la valeur 12 à B2
$[3, 1] = 42 # Affecte la valeur 42 à C1 (A=1, B=2, ...)
$['A', 1] = (2, 2) # Affecte le point (2, 2) à A1
$['A', 1].color = Color.RED # Change la couleur du point

Points et Vecteurs

  • Vous pouvez créer des points et des vecteurs par leurs coordonnées :

$A = Point(1, 2)
$B = Point(-2, 3)
$u = Vector(1, -1)

  • Vous pouvez créer un point à partir d’un vecteur :

$C = Point($u)

  • Vous pouvez créer un vecteur à partir d’un point :

$r_A = Vector($A)

  • Vous pouvez créer un vecteur à partir de deux points :

$v = Vector($A, $B)

Si A est un point ou un vecteur :
$A.x vous retourne son abscisse ;
$A.y vous retourne son ordonnée ;
$A.coords vous retourne son couple de coordonnées.


Cependant, vous n’obtenez pas un nombre comme résultat mais une expression dont la valeur change dynamiquement dès que le point ou le vecteur sont déplacés.
Pour obtenir la valeur actuelle, vous devez utiliser A.x.value et A.y.value.
Ces attributs vous permettent aussi d’affecter des coordonnées d’un point ou d’un vecteur :
$A.x = 3
$B.coords = (-1, 2) définit l’abscisse de A à 3 et les coordonnées de B à (-1, 2).
Vous pouvez aussi utiliser ces attributs pour lier des points ensemble :
$C = Point(2*$A.x, 1+$B.y)
crée un point C dont l’abscisse est toujours le double de celle de A, et l’ordonnée est toujours celle de B augmentée de 1.

Les points ont, en plus, l’attribut suivant :

  • point_size : un entier correspondant à la taille du point

Attributs communs à tous les éléments

Les attributs suivants ne s’appliquent pas seulement aux points et aux vecteurs, mais à tous les objets GeoGebra.

  • caption (une chaîne) ;
  • color (pour la définir, utiliser par ex. Color.RED ou Color(0.5, 0.9, 0.8), identique à java.awt.Color) ;
  • defined (booléen, en lecture seule) : true si l’élément est défini ;
  • infinite (booléen, en lecture seule) : true si l’élément est infini ;
  • label (une chaîne) ;
  • label_color ;
  • label_mode peut être l’une des options name, name+value, value, caption
  • label_visible (booléen) ;
  • layer (entier) : numéro entier entre 0 et 9 du calque dans lequele est afficgé l’objet ;
  • trace (booléen): si true, l’élément va laisser une trace.
  • visible (booléen) ;

Ce script crée un point rouge avec une légende noire disant : "Cliquez moi" :
$P = Point(3, 1)
$P.color = Color.RED
$P.label_color = Color.BLACK
$P.label_mode = "caption"
$P.caption = "Cliquez moi"


Les attributs peuvent être affectés simplement à la création de l’objet.
Le script suivant a le même effet que le précédent :
$P = Point(3, 1, color=Color.RED, label_color=Color.BLACK, label_mode='caption', caption="Cliquez moi")

Chemins

Droites et segments

Ce script crée une droite l passant par les points A et B :
$l = Line($A, $B)

Ce script crée une droite l1 passant par A et dirigée par le vecteur u :
$l_1 = Line($A, $u)

Demi-droites et segments peuvent aussi être créés :

$r = Ray((1, 1), (2, 0))
$s = Segment((-3, 0), (2, 1))

Les segments ont deux attributs nommés startpoint et endpoint.
Les droites, segments et demi-droites ont un attribut nommé direction qui donne leur vecteur directeur.


Axes

Il existe deux objets spéciaux, $xAxis et $yAxis qui représentent les deux axes de coordonnées.
Ce que nous pouvons faire avec est limité pour l’instant.
Ils ont l’attribut suivant :

  • visible : ce qui permet de modifier la visibilité d’un axe.

Ce script cache les deux axes dans la fenêtre Graphique :
$xAxis.visible = False
$yAxis.visible = False


Cercles,Ellipses, Hyperboles, Paraboles

Créations

C1 de centre (1, 1) et passant par le point (3, 2) ; $C_1 = Circle((1, 1), (3, 2))
C2 passant par les trois points (0, 0), (4, 0), (4, 3) ; $C_2 = Circle((0, 0), (4, 0), (4, 3))
C3 de centre A et de rayon BC ; $C_3 = Circle($A, Segment($B, $C))
C4 de centre (-2, 0) et de rayon 3 ; $C_4 = Circle((-2, 0), 3)
E1 de foyers (-2, 0), (2, 0) et de longueur de demi grand axe 3 ; $E_1 = Ellipse((-2, 0), (2, 0), 3)
E2 de foyers (1, 1), (3, 1) et passant par le point (2, 2) ; $E_2 = Ellipse((1, 1), (3, 1), (2, 2))
H1 de foyers (-2, 0), (2, 0) et de longueur de demi grand axe 1 ; $H_1 = Hyperbola((-2, 0), (2, 0), 1)
H2 de foyers (1, 1), (3, 1) et passant par le point (4, 2) ; $H_2 = Hyperbola((1, 1), (3, 1), (4, 2))
P de foyer (0, 0) et de directrice la droite (AB). $P = Parabola((0, 0), Line($A, $B))



Attributs pour les chemins

Tous les chemins (droites et courbes) possèdent les attributs :

  • thickness (une valeur numérique) ;
  • linetype (c’est une chaîne qui peut être l’une des options full, short-dash,long-dash, dot, dash-dot).


Polygones et Lignes Brisées

Pour créer un polygone de sommets A, B et C vous pouvez utiliser :
$ABC = Polygon($A, $B, $C)
ou $ABC = Polygon([$A, $B, $C])
cette dernière écriture étant plus utile si vous désirez créer un polygone à partir d’une liste quelconque de points.

Les polygones possèdent les attributs :

  • boundary : la frontière du polygone en tant que ligne brisée ;
  • points: une liste Python de tous les sommets du polygone (elle peut aussi être obtenue par list(poly)) ;
  • area ou value : l’aire du polygone ;
  • edges : une liste Python de tous les côtés du polygone ;
  • directed_area : l’aire avec un signe (+ sens anti-horaire, - sens horaire) ;
  • len(poly) la « longueur » du polygone, c'est-à-dire le nombre de sommets.

Le point d’indice i peut être obtenu par poly[i].

Il en va de même pour les lignes brisées, mais sans les attributs edges, area ou directed_area, et leur attribut value retourne leur longueur totale.


Listes

Les listes GeoGebra ne doivent pas être confondues avec les listes Python.
Les listes peuvent être créées comme suit :
my_list = List(1, 2, 3) crée une liste GeoGebra ;
python_list = [1, 2, 3] crée une liste Python.

La notation indicielle peut être utilisée pour obtenir ou supprimer un élément à une position donnée :
print my_list[1] affiche le deuxième élément (le premier ayant pour indice 0) ;
del my_list[0] supprime le premier élément.
Un nouvel élément peut être ajouté à la fin de la liste avec la méthode append :
my_list.append(42)
Il est possible de faire une boucle sur les éléments d’une liste :
for item in my_list
print item + 10
Vous pouvez convertir une liste GeoGebra en une liste Python :
python_list = list(my_list)
Vous pouvez supprimer tous les éléments d’une liste GeoGebra avec la méthode clear :
my_list.clear()


Textes

On peut créer des textes comme suit : t = Text("Bonjour à tous !")

Les textes ont les attributs suivants :

  • origin (un point). Il peut être lu ou affecté ;
  • text (la chaîne pour le texte). Elle peut être lue ou affectée ;
  • latex (un booléen): true si le texte doit être affiché en LaTeX.


Ce script place l’origine du texte t au point (2, 2) et définit le texte à afficher par "Abracadabra".
t.orgin.coords = (2, 2)
t.text = "Abracadabra"

Vous pouvez aussi effectuer ce changement d’origine par l’instruction suivante : t.orgin = (3, 1)
Mais à la différence de ce qui précède, ce ne sont pas les coordonnées qui sont actualisées, mais un nouveau point qui est créé.


Ce script place l'origine du texte t au point a,ainsi si le point A est déplacé, le texte le sera aussi :
t.origin = $A


Fonctions

Les fonctions peuvent être facilement définies dans Python :
def f(x): return sin(x)/x
$f = Function(f)

Les fonctions de deux variables sont aussi possibles.
def f(x, y): return x**2+y**2 - 5

Les fonctions ont un attribut implicitcurve :
$f = Function(f)
$c = f.implicitcurve

Les fonctions peuvent utiliser des inégalités :
def f(x, y): return x**2 > x + y
geo.f = Function(f)


Tortues

Les tortues sont des objets qui peuvent être déplacés et dessiner des formes dans la fenêtre euclidienne (voir le langage logo) Pour créer uje nouvelle tortue, il suffit de valider : t = Turtle()
Les tortues peuvent être déplacées, et le mieux à leur sujet c’est qu’elles peuvent être animées, i.e. vous pouvez surveiller leur déplacement. Leur vitesse peut être ajustée, voir ci-dessous. Voici un exemple simple pour faire dessiner un pentagone régulier à la tortue définie précédemment :
t.pen_color = Color.RED
for i in range(5):
t.forward(2)
t.turn_left(72)


Notez comment vous pouvez voir la tortue se déplacer et tourner sans à-coups. Si vous préférez que la tortue dessine instantanément, vous pouvez faire t.speed = 0

Les objets Tortue ont les attributs suivants :

  • pen_color : peut être utilisé pour obtenir ou définir la couleur du crayon de la tortue ;
  • position : peut être utilisé pour obtenir ou définir la position actuelle de la tortue ;
  • angle : peut être utilisé pour obtenir ou définir l’orientation actuelle de la tortue ;
  • pen_thickness : peut être utilisé pour obtenir ou définir la largeur du trait de crayon de la tortue ;
  • running : défini à True pour animer la tortue, à false pour arrêter son déplacement ;
  • speed : la vitesse d’animation de la tortue – c’est un nombre décimal entre 0 et 1. 0 signifie instantané, 0.01 très lent, 1 très rapide (par défaut 0.1)

Les objets Tortue ont les méthodes suivantes :

  • forward(distance): pour faire avance de distance unités. Ce qui tracera aussi un segment si le crayon est baissé ;
  • turn_left(angle): pour tourner à gauche de angle degrés ;
  • turn_right(angle): pour tourner à droite de angle degrés ;
  • clear(): réinitialise la position et l’angle de la tortue et efface le dessin.

Intersections

Intersect(x, y) fonctionne pour x et y étant, pour l’instant, seulement des droites ou des coniques. On peut aussi l’utiliser pour une liste de couples de nombres pour trouver les points d’intersection.
l = Line((0, 1), (2, 2))
c = Circle((0, 0), 3)
p, q = Intersect(l, c)

Pour tester si un point d’intersection `p` existe, utilisez `not p.infinite` (ou `p.infinite` pour tester si l’intersection n’existe pas). Notez que `p.defined` ne fonctionne pas parce que GeoGebra est basé sur la géométrie projective, dans laquelle deux droites ont toujours un point d’intersection.


Accès aux objets sélectionnés

L’objet selection permet l’accès à la sélection actuelle : - selection.all retourne la liste de tous les objets sélectionnés ; - selection.filter(<type>) retourne la liste de tous les objets de type <type> sélectionnés.

Si cela convient, les syntaxes suivantes peuvent aussi être utilisées :

  • selection.points ;
  • selection.vectors ;
  • selection.lines ;
  • selection.segments.


Gérer les événements

Vous pouvez utilisez le volet Events dans la fenêtre Python pour sélectionner un objet et un événement, taper ensuite un script dans la zone de l’éditeur de texte. La cible de l’objet peut être référencée par self. Par exemple vous pouvez écrire ce script dans le champ onupdate d’un point :
if self.x < 0:
self.caption = "negative x"
else:
self.caption = "positive x"
Aussi longtemps que le mode Étiquette du point sera défini à caption, vous pourrez voir que la légende du point change si vous le déplacez de part et d’autre de l’axe des ordonnées.

Toutes les variables définies dans le Script Python sont accessibles dans les scripts d’événements. Cependant, si vous voulez modifier la valeur d’une variable, vous devez la déclarer comme globale – sinon une variable au script d’événements est créée.

global score
score += 1


Vous pouvez aussi ajouter directement des gestionnaires d’événements en définissant les attributs suivants pour des objets :

  • onupdate ;
  • onadd ;
  • onremove ;
  • onclick ;
  • onrename.

Les attributs peuvent être définis par une fonction à un argument (qui est la cible de l’événement)
def paint_blue(pt):
pt.color = Color.BLUE
geo.A.onclick = paint_blue

Méthodes spéciales

  • answer = input(<question>) ouvre une fenêtre de dialogue vide et la chaîne rentrée est rangée dans answer ;
  • answer = input(<question>, <réponse par défaut>) comme ci-dessus, mais la fenêtre de dialogue fait apparaître au départ la réponse par défaut;
  • alert(<texte>) affiche une fenêtre de message contenant texte ;
  • debug(<texte>) écrit texet dans la Console Java ;
  • command(<texte>) évalue une commande GeoGebra et retourne une liste d’objets.


command("3x+2y=12")
crée la droite a: 2x + 3y = 12

x, y = 3, 2
r = 4
command('Circle', (x, y), r)
crée le cercle de centre le point de coordonnées(3 ; 2)et de rayon 4 c: (x - 3)² + (y - 2)² = 16

Module math

http://www.jython.org/docs/library/math.html

import math print math.sqrt(2)

from math import fabs print math.fabs(-2),math.fabs(5)

Accès à l’API GeoGebra

Pour accéder à GgbAPI, il vous suffit de préfixer l’appel par ggbApplet, (ie c’est la même syntaxe que pour JavaScript)
ggbApplet.evalCommand("x^2 + y^2 = 4")
ggbApplet.startAnimation()


es:Referencia:Jython

© 2023 International GeoGebra Institute