Aller au contenu

07 Cours Turtle

Démarrer avec Turtle⚓︎

Le module Turtle de Python permet de tracer des figures assez simplement. Dans le langage Logo développé à but pédagogique à la fin des années 1960 et utilisé dans les écoles dans les années 1980 et 1990, une petite flèche représentait un robot à l'écran qui pouvait se déplacer, et trainait à l'arrière un crayon pour laisser trace de son passage, et dessiner à l'écran. Ce robot s'appelait la "tortue".

Le module Turtle de Python en est fortement inspiré.

La documentation complète de la bibliothèque Turtle est ici.

Importer les fonctions de turtle⚓︎

Comme pour les autres bibliothèques python, on peut importer le module avec import turtle, puis appeler chaque fonction en commençant par turtle., ou importer toutes les fonctions avec from turtle import *.

🐍 Script Python
import turtle
turtle.forward(120)
turtle.left(90)

ou :

🐍 Script Python
from turtle import *
forward(120)
left(90)

Dans un éditeur comme Thonny ou IDLE, une fenêtre graphique séparée sera ouverte.

Principe général⚓︎

Une tortue apparaît au milieu de l'écran, aux coordonnées considérées par défaut comme \((0, 0)\).
On peut déplacer cette tortue avec des instructions du type forward(n) pour avancer de n pixels.
On peut faire tourner la tortue à gauche ou à droite avec left(angle) ou right(angle)où l'angle est donné en degrés. Les virages sont toujours à considérer du point de vue du robot/ tortue qui avance.
Il est également possible de déplacer la tortue en lui indiquant des coordonnées dans la fenêtre graphique avec goto(x, y).
Le crayon de la tortue peut être abaissé (pendown()) pour tracer au fur et à mesure du déplacement, ou levé (penup()) afin que la tortue se déplace sans tracer.
On peut également cacher la tortue avec hideturtle() afin qu'elle ne gêne pas la vue du dessin, mais son rôle reste le même, et cela n'a pas d'influence sur le fait que le crayon soit baissé ou levé.
Les structures usuelles de Python sont tout à fait compatibles avec le module Turtle, on pourra donc créer des boucles, des conditions, et des fonctions.

Premiers programmes⚓︎

🐍 Script Python
from turtle import *
forward(120)
left(90)
color('red')
forward(80)
🐍 Script Python
reset()
for a in range(12):
    forward(150)
    left(150)

Les principales fonctions du module Turtle de Python⚓︎

Apparence de la tortue⚓︎

  • shape(forme) Formes possibles : "classic" ou "turtle"
  • hideturtle() Masque la tortue.
  • showturtle() Montre de nouveau la tortue.

Comportement du crayon⚓︎

  • speed(n) Vitesse du tracé : de \(n = 1\) (lent) à \(n = 10\) (rapide).
  • width(n) Épaisseur du trait : de \(n = 1\) (fin) à \(n = 10\) (épais).
  • up() ou penup() Relève le crayon (pour déplacer la tortue sans dessiner).
  • down() ou pendown() Abaisse le crayon (pour recommencer à dessiner).

Déplacements usuels de la tortue⚓︎

  • forward(distance) Avance d’une distance donnée (en pixels).
  • backward(distance) Recule d’une distance donnée (en pixels). La tortue n'est pas retournée, elle a gardé sa direction précédente.
  • goto(x y) Déplace la tortue jusqu’au point de coordonnées \((x, y)\) de la fenêtre graphique.
  • setx(a) Attribue la valeur \(a\) à l’abscisse de la tortue dans la fenêtre graphique
  • sety(b) Attribue la valeur \(b\) à l’ordonnée de la tortue dans la fenêtre graphique
  • left(angle) Tourne la direction de la tortue vers la gauche d’un angle donné (en degrés).
  • right(angle) Tourne la direction de la tortue vers la droite d’un angle donné (en degrés).
  • setheading(angle) | seth(angle) Pointe la tortue vers la direction (absolue) indiquée par l’angle. Cet angle est donné en degrés. \(0°\) correspond à la direction vers l'Est (comme l'angle \(0\) vu sur le cercle trigonométrique).
  • home() Ramène la tortue dans sa position initiale.

Les couleurs⚓︎

Les couleurs peuvent a priori être définies :

  • par une chaîne de caractères prédéfinie représentant une couleur primaire ou noir ou blanc : red, green, blue, cyan, magenta, yellow, black, white
  • par un tuple représentant les valeurs RGB de la couleur. Par défaut, les valeurs données sont entre \(0\) et \(1\) pour chaque couleur.
    Par exemple \((1, 0, 0)\) représente le rouge.
    La valeur maximale peut être redéfinie par la fonction colormode(n).
  • par une chaîne de caractères représentant la couleur en notation hexadécimale.
    Par exemple "#OOFFFF" représente la couleur cyan (vert et bleu au max).

Les fonctions :⚓︎

  • colormode(n) Initialise le format RGB, \(n\) est l’intensité maximale.
  • pencolor(couleur) couleur du tracé, de type string ou (r, g, b)
  • fillcolor(couleur) Permet de remplir un contour fermé avec la couleur. begin_fill() doit être indiqué avant le tracé du contour fermé, end_fill() après.
  • color("green") Équivalent de pencolor("green") et fillcolor("green")
  • color("red", "yellow") Équivalent de pencolor("red") et de fillcolor("yellow")
  • bgcolor(0, 1, 0) Définit la couleur de fond de la fenêtre (background).

Tracés spécifiques⚓︎

  • write(texte) Le texte, de type string, est écrit à la position actuelle du crayon (avec la couleur courante).
  • circle(x) Trace un cercle de rayon \(x\), dans la continuité du tracé précédent.
  • circle(x, y) Trace un arc de cercle de rayon \(x\), dans la continuité du tracé précédent. La valeur d’angle \(y\) représente l'angle de l'arc de cercle en degrés (par exemple \(180\) pour un demi-cercle).
  • dot(x, [couleur]) Disque de diamètre \(x\), centré à l’endroit où se trouve le crayon (on peut définir la couleur intérieure en option : sans les crochets, qui sont notés ici pour marquer que ce paramètre est optionnel).

Récupérer des informations sur le crayon⚓︎

  • position() Renvoie les coordonnées actuelles de la tortue (sous forme d'un tuple \((x, y)\)).
  • heading() Renvoie l’orientation (en degrés) actuelle du crayon.

Agir sur la fenêtre d’affichage⚓︎

  • clear() Efface le dessin, la tortue reste à sa place.
  • reset() Réinitialise la page (dessin effacé, crayon à l’origine).
  • setworldcoordinate(xbg, ybg, xhd, yhd) Redéfinition du système de coordonnées dans une nouvelle fenêtre définie par les points en bas à gauche (xbg, ybg) et en haut à droite (xhd, yhd).
  • exitonclick() Permet de sortir du script en cliquant sur la fenêtre. À écrire en fin de script.

Personnalisation de la fenêtre⚓︎

  • setup(width, height, startx, starty) Permet de positionner une fenêtre turtle sur l'écran. Les paramètres sont : largeur de la fenêtre (width), hauteur de la fenêtre (height), position en abscisse sur l'écran (startx) et position en ordonnée sur l'écran (starty) du coin en haut à gauche de la fenêtre.
    On note que les coordonnées sur un écran partent du coin en haut à gauche de l'écran (l'ordonnée 200 est plus basse que l'ordonnée 100).
    Par exemple setup(600, 400, 100, 100).
    Vous pouvez tester cette fonction sur un éditeur classique (IDLE, Thonny). En revanche, cette fonction n'aura pas d'incidence sur replit qui ne peut gérer que la fenêtre prévue à cet effet.

  • title(texte) Donne un titre à la fenêtre graphique (par défaut, c'est "Python Turtle Graphics")

Objet tortue⚓︎

Il est possible de définir plusieurs objets tortue.
La syntaxe est alors celle de la programmation orientée objet : objet.methode() pour chaque tortue.

Exemple avec un peu tout⚓︎

Faites exécuter cet exemple (la vitesse a été mise à \(1\)) pour bien voir la construction, et reconnaissez le rôle de chaque instruction.

🐍 Script Python
from turtle import *
title("Mon joli dessin")     # La fenêtre a un titre
bgcolor(0.25, 0.25, 0.25)    # Le fond est de couleur grise plutôt foncée
                             # (0.25 plus proche de 0 noir que de 1 blanc)

t1 = Turtle()                # Création d'une première tortue
t1.shape("classic")          # De forme classic flèche

t1.speed(1)                  # Vitesse à 1 pour bien voir
t1.color("red")              # Couleur rouge
t1.hideturtle()              # On cache la tortue
for n in range(1, 10):       # Boucle for, classique
    t1.width(n)              # changement d'épaisseur à chaque tour de boucle
    t1.forward(100)          # On avance de 100 pixels
    t1.right(40)             # On tourne à droite de 40°
    t1.write(t1.position())  # Ecrire les coordonnées de la position actuelle
t1.showturtle()              # La tortue réapparait

t2 = Turtle()                # Création d'une deuxième tortue
t2.shape("turtle")           # De forme tortue

t2.speed(1)                  # Vitesse à 1 pour bien voir
t2.color(0, 1, 0)            # Couleur RGB avec G au max, donc c'est du vert
t2.setheading(90)            # La tortue prend la direction 90° (Nord)
for i in range(15):          # boucle for
    t2.penup()               # On va dessiner des pointillés en levant le crayon
    t2.forward(10)
    t2.pendown()             # Puis en le rabaissant
    t2.forward(10)
t2.write("direction : "+str(t2.heading())) # On affiche l'angle de direction actuel
t2.penup()                   # On lève le crayon
t2.home()                    # avant de revenir à la position initiale
t2.color("#00AAAA")          # Couleur mélange de vert et de bleu, pas au max (un cyan plus foncé)
t2.setheading(-90)           # Direction vers le Sud (-90°)
t2.forward(140)
t2.pendown()
t2.circle(50)                # On dessine un circle qui part de la position courante et y revient.

Rappel : la documentation complète de la bibliothèque Turtle est ici.