PYTHON 2 FEUILLE n° 24bis sur TURTLE

                                  FEUILLE n° 24    UTILISATION DE TURTLE                   BTS SIO

    Cours:    il est possible d'utiliser le module Turtle dans une fenêtre de Tkinter sans le dire.

                       Cela permet de faire des graphiques très vites.

                    On gère les déplacements d'une tortue( que l'on peut ne pas visualiser).

                   Pour les déplacements élémentaires on utilise :

                         forward( valeur)      pour l'avancer en ligne droite de la distance valeur

                        bacward( valeur)     pour la faire reculer en ligne droite de la distance valeur

                        left( valeur)           pour la faire tourner sur la gauche sans avancer d'un angle de valeur en degrés

                       right( valeur)       pour la faire tourner sur la droite sans avancer d'un angle de valeur en degrés

                       penup()                  pour lever le stylo , souvent suivi d'un goto( x, y ) puis d'un pendown pour

                                                     reprendre le tracé au point de coord. ( x , y )

                       pendown()              pour  reposer le stylo) afin de pouvoir écrire

                       reset()                    pour effacer le dessin et  remettre le stylo au centre

                       width(...)                   pour  choisir l'épaisseur du trait de la souris

                                                            par exemple  width(7) est très épais

                        write( " ...... " )      pour faire afficher un texte dans le dessin

                       goto( x , y )    replace la souris à la position ( x , y )

                                               ( même disposition que dans une fnêtre Tkinter )

                       circle( a )       trace simplement un cercle de rayon a complet

                                            par exemple  circle( 5) dessine un cercle de rayon 5

                                            Mais attention, le tracé du cercle commence par la position actuelle

                                           de la souris et  avec un diamêtre perpendiculaire à la souris.

                                           Le centre du cercle  est donc sur ce diamètre à une distance a / 2

                       circle( ..rayon .. ,  angle )  trace un arc de cercle de rayon et d'angle au centre  demandé

                       color(" ....")      pour fixer la couleur du tracé de la souris

                                              par exemple color("red")  permet d'avoir un tracé en rouge

                      gbcolor(" ...." )      pour fixer la couleur du fond

                     speed("fastest")      pour que la souris se déplace le plus vite possible

                                                    speed("fast")  est la vitesse normale pour la souris si on ne précise rien

                    fill(1)                  pour remplir l'intérieur du dessin fermé avec la couleur précisée avant

           REMARQUE :    Il est possible de créer des prototypes.

                                      Par exemple, quand on est amené à reproduire sur le dessin des carrés semblables.

                                     Il suffit alors d'invoquer le scrip carre(m) en précisant la longueur m d'un coté .        

               NB:   Il est conseillé de réduire la largeur des fenêtres d'écriture et d'exécution de python 2 

                  avec la souris pour voir mieux la fenêtre de construction du tracé du dessin.

     RAPPEL :  Pour supprimer le premier caractère d'une chaine C  il suffit de considérer C[1:]

                         On néglige le premier caractère et ainsi on a juste les caractères suivants.

                        Le moyen pour supprimer le premier caractère d'une chaine est donc d'en construire

                        une autre qui ne l'a pas.

---------------------------------------------------------------------------------------

    EXERCICE 1

     Donner un script en Python 2 qui trace les axes de cordonnées et trois cercles

     qui passent par l'origine, de rayons respectifs ,   150 ; 75 ; 36 de couleurs respectives ,

     bleue , jaune, marron.

   REPONSE:

             On peut proposer:

from turtle import*
def grap():      
       forward(100)
       backward(200)
       forward(100)
       left(90)
       forward(300)
       backward(330)
       forward(30)
       right(90)
       color("blue")
       circle(150)
       color("yellow")
       circle(75)
       color("brown")
       circle(36)
       color("black")

    En activant grap() on a:

>>> 
>>> grap()
>>> 

  puis le dessin suivant ( les valeurs en rouge ne sont pas dans le script

    mais expliquent )

   Pour avoir le centre du cercle de rayon a qui soit  à l'origine il faut et il suffit d'avoir

   les deux conditions:

           *  Mettre, avant, la souris  à une distance a  de l'origine.

             * Avoir le segment qui joint l'origine à la souris perpendiculaire à la souris. 

  (  autrement dit,  il faut avoir la souris tangente au cercle de centre l'origine et de rayon a. )

---------------------------------------------------------------------------------

     EXERCICE 2

            Donner un script, en Python2, qui permet de construire

            une maison basique verte avec un toit.

     REPONSE:

           On peut considérer le script suivant en mettant toutes les infos 

           nécessaires au cheminement de la souris dans une seule  liste,

            ( chaque action étant suivie de la mesure associée ):

from turtle import*
def dessincouleur():  
      L=["L",90,"F",100,"R",45,"F",70,"R",90,"F",70,"R",45,"F",100,"R",90,"F",100]       
      i=0
      while i<len(L)-1:
          action=L[i]
          mesure=L[i+1]
          trajet(action,mesure)
          i=i+2
    
def trajet(action,mesure):
      color("green")
      if action=="F":
          forward(mesure)
      elif action=="R":
           right(mesure)
      elif action=="L":
           left(mesure)       
      elif action=="B":
           backward(mesure)
      elif action=="U":
           penup()
      elif action=="D":
           pendown
      elif action=="N":
          reset()        
     else:
          print " Cela ne veut rien dire"
          input() 

          On lance dessincouleur() ce qui donne:

>>> dessincouleur()

    Donne le dessin:

  -------------------------------------------------------------------------------------

    EXERCICE 3

     Donner un script en Python 2, qui dessine votre future résidence.

 REPONSE:

            On peut proposer ce script :

from turtle import*
def dessincouleur():  
       L=["F",350,"L",90,"F",150,"L",90,"F",50,"L",90,"F",30,"R",90,"F",20,"R",90,"F",30,"L",90, 

"F",150,"L",90,"F",50,"R",90,"F",100,"R",90,"F",150,"L",45,"F",50,"L",90,"F",50,"L",45,"F",150,

"R",90,"F",50,"L",90,"F",100,"L",90,"F",150 ]
      i=0
      while i<len(L)-1:
            action=L[i]
            mesure=L[i+1]
            trajet(action,mesure)
            i=i+2
    
def trajet(action,mesure):
      color("red")
      if action=="F":
         forward(mesure)
      elif action=="R":
          right(mesure)
      elif action=="L":
          left(mesure)       
      elif action=="B":
          backward(mesure)
      elif action=="U":
          penup()
      elif action=="D":
          pendown
      elif action=="N":
        reset()        
      else:
        print " Cela ne veut rien dire"
        input()
    

       On obtient  activant dessincouleur() 

>>> dessincouleur()
>>> 

           qui donne :

 Autre rédaction possible pour éviter d'avoir L très longue écrite sur plusieurs lignes.

          On casse L en quatre listes G,H,K,W puis on pose L= G+H+K+W

          Ce qui reconstitue L

from turtle import*
def dessincouleur():
      G=["F",350,"L",90,"F",150,"L",90,"F",50,"L",90,"F",30]
      H=["R",90,"F",20,"R",90,"F",30,"L",90,"F",150,"L",90,"F",50]
      K=["R",90,"F",100,"R",90,"F",150,"L",45,"F",50,"L",90,"F",50]
      W=["L",45,"F",150,"R",90,"F",50,"L",90,"F",100,"L",90,"F",150]
      L=G+H+K+W

      i=0
      while i<len(L)-1:
            action=L[i]
            mesure=L[i+1]
            trajet(action,mesure)
            i=i+2
    
def trajet(action,mesure):
      color("red")
      if action=="F":
         forward(mesure)
      elif action=="R":
          right(mesure)
      elif action=="L":
          left(mesure)       
      elif action=="B":
          backward(mesure)
      elif action=="U":
          penup()
      elif action=="D":
          pendown
      elif action=="N":
        reset()        
      else:
        print " Cela ne veut rien dire"
        input()

                              Le dessin est le même.

---------------------------------------------------------------------

  EXERCICE 4

   Donner, en Python2 ,   un script qui demande:

                  # d'entrer le nombre d'actions sur la souris (la tortue c-à-d le curseur)

                  # d'entrer alors une par une chaque action sur la souris et la mesure qui la concerne

                  # d'entrer la couleur du tracé du dessin

     Puis qui exécute le dessin dans une fenêtre.

REPONSE:

           On peut proposer  la situation simple du carré de coté 100 :

   ( bien que dans ce cas, voir la fin de l'exercice 5,  on peut procéder

    beaucoup plus vite avec une boucle for )

from turtle import*
from random import*
def dec():   
      H=[]
      G=[]
      nombre=input("Donner le nombre d'actions sur la souris : ")
      for i in range(nombre):
           a=raw_input("Donner une action a :F,L,R,B,D,N,U  : " )
           G.append(a)
           m=input( "Donner une mesure m : entre 0 et 360 :  ")
           H.append(m)
       x=raw_input( "Donner la couleur, red, green, yellow..; :")
       for j in range(len(G)):
           color(x)
        trajet(G[j],H[j])
    
def trajet(a,m) :
      if a=="F":
          forward(m)
      elif a=="R":
          right(m)
      elif a=="L":
          left(m)
      elif a=="B":
          backward(m)
      elif a=="U":
          penup()
      elif a=="D":
          pendown
      elif a=="N":
        reset()        
      else:
           print " Cela ne veut rien dire"
          input()

    Ainsi  on active dec() et l'on obtient:

>>> dec()
Donner le nombre d'actions sur la souris : 7
Donner une action a :F,L,R,B,D,N,U  : F
Donner une mesure m : entre 0 et 360 :  100
Donner une action a :F,L,R,B,D,N,U  : R
Donner une mesure m : entre 0 et 360 :  90
Donner une action a :F,L,R,B,D,N,U  : F
Donner une mesure m : entre 0 et 360 :  100
Donner une action a :F,L,R,B,D,N,U  : R
Donner une mesure m : entre 0 et 360 :  90
Donner une action a :F,L,R,B,D,N,U  : F
Donner une mesure m : entre 0 et 360 :  100
Donner une action a :F,L,R,B,D,N,U  : R
Donner une mesure m : entre 0 et 360 :  90
Donner une action a :F,L,R,B,D,N,U  : F
Donner une mesure m : entre 0 et 360 :  100
Donner la couleur, red, green, yellow.. :red

 Ce qui donne le carré suivant:

------------------------------------------------------------------

  EXERCICE 5

             Il est fastidieux d'entrer une par une les deux infos qui caractérisent une action.

             Par exemple pour un carré il y a 7 actions donc 14 infos à donner deux par deux.

             Il peut être intéressant alors d'utiliser des listes.

           Donner un script  ( en Python 2.7 ) qui permet, en demandant la saisie de

          la LISTE DES ACTIONS sur la souris et la LISTE DES MESURES

          CORRESPONDANTESde faire le dessin.

     REPONSE:

            On peut considérer:

from turtle import*
from random import*

from turtle import*
def dec():                 
     G=input("Donner la liste des a :F,L,R,B,D,N,U  : " )    
     H=input( "Donner la liste des mesures m : entre 0 et 360 :  ")
     for j in range(len(G)):
          trajet(G[j],H[j])
    
def trajet(a,m) :    
       color("red")
       if a=="F":
         forward(m)
       elif a=="R":
          right(m)
       elif a=="L":
          left(m)
       elif a=="B":
          backward(m)
       elif a=="U":
          penup()
       elif a=="D":
          pendown
       elif a=="N":
           reset()        
       else:
            print " Cela ne veut rien dire"
            input()

                   --------------- 

    On faitt:

>>> dec()
Donner la liste des a :F,L,R,B,D,N,U  : "F","R","F","R","F","R","F"
Donner la liste des mesures m  entre 0 et 360 :  100,90,100,90,100,90,100
>>> 

Cela donne à l'écran une fenêtre:                                   

    C'est plus rapide, en deux lignes à écrire.

   MAIS il y a encore plus simple pour un carré car il y a répétion quatre fois 

   d'un même processus:  " avancer de 100 et tourner de 90 degrés"

from turtle import*
def carre():
       width(3)
       color("red")
       for i in range(4):
            forward(100)
            right(90)

              Puis on active carre()

      Il vient:

>>> 
>>> carre()
>>> 

--------------------------------------------------------------------------------------------------------------

     EXERCICE 6

       Donner un script en Python 2 qui quand on rentre les instructions, pour le stylo,

      séparées par un simple espace sans guillemet, donne le dessin avec Turtle.

     ( Par exemple, si l'on écrit :   N  F100  R120  F100  R120 F100 U  

             aussitôt cela  doit dessiner un triangle équilatéral de coté de longueur 100 .

             Autrement dit le programme reconnait lui même automatiquement les instructions

                 N    F100    R90  F60   R120  L45   U  D  B   etc ..  en découpant chaque instruction

           en une action  et une valeur qui peut être nulle si ce n'est qu'une lettre.

      REPONSE:

      On peut proposer:

from turtle import*
from random import*
def dessin():   
       D=raw_input("Donner les instructions séparées d'un blanc comme: N F100 R90  B ... ")
       t=input("Donner l'épaissaur du trait par un entier : ")    
       h=raw_input("Donner la couleur: red, yellow , ...")
       W=D.split(" ")                     # W est une liste dont les termes sont  des chaines d'instructions
      for elem in W:       
            if len(elem)==1:
                print elem
                trajet(elem,0)            # Dans ce cas l'instruction elem n'est qu'une chaine d'une lettre 
           else:                                # donc la mesure est nulle
                 m=int(elem[1:])       # Dans l'instruction elem  la lettre d'indice 0 en premier est ignorée et on 
                 print elem[0],m        # prend le restant de la chaine que l'on mute en un entier pour avoir la mesure
                 width(t)color(h)
                 color(h)

                 trajet(elem[0],m)
           
def trajet(a,m):    
       if a=="F":
          forward(m)
       elif a=="R":
          right(m)
       elif a=="L":
          left(m)
       elif a=="B":
           backward(m)
       elif a=="U":
           penup()
       elif a=="D":
           pendown
       elif a=="N":
           reset()        
       else:
             print " Cela ne veut rien dire"
             input()            

                   On obtient en activant dessin()

 >>> dessin()
Donner les instructions comme: N F100 R90  B ... N F100 R120 F100 R120 F100 U
Donner l'épaissaur du trait par un entier : 1
Donner la couleur: red, yellow , ...red
N
F 100
R 120
F 100
R 120
F 100
U
>>>     

            Vient alors le dessin

       AUTRE SOLUTION :

            Comme on répète trois une avancée  puis rotation:

from turtle import*
from random import*
def tr_equi():
       a=input("Donner la longueur d'un coté:  " )
       x=raw_input("Donner la couleur:  ")
       color(x)
       b=input("Donner l'epaisseur: ")
       width(b)
       for i in range(3):
             forward(a)
             right(120)             

              On obtient en activant tr_equi()

>>> tr_equi()
Donner la longueur d'un coté:  100
Donner la couleur:  red
Donner l'epaisseur: 1
>>> 

                 On obtient:

-------------------------------------------------------------------------------------------------------

       EXERCICE 7

              Donner un script en Python 2 qui dessine les vestiges d'un chateau vu du dessus.

           REPONSE:

from turtle import*
def dec():
      penup()
      goto(10,50)        
      color("blue")    
      write( "VESTIGES DE CHATEAU")
      penup()
      goto(0,0)
      pendown()
      L=["F",120,"R",90,"F",50,"R",45,"F",100,"R",45,"F",50,"R",90,"F",120]
      for i in [0,2,4,6,8,10,12,14,16]:
           action=L[i]
           mesure=L[i+1]
           trajet(action,mesure) 
    
def trajet(action,mesure):
      width(7)                        # pour l'épaisseur du trait
      color("red")
      bgcolor("yellow")            # pour la couleur du fond
      speed("fastest")              # pour la plus rapide vitesse
      if action=="F":       
         forward(mesure)
         color("orange")           # nouvelle couleur orange du curseur
         fill(1)                             # pour remplir le contour fermé 
        color("red")                 # pour revenir à la couleur du curseur rouge
      elif action=="R":
          right(mesure)
          circle(20)
      elif action=="L":
          left(mesure)
      elif action=="B":
          backward(mesure)
      elif action=="U":
          penup()
      elif action=="D":
          pendown
      elif action=="N":
          reset()        
      else:
          print " Cela ne veut rien dire"
          input()

       On obtient en activant dec()

>>> 
>>> dec()
>>> 

      puis 

----------------------------------------------------------------------------------------

   EXERCICE 8

         Dessiner la tête d'un extra terrestre en jaune sur fond bleu.

      REPONSE

 On peut proposer :

from turtle import*

def disque():
      speed("fastest")
      color("yellow")
      bgcolor("blue")
    
      penup()
      goto(0,10)
      pendown()
    
      for i in range(40,100):
           circle(i)    
      penup()
      goto(200,10)
      pendown()
      for i in range(40,100):
           circle(i)
      penup()
      goto(50,-30)
      pendown()
      width(9)
      forward(120)
      penup()
      goto(100,-110)
      pendown()    
      circle(220)
    

                          On obtient en activant disque()

>>> 
>>> disque()
>>> 

               puis on obtient le dessin:

---------------------------------------------------------------------------------------