Le module turtle

Le module turtle (la "tortue" en français) est un module Python contenant un crayon programmable, capable de dessiner n'importe quelles figures géométriques décrite par une suite d'instructions (tracer un trait, tournet à droite, tracer un cercle, etc.).

Pour piloter la tortue à la main il faut utiliser la console interactive de Python qui s'appelle IPython (et non la console classique d'EduPython).

La console interactive de Python est IPython, disponible dans le menu Outils -> Outils -> Ipython d'EduPython.

Première utilisation de la tortue

Pour découvrir l'utilisation du module graphique turtle de Python par la pratique, réalisez en un premier temps les actions suivantes et mémorisez-les :

1 - lancez la console intéractive IPython en cliquant sur son icône disponible dans le menu Outils -> Outils -> Ipython d'EduPython :

Icône de IPython dans le menu Outils d'EduPython

Remarque : si l'icône d'IPython n'est pas disponible il faut créer un raccourcis sachant qu'IPython est dans le répertoire "C:\Program Files\EduPython\IPython.exe"

La console interactive IPython s'ouvre alors dans une nouvelle fenêtre extérieure à EduPython :

Voici la fenêtre de la console interactive IPython

2 - Importez le module turtle en tapant la ligne from turtle import * dans la console IPython :

Importation du module de la tortue

3 - Nous allons dessiner un carré dans la fenêtre de la tortue. Pour cela tapez la commande forward(200) dans la console :

La commande forward(200) se tape dans la console IPython

La fenêtre de la tortue apparaît alors et un trait de longueur 200 est tracé :

Et voici la fenêtre de la tortue

4 - Tapez ensuite la commande left(90) :

La console IPython rappelle l'historique des commandes tapées

Le curseur de la tortue effectue alors une rotation de 90° vers la gauche :

Rotation de 90° du curseur de la tortue : il est maintenant orienté vers le haut

5 - Répétez 3 fois les étapes précédentes 3 et 4 : le carré complet est alors tracé dans la fenêtre de la tortue

Dans la console on lance les commandes pour piloter le crayon de la tortue

Et dans la fenêtre de la tortue le curseur avance et trace la figure géométrique : ici un carré de côté 200

Bon à savoir :

• la commande undo() permet d'annuler la dernière commande tapée (à tester dans la console IPython)
• la commande reset() effacte toute la fenêtre de la tortue et permet de recommencer une nouvelle figure en partant de zéro (à tester)
• les touches flèche haut et flèche bas du clavier permettent de naviguer dans l'historique de la console afin de ré-utiliser une ancienne commande sans la retaper

Enfin pour conserver les instructions traçant une figure dans un fichier afin de relancer la totalité du dessin grâce à EduPython il faut que le programme finisse par l'instruction done(). Voici par exemple le programme à taper dans EduPython pour tracer le carré de côté 200 :

# Trace un carré avec la tortue :
from turtle import *

forward(200)
left(90)
forward(200)
left(90)
forward(200)
left(90)
forward(200)
left(90)

done()

On remarque que pour tracer le carré on a lancé 4 fois le même bloc d'instructions (forward(200) suivi de left(90)). Pour optimiser le programme on peut alors demander à une boucle for de répéter 4 fois ce bloc d'instructions :

# La boucle for répète 4 fois le traçage d'un côté :
from turtle import *

for i in range(4):
        forward(200)
        left(90)

done()

6 - Après avoir effacé la fenêtre de la tortue par la commande reset(), essayez d'y dessiner un triangle équilatéral de côté 150

Pour effacer la figure dans la fenêtre de la tortue il faut utiliser la commande reset()

Après un reset() la fenêtre de la tortue est vide avec la curseur au centre orienté vers la droite

Il vous reste maintenant à rechercher expérimentalement les commandes à lancer dans IPython pour dessiner un triangle équilatéral de côté 150 avec la tortue. Vous recherchez interactivement les différentes instructions traçant le triangle dans IPython (n'hésitez pas à utiliser l'instruction undo() pour annuler la dernière commande si vous vous êtes trompé), puis une fois la solution trouvée vous enregistrerez votre programme dans EduPython dans un fichier nommé triangle.py, sans oublier l'importation du module turtle au début du programme et l'instruction done() à la fin du programme :

# Programme qui trace un triangle avec la tortue :
from turtle import *

?

done()

Voilà à quoi doit ressembler votre triangle équilatéral de côté 150 dans la fenêtre de la tortue :

Un triangle équilatéral de côté 150

Liste des instructions

Voyons maintenant les différentes instructions de la tortue. Avant de vouloir utiliser les instructions de la tortue dans un programme il faut bien penser à importer le module turtle en utilisant la ligne suivante :

from turtle import *

Après importation du module turtle, les instructions suivantes sont disponibles pour piloter la tortue et ainsi dessiner dans sa fenêtre.

IMPORTANT : toutes ces instructions sont des fonctions écrites en Python. Pour les appeller il faut toujours lancer le noms des instructions suivi d'un paire de parenthèses, que l'instruction ait besoin ou non d'un paramètre.

Exemples :

• l'instruction undo n'a pas besoin de paramètre. On la lance en tapant undo()
• l'instruction back a besoin d'un paramètre indiquant la distance à parcourir. On la lance en tapant par exemple back(50) pour reculer de 50

Dans les tableaux de synthèses ci-dessus les paranthèses ne sont pas indiquées pour ne pas allourdir la lecture : seul le nom et le rôle des instructions sont indiqués, mais pas leur syntaxe.

 

Comment dessiner ?

Pour dessiner il suffit de déplacer le curseur de la tortue (marche avant avec forward ou marche arrière avec back) et de l'orienter (tourner à droite avec right et tourner à gauche avec left). A chaque déplacement la tortue laisse une trace qui dessine la figure.

Si on veut déplacer la tortue sans dessiner il faut lever le crayon avec up, déplacer le curseur en un autre point, puis baisser le crayon avec down pour redessiner à nouveau.

La tortue ne dessine pas que des traits droits : elle peut également dessiner un cercle ou un arc de cercle grâce à la fonction circle :

• avec un seul paramètre, la fonction circle dessine un cercle complet de rayon donné. Par exemple circle(200) dessine un cercle de rayon 200 pixels
• avec deux paramètres, la fonction circle dessine un arc de cercle de rayon et d'angle donnés en degrés. Par exemple circle(100,180) dessine un demi-cercle (180 °) de rayon 100 pixels

Enfin la fonction pensize permet de configurer l'épaisseur du trait. Par exemple pensize(10) trace des traits de 10 pixels d'épaisseur.

Comment colorer une figure ?

La fonction color permet de configurer la couleur utilisée pour dessiner en utilisant les noms des couleurs en anglais sous forme de chaînes de caractères :

Testez maintenant un par un tous les exemples suivants en tapant les instructions données dans la console interactive IPython, après avoir vidé la fenêtre de la tortue avec l'instruction reset(), et observez bien le tracer des figures obtebnus afin de comprendre le rôle de chaque nouvelle instruction.

Exemple 1 : le programme suivant trace un cercle rouge d'épaiseur 10 pixels :

pensize(10)
color('red')
circle(100)

Voici le résultat :

Les instructions begin_fill et end_fill permettent de dessiner une figure fermée dont l'intérieur sera coloré.

Exemple 2 : le programme suivant trace un cercle rouge d'épaiseur 10 pixels avec l'intérieur coloré :

pensize(10)
color('red')
begin_fill()
circle(100)
end_fill()

On remarque que les instructions begin_fill et end_fill encadrent seulement les instructions de traçage (ici la fonction circle(100)) et pas les instructions de configuration de l'épaisseur du crayon ou de la couleur.

Voici le résultat :

Enfin si on passe 2 couleurs différentes à la fonction color, la première représente la couleur du trait et la seconde la couleur du fond de la figure.

Exemple 3 : le programme suivant trace un cercle rouge d'épaiseur 10 pixels avec l'intérieur coloré en jaune :

pensize(10)
color('red','yellow')
begin_fill()
circle(100)
end_fill()

Voici le résultat :

Pour utiliser plus de nuances de couleurs on peut préciser leur composantes dans le modèle ROUGE VERT BLEU (modèle RVB ou RGB).

Pour que les composantes Rouge Vert et Bleu d'une couleur soit comprise entre 0 et 255 il faut basculer le mode de couleur grâce à la fonction colormode() :

colormode(255)

Ensuite, la couleur du pinceau se configure avec la fonction pencolor(), et la couleur du fond se configure avec la fonction fillcolor(). Par exemmple le programme suivant trace à nouveau un cercle jaune avec un trait rouge :

pensize(10)
pencolor(255,0,0)
fillcolor(255,255,0)
begin_fill()
circle(100)
end_fill()

Voici le résultat :

Enfin les 3 composante d'une couleur peuvent être réunies dans une chaîne de caractères commençant par # et de la forme '#RRVVBB' où :

• RR est un octet en hexadécimal correspondant à la composante rouge (entre 00 et FF)
• VV est un octet en hexadécimal correspondant à la composante verte (entre 00 et FF)
• BB est un octet en hexadécimal correspondant à la composante bleue (entre 00 et FF)

Par exemple la chaîne '#FF0000' représente la couleur rouge et '#FFFF00' représente la couleur jaune. Le programme suivant trace à nouveau un cercle jaune avec un trait rouge :

pensize(10)
pencolor('#FF0000')
fillcolor('#FFFF00')
begin_fill()
circle(100)
end_fill()

Voici le résultat (toujours le même) :

L'avantage d'utiliser les composantes ROUGE VERT et BLEU des couleurs est de pouvoir réaliser des palettes de couleurs personalisées avec des nuanciers de couleurs très diversifiés.

Comme chaque composante ROUGE VERT et BLEU peut prendre 256 valeurs différentes (de 0 à 255), il est possible d'utiliser 256*256*256=16777216 soit plus de 16 millions de couleurs différentes !

Le programme suivant par exemple trace 30 ronds dont la couleur dépend de leurs coordonnées :

from turtle import *
from random import *

speed(0)
hideturtle()
colormode(255)

for x in range (6):
        for y in range (5):
                up()
                goto(120*x-300,120*y-300)
                down()
                
                rouge=51*x
                vert=42*y
                bleu=0
                
                pencolor(rouge,vert,bleu)
                fillcolor(rouge,vert,bleu)
                
                begin_fill()
                circle(50)
                end_fill()

done()

Et voici le résultat (30 couleurs différentes parmi les 16 millions existantes) :

Et pour changer la palette de couleurs il suffit de modifier le calcul des variables rouge, vert et bleu en fonction des coordonnées x et y. Voici un exemple :

from turtle import *
from random import *

speed(0)
hideturtle()
colormode(255)

for x in range (6):
        for y in range (5):
                up()
                goto(120*x-300,120*y-300)
                down()
                
                rouge=28*(x+y)
                vert=abs(25*x-21*y)
                bleu=12*x*y
                
                pencolor(rouge,vert,bleu)
                fillcolor(rouge,vert,bleu)
                
                begin_fill()
                circle(50)
                end_fill()

done()

Et voici le résultat :

Pour obtenir la valeur numérique d'une couleurs parmi les 16 millions de couleurs possibles, cliquez ici pour ouvrir un nuancier de couleur.

Voilà, vous venez de voir les possibiltés de base pour tracer une figure dans la fenêtre graphique de la tortue. Vous savez désormais :

• ouvrir la console IPython, y importer le module turtle et y taper des instructions pour piloter la tortue
• tracer des traits et des arcs de cercle
• configurer l'épaisseur du trait
• configurer la couleur du trait et la couleur du fond d'une figure
• annuler la dernière commande
• effacer toute la fenêtre de la tortue pour recommencer un nouveau dessin
• enregister les instructions utiles dans un fichier pour relancer la totalité du traçage de la figure dans EduPython

Vous pouvez maintenat passer à la partie "APPLICATION" de la tortue pour essayer de dessiner les différentes figures imposées.

 

Comment ajouter de l'interactivité au programme ?

Ajouter de l'interactivité consiste à prendre en compte les évènements ou les ordres venant de l'utilisateur. Ces évènements peuvent venir de 2 sources :

• l'appui sur une touche particulière du clavier
• le click sur un bouton de la souris

Voyons comment prendre en compte ces évènement avec le module turtle de Python afin que notre programme réagisse aux ordres donnés par l'utilisateur.

Commençons par le clavier : pour détecter qu'une touche du clavier a été enfoncée il aut utiliser la fonction onkeypress en lui passant en paramètre le nom d'une fonction à lancer en cas d'appui sur une touche particulière.

Voici tout de suite un premier exemple à tester dans EduPython :

from turtle import *

# ============================
# Définition des fonctions :
# ============================

def afficher_titre():
    up()
    goto(-150,300)
    write("Appuyez sur les touches flèches, BackSpace, c, r ou b")
    home()
    down()

def haut():
    setheading(90)
    forward(100)

def bas():
    setheading(-90)
    forward(100)

def gauche():
    setheading(180)
    forward(100)

def droite():
    setheading(0)
    forward(100)

# ============================
# Programme principal :
# ============================

afficher_titre()

# fonctions à lancer si on appuie sur une touche :
onkeypress(haut,"Up")
onkeypress(bas,"Down")
onkeypress(gauche,"Left")
onkeypress(droite,"Right")
onkeypress(undo,"BackSpace")
onkeypress(clear,"c")
onkeypress(reset,"r")
onkeypress(bye,"b")

# lance le gestionnaire d'évènement qui écoute les touches enfoncées :
listen()

done()

Cliquez ici pour télécharger ce programme (fichier clavier_turtle.pyw)

Dans ce programme on a créé 4 fonctions :

• la fonction haut oriente le curseur vers le haut puis avance la tortue de 100 pixels
• la fonction bas oriente le curseur vers le bas puis avance la tortue de 100 pixels
• la fonction gauche oriente le curseur vers la gauche puis avance la tortue de 100 pixels
• la fonction droite oriente le curseur vers la droite puis avance la tortue de 100 pixels

Ensuite grâce à la fonction onkeypress on indique que :

• si on appuie sur la touche "flèche vers le haut" (notée "Up" pour Python) on lance la fonction haut : onkeypress(haut,"Up")
• si on appuie sur la touche "flèche vers le bas " (notée "Down" pour Python) on lance la fonction bas : onkeypress(bas,"Up")
• si on appuie sur la touche "flèche vers la gauche" (notée "Left" pour Python) on lance la fonction gauche : onkeypress(gauche,"Up")
• si on appuie sur la touche "flèche vers la droite" (notée "Right" pour Python) on lance la fonction droit : onkeypress(droit,"Up")

De plus si on appuie sur les touches BackSpace, c, r ou b on lance restpectivement les fonctions undo, clear, reset ou bye du module turtle.

Enfin après avoir préparé le lien entre les touches du clavier et les fonctions à lancer on lance le gestionnaire l'évènement qui va détecter les touches enfoncées en appelant la fonction listen().

Grâce à la fonction onkeypress on peut lancer n'importe quelle fonction (fonction créée par l'utilisateur ou fonction native déjà existante) lorsqu'on appuie sur une touche quelconque. Il faut cependant conaître le code des touches spéciales du clavier. En voici la liste :

A retenir : pour lancer une fonction particulière en réaction à l'appui sur une touche du clavier on utilise la fonction onkeypress(fonction,code) où :

• fonction est le nom de la fonction à lancer (sans parenthèse)
• code est le code de la touche détectée (voir tableau ci-dessus)

Voyons maintenant comment prendre en compte les évènements venant de la souris. Pour cela on utilise la fonction onscreenclick qui lance une fonction particulière si on clique sur un des trois boutons de la souris.

Voici tout de suite un exemple à tester dans EduPython :

from turtle import *
# ============================
# Définition des fonctions :
# ============================

def afficher_titre():
    up()
    goto(-250,300)
    write("Cliquez gauche pour afficher les coodonées, droit pour tout effacer ou centre pour     dessiner un rond")
    home()
    down()

def afficher_coordonnees(x,y):
    goto(x,y)
    write("x=%s y=%s" % (x,y))

def dessiner_cercle(x,y):
    up()
    goto(x,y)
    down()
    dot(20)

def effacer(x,y):
    reset()
    afficher_titre()

# ============================
# Programme principal :
# ============================

afficher_titre()

# fonction à lancer si on clique avec un bouton de la souris :
onscreenclick(afficher_coordonnees) # bouton gauche
onscreenclick(dessiner_cercle,2) # bouton centre
onscreenclick(effacer,3) # bouton droit

# lance le gestionnaire d'évènement qui détecte les évèvements de la souris :
listen()

done()

Cliquez ici pour télécharger ce programme (fichier souris_turtle.pyw)

La fonction onscreenclick attend 2 paramètre : le nom de la fonction à lancer et le numéro du bouton à détecter (1 pour gauche, 2 pour centre et 3 pour droit). Si le numéro du bouton n'est pas indiqué alors la fonction onscreenclick détectera le bouton gauche par défaut. Ainsi :

• onscreenclick(afficher_coordonnees) lancera la fonction afficher_coordonnees lorsqu'on cliquera sur le bouton gauche de la souris
• onscreenclick(dessiner_cercle,2) lancera la fonction dessiner_cercle lorsqu'on cliquera sur le bouton central de la souris
• onscreenclick(effacer,3) lancera la fonction effacer lorsqu'on cliquera sur le bouton gauche de la souris

De plus la fonction onscreenclick renvoie les coordonnées du curseur de la souris sous forme de 2 entiers : les fonction à lancer doivent donc attendre 2 paramètres (x et y) afin de réceptionner les coordonées du point cliqué par la souris (même si elles ne sont pas utilisées).

Un autre exemple : on dessine une grille contenant 4 cases et on veut déterminer dans quelle case on clique :

Cliquez ici pour télécharger ce programme souris_grille.pyw commenté et le tester dans EduPython

Comment obtenir de l'aide sur une fonction particlière ?

Pour obtenir de l'aide sur une nouvelle fonction il faut utiliser la fonction help dans la console de Python en lui passant en paramètre le nom de la nouvelle fonction.

Exemple : quelle est la syntaxe et les différentes possibilités de la fonction shape qui permet de configurer la forme du curseur de la tortue ?

Pour le savoir, tapez help(shape) dans la console de Python. Il vous renvoie directement la syntaxe de shape : on comprend alors que le paramètre à passer à la fonction shape peut être 'arrow', 'turtle', 'circle', 'square', 'triangle', ou 'classic'.

A vous de les tester : shape('square'), shape('triangle'), shape('turtle'), etc.

Pour obtenir la liste de toutes les fonctions disponibles dans le module turtle il faut lancer les 2 lignes suivantes :

import turtle as tortue
dir(tortue)

On obtient alors la liste complète des 130 fonctions du module turtle. La fonction help permet ensuite d'obtenir des informations sur les nouvelles fonctions afin de pouvoir désormais les utiliser.

Voici la liste complète des 130 fonctions que propose le module turtle :

Liste des instructions de la tortue (fichier PDF)

Accéder à l'activité 2 de Python (la tortue) du serveur NESSI

Retour en haut de la page

python.gecif.net