Faire bouger la tortue

Il est possible de commander le mouvement de la tortue. Voici quatre commandes qui permettent de guider la tortue dans les quatre directions :

• Forward() (pour faire avancer la tortue en avant dans la direction où elle se trouve)
• Backward() (pour la faire reculer dans la direction où elle se trouve)
• Left() (pour la faire tourner à gauche avec un angle donné)
• Right() (pour tourner à droite avec un angle donné)

Afin de tester ces quatre commandes, exécutez le petit code suivant et notez ce qu’il fait :

t.frward(40)
t.right(90)
t.forward(40)

Si vous avez exécuter ce code, vous aurez réalisé, peut être pour une première fois, une figure toute simple avec le module turtle, vous obtiendrez ainsi une création qui ressemble à la figure suivante :

La tortue avance de 40, puis elle tourne d’un angle de 90° et enfin elle avance de 40.

Format court des commandes

Il existe des formats courtes des commandes utilisées précédemment, et voici comment elles peuvent être utiliser:

• t.rt() à la place de t.right()
• t.fd() à la place de t.forward()
• t.lt() à la place de t.left()
• t.bk() à la place de t.backward()

Utilisation des coordonnées

Si on attache un repère gradué à la fenêtre graphique, on peut définir chaque point du plan de la fenêtre par des coordonnées. Les coordonnées renseignent la position de chaque points. On peut faire bouger la tortue d’un point à un autre en utilisant les coordonnées des points. En fonction des positions des points, les cordonnées peuvent être soit positifs ou bien négatifs. Le repère est constitué de deux axes:

• Un axe horizontal, conventionnellement désigné par X, et appelé axe des abscisses (ou axe des x)
• Un axe vertical, conventionnellement désigné par Y, et appelé axe des ordonnées (ou axe des y)

L’origine du repère gradué attaché à la fenêtre graphique est situé au centre de la fenêtre. Voici un schéma qui montre un repère qui partage le plan en quatre quadrants. Chacun de ces quadrants montre le signe des coordonnées (positif ou négatif).

La position initiale de la tortue est au point de coordonnées (0 ; 0) (x=0 et y=0). Ce point est appelé Home. Pour faire bouger la tortue on utilise la méthode .goto() qui prend pour arguments les coordonnées du point de destination de la tortue.

Le code suivant permet de déplacer la tortue de sa position initiale au point (200, 200)

t.goto(200, 200)

Et voici le résultat que renvoie ce bout de code :

On vient de tracer une ligne droite de la position initiale de la tortue au point de coordonnées (200, 200). Et pour faire revenir la tortue à sa position initiale on tape le code suivant :

t.home()

Différence entre .home() et goto(0,0)

On pourrait aussi utiliser la méthode t.goto(0, 0) qui ramènera la tortue à sa position initiale. La différence entre cette méthode et la méthode .home() c’est l’orientation de la tortue. En effet, la méthode .goto(0,0) garde la dernière orientation utilisée de la tortue, tandis que .home() réinitialise, à la fois, la position de la tortue ainsi que son angle d’orientation.

Il faut donc prendre ses précautions quant à l’utilisation de l’une ou de l’autre méthode. Ça sera donc la suite du mouvement de la tortue qui permettra de prendre la décision d’utiliser l’une ou l’autre méthode.

Exercice d’application :

Voici un petit exercice qui permet de travailler les fonctions et méthodes vues dans les paragraphes précédents. 

Voici par exemple un code qui permet de dessiner un carrée 

t.forward(100)
t.right(90)
t.forward(100)
t.right(90)
t.forward(100)
t.right(90)
t.forward(100)

• Modifier le code ci-dessus pour dessiner un rectangle
• Écrire des petits programmes qui permettent de dessiner des polygones.
  • Indication: alterner des lignes droites et d’orientation avec un angle en veillant à ce que la figure finale soit fermée.
• Écrire un programme qui permet de dessiner la figure suivante :
  • Indications: Utilisez la fonction .goto() pour déplacer la tortue grâce aux coordonnées. Et utiliser la fonction t.up() pour déplacer la tortue sans tracer. Et n’oubliez pas de descendre la tortue pour faire la suite 😉

Solution de l’exercice d’application

Je vous conseille de réfléchir quelques instants sur l’exercice avant de découvrir sa solution. J’ai volontairement créer puis utiliser des fonctions. si vous n’êtes pas habitué avec ceci, je vous conseille ce tutoriel simple sur les fonctions python

import turtle
#f = turtle.getscreen()
t = turtle.Turtle()
t.up()
t.goto(-250, -250)
t.down()
a=60
b=120
def caree(a):
    for i in range(3):
        t.forward(a)
        t.left(90)
    t.forward(a)
def rect(a, b):
    for i in range(3):
        if i % 2 == 0:
            t.forward(a)
        else:
            t.forward(b)
        t.left(90)
    t.forward(b)
caree(450)
t.up()
t.goto(-200, 150)
t.down()
rect(a, b)
t.left(-90)
t.up()
t.goto(150, 150-a)
t.down()
rect(a, b)
t.up()
t.goto(-25, -100)
t.down()
t.forward(b)
t.right(150)
t.forward(b)
t.right(180-150)
t.forward(b)
t.right(150)
t.forward(b)
t.up()
#t.goto(0, 0)
t.home()
t.down()
t.backward(50)
t.right(45)
t.forward(50)
t.left(90)
t.forward(50)
t.home()
turtle.done()

Figures préenregistrées

Certaines figures ne sont pas faciles à dessiner avec les fonctions vues précédemment. Imaginons par exemple que l’on souhaite dessiner un cercle, il serait difficile et long à faire. Heureusement que le module turtle de python contient certaines fonctionnalités natives qui permettent de dessiner des figures complexes.

Dessiner un cercle

Pour dessiner un cercle, on utilise la fonction .circle() en mettant entre parenthèses le rayon du cercle. Si on utilise le code suivant :

turtle.circle(125)

On obtient la figure suivante :

Dessiner un arc de cercle

La fonction circle() peut prendre jusqu’à trois arguments. Le premier argument (rayon du cercle) est obligatoire, et les deux derniers sont facultatifs. Pour rappel, pour dessiner un cercle, la tortue part d’un point sur la circonférence du cercle et fait un tour complet jusqu’à arriver à son point de départ, elle fait donc un tour de 360°.

Le deuxième argument correspond justement à l’angle relatif au déplacement de la tortue sur la circonférence, il est par défaut égal à 360°. Pour dessiner un arc de cercle il suffit de mettre dans le deuxième argument la valeur de l’angle souhaité. Pour dessiner un demi-cercle la valeur de l’angle sera de 180°

t.circle(100, 180)

Dessiner un polygone régulier

Un polygone peut être simplement définie comme une ligne bisée à plusieurs endroits et fermée. Le nombre de brisures, donc de segments ou de côtés, détermine l’appellation du polygone. Par exemple un hexagone est tout simplement un polygone à 6 côtés.

Un polygone est régulier s’il est équilatéral (tous les côtés sont égaux) et équiangle (les angles sont tous égaux).

Un cercle peut être considéré comme un polygone régulier dont le côté est infiniment petit. C’est cette méthode qu’utilise la fonction circle() pour dessiner un cercle (ou un arc de cercle). Il est possible de spécifier à la fonction le nombre de côtés en utilisant justement son troisième argument. Pour dessiner un hexagone, il suffit de donner la valeur 6 au troisième argument de la fonction. 

t.circle(100, 360, 6)

Dessiner un disque (point)

De la même manière, pour dessiner un disque on utilise la fonction .dot()

t.dot(20)

La fonction .dot() fonctionne de la même manière que circle à quelques différences près :

• Le cercle dessiné par .dot() est un cercle rempli (disque).
• Le disque de .dot() est référencé par son centre alors que le cercle de .circle() est référencé par un point sur la circonférence
• Et enfin, la fonction .circle() prend le rayon du cercle en argument tandis que la fonction .dot() prend le diamètre du disque en argument.

A ce stade, on sait comment faire pour dessiner des figures géométriques en bougeant la tortue entre différents points ou en utilisant directement des fonctions de formes préenregistrées. Il est temps maintenant de modifier les paramètres de couleurs. Et ça sera le sujet du prochain article.

Mettez en commentaire vos impressions sur le module turtle