Tutoriel Python : Maîtriser le module turtle
Table des matières
Introduction
Pour introduire le module d’aujourd’hui, nous allons invoquer la programmation Logo qui est un langage simple pour l’enseignement de la programmation aux enfants et qui se caractérise par une tortue qui dessine à l’écran. Le module graphique Turtle de Python est inspiré de la programmation Logo et permet de piloter soi-disant un crayon pour tracer dynamiquement des figures géométriques dans un repère orthonormé virtuel centré dont l’unité des axes est le pixel.
1. Environnement de travail
Pour utiliser le module Turtle, on l’importe tout d’abord comme on a l’habitude de le faire avec les modules Python.
La première fonction que nous allons voir dans ce module est la fonction setup qui permet de positionner une fenêtre turtle. Cette fonction prend en paramètre quatre nombres : la largeur de la fenêtre (width), sa hauteur (height), la position en largeur (startx) et la position en hauteur (starty) du coin en haut à gauche de la fenêtre.
Exemple 1 :
- Code :
turtle.setup(600, 400, 100, 100)
- Résultat de l’exécution :
Par défaut la largeur de la fenêtre vaut 50% de l’écran et la hauteur 75% de l’écran.
2. Personnalisation
2.1. Titre
Comme tout autre module graphique, Turtle nous donne la possibilité de personnaliser notre fenêtre. Pour changer le titre de celle-ci, on fait appel à la fonction title.
Exemple 2 :
- Code :
turtle.title("Ceci est une fenetre")
- Résultat de l’exécution :
2.2. Couleur de fond
Pour modifier la couleur de fond de la fenêtre on utilise la fonction bgcolor qui prend en paramètre la couleur à appliquer et qui peut être sous la forme de :
- Chaîne de caractères représentant le nom (en anglais) d’une couleur primaire, du noir ou du blanc. C’est-à-dire : red, green, blue, cyan, magenta, yellow, black, white.
- Tuple représentant les valeurs RGB de la couleur divisé par 255 (pour des valeurs dans l’intervalle 0 et 1).
- Chaîne de caractères représentant la couleur en notation hexadécimale.
Exemple 3 :
Code :
turtle.bgcolor("magenta")
Résultat de l’exécution :
3. Premier tracé
3.1. Forward et backward
Avant de commencer notre premier tracé il faut avoir des repères dans la fenêtre. Comme mentionné précédemment turtle est muni d’un repère à 2 D centré dans la fenêtre.
Alors il est possible de se déplacer et de se repérer grâce aux coordonnées des abscisses et ordonnées. Le centre du repère, i.e. le point avec les coordonnées (x = 0, y = 0), est l’emplacement où apparaît le curseur.
Cependant pour faire bouger le curseur, on peut faire appel aux fonctions forward et backward, qui respectivement permettent de réaliser des pas en avant ou en arrière par rapport à une distance passée en paramètre. Ces deux fonctions ont une appellation abrégée : fd pour forward et bk pour backward.
Exemple 4 :
On reprend toujours notre première fenêtre. Si on souhaite avancer de 50 px et ne pas reculer on procède comme suivant :
- Code :
turtle.forward(50)
turtle.backward(0)
- Résultat de l’exécution :
3.2. Goto, setx et sety
Il existe une autre fonction goto permettant de faire un déplacement par rapport à des coordonnées données. La fonction goto prenden paramètre des coordonnées x et y.
Il est aussi possible de régulariser l’emplacement par rapport à l’abscisse du curseur avec setx ainsi que l’emplacement de l’ordonnée en utilisant la fonction sety.
Exemple 5 :
Dans cet exemple on passe en paramètre de la fonction goto les coordonnées (50, 60). Ensuite, on modifie la position du curseur en abscisse seulement puis en ordonnée avec setx et sety.
- Code :
turtle.goto(50, 60)
turtle.setx(10)
turtle.sety(15)
- Résultat de l’exécution :
3.3. Home
Après avoir déplacé le curseur dans la fenêtre, on aimera le positionner au centre du repère alors la fonction home permet de réaliser ceci.
Exemple 6 :
On reprend l’exemple précédent, et on ajoute la fonction home à ce code.
- Code :
turtle.goto(50,60)
turtle.setx(10)
turtle.sety(15)
turtle.home()
- Résultat de l’exécution :
3.4. Up et down
Jusqu’à présent tous nos déplacements dans la fenêtre étaient marqués, alors si on voulait changer de position en évitant de laisser une marque, on fait appel à la fonction up pour lever crayon et la fonction down pour le baisser.
Exemple 7 :
On reprend l’exemple précèdent, mais on souhaite revenir au centre du repère sans laisser de trace, alors on a procédé comme suit :
- Code :
turtle.goto(50,60)
turtle.setx(10)
turtle.sety(15)
turtle.up()
turtle.home()
- Résultat de l’exécution :
3.5. Pensize
Maintenant qu’on connaît comment se déplacer dans une fenêtre on aimera changer de « stylo ». Pour modifier les dimensions du traçage on appelle la fonction pensize qui prend en paramètre la largeur modifiée du trait.
Exemple 8 :
Dans cet exemple on affiche tout d’abord la taille actuelle du crayon à l’aide de la fonction pensize mais on ne lui passe aucun paramètre. Ensuite on lui passe 6 en paramètre pour changer de taille.
- Code :
print(turtle.pensize())
turtle.pensize(6)
turtle.goto(100,200)
- Résultat de l’exécution :
3.6. Right, left et heading
Il sera plus intéressant si nos déplacements dans une fenêtre ne sont pas aussi limités. En effet, on peut régulariser la direction du curseur qui est par défaut orienté vers l’Est, et cela en utilisant les fonctions right etleft qui servent à tourner respectivement l’angle où pointe le curseur dans la direction droite ou gauche d’une valeur passée en paramètre.
Ainsi pour savoir la direction du curseur on utilise la fonction heading.
Exemple 9 :
Dans cet exemple on affiche en premier lieu la première direction du curseur qui est 0.0, ensuite on change la direction de celui-ci et on affiche la direction finale sur laquelle le curseur pointe.
- Code :
import turtle
print(turtle.heading())
turtle.left(270)
turtle.right(100)
print(turtle.heading())
- Résultat de l’exécution :
Remarque :
Il existe une fonction towards qui permet de retourner l’angle qu’il faudrait pour arriver à un point et prend en paramètre les coordonnées de celui-ci.
3.7. Dot
La fonction dot permet d’afficher sur la fenêtre un point de diamètre et de couleur défini en paramètre.
Si on ne passe rien en paramètre de cette fonction, un point noir de diamètre par défaut s’affichera sur la fenêtre.
Exemple 10:
- Code :
turtle.dot(150, 'blue')
turtle.dot(40)
- Résultat de l’exécution :
Remarque :
Il est à noter qu’un point sera dessiné même si le crayon est levé.
3.8. Stamp
La fonction stamp permet d’imprimer la forme du curseur et de retourner l’identifiant du tampon.
La fonction clearstamp qui prend en paramètre l’identifiant du tampon permet de supprimer celui-ci. Il aussi possible de supprimer plusieurs tampons en utilisant clearstamps qui prend en paramètre le nombre de tampons à supprimer. Si on ne lui passe aucun paramètre elle supprimera tous les tampons.
Exemple 11 :
- Code :
import turtle
turtle.setup(700, 100)
for i in range(15):
turtle.stamp()
turtle.forward(10)
- Résultat de l’exécution :
Exemple 12 :
On ajoute au code précédent les deux lignes de code suivantes, où la première ligne permet de supprimer les 2 premiers tampons et la deuxième ligne permet de supprimer les 3 derniers tampons :
- Code :
turtle.clearstamps(2)
turtle.clearstamps(-3)
- Résultat de l’exécution :
4. Figures simples
Avec toutes les fonctions précédemment citées nous sommes maintenant capables de tracer des figures simples, comme les triangles, carrés, etc.
Exemple 13 :
Dessinons un triangle équilatéral !
Pour cela on va tout d’abord dessiner le premier coté du triangle, ensuite on tourne l’angle du curseur, puis le deuxième coté et on tourne d’angle pour finalement tracer le troisième coté.
- Code :
turtle.title("Mon premier triangle")
l_cote = 200
turtle.forward(l_cote)
turtle.left(360/3)
turtle.forward(l_cote)
turtle.left(360/3)
turtle.forward(l_cote)
- Résultat de l’exécution :
Exemple 14 :
Le même principe utilisé pour dessiner le triangle est appliqué pour dessiner un carré.
On boucle sur le nombre de côté du carré qui est 4, puis à chaque itération on dessine un côté et on change d’angle. Ce qui nous donne le code suivant :
- Code :
turtle.title("Mon premier carré")
l_cote = 200
for i in range(4):
turtle.forward(l_cote)
turtle.left(90)
- Résultat de l’exécution :
Exemple 15 :
Pour les cercles, il existe une fonction circle qui permet de les dessiner sans avoir à écrire des lignes de code. Cette fonction peut prendre en paramètre le rayon du cercle, l’angle (si on veut ne dessiner qu’une partie du cercle) et les étapes nécessaires pour tracer.
On dessine dans cet exemple un premier cercle de rayon 150 px.
- Code :
turtle.title( "Mon premier cercle")
turtle.circle(150)
- Résultat de l’exécution :
Exemple 16 :
On ajoute au code précèdent la ligne de code suivante qui permet de dessiner le ¼ d’un cercle de rayon 75 px :
- Code :
turtle.circle(75, 90)
- Résultat de l’exécution :
Exemple 17 :
Dans l’exemple qui suit nous allons dessiner un octogone de longueur 90 px en utilisant la fonction circle.
- Code :
turtle.title("Octogone")
turtle.circle(90, steps = 8)
- Résultat de l’exécution :
5. Exercice
Exercice 1 :
Ecrire un programme qui permet de dessiner un octogone sans faire appel à la fonction circle.
Exercice 2 :
Ecrire un programme qui dessine 10 cercles du plus petit au plus grand avec pour centre l’origine du repère.
Exercice 3 :
Ecrire un programme qui dessine 10 points, du plus petit au plus grand et de différentes couleurs chacun.
Exercice 4 :
Ecrire un programme qui permet de dessiner la figure suivante :
Exercice 5 :
Ecrire un programme qui dessine un flocon de Von Koch.
6. Correction
Exercice 1 :
Le même principe du carré est appliqué ici. On change que le nombre des cotés qui est 8 dans ce cas et les angles qui sont de 45°.
- Code :
turtle.title("Exercice 1 ")
longueur_cote = 100
for i in range(8):
turtle.forward(longueur_cote)
turtle.left(360/8)
- Résultat de l’exécution :
Exercice 2 :
- Code :
import turtle
rayon = 100
ecart = 20
for i in range(10):
turtle.up()
turtle.goto(0, -rayon)
turtle.down()
turtle.circle(rayon)
rayon += ecart
turtle.up()
turtle.home()
- Résultat de l’exécution :
Exercice 3 :
Pour cet exercice on a créé tout d’abord une liste contenant les noms de couleurs, ensuite on a bouclé sur le nombre de celles-ci et à chaque itération on choisit aléatoirement une couleur puis on affiche un point de cette couleur, puis cette couleur est supprimer de la liste pour éviter de la choisir dans les prochaines itérations. Ensuite on met à jour le diamètre et on se déplace au prochain point.
- Code :
import turtle
from random import randint
c = ['black', 'grey', 'brown', 'orange', 'pink', 'purple',
'red', 'blue', 'yellow', 'green']
turtle.setup(700, 100)
diametre = 20
turtle.up(); turtle.setx(-turtle.window_width()/2+2*diametre); turtle.down()
for i in range( len(c) ):
index = randint( 0, len(c) - 1)
turtle.dot( diametre, c[index] )
del c[index]
diametre += 5; turtle.up(); turtle.fd(1.5*diametre); turtle.down()
- Résultat de l’exécution :
Exercice 4 :
Dans cet exercice nous avons créé une boucle for qui à chaque itération imprime le tampon du curseur, change l’orientation du celui-ci, lève le crayon, se déplace d’un écart déterminé et repose le crayon pour l’itération suivante.
- Code :
import turtle
turtle.setup(640, 480)
ecart = 4
for i in range(30):
turtle.stamp()
turtle.left(30)
turtle.up(); turtle.forward(ecart); turtle.down()
ecart += 3
- Résultat de l’exécution :
Exercice 5 :
Dans cet exercice, nous avons tout d’abord défini une fonction récursive courbe_von_koch qui permet de réaliser une courbe de Von Koch et qui prend en paramètre la longueur des côtés du triangle et le nombre d’étapes qui détermine le nombre de pics du flocon. Puis on a programmé une deuxième fonction flocon_von_koch qui trace le flocon et prend les mêmes paramètres de la première.
- Code :
import turtle
def courbe_von_koch (longueur, etape):
if etape == 0:
turtle.forward (longueur)
else:
courbe_von_koch (longueur/3, etape-1)
turtle.left (60)
courbe_von_koch (longueur/3, etape-1)
turtle.right (120)
courbe_von_koch (longueur/3, etape-1)
turtle.left (60)
courbe_von_koch (longueur/3, etape-1)
def flocon_von_koch (longueur, etape):
for i in range (3):
courbe_von_koch (longueur, etape)
turtle.right (120)
flocon_von_koch (100, 3)
- Résultat de l’exécution :
Conclusion
Dans ce tutoriel nous avons vu les différents éléments de base du module Turtle qui permettent de manipuler le curseur pour tracer et dessiner des figures. Rappelons-nous que ce module offre la possibilité de personnaliser une fenêtre, de changer sa couleur de fond, de changer la taille du tracé, d’afficher des points colorés etc.
Il est à noter qu’il existe d’autres fonctions permettant de créer des figures plus complexes que celles qu’on a abordé lors de ce tutoriel.
Article publié le 09 Octobre 2020par Imane BENHMIDOU