Programmation Python/Turtle

Et pour quelques widgets de plus...

Les threads

Programmation Python

Partie 1 - Introduction

Partie 2 - Le langage

Partie 3 - Les bibliothèques

Version imprimable

[ Modifier le sommaire ]

Et pour quelques widgets de plus...

Les threads

Un peu de détente avec le module turtle

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(90)
>>> left(60)
>>> color('blue')
>>> forward(50)

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

>>> reset()
>>> a = 0
>>> while a <12:
		a+=1
		forward(150)
		left(150)

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

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

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

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

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

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

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

Python 3 par exemple/Turtle
Un exemple de fonction avec le module Turtle a déjà été présenté sur la page fonctions. Vous y trouverez aussi trois petits exercices.

Tracer une spirale quelconque

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

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

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

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

Documentation de la bibliothèque