Le module graphique turtle permet de piloter un «crayon» afin de tracer dynamiquement des figures géométriques.

Les dessins sont réalisés dans un repère orthonormé virtuel centré sur la fenêtre d'affichage. L'unité des axes est le pixel. Le repère n'est pas visible à l'écran.

La forme par défaut du crayon de tracé est une flèche «orientée», placé au départ à l'origine du repère. Le crayon est situé à la pointe, la flèche montre le sens du tracé en cours ou à venir.

La liste complète des fonctions disponibles grâce au module turtle est disponible sur la documentation officielle.
On pourra aussi télécharger un petit résumé au format .pdf en cliquant ici.

Pour dessiner avec turtle, il faudra écrire en en-tête du fichier :

from turtle import *

Attention avec l'interpréteur de Pyzo

Après avoir exécuté correctement un programme utilisant le module turtle une première fois, le moteur d'interface graphique de Pyzo renvoie parfois un signal d'erreur qui se termine par :

turtle.Terminator

Dans cette situation, il faut redémarrer l'environnement en cliquant sur le bouton .

Avec des élèves en difficulté, ce module peut être un bon outil de remédiation. En effet...

• on peut l'utiliser en entrant les instructions du tracé : celles-ci seront affectées au crayon défini par défaut.

• on peut aussi définir (nommer) un crayon et appliquer les méthodes précédentes à ce crayon sous la forme nom_crayon.nom_methode(parametres_eventuels). Cette seconde méthode sera privilégiée par la suite car elle est plus explicite (on ne s'adresse pas à un crayon anonyme) et permet de piloter plusieurs crayon en même temps (voire même une liste de crayons).

Les déplacements peuvent être relatifs (ils dépendent de la position dans laquelle est la tortue) ou absolus (selon les coordonnées et l'orientation angulaire du repère). Les deux scripts suivants permettent d'obtenir le même dessin de carré que celui représenté ci-contre.

• Un carré obtenu par déplacements relatifs :

• Le même carré obtenu par déplacements absolus :

Le module turtle accepte les paramètres représentant les couleurs sous deux formats :

• Le format RGB sous la forme d'un triplet (tuple) de composantes. Dans ce cas, il faut initier la valeur maximale des composantes avec la méthode colormode(a) (valeur de 1.0 par défaut).
• La dénomination des couleurs sous forme de chaînes de caractères. Cette dénomination peut être explicite ('red', 'blue', etc...) ou donnée par un code hexadécimal (par exemple '#FF0000' pour le rouge). On peut obtenir ces codes facilement avec un «analyseur de couleur» comme Just Color Picker.

Deux méthodes nécessitent une valeur de couleur en paramètre :

• pencolor(coul) qui indique la couleur (coul) du tracé.
• fillcolor(coul) qui indique la couleur (coul) du remplissage.

from turtle import *
stylo = Turtle()
colormode(255)
stylo.width(2)
stylo.pencolor((0, 0, 255))
stylo.fillcolor((255, 255, 0))

stylo.begin_fill()                      # Indispensable pour "remplir" un tracé
for i in range(5):
    stylo.forward(100)
    stylo.right(144)
stylo.end_fill()

Ces deux méthodes sont incluses dans la méthode color() qui prend soit un, soit deux paramètres :

• Avec un seul paramètre (valeur de la couleur), le tracé et le remplissage se feront de la même couleur.
• Avec deux paramètres, le tracé se fera dans la couleur correspondant 1^er paramètre, le remplissage se fera avec celle du 2^nd paramètre.

Le module turtle permet d'afficher une fenêtre contenant un formulaire à compléter par l'utilisateur. Ce formulaire renverra au programme :

• un texte (type str) avec l'instruction textinput('Nom de la fenêtre', 'message').
• un nombre (type float) avec l'instruction numinput('Nom de la fenêtre', 'message').

from turtle import *
nom = textinput('Saisie d\'un texte', 'Entrer un message :')
a = numinput('Saisie d\'un nombre', 'Combien de répétitions ?')

stylo = Turtle()
stylo.speed(0)

for i in range(int(a)):
    stylo.write(nom, font = ('Times New Roman', 12))
    stylo.left(10)
    stylo.up()
    stylo.forward(10*i)
    stylo.down()
exitonclick()

Il est aussi possible de prendre en compte des évènements :

• L'appui sur une touche du clavier avec l'instruction onkey(f, key) où f est la fonction (sans paramètre !) à exécuter lorsque l'utilisateur appui sur la touche key (nommée par une chaîne de carcactères comme 'Left', 'space', 'A', ...).
• Le clic (gauche) de souris avec l'instruction onscreenclick(f) où f est la fonction à exécuter (avec pour paramètres l'abscisse x et l'ordonnee y du clic dans la fenêtre).
• Les deux instructions précédentes doivent être suivie par l'instruction listen() qui permet d'attendre les événements.
  Le programme doit se terminer par l'instruction mainloop(), boucle d'attente des événements (on le reverra dans l'étude du module d'interfaces graphiques tkinter)

##----- Importation des Modules -----##
from turtle import *

##----- Définition des Fonctions -----##
def effacer():
    """Efface la fenêtre après appui sur la barre espace."""
    stylo.clear()

def tracer(x, y):
    """Trace un disque de centre le clic de souris."""
    global n                                        # Prise en compte (manipulation) de la variable globale
    n += 1
    stylo.up()
    stylo.goto(x, y)
    stylo.down()
    if n<=25:
        stylo.dot(10*n, (10*n, 255-10*n, 10*n))
    stylo.up()
    stylo.forward(10*n/2)
    stylo.down()
    stylo.write(str(n), font = ('Times New Roman', 12))
    
##----- Programme principal -----##
n = 0                                               # Variable globale, prenant en compte le n° du clic
stylo = Pen()
colormode(255)

onscreenclick(tracer)
onkey(effacer, 'space')

listen()
mainloop()