Programmation Python/Turtle

Un livre de Wikilivres.
Aller à la navigation Aller à la recherche

Un peu de détente avec le module turtle[modifier | modifier le wikicode]

Turtle est un module graphique du langage de programmation Python. Il est inspiré de la programmation Logo et permet de déplacer une tortue sur l’écran.

Comme nous venons de le voir, l'une des grandes qualités de Python est qu'il est extrêmement facile de lui ajouter de nombreuses fonctionnalités par importation de divers modules.

Pour illustrer cela, et nous amuser un peu avec d'autres objets que des nombres, nous allons explorer un module Python qui permet de réaliser des « graphiques tortue », c'est-à-dire des dessins géométriques correspondant à la piste laissée derrière elle par une petite « tortue » virtuelle, dont nous contrôlons les déplacements sur l'écran de l'ordinateur à l'aide d'instructions simples.

Activer cette tortue est un vrai jeu d'enfant. Plutôt que de vous donner de longues explications, nous vous invitons à essayer tout de suite :

>>> from turtle import *
>>> forward(120)
>>> left(90)
>>> color('red')
>>> forward(80)

L'exercice est évidemment plus riche si l'on utilise des boucles :

>>> reset()
>>> a = 0
>>> while a <12:
		a+=1
		forward(150)
		left(150)
Apprendre à programmer avec Python 8.png

Attention cependant : avant de lancer un tel script, assurez-vous toujours qu'il ne comporte pas de boucle sans fin, car si c'est le cas vous risquez de ne plus pouvoir reprendre le contrôle des opérations (en cas de boucle infinie, pressez CTRL + C, ou alors arrêter Python dans le gestionnaire de tâches sous Windows ou le moniteur d'activité sur Mac et Linux).

Consultez également ces pages dans d’autres projets Wikimedia :

Article encyclopédique sur Wikipédia.
Définition sur Wiktionnaire.


Fonctions disponibles[modifier | modifier le wikicode]

Pour utiliser une fonction il faut inscrire son nom et lui donner une valeur dans les parenthèses.

Les principales fonctions mises à votre disposition dans le module turtle sont les suivantes :

Déplacement[modifier | modifier le wikicode]

  • forward(distance) : Avance d’une distance donnée. Type de donnée : pixel.
  • backward(distance) : Recule d’une distance donnée. Type de donnée : pixel.
  • left(angle) : Pivote vers la gauche. Type de donnée : angle.
  • right(angle) : Pivote vers la droite. Type de donnée : angle.
  • goto(x, y) : Va à l’endroit de coordonnées (x, y) - Type de donnée : pixel /!\ Ne pas oublier d'utiliser la fonction up() avant d'utiliser goto() car sinon il tracera le parcours effectué.

Gestion de l'écran, de l'affichage[modifier | modifier le wikicode]

  • reset() : Efface l’écran, recentre la tortue et remet les variables à zéro.
  • up() : Relève le crayon (pour pouvoir avancer sans dessiner).
  • down() : Abaisse le crayon (pour recommencer à dessiner).
  • ht() : Masque la tortue.
  • st() : Afficher la tortue.
  • title(titre) : Donne un titre à la fenêtre (par défaut le titre est "Turtle Graphics"). Type de donnée : chaîne de caractère.
  • width(épaisseur) : Choisit l’épaisseur du tracé. Type de donnée : pixel.
  • speed(vitesse) : Choisit la vitesse à laquelle se déplace le curseur. Type de donnée : chaîne de caractère. Vitesses proposées :
    • "slowest" => Le plus lent
    • "slow" => Lent
    • "normal" => Normal
    • "fast" => Rapide
    • "fastest" => Le plus rapide

Gestion de la couleur[modifier | modifier le wikicode]

  • color("couleur") : Détermine la couleur du tracé (noir par défaut). Type de donnée : chaîne de caractère
  • bgcolor("couleur") : Préciser la couleur de l'arrière plan de la scène.
  • fill(1) : Remplit un contour fermé à l’aide de la couleur sélectionnée.

La couleur peut être :

  • une couleur prédéfinie précisée entre apostrophes droites (exemples : 'red', 'yellow', 'green', 'blue', 'brown', 'violet', 'purple', etc.),
  • une couleur RVB avec trois variables r, v, et b comprises entre 0 et 1 (exemple : 1,0,0 pour le rouge).

Couleurs proposées :

  • "blue" => Bleu
  • "red" => Rouge
  • "green" => Vert
  • "yellow" => Jaune
  • "brown" => Marron
  • "black" => Noir
  • "white" => Blanc
  • "pink" => Rose
  • "orange" => Orange
  • "purple" => Violet
  • "grey" => Gris


Le remplissage peut se faire de deux manières. Par exemple pour remplir un carré :

begin_fill()
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
forward(100)
end_fill()
fill(1)
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
forward(100)
fill(0)

Objets utiles[modifier | modifier le wikicode]

  • circle(rayon, angle) : Trace un cercle de rayon donné. L’argument facultatif angle indique l’angle de l’arc de cercle (par défaut 360, soit un cercle complet). Type de donnée : rayon en pixel, angle un angle en degré.
  • write(texte) : Écrit du texte. Type de donnée : chaîne de caractère.

Compléments[modifier | modifier le wikicode]

  • Le module turtle s'appuie sur le module tkinter (Tkinter pour les versions de python antérieures à 3), ça permet d'en utiliser les fonctionnalités. Par exemple pour enregistrer sa production au format postscript :
import turtle

#......
#.......

turtle.getcanvas().postscript(file="monoeuvre.eps")
  • Le module turtle permet de manipuler plusieurs tortues.
fred = turtle.Turtle()
martha = turtle.Turtle()

fred.forward(100)
martha.left(45)


Si les méthodes associées aux tortues sont utilisées sans référence à une tortue particulière, elles s'appliquent à une tortue "anonyme". Celle-ci est automatiquement créée pour être l'objet de la méthode.

De même, si aucune fenêtre d'affichage n'existe, une telle fenêtre est automatiquement créée.

Ces automatismes, permettent avec simplicité, le lancement de l'environnement de dessin, dès l'utilisation d'une méthode tortue. Ils sont réellement pratiques, pour faciliter l'initiation au langage algorithmique, ce qui est la fonction d'origine des langages à géométries tortues.

Cependant ces automatismes peuvent ensuite nuire à la compréhension de l'aspect objet du langage, en devenant une source de confusion quant aux instanciations d'objets, tortue (anonyme) ou écran, réalisées ainsi implicitement.

C'est pour cela qu'il vaut donc mieux, ensuite, les expliciter.

scene = turtle.Screen()

scene.setup(width=0.5, height=1.0, startx=-1, starty=0)  
# width vraie dimension si entier, proportion de l'écran si décimal
# startx entier, position par rapport à la gauche de l'écran si positif, par rapport à la droite si négatif

Exemples[modifier | modifier le wikicode]

Tracer une spirale quelconque[modifier | modifier le wikicode]

from turtle import *
angle = 5
distance = 10
compteur = 0

while compteur <= 30:
    forward(distance)
    left(angle)
    compteur += 1
    angle += 2

Mais aussi de manière plus simple:

from turtle import *
speed("fastest")           #Pour l'aider à aller plus vite
rayon = 1                  #Le premier rayon par défaut
rayonSpiral = 100
while(rayon < rayonSpiral): 
    circle(rayon, 180)
    rayon += 2             #écartement entre 2 demi-cercles de la spirale

Reproduction de l'œuvre "composition arithmétique" de Theo Van Doesburg[modifier | modifier le wikicode]

from turtle import *
from math import *

def cadre(x):
    begin_fill()
    for i in range(4):
        forward(x)
        left(90)
    end_fill()

def carre (x):                                      # x est la taille du cadre
    y=(sqrt(2*x**2))/3                              # y est la taille du carré
    up()
    left (45)
    forward(y)
    down()

    begin_fill()
    for i in range (4):
        forward (y)
        left(90)
    end_fill()

    up()
    forward(y/2)
    right(135)
    forward(x/2)
    left(90)

x=600                                              # initialisation
up()                                               # on se déplace en (-x, -x)
goto(-x/2,-x/2)
down()

color("grey")                                      # couleur du cadre principal
cadre(x)                                           # on dessine le cadre principal

color ("white")                                    # couleur des carrés
for i in range (4):                                # on dessine les 4 carrés succesifs
    carre(x/2**i)

ht()                                               # on cache la tortue à la fin du tracé
getcanvas().postscript(file="monoeuvre.eps")       # on récupère le fichier image au format eps
done()

Tracer une lanterne[modifier | modifier le wikicode]

from turtle import *
import math

def lanterne(l = 100):
   left(90)
   forward(l)
   right(90)
   forward(l)
   right(90)
   forward(l)
   right(90)
   forward(l)
   right(135)
   forward(l * math.sqrt(2))
   left(90)
   fillcolor("red")
   begin_fill()
   forward(l * math.sqrt(2) / 2)
   left(90)
   forward(l * math.sqrt(2) / 2)
   end_fill()
   left(90)
   forward(l * math.sqrt(2))
   right(45)

lanterne(l = 100)

ht()
done()

Tracer un parcours/message[modifier | modifier le wikicode]

Les traces laissées par la tortue peuvent aussi servir à afficher des messages secrets, des itinéraires... à partir d'éléments simples. On peut attribuer, par exemple aux 4 lettres A, R, D et G les fonctions Avancer, Reculer, tourner à Droite et tourner à Gauche. La tortue pourra ainsi se déplacer selon un ordre compact tel que "ADADADAD" pour tracer un carré.

Exemple permettant de tracer un mot mystère (ici un pseudonyme).

from turtle import *

def parcours(instruction, pas):
    """ fonction gérant l'affichage.
    arguments :
    - instruction : une chaîne de caractère composée de A, R, D ou G
    - pas : un entier, donnant en pixel le déplacement de chaque instruction Avancer ou Reculer
    """
    for iteration in range(len(instruction)):
        if instruction[iteration] == "A" :
            forward(pas)
        elif instruction[iteration] == "R":
            backward(pas)
        elif instruction[iteration] == "D":
            right(90)
        elif instruction[iteration] == "G":
            left(90)
        else: #pour gérer tout ce qui n'est pas A, G, D, R
            pass

# Variable avec le mot mystère
pseudo = "RRDAAGAADAADAADDAAAGAAAARRRRDAGAAAAARRRRRDAAGAADAARRGAADAADAAAAGAGAAAADADAAAAGAGAAAARRRRDAGAAAADAADAAAADAADDAAAAARRGAAAADAA"

#Appel de la fonction pour afficher pseudo avec un pas de 10
parcours(pseudo, 10)


Sources[modifier | modifier le wikicode]