Vous avez un devoir maison de SNT ou de NSI ? Vous vous intéressez à l’art génératif ? Vous êtes au bon endroit ! Plus besoin d’écumer Internet à la recherche d’informations : voici un condensé de trucs et astuces sur le module Turtle pour tous niveaux pas à pas.
Tout d’abord, il faut savoir ce que l’on utilise. Turtle est donc une bibliothèque graphique dans le langage de programmation Python. Elle contient donc un ensemble de modules et de fonctions pré-écrites qu’il est possible de réutiliser à volonté dans chaque programme.
Au début de chaque programme utilisant des fonctions de la bibliothèque Turtle, il est donc nécessaire d’importer la bibliothèque (par convention en tout début de programme) avec cette ligne :
from turtle import *
En cas d’oubli, un message d’erreur s’affichera dès que vous utiliserez une fonctionnalité propre au module.
Utiliser un IDE
Pour commencer à coder, vous avez besoin d’utiliser un IDE (de l’anglais Integrated Development Environment), un logiciel regroupant différents outils nécessaires à la création de programmes informatiques.
Pour ma part, j’utilise Thonny, qui a pour avantage d’être facile à utiliser, et de permettre de repérer facilement les erreurs. Voici donc une petite parenthèse sur l’utilisation d’une IDE, qu’il est possible de sauter pour les personnes ayant déjà codé.
Vous pouvez installer Thonny sur ordinateur ici. Le lien vous mène à la page suivante :
Il vous faudra cliquer sur Windows, Mac ou Linux selon votre système d’exploitation.
Après avoir installé l’application, vous devez tomber sur cet écran (ou dans une version en blanc, modifiable dans les paramètres).
Grosso – modo, l’écran se divise en deux parties :
Les codes s’écrivent dans le rectangle indiqué par la flèche bleue, tandis que la console d’exécution est indiquée par la flèche rouge. Dans le cas d’un programme Python utilisant Turtle, une fenêtre à part s’ouvre lors de l’exécution du code.
Par défaut, la Tortue se trouve au milieu, aux coordonnées (0,0)
Des commandes de base
Le concept de Turtle est simple : une « tortue », généralement symbolisée par une flèche se déplace sur l’écran et laisse des traces sur son passage. Le code permet donc de générer des formes géométriques, des dessins…
Bien évidemment, il existe des dizaines et des dizaines de commandes dans la bibliothèque Turtle. Il est cependant possible de résumer la base en quatre commandes : avancer, reculer et tourner.
forward() #avancer
backward() #reculer
left() #tourner à gauche
right() #tourner à droite
Entre les parenthèses se mettent les paramètres des fonctions. Concrètement, le programmeur y écrit donc les valeurs qu’il souhaite assigner à la fonction. Pour forward (et pour sa réciproque backward), cette valeur correspondra à la distance en pixels que la tortue avance (ou recule), tandis que pour left (et également right), ce sera l’angle en degré que la tortue tourne.
A l’aide des commandes, nous allons essayer de tracer un carré. Retour en primaire, comment se trace un carré ? Il suffit de tracer quatre traits, et de tourner à chaque fois de 90°. Cela donne donc :
from turtle import * #importe le module
forward(50) #avance de 50px
left(90) #tourne à gauche de 90°
forward(50)
left(90)
forward(50)
left(90)
forward(50)
left(90)
Ou encore, comme nous répétons la même action quatre fois, nous pouvons le réduire ainsi :
from turtle import *
for i in range(4): #boucle répétant 4 fois ce qu'il y a incrémenté ci dessous
forward(50)
left(90)
Cela donne donc :
Les couleurs
Les couleurs en Python peuvent être changées de différentes manières. La couleur par défaut de la tortue est noire. La fonction color() permet de la changer, avec entre parenthèse la nouvelle couleur.
Principalement, il est possible d’utiliser le système rgb, autrement dit Red Green Blue. Comme vous le savez peut-être, chaque couleur perçue par l’oeil humain est en réalité le mélange de trois couleurs primaires, le rouge, le vert et le bleu. L’écran d’un ordinateur, d’un téléphone etc… reproduit ce principe naturel. Le système rgb assigne donc des valeurs à chacune des trois couleurs, allant de 0 (couleur absente) au maximum 255.
Par exemple, la couleur que nous appelons le rouge, peut être transmis à une machine par 255, 0, 0, ce qui veut dire que l’intensité du rouge est maximale, tandis que le vert et le bleu sont inexistants. Le violet, mélange de rouge et de bleu, peut être codé comme 150, 0, 150, soit une présence importante de rouge et de bleu, mais pas de vert.
Personnellement, j’utilise ce site, qui permet de chercher en détail la couleur souhaitée, ou encore ce site, qui génère facilement des palettes de teintes proches.
Exemple :
from turtle import *
colormode(255) #initialise le système de couleur en mode rgb
color(215, 42, 42) #défini la couleur de la tortue, et donc de son tracé
for i in range(4): #trace le carré
forward(50)
left(90)
Le tracé de la tortue n’est donc plus noir, la couleur par défaut, comme dans le premier exemple, mais est maintenant rouge.
Turtle permet également l’utilisation d’un certain nombre de couleurs, en les appelant par leur nom en anglais.
from turtle import *
color("blue")
for i in range(4):
forward(50)
left(90)
Le tracé est donc maintenant bleu (blue en anglais). Il est important de noter que la couleur utilisée ainsi doit être entre guillemets, sans quoi l’exécution déclenche une erreur.
Des commandes des couleurs
Si vous désirez colorer l’intérieur d’une figure géométrique, il vous est possible d’utiliser la fonction fillcolor(), avec la couleur du remplissage en argument. Il faudra également préciser le début du remplissage avec begin_fill(), et la fin avec end_fill().
from turtle import *
fillcolor("blue") #sélection de la couleur bleu
begin_fill() #début du remplissage
for i in range(4):
forward(50)
left(90)
end_fill() #fin du remplissage, après avoir tracé le carré
De plus, il est possible de choisir une couleur de fond, celle par défaut étant le blanc. Pour cela il est possible d’utiliser bgcolor(), avec la couleur en argument.
from turtle import *
bgcolor("red") #la couleur du fond définie comme étant rouge
fillcolor("blue")
begin_fill()
for i in range(4):
forward(50)
left(90)
end_fill()
Pas très agréable à regarder, je vous l’accorde, mais il est donc facile de remplir le fond ou des formes géométriques en Python.
Les commandes les plus utiles
Il est possible de parler et d’expliquer toutes les fonctionnalités du module durant toute la nuit. Le tableau ci dessous est donc simplement un condensé de celles que je trouve personnellement les plus utiles. Il est important de noter que toutes les fonctions suivantes sont compatibles avec la calculatrice Numworks, sauf indication contraire.
La fonction
Qu’est ce qu’elle fait ?
Commentaire
goto()
Déplace la tortue vers les coordonnées (x,y) entrées en paramètre.
Cette fonction déplace seulement la tortue, et ne la téléporte pas, il y aura donc une trace de son passage.
penup()
Lève le « stylo » : la tortue ne laisse pas de trace sur son passage.
pendown()
Baisse le « stylo » : la tortue laisse une trace de son passage.
Il peut être utile, en le combinant avec goto() et penup(), d’en faire une nouvelle fonction permettant un déplacement sans trace. Ceci réduit les lignes et améliore la lisibilité.
speed()
Règle la vitesse de la tortue.
La vitesse la plus rapide à rentrer dans les paramètres est 0. Pour le reste des vitesses, elles vont de 1 (lent) à 10 (rapide).
circle()
Trace un cercle de rayon précisé en paramètre.
write()
Ecrit le texte mis en argument à l’emplacement de la Tortue.
Attention à bien mettre le texte entre guillemets !
pensize()
Défini la taille du « stylo » en pixel.
position()
Renvoie la position (x,y) de la Tortue.
Elle peut sembler peu utile à première vue, mais est un outil important une fois utilisé intelligemment, notamment pour des dessins complexes.
heading()
Renvoie l’orientation de la Tortue.
setheading()
Oriente la Tortue du degré mis en paramètre.
showturtle()
Rend la Tortue visible.
Durant l’étape de la conception du dessin, il est utile de pouvoir voir la Tortue.
hideturtle()
Masque la Tortue.
La Tortue est visible par défaut, il est important de penser à ce que cela ne soit pas le cas à la fin (à moins de l’intégrer dans le dessin)
Screen().setup()
Défini la taille de l’écran sur lequel se trouve le dessin, avec (longueur, hauteur) en paramètre.
Pas compatible avec la calculatrice Numworks, qui possède déjà une taille d’écran fixée.
reset()
Réinitialise le dessin.
Un petit programme (encore un fois horrible esthétiquement), qui rassemble une majorité des codes ci dessous.
from turtle import *
Screen().setup(400,200) #défini la taille de l'écran à 400px sur 200px
hideturtle() #cache la tortue
pensize(5) #défini la taille du stylo à 5px
speed(10) #défini une vitesse rapide
penup() #lève le stylo
goto(10,-60) #va a la position (10, -60)
pendown() #baisse le stylo
color("green") #la couleur de la tortue est verte
circle(40) #trace un cercle de rayon 40px
penup() #lève le stylo
goto(-40,20) #va a la position (-40, 20)
pendown() #baisse le stylo
write("Hello, world") #écrit le texte Hello, world
Je vous invite cependant à essayer toutes les fonctions, puisque seule la pratique et la recherche à tâtons vous permettront de vraiment vous les approprier.
D’autres astuces ?
N’hésitez pas à utiliser d’autres modules pour la réalisation de votre dessin. Le module random, notamment, permet de réaliser des motifs placés aléatoirement, ou de tailles ou de couleurs aléatoires. Les étoiles dans le ciel, par exemple, sont facilement réalisables par ce moyen.
Il est également possible d’utiliser l’itération de la boucle for i in range pour produire des dégradés faciles (voir le code ci dessous), ou augmenter progressivement une taille etc…
Les limites du codage sont infinies, mais ce sont ici quelques astuces que j’ai retenu de ma propre expérience dans l’art génératif.
Un résultat
Voici donc un court code qui emploi uniquement les commandes du tutoriel (hormis les variables et les boucles qui ne sont pas propres au module Turtle) :
from turtle import *
#paramètres de départ
Screen().setup(340,240)
colormode(255)
speed(0)
#le fond
cote = 1
for i in range(160):
color(30+i,30,80+i)
for i in range(4):
forward(cote)
right(90)
cote+=0.5
penup()
goto(0,0)
pendown()
#la rosace
x = 100
col = 50
for i in range(7):
color(col,col,col)
for i in range (10):
circle(x)
left(360/10)
x-=10
col+=25
N’hésitez pas à le reprendre pour changer les variables, les couleurs etc… Le hasard est parfois le meilleur moyen d’arriver à un magnifique résultat !
Conclusion
« Les frontières du possible sont tracées par ce que l’imaginaire ose »
André Malraux
A vos ordinateurs ! Toutes les leçons du monde ne remplaceront jamais l’expérience. Ainsi, la curiosité, l’entrainement et la pratique restent le meilleur moyen de progresser en codage. Le tutoriel devrait cependant vous permettre de faire les premiers pas en art génératif !
Tutoriels
