PYTHON 2 FEUILLE n° 24 huit sur TURTLE

                           PYTHON 2.7      FEUILLE n° 24     huit   sur TURTLE

                Cours:

                             # Il peut être intéressant de mettre tout de suite les bords en couleur de fond

                                 en colorant simplement l'intérieur car on a juste l'intérieur à effacer pour effacer .

                            # Ovale:

                               D'après, le dictionnaire Robert, c'est " une courbe qui est fermée par deux arcs de cercles".

                               Cela correspond à la forme d'un œuf.

                               On peut donc obtenir avec Turtle un ovale:

from turtle import*
from random import*
def ovale(r):
      speed(10),width(5)
      left(45)                                 # pour avoir l'ovale vertical au lieu d'horizontal
      for i in range(2):                 # Pour renouveler deux fois
           color("red")                    # premier arc en rouge à droite de rayon r
           circle(r,90)
           color("green")              # second arc en vert en haut de rayon r/2
           circle(r/2,90)
      mainloop()

                En activant ovale(150) on a :

>>> 
>>> ovale(150)
>>>

                                    puis:

                                          Ovaleturtle

             La construction commence par l'arc rouge à droite puis par l'arc vert en haut

             en tournant dans le sens trigo.

             Le début de l'arc rouge est à l'origine mais le point  le plus bas n'est pas l'origine..          

              Le tracé est très très proche de celui d'une elipse. La différence est imperceptible.

             Dans la figure ci-dessous on voit en bleu une ellipse collée à l'ovale. 

               Comparaison entre ovale ellipse turtle 1

              # Ellipse:

                         Une ellipse d'axes, les axes de coordonnées, de longueurs 2a et 2b

                         s'obtient en considérant les points de coordonnées:

                        ( a cos(i) , b sin(i) )            avec i qui varie entre 0 et 2π  radians.

                          Pour l'obtenir avec turtle on peut considérer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def ellipse(a,b):                                     #   a > 0  et b > 0  toujours
      speed(0),width(3)
      deplace(a,0)             #   ( a ,0 ) et (- a,0 ) sont les coord des points de l'ellipse sur l'axe des abscisses  
      ht()                            #   (0 , b ) et (0 , - b ) sont les coord des points de l'ellipse sur l'axe des ordonnées 
      color("blue")
      i=0    
      while i<6.3:                     #     2π  radians est environ  6,28   On a pris 6,3
              x=a*cos(i)               
              y=b*sin(i)
              goto(x,y)
              i=i+0.1
      mainloop() 

                        En activant ellipse(60,120) il vient :

>>> 
>>> ellipse(60,160)
>>>

                                   Puis:

                                         Ellipse verticale turtle

              On peut comparer sur un exemple un ovale et une ellipse en considérant:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def ellipse(a,b):
      speed(0),width(5)
      deplace(39,b-16)
      ht()
      i=0    
      while i<6.3:
               x=-53+a*cos(i)
               y=106+b*sin(i)
               goto(x,y)
               i=i+0.1
def ovale(r):
      speed(10),width(5)
      left(45)   
      for i in range(2):     
           color("red")        
           circle(r,90)
           color("green")      
           circle(r/2,90)
def commande():    
      ovale(150)
      color("blue")
      fillcolor("white")
      begin_fill()
      ellipse(92,123)
      end_fill()
      mainloop()

                                               En activant commande() il vient:

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

                                                   Puis on retrouve la figure:

                                                  Comparaison entre ovale ellipse turtle 1

             # ROTATION:

           Soit le point M(x,y) dans le plan muni d'un repère orthonormé d'origine O.

          Soit le point M ' ( x' ,y' ) son image par la rotation de centre O et d'angle θ.

          On a :

                                     x '= x cos(θ) - y sin(θ)

                                     y ' = x cos( θ) + y sin(θ)

            Dans le cas où     θ =  45°    on a:    cos(θ) =  sin(θ) = 0,5 √2

            On utilise  la rotation R( O , 45° ).

            Il vient alors :

                                   x'= 0,5 √2    ( x - y) 

                                   y'=  0,5 √2    ( x + y) 

               Si le point M(x,y) décrit une ellipse ( E ) alors le point M '( x' ,y ' ) va décrire 

               l'ellipse image ( E' ) par la rotation R.

              Le point de coord ( a , 0 ) a pour image alors le point de coord (  0,5 √2  ,  0,5 √2 )

              On peut donc ainsi obtenir le tracé de ( E' ) à partir de celui de ( E ).

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

   EXERCICE 0:

    1.   Donner un  script, en Python 2.7, qui permet d'obtenir une ellipse sans avoir à effacer le

      tiret ( sorte de cordon ombilicale ) entre l'origine et le premier point de départ

      de la construction de l'ellipse .

     ( En effet, dans le précédent script,  pour masquer l'effet du premier goto(x,y) de la boucle while,

       la couleur blanche de fond pour l'intérieur de l'ellipse a été nécessaire. Ce qui est gênant. )

     2. Modifier,  alors ce script pour avoir un bracelet d'ellipses identiques horizontales.

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

     REPONSE:

   1.  On peut considérer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def ellipse(d,a,b):
       ht(),speed(0),width(3),color("blue")    
       x=d+a                                           # ces trois lignes placent la souris déjà sur l'ellipse désirée
       y=0                                               #  Cela neutralise le premier got(o(x,y) de la boucle while.
       deplace(x,y)
       i=0
       while i<6.3 :        
               x= d+a*cos(i)                             #  Ce d permet de déplacer l'ellipse horizontalement
               y=b*sin(i)
               goto(x,y)
               i=i+0.1    
def commande():
       ellipse(100,20,50)             # Elle est verticale de centre, à 100 de l'origine O sur l'axe des abscisses
       mainloop() 
                                                  On obtient en activant commande()

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

                                                          Puis : 
  

                  Uneellipseturtle

    2.        Pour avoir le bracelet il suffit  seulement de remplacer  le def commande() 

           par:

def commande():
      for i in range(10):
           ellipse(12*i,20,50)      #        De 12 en 12 on deplace l'éllipse pour former un bracelet 

      mainloop()                       #     de 10 ellipses identiques

                  En activant commande() on a :

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

                                      Puis :                                

                                      Braceletsturtle

                    En modifiant le script on peut faire varier la couleur des ellipses:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def ellipse(d,a,b,couleur):              # On introduit un paramètre couleur pour l'ellipse
      ht(),speed(0),width(3),color(couleur)    
      x=d+a
      y=0
      deplace(x,y)
      i=0
      while i<6.3:
             x=d+a*cos(i)
             y=b*sin(i)
             goto(x,y)
             i=i+0.1
def commande():       # Les modifications suivantes
      E=["black","green","blue","grey","red","yellow","violet","orange","brown"]
      for i in range(9):
           ellipse(12*i,20,50,E[i])
      mainloop()
                        

                                  En activant commande() il vient :

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

                                         Puis

                                   Braceletscouleurturtle

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

    EXERCICE 1:

                     Donner un script, en Python 2.7, qui fait tomber la pointe d'une tour.

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

           On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup()
      goto(x,y)
      pendown()       
def triangleiso(c,h):                                      
      l=round(c/2,2)
      u=round(h**2,2)                  
      v=round(l**2)
      p=u+v 
      m=round(p**0.5,2)               
      k=round(h/l,2)                      
      q=round(atan(k),2)              
      j =degrees(q)                      
      left(j)
      forward(m)
      right(2*j)
      forward(m)
      right(180-j)
      forward(c)
      right(180)
def rect(a,b):    
      for i in range(2):
           forward(a)
           right(90)
           forward(b)
           right(90)    
def pointe():
      speed(10)    
      reset()      
      width(1)
      ht()
      fillcolor("yellow")
      begin_fill()   
      rect(100,200)                       # fabrication de la tour
      end_fill()
      rect(100,10)
      rect(100,15)
      width(3)
      E=["green","orange","red","brown"]           # Les couleurs successives de la pointe
      for i in range(4):
           left(10*i)
           color("white")                     # Pour éviter d'avoir à effacer les bords  on les  
           fillcolor(E[i])                                         #  met en couleur du fond  blanc
           begin_fill()
           triangleiso(100,300)
           end_fill()
           color("white")        
           fillcolor("white")                   # On n'a plus que l'intérieur de la pointe à
           begin_fill()                            # effacer en le mettant en couleur de fond
           triangleiso(100,300)
           end_fill()
        
      color("white")        
      fillcolor("red")
      begin_fill()
      triangleiso(100,300)
      end_fill()    
      deplace(-100,20)    
      width(4)
      color("white")        
      fillcolor("white")
      begin_fill()
      triangleiso(100,300)
      end_fill()   
      left(30)
      deplace(-150,-40)
      color("white")        
      fillcolor("orange")
      begin_fill()
      triangleiso(80,150)
      end_fill()
      color("white")        
      fillcolor("white")
      begin_fill()
      triangleiso(80,150)
      end_fill()    
      left(30)
      deplace(-150,-100)           
      color("white")        
      fillcolor("brown")
      begin_fill()
      triangleiso(80,150)
      end_fill()
      mainloop()

                                  En activant pointe() on obtient :

>>> 
>>> pointe()
>>> 

                                Puis on a à la fin:

                     Pointecasseeturtle

         Au début on a la pointe, au dessus de la tour,  verte.

                              Pointeturtle

                La pointe change de couleur en tombant sur la gauche 

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

   EXERCICE 2  

        Donner un script, en Python 2.7 qui anime un Monsieur  Fil de Fer.

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

      REPONSE:     

               On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup()
      goto(x,y)
      pendown()    
def sol():
      ht()
      speed(0),width(6),color("brown")
      deplace( 200,-103)
      backward(340)
      deplace(0,0)
     
def jambesbras():
      speed(0),ht(),width(3)
      deplace(-15,70)
      color("black")
      circle(13)
      for i in range(5):
           color("black")
           deplace(-20,-8)              #jambe noire
           right(120),forward(60)   
           right(40), forward(40)
           left(10)                  
    
           deplace(-10,-8)            # jambe noire
           left(110),forward(60)        
           right(30),forward(40)     
           left(80)
    
           deplace(-30,50)            # bras noir
           right(130)
           forward(30)    
           left(60)
           forward(15)
           left(70)        
    
           deplace(0,50)              # bras noir
           right(40)
           forward(30)    
           left(50)
           forward(15)           
           right(90)

           width(7)
           color("white")
           deplace(-20,-10)
           right(51),forward(60)    # Pour effacer  jambe 
           right(42), forward(40)      
        
           deplace(-10,-9)
           left(124),forward(60)        # Pour effacer jambe
           right(33),forward(40)     
    
           deplace(-30,50)
           right(45)
           forward(30)    
           left(50)
           forward(15)
     
           deplace(0,50)
           left(40)
           forward(30)    
           left(50)
           forward(15)
           width(3)
           right(17)
         
      color("black")
      deplace(-20,-8)              #jambe noire à la fin
      right(120),forward(60)   
      right(40), forward(40)
      left(10)                  
    
      deplace(-10,-8)            # jambe noire à la fin
      left(110),forward(60)        
      right(30),forward(40)     
      left(80)
    
      deplace(-30,50)            # bras noir à la fin
      right(130)
      forward(30)    
      left(60)
      forward(15)
      left(70)        
    
      deplace(0,50)             # bras noir à la fin  
      right(40)
      forward(30)    
      left(50)
      forward(15)           
      right(90)                         
    
def commande():
      ht(),speed(0),reset()
      sol()
      jambesbras()       
      mainloop()

                      En activant  commande() il vient:

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

                                 Puis:

                Monsieur fil de fer turtle

              Le sol et la tête restent. les jambes et les bras semblent bouger.

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

  EXERCICE 3:

           Donner un script, en Pyton 2.7, qui donne une paire d'yeux ovales.

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

      REPONSE:

        On peut proposer:

from turtle import*
from random import*
from math import*

def deplace(x,y):
       penup(),goto(x,y),pendown()
def vue(c,d):
      ht() ,  speed(0),width(3)
      i=0
      fillcolor("yellow")
      begin_fill()
      while i<6.3:                           # Création de l'ellipse pleine jaune
               color("yellow"
               x=c+40*cos(i)
               y=d+60*sin(i)
               goto(x,y)
               i=i+0.1
      end_fill()
      ht()
      backward(20)
      fillcolor("green")             #    Pupille verte
      begin_fill()
      left(90)
      circle(20)
      end_fill()
      right(90)
      width(5)
    
      color("yellow")           #   Ajustement précis pour que les bords ne soient pas entaillés.
      forward(24)         
      color("white")
      forward(26)         
      width(3)
        
def trace():
      speed(0)
      vue(0,0)
      vue(100,0)
      mainloop()

                                      En activant   trace()  il vient :

>>> 
>>> trace()  
>>> 

                                Puis:

                         Sans titre 4

              Pour éviter les ajustements liés au traces des déplacements on peut aussi proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def ellipse(d,a,b):
      ht(),speed(0),width(3),color("yellow")    
      x=d+a
      y=0
      deplace(x,y)
      i=0
      while i<6.3 :        
              x=d+a*cos(i)
              y=b*sin(i)
              goto(x,y)
              i=i+0.1    
def mire():
      for i in range(2):
           color("white")
           fillcolor("yellow")
           begin_fill()
           ellipse(60*i,20,50)
           end_fill()
           left(90*(1-i))
           color("green")
           fillcolor("green")
           begin_fill()
           deplace(10+i*60,0)
           circle(10)
           end_fill()
     mainloop()

                             En activant mire() on a :

>>> 
>>> mire()
>>> 

                              Puis on a :

                               Nieunieuturtle

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

  EXERCICE 4:

       Donner un script , en Python 2.7 , qui plante un clou.

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

   REPONSE:

      On peut proposer simplement avec quatre positions du marteau:

           Horizontal , En haut , Oblique , En bas)

from turtle import*
from random import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def rect(a,b,couleur):
       speed(0),width(2),color(couleur)
       for i in range(2):
             forward(a),left(90),forward(b),left(90)
def sol():
       width(4),speed(0)
       deplace(-50,0)
       color("brown"),forward(250)        
def clou():
       ht(),speed(0),width(3)
       deplace(50,22)
       rect(20,5,"black")    
       forward(13) ,  right(180)
       rect(5,20,"black")

def marteau_horizontal():
       width(4), color("black")
       deplace(129,43)
       forward(60), left(90),forward(15),right(180)
       fillcolor("black")
       begin_fill()
       rect(30,20,"black")
       end_fill()
       deplace(129,43),left(90)    
def supprime_marteau_horizontal():                                 # En fait on repasse en couleur blanche du fond
       width(4),color("white"), forward(60),left(90)
       forward(15),right(180),color("white")
       fillcolor("green")
       begin_fill()
       rect(30,20,"white")
       end_fill()
       deplace(129,43), left(90)
              
def marteau_en_haut():
      width(4),color("black"),right(40),forward(60),left(90)
      forward(15),right(180)
      fillcolor("black")
      begin_fill()
      rect(30,20,"black")
      end_fill()
      deplace(129,43),left(90)
def supprime_marteau_en_haut():              
       width(5),color("white"),forward(60),left(90)
       forward(15),right(180)
       fillcolor("white")
       begin_fill()
       rect(30,20,"white")
       end_fill()
       deplace(129,43),right(40)
              
def retour_marteau_oblique():
       width(4),color("black"),left(150)
       deplace(129,43)
       forward(60),left(90),forward(15)
       right(180)
       fillcolor("black")
       begin_fill()
       rect(30,20,"black")
       end_fill()
       deplace(129,43)
       left(90)
def supprime_marteau_oblique():
       width(4),color("white")
       deplace(129,43)
       forward(60),left(90),forward(15),right(180)
       fillcolor("white")
       begin_fill()
       rect(30,20,"white")
       end_fill()
       deplace(129,43),left(90)
              
def marteau_enfonce_clou():
       width(4),color("black"),left(40)
       deplace(129,43)
       forward(60),left(90),forward(15),right(180)
       fillcolor("black")
       begin_fill()
       rect(30,20,"black")
       end_fill()
       deplace(129,43),left(90)
       color("blue")  
       write(" Hé Bé  !")

def mis():
      speed(0)
      setup(),sol(),clou()
      marteau_horizontal(),supprime_marteau_horizontal()              #  tracé puis effacement
      marteau_en_haut(),supprime_marteau_en_haut()                    #  tracé puis effacement
      retour_marteau_oblique(),supprime_marteau_oblique()             #  tracé puis effacement
      marteau_enfonce_clou()                                                                 # Tracé final
      mainloop()

                                            En activant  mis() on a :

>>> 
>>> mis()
>>> 

 

                                       Puis à la fin :

                Clouplanteturtle

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

             EXERCICE 5:

           Donner un script qui permet d'avoir une fleur formée de quatre ellipses blanches de bords noirs et 

          d'un disque central jaune.

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

    REPONSE:

                On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def ellipse(a,b):
      ht(),speed(0),width(3)    
      x=a
      y=0
      deplace(x,y)
      i=0
      while i<6.3 :        
              x=a*cos(i)       
              y=b*sin(i)
              goto(x,y)
              i=i+0.1            # La première ellipse est tracée
       x=a*0.5*2**0.5       # Pour placer la souris au point correspondant à i = 0 de l'ellipse image
       y=a*0.5*2**0.5         # Cela évite le tiret créé par goto(x,y) entre O et ce point.
       deplace(x,y)
       i=0
       while i<6.3 :        
               x=(0.5*2**0.5)*(a*cos(i)-b*sin(i))
               y=(0.5*2**0.5)*(a*cos(i)+b*sin(i))
               goto(x,y)
               i=i+0.1
def commande():   
      color("black")
      ellipse(120,240)
      ellipse(240,120)           # Permuter a et b permet d'envisager l'ellipse horizontale et son image 
      fillcolor("yellow")
      begin_fill()
      deplace(120,0)
      left(90)
      circle(120)        
      end_fill()
      mainloop()

                                             En activant commande() on a :

>>> 
>>> commande()
>>

                                              Puis :

                  Fleurturtle

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

   EXERCICE 6:

         Donner un script, en Python 2.7, qui crée une couronne de huit cercles de couleurs variées

         avec un disque jaune bordé de noir au centre.

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

           REPONSE:

              On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def cercle(r,a,b,couleur):
      ht()
      width(4)
      deplace(a,b)
      color(couleur)
      circle(r)
def commande():
      speed(0)
      m=3.14116/4                         # cela correspond à 45°
      E=["green","blue","grey","red","yellow","violet","orange","brown"]
      a=10
      b=15
      for i in range(8):
           x=a+140*cos(i*m)             #  les points de départ des constructions des huit cercles 
           y=b+140*sin(i*m)             # sont sur le cercle de centre de coord( a,b ) et de rayon 140
           cercle(60,x,y,E[i])             #  décalés de 45° dans le sens trigo
      color("black")
      deplace(10,-3)
      fillcolor("yellow")
      begin_fill()
      circle(78)
      end_fill()
      mainloop()

                            En activant commande() il vient:

>>> 
>>> commande()
>>

                                    Puis:

                                 Couronneturtle                                  

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