TP n
◦1:Le module Turtle S
Objectifs de ce travail :
1. (re)d´ecouvrir le langage Python au travers de la manipulation d’une stylo ; 2. (re)d´efinir les notions de boucles et de fonctions.
On utilisera l’environnement Thonny pour ´ecrire le code. Les r`egles d’´ecritures d’un code Python sont donn´ees dans la PEP8 ici✍. On respectera en particulier les indications suivantes :
— On importe les biblioth`eques, puis les variables, puis les fonctions avant le programme principal.
— On met toujours un espace apr`es un ’=’ ;
— Les noms des fonctions et des variables en minuscules.
1 Premi` ere manipulation :
Le module Turtle de Python contient une listes d’instructions simples pour commander le d´eplacement et le comportement d’un stylo.
Avant d’en utiliser toutes les possibilit´es, il faut l’importer :
from t u r t l e import ∗
#ou si mple me nt i mport t u r t l e
Importation des librairies
Les principales instructions sont rassembl´ees dans ce tableau :
Commandes Alias Explications Commentaires
forward(nbre) fd(nbre) avance de nbre pixels nbre est un entier backward(nbre) bk(nbre) recule de nbre pixels nbre est un entier
left(angle) lt(angle) tourne de angle degr´e sens trigo
right(angle) tr(angle) tourne de angle degr´es sens r´etrograde
penup() pu() monte le stylo
pendown() pd() descend le stylo
speed(n) change la vitesse du trac´e de 0(lent) `a 10(rapide) D’autres instructions existent, `a vous de les rechercher selon vos besoins...
➀ Ouvrez le fichier test.py dans Thonny et ex´ecutez le.
➁ Ouvrez le fichier testMeilleur.py. Pourquoi est-il mieux que le pr´ec´edent ? Exercice n◦1
Remarquez que par d´efaut, la tortue se place au centre de la fenˆetre...
➀ Construire un programme qui construit un carr´e de cˆot´e 50 pixels ;
➁ Construire un programme qui construit un triangle ´equilat´eral de cˆot´e 50 pixels ;
➂ Construire un programme qui r´ealise cette figure : Exercice n◦2
2 Am´ eliorations l´ egitimes :
2.1 R´ep´etitions d’instructions :
La construction d’un carr´e consiste en la r´ep´etition de quatre instructions identiques. En programmation, la r´ep´etition se r´ealise `a l’aide d’ une boucle.
Il en existe principalement deux :
Avec une boucle for...
from t u r t l e import ∗ f o r i in range( 4 ) :
f d ( 5 0 ) l t ( 9 0 )
Fichier boucleForCarre.py
iest une variable de boucle qui prend successivement les valeurs enti`eresi= 0,1,2,3 (et oui, on s’arrˆete `a 3 !).
Remarquez l’indentationqui permet de rep´erer le bloc d’instructions.
Avec une boucle tant que...
from t u r t l e import ∗ i= 0
while i<4:
f d ( 5 0 ) l t ( 9 0 ) i= i +1
Fichier boucleWhileCarre.py
Le bloc d’instructions est r´ep´et´e tant que la condition i <4 estvraie! Il faut donc que :
— isoit initialis´ee avant la boucle (i= 0) ;
— isoit modifi´ee dans le bloc d’instructions (i=i+ 1) ;
— que la condition i <4 puisse devenir fausse sinon on boucle `a l’infini !
A l’aide d’une boucle r´ealiser un triangle ´equilat´eral`
Exercice n◦3 :
Remarque : Une boucle forest diteborn´ee car on connaˆıt au pire le nombre d’it´erations d`es sa d´eclaration ; une boucle whileest dite non born´ee.
2.2 Factorisation du code :
La r´ealisation d’un carr´e, d’un triangle, fait appel aux mˆemes instructions : on peut factoriser celles-ci en cr´eant une fonction d´edi´ee qui d`es qu’on l’appelle cr´ee le carr´e. Voici le code :
from t u r t l e import ∗ def c a r r e ( ) :
’ ’ ’ t r a c e un c a r r e de c o t e 50 ’ ’ ’ f o r i in range( 4 ) :
f d ( 5 0 ) l t ( 9 0 )
Fichier carre1.py
➀ Ouvrez le fichier carre1.py dans Thonny et ex´ecutez le. Que se passe t-il ?
➁ Dans la console, tapez carre().
Exercice n◦4 :
La fonction carre() peut contenir des param`etres ; il suffit de les placer `a l’endroit indiqu´e.
Un carr´e a des angles invariants mais peut changer de dimension. D’o`u l’id´ee de la passer en param`etres :
from t u r t l e import ∗ def c a r r e ( c o t e ) :
’ ’ ’ t r a c e un c a r r e de c o t e c o t e ’ ’ ’ f o r i in range( 4 ) :
f d ( c o t e ) l t ( 9 0 )
Fichier carre2.py
Comprenez bien !
— coteest unevariable localequi n’existe que dans la fonction carre ; son nom est explicite mais on pourrait l’appelerbrouette, cela ne changerait rien !
— `A l’appel de la fonction, on doit pr´eciser la valeur souhait´ee decote.
A l’aide du fichier carre2.py, construisez un carr´e de 20 pixels, de 100 pixels puis de 200 pixels.` Exercice n◦5 :
Une fonction est pr´ecieuse en Python ou ailleurs ; elle permet de structurer son code et d’affecter une mission particuli`ere `a un bout de code.
➀ Nommez les fonctions utilis´ees, leurs param`etres et `a quoi elles servent ;
➁ Tapez ce code et sauvegardez sous le nom frise1.py ;
➂ Modifier ensuite le code pour que la rotation de 5 degr´es passe en param`etre. Enregistrez sous le nom frise2.py.
from t u r t l e import ∗ def c a r r e ( c o t e ) :
f o r i in range( 4 ) : f d ( c o t e )
l t ( 9 0 )
def f r i s e ( nbre , c o t e ) : s p eed ( 1 0 0 )
f o r i in range( nbre ) : c a r r e ( c o t e )
l t ( 5 )
Fonctions python Exercice n◦6 :
➀ D´efinir une fonction triangle, avec le param`etrelong, qui construit un triangle ´equilat´eral de cˆot´elong;
➁ De fa¸con plus g´en´erale, un carr´e et un triangle rectangle appartiennent `a la famille des polygones r´eguliers( dont les cˆot´es ont la mˆeme longueur...). Construire une fonction polyReg avec les param`etres nbre etdim qui construit un polygone r´egulier `a nbre cˆot´es de longueur dim.
Exercice n◦7 :
R´ealiser une spirale semblable...
D´efi !
Python cr´ee des objets et des m´ethodes qui peuvent en modifier les ´etats( position, couleur, forme,...) ; c’est le principe simplifi´e de la Programmation Orient´ee Objet.
Lorsqu’on souhaite la cr´eation de plusieurs tortues, on commence par les cr´eer (on parle d’instanciation...) avant de les modifier. Un exemple !
from t u r t l e import ∗
from random import r a n d i n t
#################################################
py= T u r t l e ( ) py . c o l o r ( ’ g r e e n ’ ) thon= T u r t l e ( ) thon . c o l o r ( ’ r ed ’ )
#################################################
f o r i in range( 5 0 ) : n = r a n d i n t ( 1 , 100)
i f n%2 == 0 : py . l t ( 9 0 ) py . f d ( n ) e l s e:
thon . r t ( 9 0 ) thon . f d ( n )
multiTurtle.py
➀ Quelle est la nature de la variablen?
➁ La m´ethode color change la couleur de la tortue `a laquelle elle est attach´ee ; la m´ethodeshape change la forme de la tortue parmi les choix : ”arrow”,”circle”,”classic”,”square”,”triangle”, ”tortue”. Modifier la forme des tortuespy etthon.
Exercice n◦8 :
On peut interagir avec une tortue par l’action au clavier ou `a la souris. Pour cela il faut d’abord d´eclarer :
— la m´ethodelisten() qui permet d’´ecouter les ´ev´enements ext´erieurs ;
— la m´ethode mainloop() qui d´emarre la r´eception des ´ev´enements.
➀ Ouvrez le fichier interaction1.py et ex´ecutez-le.
➁ Modifier ce programme pour que vous puissiez ´ecrire vos initiales en lettres capitales.On pourra changer l’´etat de la tortue pour une meilleure visibilit´e.
Exercice n◦9 :
L’instruction :
valeur= int(numinput(”D´eplacement”,”Donner une valeur en pixels)) permet la saisie d’un nombre au clavier alors que :
write(”salut !”,aligne=”left”) permet d’´ecrire un message `a gauche de l’endroit o`u se situe la tortue.
Modifier le programme pr´ec´edent afin que la tortue se d´eplace de la valeur en pixels saisie au clavier.
Exercice n◦10
De mˆeme on peut utiliser la souris :
➀ Ouvrez le fichier interaction2.py et ex´ecutez-le.
➁ Dans la console, tapez l’instruction help(onscreenclick). `A quoi correspond ’fun’ ? Exercice n◦11 :
4 Vers un petit jeu...
On peut d’ores et d´ej`a envisager de construire le petit jeu suivant dont la r`egle est ´el´ementaire :
Une tortue apparaˆıt furtivement dans la fenˆetre ; si vous parvenez `a cliquer dessus, c’est gagn´e ! Le code suivant pourrait vous ˆetre utile :
from t u r t l e import ∗
from random import r a n d i n t import time
#################################################
py= T u r t l e ( ) py . c o l o r ( ’ g r e e n ’ ) py . shape ( ” t u r t l e ” ) py . h i d e t u r t l e ( ) py . up ( )
#################################################
b g c o l o r ( ’ b l u e ’ )
#################################################
f o r i in range( 5 0 ) :
abs= r a n d i n t (−200 ,200) ord= r a n d i n t (−200 ,200) py . goto (abs, ord) py . s h o w t u r t l e ( ) time . s l e e p ( 1 ) py . h i d e t u r t l e ( ) time . s l e e p ( 1 )
#################################################
l i s t e n ( ) mainloop ( )
jeu1.py
Pour r´ealiser ce jeu il faut se poser les bonnes questions :
— Comment faire apparaˆıtre al´eatoirement et furtivement une tortue ?
— Comment simuler le clic sur celui-ci ?
— Comment d´eclarer le jeu gagn´e donc termin´e ? !
— ....
