Turtle

Introduction

La tortue graphique (ou Turtle) est un module d'initiation à la programmation. Son fonctionnement consiste à réaliser des dessins par le déplacement d'une tortue virtuelle dotée d'un stylo sur un plan orthonormé.

Fonction	Synonyme	Description
forward(n)	fd(n)	Avancer la tortue de n pixel
backward(n)	bk(n)	Reculer la tortue de n pixel
left(n)	rt(n)	Effectuer une rotation de la tortue d'un angle de n degrés vers la gauche (sans antihoraire)
right(n)	lt(n)	Effectuer une rotation de la tortue d'un angle de n degrés vers la droite (sans horaire)
goto(x, y)		Déplacer la tortue aux coordonnées (x, y)
penup()	pu()	Lever le crayon
pendown()	pd()	Baisser le crayon

Vous pouvez consulter la documentation de ces fonctions et en découvrir bien d'autres sur le site officiel de Python : https://docs.python.org/fr/3/library/turtle.html

Préparation

Arborescence

Avant de commencer, vous allez mettre à jour (ou créer) le dossier de travail dédié à la spécialité NSI. Nous partagerons ainsi une même arborescence simplifiant ainsi la recherche de tout fichier.

Ordinateurs du lycée

Si vous travaillez sur les ordinateurs du lycée, votre dossier de travail doit être placé dans votre zone personnelle. Celle-ci est accessible de plusieurs manières :

• Directement depuis le bureau en cliquant sur l'icône intitulée Zone personnelle
• Depuis l'Exportateur Windows en allant dans Bureau puis Zone personnelle
• Depuis l'Explorateur Windows en allant dans le lecteur réseau P:

Ordinateur de la région

Si vous travaillez sur l'ordinateur portable de la région, vous êtes libre de choisir l'emplacement de votre répertoire de travail.

Création ou mise à jour de l'espace de travail

• Créer le dossier NSI s'il n'existe pas déjà
• Dans le dossier NSI, créer le dossier chapitre_03
• Déplacer dans le dossier chapitre_03 les fichiers du TP2
• Si besoin, renommer le dossier html créé dans le cadre du TP HTML/CSS en chapitre_02

Logiciel

Vous devez disposer d'un interpréteur Python sur votre machine. Nous recommandons fortement l'utilisation de l'application Thonny avec lequel ces travaux pratiques ont été conçus et testés.

Exercice 1 - Premiers déplacements

Vérifier le bon fonctionnement du module Turtle. Pour cela :

• Lancer l'application Thonny
• Créer un nouveau fichier et y copier/coller le code ci-après
• Enregistrer le fichier dans le répertoire chapitre_03 en le nommant tp3_turtle.py
• Lancer l'exécution du programme

import turtle

# Tracé de démonstration
turtle.goto(40, 40)
turtle.right(90)
turtle.forward(40)
turtle.left(90)
turtle.penup()
turtle.backward(20)
turtle.pendown()
turtle.backward(20)

# Boucle des événements
# Nécessaire pour voir capter mes interactions avec le souris ou le clavier
# Nécessaire aussi pour l'affichage sous Basthon ou éviter de bloquer EduPython
# turtle.mainloop()

Point d'attention

Pouvez-vous décrire le rôle de chaque instruction du tracé ?

Point d'attention

Pouvez-vous situer l'origine (point de coordonnées (0,0)) du plan orthonormé au sein de la fenêtre Turtle ?

Astuce

En l'absence de l'appel de la fonction turtle.mainloop(), la console Python reste accessible sous Thonny. À l'exécution de votre programme, vous pouvez alors y saisir d'autres instructions Turtle et voir directement le résultat à l'écran. Tester par exemple turtle.goto(-100, 100)

Exercice 2 - Aide au tracé

Affichage d'une grille

Afin d'éventuellement mieux visualiser la position de la tortue dans le plan, nous avons écrit une fonction capable d'afficher une grille à l'écran. Suivre les instructions suivantes pour pouvoir l'afficher.

• Créer un nouveau fichier
• Y copier/coller le code ci-après
• Enregistrer le fichier dans le répertoire chapitre_03 en le nommant aide.py

import turtle as t

def jump_to(x, y):
    t.penup()
    t.goto(x, y)
    t.pendown()

def draw_custom_grid(width, height, step, color):
    top_left_x = -width//2
    top_left_y = height//2

    t.pencolor(color)
    t.tracer(False)

    i = 0
    while i <= height//step:
        jump_to(top_left_x, top_left_y-step*i)
        t.forward(width)
        i += 1

    t.right(90)

    j = 0
    while j <= width//step:
        jump_to(top_left_x+step*j, top_left_y)
        t.forward(height)
        j += 1

    t.penup()
    t.home()
    t.pencolor("black")
    t.pendown()
    t.tracer(True)

def grille(width=800, height=800):
    draw_custom_grid(width, height, 10, '#e0e0e0')
    draw_custom_grid(width, height, 100, '#cccccc')

Afficher la grille

Retourner au fichier tp_turtle.py. Ajouter le code nécessaire pour importer le module aide, qui correspond au fichier aide.py créé précédemment, puis appeler la fonction grille() de ce module.

import turtle
import aide

# Tracé de la grille
aide.grille()

# Tracé de démonstration
...

Point d'attention

Savez-vous expliquer précisément ce que fait l'instruction import aide ?

Remarque

Afficher la grille n'a rien d'indispensable, elle peut cependant vous aider à vous repérer en phase de débogage.

Exercice 3 - Formes géométriques

Tracer un carré

Nous souhaitons tracer un carré. Suivre les instructions suivantes :

• Ouvrir le fichier tp3_turtle.py
• Supprimer le code du tracé de démonstration
• Élaborer un algorithme permettant de tracer un carré en ne faisant qu'avancer ou tourner la tortue
• Écrire le code qui permettrait de tracer un carré de 100 pixels de côté

Tracer un triangle équilatéral

Nous souhaitons tracer un triangle équilatéral à l'écran. Suivre les instructions suivantes :

• Créer un nouveau fichier et l'enregistrer immédiatement en le nommant tp3_triangle.py
• Trouver un algorithme permettant de tracer un triangle équilatéral en ne faisant qu'avancer ou tourner la tortue
• Écrire le code qui permettrait de tracer un triangle équilatéral de 100 pixels de côté

Exercice 4 - Utilisation des boucles

Si vous n'avez pas pensé utiliser une boucle, vous devriez constater une répétition de certaines commandes. Exemple pour le tracé d'un carré :

# Tracé d'un carré
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)

Pour éviter ces répétitions, vous pouvez utiliser une boucle qui se chargera de répéter les commandes dédiées au tracé d'un seul côté du carré.

# Tracé d'un carré
i = 0
while i < 4:
    turtle.forward(100)
    turtle.right(90)
    i = i + 1

• Ouvrir le script tp3_turtle.py
• Remplacer l'ancienne implémentation du tracé d'un carré par celle faisant usage d'une boucle
• Vérifier son bon fonctionnement
• Modifier le fichier tp3_triangle.py de façon à ce que le tracé du triangle équilatéral se fasse aussi à l'aide d'une boucle

Exercice 5 - Utilisation des fonctions et des modules

Tracé de plusieurs carrés

Nous souhaiterions effectuer le tracé de plusieurs carrés à l'écran.

• Ouvrir le script tp3_turtle.py
• Modifier le code de façon à tracer trois carrés distincts à l'écran (copier/coller de code autorisé)

Astuce

Si vous souhaitez démarrer un tracé à un autre endroit du plan que l'origine, pensez à déplacer au préalable la tortue en levant son crayon. Vous pouvez aussi réinitialiser la position et l'angle de la tortue en utilisant la fonction turtle.home().

Factorisation du code

Vous avez probablement dupliqué le code du carré initial. Dupliquer du code n'est pas une bonne pratique de programmation. Nous pouvons éviter cela grâce à une fonction, c'est-à-dire un bloc de code nommé et réutilisable qui ne s'exécute que si on l'appelle. L'action consistant à mutualiser du code dupliqué au sein d'une fonction s'appelle factoriser.

import turtle

def carre():
    """Dessine un carré de 100 pixels de côté"""
    i = 0
    while i < 4:
        turtle.forward(100)
        turtle.right(90)
        i = i + 1

• Ouvrir le fichier tp3_turtle.py
• Copier/coller le code ci-dessus en début de fichier (une fonction doit être définie avant son utilisation)
• Modifier votre code du tracé des trois carrés en faisant cette fois appel à la fonction carre()

Point d'attention

Savez-vous expliquer ce qu'est factoriser du code ?

Point d'attention

Comprenez-vous le rôle de la ligne """ Dessine un carré de 100 pixels de côté """ ?
Si ce n'est pas le cas, lire les explications de cette page ou la PEP 257

Création d'un module

• Créer un nouveau fichier et l'enregistrer immédiatement dans un fichier nommé formes.py
• Importer le module turtle
• Déplacer le code de la fonction carre() du fichier tp3_turtle.py vers le fichier formes.py
• Modifier le fichier tp3_turtle.py de façon à importer le module formes et appeler la fonction de tracé des carrés depuis ce module formes.carre()

Fichier formes.py

import turtle

def carre():
    """Dessine un carré de 100 pixels de côté"""
    i = 0
    while i < 4:
        turtle.forward(100)
        turtle.right(90)
        i = i + 1

Exemple de fichier tp3_turtle.py

import turtle
import formes

turtle.pu()
turtle.goto(-150, 150)
turtle.pd()
formes.carre()

turtle.pu()
turtle.goto(150, 150)
turtle.pd()
formes.carre()

turtle.pu()
turtle.goto(150, -150)
turtle.pd()
formes.carre()

Point d'attention

Êtes-vous capable de repérer une autre portion de code potentiellement factorisable dans l'exemple de fichier tp3_turtle.py ci-dessus ?

Fonction de tracé d'un triangle équilatéral

• Ouvrir le fichier formes.py
• De la même manière que pour le carré, créer la fonction triangle()
• Tester cette fonction dans le fichier tp3_triangle.py en dessinant 3 triangles

Exercice 6 - Utilisation des paramètres

Nous souhaitons maintenant pouvoir dessiner des formes géométriques de différentes tailles. Pour ce faire, nous allons rendre l'algorithme de tracé d'un carré paramétrable en ajoutant un paramètre à la fonction carre().

def carre(longueur):
    '''Dessine un carré de "longueur" pixels de côté'''
    i = 0
    while i < 4:
        turtle.forward(longueur)
        turtle.right(90)
        i = i + 1

• Modifier la fonction carre() définie dans le fichier formes.py
• Modifier le fichier tp3_turtle.py de façon à tracer trois carrés : un de 20 pixels, un autre de 100 pixels et un dernier de 200 pixels
• Faire de même avec la fonction triangle() et tracer trois triangles de taille différente dans le fichier tp3_triangle.py

Exercice 7 - Polygones

Le carré et le triangle équilatéral sont des polygones réguliers. Un polygone régulier est un polygone dont les côtés et les angles intérieurs ont la même mesure.

• Ouvrir le fichier formes.py
• Écrire la fonction polygone() permettant de tracer un polygone régulier à partir de son nombre de côtés et leur longueur. Vous trouverez ci-après le code à trou permettant de réaliser cette fonction.
• Tester cette fonction dans le fichier tp3_turtle.py
• Modifier les fonctions carre() et triangle de manière à ce qu'elle fasse appel à la fonction polygone() pour le tracé

def polygone(n, longueur):
    '''Dessine un polygone régulier de "n" côtés de "longueur" pixels'''
    i = 0
    while i < ...:
        turtle.forward(...)
        turtle.right(...)
        i = i + 1

⚠️ Rendu des travaux pratiques

Avant d'aller plus loin, le travail effectué jusqu'à présent doit être rendu. Pour ce faire :

• Se connecter à l'ENT
• Accéder à l'application Exercice
• Trouver le formulaire TP 3.3 Turtle - Premier rendu
• Déposer les fichiers tp3_turtle.py, tp3_triangle.py et formes.py
• Se connecter à Pronote
• Répondre au questionnaire d'évaluation

Exercice 8 - Dessin

Générer des dessins

Nous souhaitons maintenant effectuer des tracés plus ambitieux :

• Ajouter le code des fonctions dessin_1() et dessin_2() ci-après au fichier formes.py
• Tester ces fonctions dans le fichier tp3_turtle.py

def dessin_1(n, longueur):
    '''Dessine une combinaison de "n" carrés de taille "longueur"'''
    while n > 0:
        carre(longueur)
        turtle.right(10)
        n = n - 1

def dessin_2(n, longueur):
    '''Dessine une série de "n" carrés de taille "longueur"'''
    while n > 0:
        carre(longueur)
        turtle.pu()
        turtle.forward(2*longueur)
        turtle.pd()
        turtle.right(10)
        n = n - 1

Conseil

Vous pouvez modifier la vitesse de déplacement de la tortue grâce à la fonction turtle.speed()

Reproduire un dessin

Essayer de produire un dessin se rapprochant de la capture d'écran suivante :