PYTHON 2 FEUILLE n° 24 six sur TURTLE

                              PYTHON 2.7            FEUILLE n° 24  six  sur Turtle     mai 2019

                   Cours:                 ANIMATION

                                # Pour donner, encore mieux, l'impression de roulement il peut être

                                      intéressant de faire évoluer des détails de la figure.

                               # home()

                                  fait revenir le curseur au départ de l'action en traçant un trait droit

                              #   ht()  

                                       C'est intéressant pour ne plus voir le curseur sur le dessin .

                                       penup()   ,  lui, empêche le curseur d'écrire.

                              # st() 

                                          C'est, au contraire,  pour faire apparaître le curseur.

                       NB:  Python 2.7 est très précis quant à l'indentation et à la police des caractères.

                               Aussi, si vous utilisez Ctrl C puis Ctrl V , il se peut que vous soyez amené à

                               réécrire le texte du script à l'identique, dans la fenêtre New Window,

                               simplement pour ces problèmes d'interface.        

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

   EXERCICE 0:

          Donner un script, en Python 2.7,  qui dessine ce disque jaune bordé de bleu 

          où l'on voit un rayon bleu vertical en bas.

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

    REPONSE 

          On peut proposer:

from turtle import*
from random import*    
def cercle():
      speed(0), width(4)
      color("blue"),fillcolor("yellow"),begin_fill()      # sur une ligne pour gagner de la place
      circle(40)
      end_fill()
      width(4)    
      penup() ,  goto(0,40) , pendown()          
      home()                                              # pour revenir à la position du début avec un trait droit visible

                                                              #  qui visualise le rayon voulu.
      ht()                                                  # pour ne plus voir  le curseur sur le dessin

                En activant cercle() on obtient:

>>> 
>>> cercle()
>>>             

                       Puis, on a à l'écran la figure demandée.

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

     EXERCICE 1:

          En vous inspirant de la feuille précédente donner un script, en Python 2.7,

          qui permet de donner l'impression d'un roulement d'un disque sur le sol

          grace aux positions évolutives d'un rayon du disque.

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

      REPONSE:

      On peut envisager:

from turtle import*
from random import*
def temporisteur():
       for j in range(10**6):
             j=j+1
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()    
def cercle(i):
      speed(0), width(4)
      color("blue"),fillcolor("yellow"),begin_fill()
      circle(40)
      end_fill()
      width(2),color("orange")
      goto(280,0),backward(280)                        # pour avoir le sol en orange
      color("blue")  , width(4)    
      deplace(i*40,40)                                # pour mettre le stylo  à l'origine du rayonr 
      if i==0:                                               # pour avoir le rayon vertical d'en bas du premier disque
        goto(0,0)
      elif i== 1:                                           #  pour avoir le rayon horizontal gauche du second disque
           goto(-40+i*40,40)
      elif i==2:                                             # pour avoir le rayon vertical d'en haut  du troisième disque                                   
           goto(i*40,80)
      elif i==3:                                              #  pour avoir le rayon horizontal droit du quatrième disque
           goto(40+i*40,40)                           
      elif i==4:                                              # pour avoir le rayon vertical d'en bas du cinquième disque
           goto(i*40,0)
      elif i==5:                                              #  pour avoir le rayon horizontal gauche du sixième disque
           goto(-40+i*40,40)
      elif i==6:                                              # pour avoir le rayon vertical d'en haut  du septième disque  
           goto(i*40,80)
      penup(),home(),pendown()                 
def figure():
       reset()                                                   # pour effacer l'écran
       speed(0)  , color("blue")                      # pour avoir la vitesse maxi et la couleur du du stylo
       for i in range(7):
             deplace(i*40,0)
             cercle(i)        
             temporisteur()
             clear()       
       cercle(40)
       ht()                                                                  # pour ne plus voir  le curseur sur le dessin                                        

                    En activant figure() on obtient:

>>> 
>>> figure()
>>> 

                         Puis on a à la fin:

                Le rayon semble tourner dans le sens des aiguilles d'une montre sur le sol orange.          

              à mesure du décalage du disque. D'où l'effet de roulement si l'on prend un peu de recul.

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

              EXERCICE 2

  Donner un script, en Python 2.7,  qui fait apparaître le personnage petitbon suivant:

               C'est une" Lumière" car c'est une ampoule.

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

            REPONSE:

              On peut considérer;

from turtle import*
from random import*
def cercle(r):
       width(6)
       color("blue") ,  fillcolor("yellow") , begin_fill()
       circle(r)
       end_fill()
def cercle2(r):
       width(3) , color("blue") , speed(0)                              
       fillcolor("yellow") , begin_fill()
       circle(r)
       end_fill()
       penup()
       forward(-15) , left(90) , forward(20) , right(110)    # pour placer le stylo au début de la bouche 
       pendown()
       circle(40,45)                                                         # pour l'arc de la bouche
       penup()
       right(110) , forward(20) , left(85) ,forward(-25) , left(90) , forward(50)        # pour placer le stylo au niveau de l'oeil gauche
       pendown()                                                                                                 # avec la bonne inclinaison
       circle(1)                                                                       # pour le cercle de  l'oeil gauche de rayon 1
       penup()
       right(90) , forward(20) , pendown()                    # pour placer le stylo au niveau de l'oeil droit      
       circle(1)                                                             # pour le cercle de l'oeil droit de rayon 1
       penup()
       forward(-15) , right(90) , forward(50) , left(90)            # retour à la position de départ du traçé du disque
       pendown()
def figure():                                                               # poste de commandement
       cercle2(40)
       carre()
def carre():
       color("green") , width(5) , speed(0)
       penup()
       forward(-10),  left(90), forward(80),  right(90)       # pour déplacer le stylo en haut à gauche du disque
       pendown()
       fillcolor("red")
       begin_fill()
       for i in range(2):                                         # trace le carré  bordé de vert rempli de rouge du dessus du disque
             forward(20),  left(90),  forward(20), left(90)
       end_fill()
       penup()
       forward(20) , right(90) , forward(80),left(90)                    # pour faire revenir, sans tracé, le stylo en bas du disque
       pendown()

       ht()                                                                                            # pour ne plus voir  le curseur sur le dessin

                        On obtient en activant figure() :

>>> 
>>> figure()
>>> 

                        Puis la figure.

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

   EXERCICE 3:

      Reprendre le personnage précédent, en donnant un script, en Python 2.7 , qui 

             permet de le faire circuler suivant un rectangle .

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

 REPONSE:

        On peut considérer : 

from turtle import*
from random import*
def cercle(r):
       width(6)
       color("blue")
       fillcolor("yellow")
       begin_fill()
      circle(r)
      end_fill()
def cercle2(r):
       width(3)
       color("blue")
       speed(0)
       fillcolor("yellow")
       begin_fill()
       circle(r)
       end_fill()
       penup()
       forward(-15),left(90),forward(20),right(110)
       pendown()
       circle(40,45)
       penup()
       right(110),forward(20),left(85),forward(-25),left(90),forward(50)
       pendown()    
       circle(1)    
       penup()
       right(90),forward(20),pendown()    
       circle(1)    
       penup()
       forward(-15),right(90),forward(50),left(90)   
       pendown()
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()
def carre():
       color("green")
       width(5),speed(0)
       penup()
       forward(-10),left(90),forward(80),right(90)
       pendown()
       fillcolor("red")
       begin_fill()
       for i in range(2):
             forward(20),left(90),forward(20),left(90)
       end_fill()
       penup()
       forward(20),right(90),forward(80),left(90)
       pendown()
    
def temporisateur():
       for j in range(10**6):
             j=j+1
def petitbon():
    reset()
    speed(0)       
    a=0
    b=0
    for i in range(5):
          deplace(i*40,0)
          cercle2(40)
          carre()
          a=i*40
          temporisateur()
          clear()        
    for i in range(6):
          deplace(a,i*40)
          cercle2(40)
          carre()
          b=i*40
          temporisateur()
          clear()               
    for i in range(5):
          deplace(-i*40+a,b)       
          cercle2(40)
          carre()
          temporisateur()
          clear()      
    for i in range(6):
          deplace(0,-i*40+b)
          cercle2(40)
          carre()
          temporisateur()
          clear()       
    cercle2(40)
    carre()

    ht()                                   # pour ne plus voir  le curseur sur le dessin

                                              En activant petitbon() il vient :

 >>> 
>>> petitbon()
>>> 

                          Puis le personnage précédent décrit un rectangle. Il va à droite puis en haut                                  

                                       ensuite à gauche et enfin redescend au point de départ.

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

    EXERCICE 4:

         Le fantôme de Canterville.

         Donner un script, en Python2.7, qui dessine un fantome avec deux yeux et une bouche

          et qui fait apparaître  les deux phrases suivantes :

                             Fantôme nous n'avons pas peur

                             Tu en verras de toutes les couleurs

           de façon à  avoir  : 

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

   REPONSE:

              On peut envisager :

from turtle import*
from random import*
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()    

def fantome():
       width(5)
       color("blue")
       deplace(0,110)
       write(" Fantome nous n'avons pas peur")                 # pour écrire à l'écran
       deplace(0,90)
       write("Tu en verras de toutes les couleurs")
       deplace(0,0)   
       width(3)
       color("orange")
       speed(0)
       penup()
       forward(-15),left(90),forward(20),right(110)
       pendown()
       circle(40,55)                                                                                         #  pour l'arc de la bouche
       penup()
       right(110),forward(20),left(85),forward(-25),left(90),forward(50)
       pendown()
       fillcolor("green")
       begin_fill()
       circle(6)                                                                                # L'oeil gauche
       end_fill()
       penup()
       right(90),forward(20),pendown()    
       fillcolor("green")
       begin_fill()
       circle(6)                                                                                 # son oeil droit 
       end_fill()    
       penup()
       forward(-15),right(90),forward(50),left(90)   
       pendown()

       ht()                                                                    # pour ne plus voir  le curseur sur le dessin

                       En activant fantome() on obtient:

 >>> 
    >>> fantome()
    >>>

                           Puis la figure:

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

     EXERCICE 5:

               Reprendre les personnages fantôme et petitbon.

              Donner un script, en Python 2.7, qui fait tourner petibon autour du fantôme suivant

              un rectangle et  affiche le message :

                                    Fantôme nous n'avons pas peur

                                   Tu en verras de toutes les couleurs

               avec les deux personnages qui se confondent au centre à la fin.

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

    REPONSE:

          On peut proposer:

from turtle import*
from random import*
def cercle(r):                             # pour tracer un disque jaune bordé de bleu 
       width(6)
       color("blue")
       fillcolor("yellow")
       begin_fill()
       circle(r)
       end_fill()
def cercle2(r):
       width(3)
       color("blue")
       speed(0)
       fillcolor("yellow")
       begin_fill()
       circle(r)
       end_fill()
       penup()                                                                    
       forward(-15),left(90),forward(20),right(110)
       pendown()
       circle(40,45)
       penup()
       right(110),forward(20),left(85),forward(-25),left(90),forward(50)
       pendown()    
       circle(1)    
       penup()
       right(90),forward(20),pendown()    
       circle(1)    
        penup()
       forward(-15),right(90),forward(50),left(90)   
       pendown()
def fantome():
       speed(0)
       width(5)
       color("blue")
       deplace(0,-60)
       write(" Fantome nous n'avons pas peur")
       deplace(0,-80)
       write("Tu en verras de toutes les couleurs")
       deplace(0,0)   
       width(3)
       color("orange")
       speed(0)
       deplace(85,105)
       penup()
       forward(-15),left(90),forward(20),right(110)
       pendown()
       circle(40,45)
       penup()
       right(110),forward(20),left(85),forward(-25),left(90),forward(50)
       pendown()
       fillcolor("green")
       begin_fill()
       circle(6)
       end_fill()
       penup()
       right(90),forward(20),pendown()    
       fillcolor("green")
       begin_fill()
       circle(6)
       end_fill()    
       penup()
       forward(-15),right(90),forward(50),left(90)   
    pendown()
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()
def carre():
       color("green")
       width(5),speed(0)
       penup()
       forward(-10),left(90),forward(80),right(90)
       pendown()
       fillcolor("red")
       begin_fill()
       for i in range(2):
             forward(20),left(90),forward(20),left(90)
       end_fill()
       penup()
       forward(20),right(90),forward(80),left(90)
       pendown()
    
def temporisateur():
       for j in range(10**6):
             j=j+1
def petitbon():
       speed(0)
       a=0
       b=0
       for i in range(5):
             deplace(i*40,0)
             cercle2(40)
             carre()
             a=i*40
             temporisateur()
             clear()
             fantome()
       for i in range(6):
             deplace(a,i*40)
             cercle2(40)
             carre()
             b=i*40
             temporisateur()
             clear()
             fantome()
       for i in range(5):
             deplace(-i*40+a,b)       
             cercle2(40)
             carre()
             temporisateur()
             clear()
             fantome()
       for i in range(6):
             deplace(0,-i*40+b)
             cercle2(40)
             carre()
             temporisateur()
             clear()
             fantome()
       cercle2(40)
       carre()
       fantome()
                                                  En activant petitbon() onobtient:

>>> 
>>> petitbon()
>>> 

                   puis la figure: 

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

    EXERCICE 6:           Jet d'un dé              

          Donner , en Python 2.7, un script qui fait rouler un dé sur le sol et affiche à la fin

          à l'intérieur du dé un entier, au hasard, entre 1 et 6.

         Le dé sera représenté par un carré vert de coté 50  et le sol par un trait orange.

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

     REPONSE:

             On peut proposer:

from turtle import*
from random import*
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()
def carre(x,y):
       deplace(x,y)
       color("green")
       width(5),speed(0)
       fillcolor("white")
       begin_fill()
       for i in range(2):
              forward(50),left(90),forward(50),left(90)
       end_fill()
def sol():
       speed(0)
       color("orange")
       width(3)
       goto(400,0)
       goto(-100,0)
       goto(0,0)
def proto(i):
       sol()
       width(4)
       left(60)
       carre(50*i,0)
       clear()
       right(30)
       carre(50*i,0)
       clear()
       right(30)
       carre(50*i,0)    
       clear()
       sol()   
   
def jetcube():
       reset()
       speed(0)
       n=randint(1,6)
       for i in range(5):
             proto(i)
       carre(250,0)
       deplace(275,20)
       color("black")
       write(n)
       deplace(-20,0)

       ht()                                        # pour ne plus voir  le curseur sur le dessin                 

                                             En activant jetcube() on a :

  >>> 
>>> jetcube()
>>>                 

                           Puis à la fin  par exemple:

        Le dé semble rouler d'abord, puis il s'arrête et un chiffre entre 1 et 6 aléatoire apparaît dedans.

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

 EXERCICE  7 :

           Donner, en Python 2.7, un script où une roue tourne puis fait apparaître sur la roue

           un entier entre 1 et 10  aléatoire en haut.

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

               REPONSE:

                       On peut proposer :

from turtle import*
from random import*
def deplace(x,y):         
       penup()
       goto(x,y)
       pendown()
def cercle(r,x,y,a):
       deplace(x,y-r)
       color("blue")
       width(5),speed(0)
       fillcolor("yellow")
       begin_fill()
       circle(r)                                      # pour construire le cercle de la roue
       end_fill()
       deplace(x,y)
       for i in range(10):                     # pour construire les secteurs de la roue
              left(a)
              color("black")
              forward(r),backward(r),left(36)           # les rayons de la roue avec 36 degrés d'angle
        
def commande():
       n=randint(1,10)
       a=45                                                 # angle de décalage à chaque construction des roues successives
       x=0
       y=0
       cercle(100,a,x,y)
       for j in range(1,3):
             cercle(100,a,0,0)
             clear()
       cercle(100,a,x,y)
       width(10)
       color("black")   
       deplace(x+43,y+50)
       write(n)
       ht()                                       # pour ne plus voir le curseur  

                                     En activant commande() il vient

>>> 
>>> commande()
>>>

                                     Puis la copie d'écran est:

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