Le python et la tortue
|
Dans ce didacticiel, vous apprendrez comment prendre en main très facilement le module turtle (émulation du langage LOGO), ce qui vous permettra de tracer de jolis graphiques, parfois complexes, à l'aide de quelques commandes vraiment basiques. |
|
Tag de cet article : Programmation
Objet de ce didacticiel :
Dans ce didacticiel, je vais vous présenter les fonctions de base pour utiliser de façon ludique le module "turtle" de Python 2.6.
Le module turtle est une sorte d'émulation d'un vieux language didactique nommé LOGO, qui permettait à des jeunes étudiants d'approcher le monde de la programmation structurée en dirigant sur l'écran d'un pc une petite tortue, capable de tracer des formes géométriques en fonction de certaines commandes.
Il existait même des versions avec un robot sur roulettes, qui traçait le programme devant vos yeux sur une grande feuille de papier.
Il n'est pas nécessaire de maitriser Python pour se lancer dans la lecture de ce didacticiel, juste avoir une petite idée des instructions permettant de boucler, telles que while ou for. Pour ceux qui veulent en savoir plus, toutes les explications de cette page sont inspirées de la lecture de la documentation officielle en anglais, située à cette adresse :
http://docs.python.org/library/turtle.html
Dans un soucis de simplicité, les exemples expliqués dans cet article n'utilisent pas Python en mode programmation objet. Etant donné qu'il s'agit d'une initiation accessible au plus grand monde, j'ai préféré rester en mode procédural, qui est beaucoup plus compréhensible pour le débutant. Vous pouvez suivre ce didacticiel immédiatement après avoir installé Python 2.6. sur votre ordinateur, tel que je l'ai expliqué dans mon article précédent sur Python.
Les premières fonctions :
Allons-y ! Jettons-nous à corps perdu dans ce module sympathique, et passons en revue nos premières fonctions :
shape('turtle') : cette fonction permet de choisir la forme de son traceur. La forme par défaut est celle nommée 'classic'. Dans l'illustration ci-dessous, vous pouvez voir les 6 types différents de traceur. Pour ma part, je trouve sympathique l'image de la petite tortue, c'est pourquoi je mettrais souvent au début des exemples de ce didacticiel l'instruction suivante : shape('turtle').
Note : vous pouvez remarquer que le cercle n'est pas un traceur qui montre clairement la direction vers laquelle le prochain tracé se fera.
clear() : ceci efface tout ce qui est à l'écran. Idéal quand on veut repartir de zéro.
speed(10) : vitesse d'avancement de la tortue durant le traçage. Attention : 0 signifie qu'aucune animation n'aura lieu (donc c'est en quelque sorte la vitesse la plus rapide). Mais vous pouvez aussi utiliser une échelle allant de 1 à 10 : 1 étant la vitesse la plus lente, 10 la plus rapide.
up() : on signale à la tortue que durant ses futurs déplacements, elle ne doit plus rien tracer ! C'est comme si la tortue levait son crayon de la feuille de papier.
down() : on signale à la tortue qu'elle peut recommencer à tracer lors du prochain déplacement. La tortue repose donc la mine de son crayon sur la feuille de papier.
goto(x,y) : on translate la tortue au point x,y . Attention, si le crayon de la tortue est baissé, ce déplacement trace aussi un trait. Notez bien que l'instruction goto ne change pas l'orientation de la tortue !
color('green') : change la couleur du prochain tracé. Vous avez le choix entre des noms de couleurs prédéfinies, exemple : 'black', 'white', 'green', 'red', 'yellow'... (en anglais évidemment). Ou mieux encore, vous pouvez utiliser les composantes R G B d'une couleur : exemple color(125,1,244). Chaque composante consistant en un chiffre entier entre 1 et 255 à condition de faire appel préalablement à la commande colormode(255).
bgcolor('black') : cette commande permet de changer la couleur de fond. Pour ma part, je trouve que le noir fait bien ressortir les tracés.
left(x) : cette commande ajoute à l'orientation actuelle de la tortue un angle de x degrés. C-à-d, si la tortue pointe déjà vers le nord (90°) et que vous faites un left(20), la tortue pointera alors à 110°. Cette commande fait donc une simple rotation du traceur vers la gauche d'un angle de x°.
right(x) : idem que left mais vers la droite.
L'image ci-dessous montre comment fonctionne l'orientation par défaut du traceur.
setheading(x) : Maintenant, parfois, indépendamment de l'orientation actuelle du traceur, on peut vouloir le diriger directement dans une direction donnée, et non pas ajouter une rotation à sa direction actuelle. On utilise alors setheading. Exemple : setheading(90) place la tortue prête à se diriger vers le Nord.
forward(100) : la commande la plus évidente de toute ! forward(100) fait avancer la tortue, droit devant elle, en dessinant un trait de 100 pixels.
backward(50) : la même chose que forward, excepté que la tortue dessine son trait, mais en partant en marche arrière (et sans se retourner de 180° !).
dot(x,'blue') : trace un point circulaire de diamètre x, centré à l'endroit où se trouve le traceur. Le traceur ne change pas d'orientation une fois le point dessiné. Le paramètre de couleur est optionnel : exemple dot(25) dans ce cas c'est la couleur du moment qui est appliquée.
circle(x) : cette commande trace un cercle complet de rayon x en partant de la position et de l'orientation actuelle du traceur, en tournant vers la gauche, et revient donc à la position initiale juste avant le tracé. Note : ce cercle n'est donc pas centré à la position initiale du traceur, mais bien tangent. Si on met un signe - devant le chiffre du rayon, le cercle sera dessiné en partant vers la droite !
circle(x,y) : cette variante fait la même chose que circle(x) mais se limite à dessiner le cercle seulement sur un arc de y°. Si y n'est pas égal à 360, la position finale du traceur n'est donc pas égale dans ce cas à sa position initiale, ni même son orientation.
Quelques scripts pour l'exemple :
Rien de tel pour avancer dans la compréhension des commandes de voir des exemples simples et concrets sur la manipulation de notre petite tortue. L'ensemble des huit scripts se retrouve dans une archive zip que vous pouvez télécharger tout en bas de cette page.
Script turtle1.py
# -*- coding:utf-8 -*-
from turtle import *
# initialisation
clear()
speed(1)
shape('turtle')
bgcolor('black') # ou bgcolor('#000000')
# épaisseur du trait
width(1)
# c'est parti :
color('green')
forward(50)
left(90)
color('red')
forward(50)
right(90)
color('blue')
forward(50)
left(90)
color('yellow')
forward(50)
# pour terminer, on se replace au centre
up()
goto(0,0)
exitonclick()
Une simple illustration (on ne peut plus basique) du déplacement du traceur. Remarquez l'instruction exitonclick() qui permet de mettre en place facilement une sortie du programme simplement en cliquant sur la fenêtre. Vraiment rien de compliqué dans ce premier script !
Script turtle2.py
# -*- coding:utf-8 -*-
from turtle import *
# initialisation
clear()
speed(2)
shape('turtle')
bgcolor("#000000")
color('white')
# épaisseur du trait
width(1)
# Au départ, la tortue est en (0, 0)
goto( 120, 40)
goto(-100, 90)
goto( -40,-100)
goto( 60, -40)
goto( 0, 0)
# pour différencier la tortue de son trait, on la met en vert à la fin
color('green')
exitonclick()
Dans ce deuxième script, on regarde plutôt le fonctionnement de goto(x,y) qui ne change pas l'orientation de notre petite tortue.
Script turtle3.py
# -*- coding:utf-8 -*-
from turtle import *
speed(0)
colormode(255)
a = 1
while a < 256 :
up()
goto( 0, a)
down()
color(a,1,a)
goto(50, a)
a = a + 1
hideturtle()
exitonclick()
Ce troisième script utilise une boucle while. On trace simplement des petites barres de 50 pixels (qui sont donc des petits traits de déplacements du traceur), et on remonte à chaque fois d'un pixel vers le haut. Ce qui crée un dégradé car nous changeons la couleur à chaque incrémentation. On rend ensuite le traceur invisible car dans ce dessin, sa présence finale n'est pas très jolie.
Script turtle4.py
# -*- coding:utf-8 -*-
from turtle import *
speed(2)
# Part de (0,0) et trace un quart de cercle (90°) avec un rayon de 100.
circle(100, 90)
# on arrive en (100,100)
left(90)
forward(100)
# on arrive en (0,100)
left(90)
forward(100)
# on est revenu à (0,0)
# on va remplir un cercle en rouge en (100,100):
up()
goto(100,100)
down()
# à ce stade la tortue est dirigée vers le bas (270°)
color('red')
begin_fill()
circle(40)
end_fill()
up()
goto(0,0)
exitonclick()
Dans cet exemple, on illustre la peinture de formes géometriques. Avant de tracer une forme "fermée" comme un cercle, on signale que cette forme va devoir être colorée grâce à l'instruction begin_fill(). Quand la forme est terminée, on initie la colorisation de la forme en faisant simplement end_fill().
Script turtle5.py
# -*- coding:utf-8 -*-
from turtle import *
clear()
speed(10)
shape('turtle')
bgcolor('black')
color('yellow')
width(2)
for i in range(0, 10):
up()
goto(0,0)
down()
setheading(i*36)
circle(50, 180)
up()
goto(0,120)
setheading(180)
color('green')
exitonclick()
Encore un simple script qui utilise cette fois-ci une boucle for. Remarquez le range(0,10) qui signifie que i va prendre successivement les valeurs de 0 à 9.
Script turtle6.py
# -*- coding:utf-8 -*-
from turtle import *
clear()
speed(10)
shape('turtle')
bgcolor('black')
color('white')
width(1)
for i in range(0, 20):
up()
goto(0,0)
down()
setheading(i*18)
circle(100)
up()
goto(0,220)
setheading(180)
color('green')
exitonclick()
En voilà une belle rosace. Simplement constituée de cercles identiques mais décalés de façon régulière... Aucune difficulté majeure dans ce script.
Script turtle7.py
# -*- coding:utf-8 -*-
from turtle import *
from random import randrange
speed(0)
for i in range(1,21) :
up()
x=randrange(400)-(200)
y=randrange(400)-(200)
d=randrange(40)+1
goto(x,y)
down()
dot(d, 'red')
color('black')
up()
forward(15)
down()
write(str(i))
up()
goto(0,0)
exitonclick()
Le script 7 utilise le module random qui nous permettra de positionner aléatoirement des boules rouges de diamètres variés. L'instruction randrange(400) sort une valeur au hasard entre 0 et 399. Mais comme je veux une valeur aléatoire entre -200 et 200, je soustrais donc d'office 200 à mon chiffre obtenu, pour répartir harmonieusement les boules autour du centre (0,0). Remarquez aussi l'instruction write() qui écrit le numéro des boules i, à 15 pixels à droite de chaque boule. L'instruction str() transforme un nombre en chaine de caractères, utilisable ensuite dans write().
Script turtle8.py
# -*- coding:utf-8 -*-
from turtle import *
clear()
speed(10)
shape('turtle')
bgcolor('black')
color('lightgrey')
begin_fill()
circle(100,180)
circle( 50,180)
circle(-50,180)
end_fill()
up()
goto(0,200)
setheading(180)
down()
color('brown')
begin_fill()
circle(100,180)
circle( 50,180)
circle(-50,180)
end_fill()
color('lightgrey')
up()
goto(0,50)
down()
dot(30)
color('brown')
up()
goto(0,150)
down()
dot(30)
color('green')
up()
goto(0,- 20)
exitonclick()
Et voilà une première application concrète de notre petite tortue traceuse : un symbole ying-yang dessiné par programmation ! C'est chouette, non ?
Conclusion
Voilà, c'est ici que se termine notre découverte du module turtle sous python 2.6. Ce n'était qu'un premier aperçu : car il y a moyen de faire des tas de choses superbes avec ce module, et même des petits jeux, car on peut ajouter de l'interactivité entre l'utilisateur et la tortue. Si vous voulez aller beaucoup plus loin avec turtle, vous pouvez vous amuser à étudier les exemples plus complexes présentés dans cette page :
http://code.google.com/p/python-turtle-demo/
Voilà, j'espère que ce didacticiel vous aura été utile pour une première prise en mains.
C.G.
Octobre 2009
Document associé :
| 8 scripts python pour le module turtle | |
Ce document reprend les huit scripts expliqués dans le didacticiel "Le python et la tortue". |
|
| ( Voir le document ) | |
 |
|
Faites votre commentaire :