|
Page 11 sur 13
Un peu de dessin avec le module Turtle
Le module Turtle est un module pour effectuer un peu de dessin. Ne vous attendez pas à des animations 3D époustouflantes, si j'en parle, c'est simplement pour entraîner les bases de la programmation, cela changera un peu des exercices purement mathématiques.
Le dessin se fait par le biais d'une flèche, que je vais plutôt appeler "curseur", et qui se comporte comme un stylo auquel on donne des ordres, sous forme de commandes ( on voit là une magnifique ligne rouge en train d'être tracée :) ) :
Fonctions de base du module
Comme pour chaque module, il faut commencer par son importation :
Puis on donne les instructions.
Plutôt que de m'étendre sur des explications qui n'amélioreraient pas forcément la compréhension, je préfère commencer par un exemple :
Exercice :
Exécuter le code suivant, et comprendre le sens de chacune des instructions fournies à turtle, ainsi que les unités des valeurs fournies en paramètre dans chaque instruction ( qui sont en fait des fonctions ) :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
from turtle import *
color('red')
forward(200)
left(90)
color('black')
forward(50)
right(150)
color('blue')
forward(300)
up()
goto(-100,-100)
down()
color('green')
width(5)
forward(100)
raw_input() ## Pause obligatoire pour observer le chef d'oeuvre
|
Arrivé à ce point, si vous avez compris le sens de l'instruction "forward", ainsi que son paramètre, vous comprendrez aisément le sens de l'instruction "backward" ainsi que son utilisation. Ce qui peut encore paraitre un peu flou, ce sont les instructions "up" et "down". Si c'est le cas, n'oubliez pas ma première remarque : le curseur se comporte comme un stylo...
Voici maintenant une liste des instructions de base :Turtle dans le tuto de Gérard Swinnen.
Pour une documentation plus complète, il faut évidemment voir l'officielle en anglais : Documentation officielle Turtle.
Il est temps de tester tout ça :
Exercices :
Dessiner chacune des figures suivantes, en réfléchissant bien aux données que l'utilisateur doit fournir ( longueurs, angles, ... ) afin de permettre un maximum de possibilités :
- un carré en rouge,
- un triangle équilatéral en vert,
- un rectangle en noir,
- un triangle rectangle isocèle en jaune,
- un triangle isocèle en bleu ( là, ça commence à se gâter ),
- un cercle en violet,
- un escalier avec 10 marches en gris ( pour le plaisir, je l'ai rempli en gris ),
- une étoile à 5 branches, dont chaque trait change de couleur,
- un triangle quelconque, dont l'utilisateur donne les coordonnées, si c'est possible ( attention, cette question est beaucoup plus difficile qu'elle ne le parait, et elle est à réserver à ceux qui maitrisent les calculs de grandeurs en géométrie ).
Constructions répétitives
Vous vous êtes maintenant un peu amusé à dessiner quelques figures de base, et je ne sais pas comment vous vous y êtes pris.
Pour dessiner l'escalier, avez-vous dessiner chacune des marches une à une ? Ou avez-vous trouvez une autre méthode plus rapide ?
Si non, comment vous y prendriez-vous pour dessiner un polygone régulier à 30 côtés ? ou à 120 côtés ? ( cela dit, avec turtle, ce dernier ressemblerait plutôt à un cercle ).
Il faut bien sûr penser à utiliser les boucles pour les séquences d'instructions répétitives.
Exercices :
- Si ce n'est pas déjà fait, réécrire le dessin du carré, du triangle équilatéral, de l'escalier et de l'étoile à l'aide d'une boucle.
- Construire le polygone régulier à 30 côtés comme ci-dessus.
- Construire les figures suivantes :
( 25 cercles imbriqués )
Eviter le superflux avec une meilleure structure
Dans la dernière question de l'exercice précédent, il fallait dessiner des carrés de tailles identiques, ce qui a pour avantage de ne pas demander de modifications dans le code du dessin du carré en soit. Les choses se compliquent nettement si je décide de dessiner une suite de carrés en alternance avec des étoiles et des triangles, le tout avec des tailles différentes à chaque fois, suivie de carrés imbriqués, puis d'une colonne d'étoiles de tailles différentes.
Il faudrait créer trois boucles :
- une pour la suite de figures en alternance,
- une pour la suite de carrés imbriqués,
- une pour la colonne d'étoiles.
Dans la première boucle seraient définies les constructions du carré, de l'étoile et du triangle équilatéral. Dans la seconde boucle, il faudrait redéfinir la construction du carré, et enfin dans la 3e boucle, celle de l'étoile. Cela rend le code inutilement long et très confus.
Vous aurez compris où je veux en venir : l'utilisation de fonctions permettrait largement de pallier à tous ces inconvénients.
En effet, il suffit de créer une fonction Carre ( dépendante d'un paramètre, je vous laisse deviner lequel ), une fonction Etoile ( également dépendante d'un paramètre ) et une fonction TriangleEquilateral ( dépendante d'un paramètre ), et d'appeler ces fonctions à chaque qu'on a besoin de dessiner les éléments cités. Pour la création de fonctions, je vous renvoie au paragraphe concernant la Structure fonctionnelle.
Les trois boucles dont nous aurions besoin bénéficieraient alors d'une belle cure de minceur, et nous pourrions réutiliser tous ces dessins sans avoir à les redéfinir ailleurs.
Exercices : Réaliser les figures suivantes ( exercices issus du livre de Swinnen ) :
|
Python 
