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.
Signalons également un site en français proposant une bonne présentation de ce module tortue : zestedesavoir.

Pour importer d'un seul coup toutes les fonctions du module afin de dessiner avec turtle, il faudra écrire en en-tête du fichier :


from turtle import *

Un premier tracé

Ce module peut être un bon outil pour faire le lien entre l'initiation à la programmation faite au collège avec le langage Scratch et l'algorithmique au lycée. Voici comment traduire en Python le programme ci-contre, réalisé avec Scratch :

from turtle import *
for i in range(50):
    forward(2*i)
    left(90)

Gestion des déplacements

Les déplacements peuvent être relatifs (ils dépendent de la position courante de 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 :
from turtle import * for i in range(4): forward(100) left(90)
Le même carré obtenu par déplacements absolus :
from turtle import * x, y = 0, 0 for i in range(4): if i%2 == 0: x = 100-x else: y = 100-y goto(x, y)

Fenêtre d'affichage

L'unité du système de coordonnées du module turtle dépend de la taille de la fenêtre d'affichage. Par exemple, dans les exercices interactifs de ce site, les axes sont gradués des valeurs -200 à 200 :

from turtle import *

def aller_sans_tracer(x, y):
    up()
    goto(x, y)
    down()

speed(0)			# Vitesse la plus rapide


##----- Axe des abscisses -----##
aller_sans_tracer(-200, 0)
forward(400)
for i in range(9):
    aller_sans_tracer(-200+i*50, -8)
    goto(-200+i*50, 8)


##----- Axe des ordonnées -----##
aller_sans_tracer(0, -200)
goto(0, 200)
for i in range(9):
    aller_sans_tracer(-8, -200+i*50)
    goto(8, -200+i*50)

Modifier les unités des axes du repère

Il n'est pas possible d'agrandir indéfiniment les dimensions de la fenêtre d'affichage, mais il est heureusement possible de modifier les unités des axes grâce à la méthode .setworldcoordinates() appliquée à une instance de l'écran d'affichage ci-après affectée à la variable fenetre (fenetre = Screen()).

Par exemple :

Avec un repère orthonormè usuel gradué de -10 à 10 :
from turtle import * def aller_sans_tracer(x, y): up() goto(x, y) down() ##----- Fenêtre d'affichage et options -----## fenetre = Screen() # Instance de la fenêtre fenetre.setworldcoordinates(-10, -10, 10, 10) speed(0) # Vitesse la plus rapide ##----- Axe des abscisses -----## aller_sans_tracer(-10, 0) forward(20) for i in range(21): aller_sans_tracer(-10+i, -0.3) goto(-10+i, 0.3) ##----- Axe des ordonnées -----## aller_sans_tracer(0, -10) goto(0, 10) for i in range(21): aller_sans_tracer(-0.3, -10+i) goto(0.3, -10+i)
Avec un repère orthogonal gradué de -100 à 100 en abscisse et de -5 à 5 en ordonnée :
from turtle import * def aller_sans_tracer(x, y): up() goto(x, y) down() ##----- Constantes -----## x, y = 100, 5 pas_x, pas_y = x/10., y/10. ##----- Fenêtre d'affichage et options -----## fenetre = Screen() # Instance de la fenêtre fenetre.setworldcoordinates(-x, -y, x, y) speed(0) # Vitesse la plus rapide ##----- Tracé des axes (avec un peu d'arithmétique) -----## for k in (0, 1): aller_sans_tracer((k-1)*x, -k*y) goto((1-k)*x*2, k*y*2) for i in range(21): aller_sans_tracer((1-k)*(-x+i*pas_x)-k*0.3*pas_x, k*(-y+i*pas_y)-0.3*pas_y*(1-k)) goto((1-k)*(-x+i*pas_x)+k*0.3*pas_x, k*(-y+i*pas_y)+0.3*pas_y*(1-k))