PYTHON 2 FEUILLE n° 24 sept sur TURTLE

                                                   PYTHON 2.7                 FEUILLE n° 24  sept   sur Turtle

                  Cours:

                         # clear() 

                                 a un défaut c'est d'effacer tout l'écran.

                                  Or, on peut vouloir garder une partie du tracé pour n'animer

                                  qu'un morceau du dessin.

                                 Une solution est de mettre en couleur de fond le morceau de dessin.

                                 Il disparaît donc à nos yeux.

                             # mainloop()

                                        Après le tracé du dessin, pour éviter le blocage de la fenêtre de turtle ,

                                       avec en haut le message << Turtle ne répond plus >>,

                                      il est intéressant de mettre à la fin du script de lancement, mainloop().

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

   EXERCICE 0:

           Que donne le script suivant ?

from turtle import*
from random import*
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()
def fabriquerayon():
       deplace(-125,-12)
       forward(33)
       backward(66)
       forward(33)
       right(90)
       forward(33)
       backward(66)
       forward(33)
    
       deplace(75,-12)
       forward(33)
       backward(66)
       forward(33)
       right(90)
       forward(33)
       backward(66)
       forward(33)

def rayon():
       speed(0)
       right(20)
       width(3)
       ht()
       L=["black","white"]       
       for i in range(30):
              right(i*20)
             if i%2==0:
                 color(L[0])
                 fabriquerayon()
                 color(L[1])
                 fabriquerayon()
       color("black")
       fabriquerayon()
def pneu():
       deplace(-160,-12)
       forward(300)
       deplace(-125,-52)
       circle(40)
       deplace(-125,-47)
       circle(35)
       deplace(75,-52)
       circle(40)
       deplace(75,-47)
       circle(35)
     
def rot():
       pneu()
       speed(10)
       rayon()
       mainloop()
    

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

   REPONSE:

                 Après avoir activé rot() on obtient:

 >>> 
>>> rot() 
>>> 

                                      puis:                                            

                                             Les rayons des roues semblent tourner.

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

     EXERCICE 1:

      Donner un script , en Python2.7, qui donne l'impression de faire rouler une voiture

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

    REPONSE:

                  On peut proposer :

                   En activant commande() on obtient :

from turtle import*
from random import*
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()
def rect():                             # construction de la caisse  de la voiture

       deplace(-200,0)
       color("blue")
       fillcolor("green")
       begin_fill() 
       for i in range(2):
             forward(350),left(90),forward(100),left(90)
            end_fill()
def triangle():                      # avant de la voiture 
       width(1)
       deplace(150,0)
       left(30)
       color("blue")
       fillcolor("green")
       begin_fill()
       for j in range(2):
            forward(100),left(120),forward(100),left(120)
       end_fill()    
       left(210)
    
def cercle():               # fabrication des roues
       width(12)
       color("black")
       fillcolor("white")           # pour la roue gauche
       begin_fill()
       deplace(-125,-50)

       circle(40)
       end_fill()
       fillcolor("white")                      # pour la roue droite
       begin_fill()
       deplace(75,-50)                  
       circle(40)
       end_fill()
def sol():                      # fabrication du sol
      color("brown")
      width(10)
      deplace(-200,-55)
      forward(400)
def deco():                         
      width(2)
      color("yellow")
      deplace(-150,80)
      forward(250)
def toit():
      color("blue")
      deplace(-100,100)
      fillcolor("yellow")
      begin_fill()
      left(60),forward(50),right(60)
      forward(100),right(30),forward(85)
      end_fill()

def fabriquerayon():
      deplace(-125,-12)          # rayons ortogonaux de la roue gauche
      forward(33)
      backward(66)
      forward(33)
      right(90)
      forward(33)
      backward(66)
      forward(33)
    
      deplace(75,-12)                   # rayons ortogonaux de la roue droite
      forward(33)
      backward(66)
      forward(33)
      right(90)
      forward(33)
      backward(66)
      forward(33)

def rayon():                            # pour alterner en noir puis en blanc les rayons
       speed(0)
       left(20)
       width(3)
       ht()
       L=["black","white"]       
       for i in range(30):
             right(i*20)
             if i%2==0:
                 color(L[0])
                 fabriquerayon()
                 color(L[1])
                 fabriquerayon()
       color("black")                                # pour avoir les rayons à la fin
       fabriquerayon()   

def commande():
       speed(10)
       rect()
       cercle()
       sol()
       triangle()
       deco()
       toit()
       rayon()
       mainloop()               # empêche l'écran de Turle de se bloquer     
       ht()                            # masque la souris
    
    
 

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

                             Puis on a, à l'écran :              

                                            Les rayons  tournent en créant l'illusion du déplacement.

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

         EXERCICE 2:

                         Que donne le script en Python 2.7, suivant ?

from turtle import*
from random import*
def deplace(x,y):
       penup()
       goto(x,y)
       pendown()
def rect(a,b,x,y):                                    # rectangle à partir du pointde coord (x,y)
       width(4)                         #   a est la largeur  b est la longueur du rectangle
       speed(0)
       deplace(x,y)    
       for i in range(2):
            forward(a),left(90),forward(b),left(90)
def cercle(r,x,y):                            #  cercle de rayon r de centree de coord ( x,y)
      width(4)
      speed()
      deplace(x,y-r)
      circle(r)
def hautjambe(x,y):      # rectangle de 10 par 30 à partir du point de coord (x,y)
      speed(0)
      deplace(x,y)
      rect(10,30,x,y)
def rotule(x,y):                          # cercle de rayon 5 de centre le point (x+5,y- 5)
      speed(0)
      cercle(5,x+5,y-5)
def basjambe(x,y):       # rectangle de 10 par 30 à partir du point (x,y-40)
      rect(10,30,x,y-40)
      forward(25)
      deplace(x,y)
def jambetendue(x):
      hautjambe(x,0)
      rotule(x,0)
      basjambe(x,0)
def jambepliee(x):
      left(20)
      hautjambe(x,0)
      rotule(x+3,1)
      right(40)
      basjambe(x-10,3)
      left(20)
def dessin():
      ht()
      color("black")
      jambetendue(0)
      jambepliee(45)
      mainloop()
     

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

   REPONSE:

             En activant dessin() , on obtient les deux jambes suivantes:

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

     EXERCICE 3:

            Donner un script , en Python 2.7, qui permet de faire bouger les deuxjambes de l'exercice précédent.

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

      REPONSE:

                On peut proposer :

from turtle import*
from random import*
def deplace(x,y):
      penup()
      goto(x,y)
      pendown()
def rect(a,b,x,y):                                 # rectangle à partir du point de coord (x,y)
      width(4)                                    # a est la largeur  b est la longueur
      speed(0)
      deplace(x,y)    
      for i in range(2):
            forward(a),left(90),forward(b),left(90)
def cercle(r,x,y):                               #  cercle de rayon r de centre de coord ( x,y)
      width(4)
      speed()
      deplace(x,y-r)
      circle(r)
def hautjambe(x,y):                  # rectangle de 10 par 30 à partir du point de coord (x,y)
      speed(0)
      deplace(x,y)
      rect(10,30,x,y)
def rotule(x,y):                             # cercle de rayon 5 de centre le point de coord  (x+5,y- 5)
      speed(0)
      cercle(5,x+5,y-5)
def basjambe(x,y):                   # rectangle de 10 par 30 à partir du point de coord (x,y-40)
      rect(10,30,x,y-40)
      forward(25)
      deplace(x,y)
def jambetendue(x):
      hautjambe(x,0)
      rotule(x,0)
      basjambe(x,0)
def jambepliee(x):
      left(20)
      hautjambe(x,0)
      rotule(x+3,1)
      right(40)
      basjambe(x-10,3)
      left(20)
def trait():
      deplace(-10,35)
      width(8)
      color("blue")
      forward(70)
      deplace(0,0)
      color("black")
      width(3)
def pas():
      speed(0)
      ht()    
      color("black")
      jambetendue(0)
      jambetendue(40)
      clear()
      for i in range(2):
           color("black")
           trait(),jambetendue(0),jambepliee(40)      
           color("white")                                                  # Efface en donnant la couleur du fond
           jambepliee(40)
           color("black")
           jambetendue(40)
           color("white")                                                 #  Efface en donnant la couleur du fond
           jambetendue(0)
           color("black")
           jambepliee(0)
           color("white")                                                      #  Efface en donnant la couleur du fond
           jambetendue(40),jambepliee(0)
           color("black")
           jambepliee(40),jambetendue(0)
           color("white")                                                    #  Efface en donnant la couleur du fond
           jambepliee(40),jambetendue(0)                  
                                       
      color("black")
      trait()
      jambetendue(0)
      jambetendue(40)        
      mainloop()

                           Quand on active  pas() il vient:

>>> 
>>> pas()
>>>

                       Puis on voit les deux jambes tantôt tendues tantôt pliées.

                  NB:    En permutant certaines lignes on peut modifier le rythme.

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

             EXERCICE 4 

         Donner un script , en Python 2.7 , qui permet de dessiner le personnage ci-dessous 

        qui bouge ses jambes.

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

        REPONSE:

                                 On peut proposer :

from turtle import*
from random import*
def deplace(x,y):
      penup()
      goto(x,y)
      pendown()
def rect(a,b,x,y):                   # rectangle à partir du point (x,y)
      width(4)                                   # a est la largeur  b est la longueur
      speed(0)
      deplace(x,y)    
      for i in range(2):
           forward(a),left(90),forward(b),left(90)
def cercle(r,x,y):                                   #  cercle de rayon r de centre ( x,y)
      width(4)
      speed()
      deplace(x,y-r)
      circle(r)
def hautjambe(x,y):                # rectangle de 10 par 30 à partir du point(x,y)
      speed(0)
      deplace(x,y)
      rect(10,30,x,y)
def rotule(x,y):                   # cercle de rayon 5 de centre le point (x+5,y- 5)
      speed(0)
      cercle(5,x+5,y-5)
def basjambe(x,y):                    # rectangle de 10 par 30 à partir du point (x,y-40)
      rect(10,30,x,y-40)
      forward(20)
      deplace(x,y)
def jambetendue(x):
      fillcolor("grey")
      begin_fill()
      hautjambe(x+7,10)
      end_fill()
      rotule(x+7,10)
      basjambe(x+7,10)
def jambepliee(x,y):
      left(60)
      hautjambe(x+27,y+20)
      rotule(x+34,28+y)
      right(60)
      basjambe(x+32,y+23)
      deplace(0,0)
def jamberecul(x,y):
      right(10)
      fillcolor("grey")
      begin_fill()
      hautjambe(x,y)
      end_fill()
      right(20)
    rotule(x-3,y-3)
    basjambe(x-18,y+2)
    left(30)
def jambelevee(x):
      left(20)
      hautjambe(x+15,9)
      rotule(x+18,8)
      basjambe(x+29,6)    
      right(20)
      ht()    
def trait():
      ht()
      width(2)
      color("green")
      fillcolor("red")
      begin_fill()
      rect(10,10,4,155)          # pour le chapeau
      end_fill()
      width(5)
      color("black")
      fillcolor("green")
      begin_fill()
      rect(30,80,-6,41)               # pour le buste
      end_fill()
      deplace(9,123)
      fillcolor("yellow")
      begin_fill()
      circle(15)                            # pour la tête
      end_fill()
      color("black")
      cercle(1,15,141)                       # pour un oeil
      rect(10,40,5,75)
      deplace(-30, -36)
      width(3)
      color("brown")
      forward(150)                              # pour le sol
      deplace(0,0)
      color("black")
      width(3)
    
def test():
      ht()
      reset()
      trait()
      color("black")
      jamberecul(0,13)                # une jambe gauche en arrière
      deplace(0,0)
      jambelevee(0)                   #  unejambe  droite   levée
      deplace(0,0)
      color("white")                 
      jambelevee(0)                      # effacement de la jambe  droite lévée
      deplace(0,0)
      color("black")
      jamberecul(0,13)                             
      deplace(0,0)
      jambepliee(0,0)
      color("white")
      deplace(0,0)
      jambepliee(0,0)
      color("black")   
      jamberecul(0,13) 
      jambetendue(2)
      color("white")
      jamberecul(0,13)
      color("black")
      jambetendue(-3)  
      width(5)
      color("black")
    
      trait()     
      mainloop()

                                En activant test() on obtient:

>>> 
>>>  test()
>>> 

                             Puis on a la figure ci-dessus ou les jambes bougent.

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

    EXERCICE 5:

    Donner un script , en Python 2.7, qui fait planer le personnage  fantôme au dessus

    de jambes qui bougent

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

.    REPONSE :

                On peut proposer :

from turtle import*
from random import*
def deplace(x,y):
      penup()
      goto(x,y)
      pendown()
def rect(a,b,x,y):                        # rectangle à partir du point (x,y)
      width(4)                                # a est la largeur  b est la longueur
      speed(0)
      deplace(x,y)    
      for i in range(2):
           forward(a),left(90),forward(b),left(90)
def cercle(r,x,y):                      #  cercle de rayon r de centre ( x,y)
      width(4)
      speed()
      deplace(x,y-r)
      circle(r)
def hautjambe(x,y):                  # Un rectangle de 10 par 30 à partir du point(x,y)
      speed(0)
      deplace(x,y)
      rect(10,30,x,y)
def rotule(x,y):                        # Un cercle de rayon 5 de centre le point (x+5,y- 5)
      speed(0)
      cercle(5,x+5,y-5)
def basjambe(x,y):                     # Un rectangle de 10 par 30 à partir du point (x,y-40)
      rect(10,30,x,y-40)
      forward(20)
      deplace(x,y)
def jambeverticale(x,y):                            # La jambe est  totalement verticale
      fillcolor("white")
      begin_fill()
      hautjambe(x+7,y+10)
      end_fill()
      rotule(x+7,y+10)
      basjambe(x+7,y+10)
def jambepeupliee(x,y):               # La jambe est légèrement en avant pliée
      left(20)
      hautjambe(x+12,y+10)
      rotule(x+16,9+y)
      right(40)
      basjambe(x+3,10+y)
      left(20)
def jambepliee(x,y):                       # La jambe est en avant pliée
      left(60)
      hautjambe(x+27,y+20)
      rotule(x+34,28+y)
      right(60)
      basjambe(x+32,y+23)
      deplace(0,0)
def jambepeurecul(x,y):                  # La jambe est un peu en arière
      ht()
      right(5)
      fillcolor("white")
      begin_fill()
      hautjambe(x,y)
      end_fill()
      right(5)
      rotule(x-1,y-3)
      basjambe(x-6,y-5)
      left(10) 
def jamberecul(x,y):              # La jambe est  raide en arrière
      right(10)
      fillcolor("white")
      begin_fill()
      hautjambe(x,y)
      end_fill()
      right(20)
      rotule(x-3,y-3)
      basjambe(x-18,y+2)
      left(30)
def jambelevee(x,y):                  # La jambe est raide levée
      left(20)
      hautjambe(x+15,y+9)
      rotule(x+18,y+8)
      basjambe(x+29,y+6)    
      right(20)
      ht()    
def sol():                                # Pour faire le sol
      ht() 
      deplace(-30, -36)
      width(3)
      color("brown")
      forward(150)
      deplace(0,0)
def fantome(x,y,couleurprincipale,couleur):     #construction du fantôme 
      ht()
      speed(0)
      width(3)
      deplace(x,y+70)
      color(couleurprincipale)
      speed(0)
      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(couleur)
      begin_fill()
      circle(6)
      end_fill()
      penup()
      right(90),forward(20),pendown()    
      fillcolor(couleur)
      begin_fill()
      circle(6)
      end_fill()    
      penup()
      forward(-15),right(90),forward(50),left(90)   
      pendown()     
def test():
      ht()
      reset()
      sol()
      fantome(0,0,"orange","green")
      color("red")
      deplace(50,100)
      write( " OH ! oh ! OH !")    
      fantome(0,0,"white","white")                    # pour faire disparaître le fantôme
      color("blue")
      jamberecul(-5,13)
      jambelevee(15,0)   
      fantome(50,90,"orange","green")   
      color("white")
      jambelevee(15,0)
      jamberecul(-5,13)
      sol()                                                    # Le sol est souvent à refaire
      color("black")
      jambepeurecul(-5,13)
      jambepeupliee(15,0)
      fantome(50,90,"white","white")  
      color("white")
      jambepeupliee(15,0)
      jambepeurecul(-5,13)
      sol()
      color("green")
      jambepliee(15,0)
      jambeverticale(-5,0)
      fantome(50,90,"white","white")
      fantome(150,0,"orange","green")
      color("white")
      jambepliee(15,0)
      jambeverticale(-5,0)
      sol()
      color("black")   
      jamberecul(-5,13)
      color("orange")
      jambeverticale(15,0)
      fantome(150,0,"white","white")
      color("white")
      jamberecul(-5,13)
      sol()
      color("orange")
      jambeverticale(-5,0)
      fantome(150,100,"orange","green")
      deplace( 150,90)
      write("Hé Bé ! " )     
      mainloop()

                             En activant test() il vient :

>>> 
>>> test()
>>> 

                                  Puis :

            Les jambes bougent sur place en changeant de couleurs et le fantôme se déplace.

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

EXERCICE 6:

    Donner un script en Python 2.7, fait se balader une jambe avec six positions.

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

     REPONSE:

from turtle import*
from random import*
def deplace(x,y):
      penup()
      goto(x,y)
      pendown()
def rect(a,b,x,y):                        # rectangle à partir du point (x,y)
      width(4)                                # a est la largeur  b est la longueur
      speed(0)
      deplace(x,y)    
      for i in range(2):
           forward(a),left(90),forward(b),left(90)
def cercle(r,x,y):                      #  cercle de rayon r de centre ( x,y)
      width(4)
      speed()
      deplace(x,y-r)
      circle(r)
def hautjambe(x,y):                  # Un rectangle de 10 par 30 à partir du point(x,y)
      speed(0)
      deplace(x,y)
      rect(10,30,x,y)
def rotule(x,y):                        # Un cercle de rayon 5 de centre le point (x+5,y- 5)
      speed(0)
      cercle(5,x+5,y-5)
def basjambe(x,y):                     # Un rectangle de 10 par 30 à partir du point (x,y-40)
      rect(10,30,x,y-40)
      forward(20)
      deplace(x,y)
def jambeverticale(x,y):                            # La jambe est  totalement verticale
      fillcolor("white")
      begin_fill()
      hautjambe(x+7,y+10)
      end_fill()
      rotule(x+7,y+10)
      basjambe(x+7,y+10)
def jambepeupliee(x,y):               # La jambe est légèrement en avant pliée
      left(20)
      hautjambe(x+12,y+10)
      rotule(x+16,9+y)
      right(40)
      basjambe(x+3,10+y)
      left(20)
def jambepliee(x,y):                       # La jambe est en avant pliée
      left(60)
      hautjambe(x+27,y+20)
      rotule(x+34,28+y)
      right(60)
      basjambe(x+32,y+23)
      deplace(0,0)
def jambepeurecul(x,y):                  # La jambe est un peu en arière
      ht()
      right(5)
      fillcolor("white")
      begin_fill()
      hautjambe(x,y)
      end_fill()
      right(5)
      rotule(x-1,y-3)
      basjambe(x-6,y-5)
      left(10) 
def jamberecul(x,y):              # La jambe est  raide en arrière
      right(10)
      fillcolor("white")
      begin_fill()
      hautjambe(x,y)
      end_fill()
      right(20)
      rotule(x-3,y-3)
      basjambe(x-18,y+2)
      left(30)
def jambelevee(x,y):                  # La jambe est raide levée
      left(20)
      hautjambe(x+15,y+9)
      rotule(x+18,y+8)
      basjambe(x+29,y+6)    
      right(20)
      ht()
def sol():
      ht() 
      deplace(-30, -36)
      width(3)
      color("brown")
      forward(250)
      deplace(0,0)

def geste():
      ht()
      reset()
      sol()   
      color("red")
      jamberecul(-5,13)
      color("white")
      jamberecul(-5,13)  
      color("blue")           
      jambepeurecul(20,13)
      color("white")
      jambepeurecul(20,13)   
      color("green")
      jambeverticale(40,-2)
      color("white")
      jambeverticale(40,-2)    
      color("black")
      jambepeupliee(70,0)
      color("white")
      jambepeupliee(70,0)

      color("violet")
      jambelevee(90,0) 
      color("white")
      jambelevee(90,0)
   
      color("orange")
      jambepliee(115,-5)
      color("white")
      jambepliee(115,-5)
    
      color("blue")
      jambeverticale(-5,-2)              
      sol()       
      mainloop()

                             En activant geste() on a :

>>> 
>>>  geste()
>>> 

                                        Puis on obtientà la fin :                              

                en ayant avant successivement les positions suivantes puis la jambe verticale bleue

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