PYTHON 2 FEUILLE n° 24 quinto sur TURTLE

                                   PYTHON 2.7       FEUILLE n° 24 quito   sur  Turtle    

         Cours :

               #  Pour dessiner un polygone régulier on utilise:

             circle( rayon, angle au centre qui intercepte la totalité du polygone, nombre demandé de cotés  )

               par exemple:

 from turtle import*

def poly():
       circle(100,360,6)

            Quand on active poly() cela donne la figure

                Le cercle sur lequel  il y a les sommets est de rayon 100.

                L'angle au centre est de 360° .

                Il y a 6 cotés égaux.

             # ANIMATION GRAPHIQUE.

             ##  L'animation est basée sur la répétition décalée et la disparition

               de la figure précédente.

               Pour effacer l'image précédente on utilise:

                  clear()

             ##   Speed(0) est la plus grande vitesse pour le tracé, 

                    donc aussi pour les déplacements.

                    Cela peut tellement être rapide que l'on devine à peine 

                     les figures que l'on fait bouger.

                    Donc, pour que l'apparition de figures intermédiaires soit, certes, 

                      plus rapide grace à speed(0) mais aussi  plus visible,

                     on utilise un Temporisteur comme :

                    for j in range(10**6):

                          j=j+1

                     Cela occupe un micro-instant l'ordinateur juste avant l'effaçage.

                     Donc ça rend visible un micro-instant la figure que l'on déplace.

                     On le place donc juste avant clear()         

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

      EXERCICE 1 

     Donner un script , en Python 2.7, qui fait la rosace suivante

      quand on saisit son demi rayon a :

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

   REPONSE:

      On peut proposer:

from turtle import*
from random import*
def trianglequi(a):
       for i in range(3):
             forward(a)
             left(120)
def rect(b,c):
    for i in range(2):
          forward(b)
          left(90)
          forward(c)
          left(90)
def triangequiplein(a,d):           # donne un triangle équilatéral plein de coté a et de couleur d
       fillcolor(d)                                           # de coté a et de couleur d
       begin_fill()
       trianglequi(a)
       left(60)
       end_fill()
    
def cercleplein(a,d):                  # Donne un cercle plein de rayon a+40
       fillcolor(d)                                  # de couleur d
       begin_fill()
       circle(a+ 40)
       end_fill()
    
def deplace(x,y):     # déplace la souris au point correspondant à (x ,y )
       penup()
       goto(x,y)
       pendown()
    
def rose():
       a=150
       speed(0)
       reset()
       width(3)
       deplace(0,-(a+40))
       cercleplein(a,"yellow")
       deplace(0,0)  
       for i in range(6):
              triangequiplein(a+30,"orange")        
       for i in range(6):
             triangequiplein(a+15,"green")                      
       for i in range(6):                                    # pour répéter six fois    
             fillcolor("yellow")
             begin_fill()
             trianglequi(a*0.75)
             end_fill()
             fillcolor("red")
             begin_fill()
             trianglequi(a/2)
             end_fill()
             fillcolor("blue")
             begin_fill()
             trianglequi(a/3)
             end_fill()
             left(60)

                       En activant rose() on obtient:

>>> 
>>> rose()
>>>

               Puis la rosace demandée

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

   EXERCICE 2:

 Donner ,en Python 2.7, un script qui dessine un clocher .

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

     REMARQUE:

                 On peut proposer :

from turtle import*
from random import*
from math import*
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)
def rect(a,b):    
      for i in range(2):
            forward(a)
            right(90)
            forward(b)
            right(90)
    
def clocher():
      reset()    
      fillcolor("grey")
      begin_fill()       
      rect(100,200)
      end_fill()
      rect(100,10)
      rect(100,15)
      E=["grey","blue","grey"]
      for i in range(3):
            fillcolor(E[i])
            begin_fill()
            triangleiso(100-i*40,300-i*20)
            end_fill()
            right(180)
            forward(20)

                   En activant clocher() il vient :

>>> 
>>> clocher()
>>> 

                  Puis :

---------------------------------------------------------------------------------------
        
   EXERCICE 3:

    Donner un script, en Python 2.7, qui affiche cinq cercles décalés

   régulièrement, épais et bleus.

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

   REPONSE:

       On peut envisager:

from turtle import*
from random import*
def cercle(r):           
      circle(r)
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()
def descercles():
       reset()
       speed(0)
       width(6)
       color("blue")
       for i in range(5):
             deplace(i*40,0)
             pendown()
             cercle(40)

                     En activant descercles() il vient:

>>> 
>>> descercles()
>>> 

                                              Puis:

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

      EXERCICE 4

          Reprendre l'exercice précédent mais en les faisant progressivement disparaitre

           avec la commande clear(), tout en laissant le dernier pour donner l'impression 

           d'un déplacement.

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

  REPONSE:

      On peut proposer :

from turtle import*
from random import*
def cercle(r):                              # inchangé      
       circle(r)
def deplace(x,y):                           # inchangé    
      penup()
      goto(x,y)
      pendown()
def descercles2():                      # les deux dernières lignes ont changé
      reset()
      speed(0)
      width(6)
      color("blue")   
      for i in range(5):
           deplace(i*40,0)
           cercle(40)
           clear()                 # supprime le cercle précédent
           cercle(40)              #  le dernier ne est pas effacé

                En activant  descercles2() il vient:

>>> 
>>> descercles2()
>>> 

                                              Puis à la fin du défilement:      

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

    EXERCICE 5:

        Donner un script , en Python 2.7, qui  donne la figure cidessous:

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

 REPONSE:

         On peut proposer:

from turtle import*
from random import*
def cercle(r):                          #  inchangé      
      circle(r)
def deplace(x,y):                #  inchangé
       penup()
       goto(x,y)
      pendown()
def descercles3():
       reset()
       speed(0)
       width(6)
       color("blue")
       a=0
       b=0
       for i in range(5):
             deplace(i*40,0)
             cercle(40)
             a=i*40                           # Le point bas du cinquième cercle horizontal a pour abscisse a et 0 pour ordonnée
       for i in range(6):
             deplace(a,i*40)
             cercle(40)
             b=i*40                         # Le point bas du sixième  cercle vertical a pour abscisse a et b pour ordonnée
       for i in range(5):
             deplace(-i*40+a,b)
             cercle(40)                        # Le point bas du cinquième cercle horizontal  a pour abscisse a=0 et b pour ordonnée
       for i in range(6):
             deplace(0,-i*40+b)
             cercle(40)

                        En activant descercles3() on a:

 >>> 
>>> descercles3()
>>> 

           Puis on a la figure demandée.

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

   EXERCICE 6:

       Reprendre l'exercice précédent en faisant effacer au fur et à mesure les cercles pour

         donner l'impression du mouvement.

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

    REPONSE:

       Il suffit de rajouter clear() à la fin de chaque boucle for.

      On peut aussi rajouter cercle(40) à la fin pour terminer avec l'image du cercle..

from turtle import*
from random import*
def cercle(r):                          #  inchangé      
      circle(r)
def deplace(x,y):                #  inchangé
       penup()
       goto(x,y)
      pendown()
def descercles4():
       reset()
       speed(0)
       width(6)
       color("blue")
       a=0
       b=0
       for i in range(5):
             deplace(i*40,0)
             cercle(40)
             a=i*40  

             clear()                       
       for i in range(6):
             deplace(a,i*40)
             cercle(40)
             b=i*40  

            clear()                   
       for i in range(5):
             deplace(-i*40+a,b)
             cercle(40)

             clear()
       for i in range(6):
             deplace(0,-i*40+b)
             cercle(40)

              clear()

       cercle(40)

                En activant cercles{() on obtient:

 >>> 
>>> descercles4()
>>> 

                  Puis le défilement demandé

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

    EXERCICE 7:

    Reprendre l'exercice précédent en ajoutant un Temporisateur.

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

          REPONSE:

               On peut proposer:

from turtle import*
from random import*
def cercle(r):                          #  inchangé      
      circle(r)
def deplace(x,y):                #  inchangé
       penup()
       goto(x,y)
      pendown()
def temporisateur():                #    TEMPORISATEUR  
       j=j+1

def descercles4():
       reset()
       speed(0)
       width(6)
       color("blue")
       a=0
       b=0
       for i in range(5):
             deplace(i*40,0)
             cercle(40)
             a=i*40  

             temporisateur()                    # introduction du temporisateur juste avant clear()

             clear()                      
       for i in range(6):
             deplace(a,i*40)
             cercle(40)
             b=i*40  

             temporisateur()                  # introduction du temporisateur juste avant clear()

             clear()                   
       for i in range(5):
             deplace(-i*40+a,b)
             cercle(40)

             temporisateur()                 # introduction du temporisateur juste avant clear()

             clear()
       for i in range(6):
             deplace(0,-i*40+b)
             cercle(40)

             temporisateur()                      # introduction du temporisateur juste avant clear()

             clear()

       cercle(40)

                   En activant cercles{() on obtient:

 >>> 
>>> descercles4()
>>> 

                  Puis on a  le défilement demandé mais 

                  en distinguant  clairement chaque cercle intermédiaire.

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

   EXERCICE 8:

       Reprendre la situation de l'exercice précédent mais avec 

      l'intérieur du cercle bleu de couleur jaune.

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

   REPONSE:

                         Il suffit de remplacer

def cercle(r):                            
      circle(r)            

                       par:

def cercle(r):
       fillcolor("yellow")
       begin_fiil()
       circle(r)
       end_fill()

                             En activant  descercle4() on obtient le même défilé mais avec 

                                 des diques jaunes bordés de bleu.

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