PYTHON 2 FEUILLE n° 24 neuf sur TURTLE

                          PYTHON 2.7   FEUILLE n° 24    neuf   sur   TURTLE    Mai 2019

                     MULTI   SOURIS   

     COURS: 

          •   Il peut être judicieux de faire travailler  plusieurs souris pour

             plus de fluidité.   C'est le principe de la  division du travail.

             C'est très facile à mettre en œuvre.

             Il suffit de les déclarer en disant :

                        t1=clone()              ( On peut prendre une autre nom comme,  tartenpion=clone()  

                                                         ou    peintre=clone()         )

             Alors les actions seront effectuées par la souris t1

              tant que l'on ne déclare pas une autre souris en mettant

                         t2=clone()

             Alors, c'est la seconde souris qui fait la suite du travail :

           Ainsi de suite.

             Le nombre de clones de souris n'est pas limité.

           •  L'objectif est d'arriver à faire travailler en simultané ou 

               presque simutanément  certaines souris  qui n'ont pas

                de tâches successives. 

           • •  Il y a une première possibilité :   Avancer - Reculer 

                Faire avancer t1 d'un petit ∆ puis la faire revenir au départ,

                pour  faire avancer  t2  d'un petit  ∆ '   puis la faire revenir au départ.

                De nouveau alors, faire avancer t1  d'un  ∆  plus grand  puis la faire

               revenir au départ,   pour faire avancer  t2  d'un  ∆ '  plus grand...   ......

               Ainsi de suite.

               Cela donne seulement  l'impression de déplacements simultanés.

               C'est fastidieux.

                • •  Il y a une seconde  possibilité:  Marcher sans reculer tantôt 

                   avec l'une tantôt avec l'autre.

                Les deux souris t1 et t2 sont alors comme deux pieds 

                 qui avancent, pas par pas, alternativement mais pas

                vers le même endroit comme si les jambes n'étaient pas reliées .

                 L'inconvénient est  de devoir faire faire deux dessins de même

                 dimensions qui diffèrent seulement par les autre éléments comme :

                  Couleur , emplacement , orientation, épaisseur du trait    .... etc.

                C'est également fastidieux. Ce n'est qu'une impression de mouvement 

                simultané.

              • •  Il y a une troisième possibilité:  Confier à l'ordinateur le soin  

                   faire avancer, si possible en même temps, les souris en optimisant

                  la gestion dans le temps des deux piles d'instructions pour chaque souris .

                  On utiise pour cela  pour chaque souris un  thread.

                  On arrive alors souvent à un vraie simultanéité et plus de fluidité

                   car l'ordinateur sait optimiser.

                  L'inconvénient vient de la complexité des notions abstraites à mettre en œuvre.

                 ( Hors du programme de maths en algo du BTS SIO  mais par contre vu avec l'option 

                     informatique )

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

    EXERCICE 1:

          Reprendre l'exercice précédent, avec le Monsieur Fil de Fer.

          Casser à l'aide de plusieurs souris, le script.

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

   REPONSE:

               On peut proposer:

from turtle import*
from random import*

def deplace(x,y):
       penup()
       goto(x,y)
       pendown()    
def sol():
       ht()
       t1=clone()                                             # Première souris clone  . Elle va faire le sol.
       speed(0), width(6), color("green")
       deplace( 250,-103)
       st()
       backward(340)
       color("black")
def jambesbras():
       speed(0),width(3)
       deplace(-15,70)
       t2=clone()  
       color("orange")                 # Seconde souris  clone  déclarée. Elle va faire seulement  la tête 
       circle(13)                            # qui est uncercle orange.
       color("black")                    # Mis pour  avoir la souris en noir. 
       for i in range(7):       
             t3=clone()                        # Troisième souris clone déclarée. Elle va faire seulement  les jambes en bleu.
             color("blue")       
             deplace(-20,-8)                     #  Une  jambe
             right(120),forward(60)   
             right(40), forward(40)
             left(10)                  
    
             deplace(-10,-8)                        # Autre jambe
             left(110),forward(60)        
             right(30),forward(40)     
             left(80)        
             width(3)
        
             t4=clone()                         # Quatrième souris clone déclarée. Elle fait les bras en bleu
             color("blue")
             deplace(-30,50)                  # Un bras 
             right(130)
             forward(30)    
             left(60)
             forward(15)
             left(70)     
    
             deplace(0,50)              #   Autre bras
             right(40)
             forward(30)    
             left(50)
             forward(15)           
             right(90)
       
             t5=clone()            #  Cinquième souris clone déclarée. Elle sert degomme pour les jambes et bras
             width(11)
             color("white")
             deplace(-20,-10)
             right(51),forward(60)                   # Pour effacer une  jambe 
             right(42), forward(40)      
        
             deplace(-10,-9)
             left(124),forward(60)                        # Pour effacer l'autre jambe
             right(39),forward(44)       
                      
             deplace(-30,50)                             # Pour effacer un bras
             right(45)
             forward(30)    
             left(50)
             forward(15)
    
             deplace(0,50)                  # Pour effacer l'autre bras
             left(40)
             forward(30)    
             left(50)
             forward(15)
             width(3)
             right(17)               # Les jambes et les bras ont été effacés. Il reste le sol et la tête
        
       t6=clone()             # Sixième souris clone déclarée.  Elle refait les jambes en violet,, qui restent à la fin.
       width(3)
       color("violet")
       deplace(-20,-8)                    #  Une  jambe en violet, refaite
       right(120),forward(60)   
       right(40), forward(40)
       left(10)                  
    
       deplace(-10,-8)                        # Autre jambe, en violet,  refaite
       left(110),forward(60)        
       right(30),forward(40)     
       left(80)
       color("black")
       t7=clone()                    #  Septième souris clone déclarée. Elle va recréer, en bleu, les deux bras qui vont rester     
       color("blue")
       deplace(-30,50)            #    Un bras, en bleu,  refait

       right(130)
       forward(30)    
       left(60)
       forward(15)
       left(70)        
    
       deplace(0,50)              # Autre  bras, en bleu, refait
       right(40)
       forward(30)    
       left(50)
       forward(15)           
       right(90)
       color("black")         #  Pour avoir la souris en noir
    
def commande():
       speed(0), reset()
       sol()
       jambesbras()       
       mainloop()                

         En activant  commande() on obtient:
>>> 
>>> commande()
>>> 

                    Puis:

                    On voit certaines souris,  volontairement non cachées , pour  s'en apercevoir.

                   Les bras et jambes apparaissent puis dsparaissent, un certain nombre de fois et,

                  à la fin, elles restent de cette couleur.

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

      EXERCICE 2:

         Donner un script , en Python 2.7, qui, avec deux souris, l'une pour les positions d'un missile

        tiré de la mer, l'autre pour les positions de l'antimissile, organise une poursuite et l'interception.

         On notera:              a =Turtle()        la souris du missile

                                          b =Turtle()        la souris de l'antimissile

                                          c=Turtle           la souris de l'explosion

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

    REPONSE: :

             On peut considérer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def mer():
      width(25)
      color("blue")
      forward(400)
      backward(400)
def missile(j):
      color("green")
      width(15)
      a=Turtle()
      speed(0),
      left(45)
      penup(), forward(3*j),pendown()
      forward(3)
      right(45)
def antimissile(k):
      color("red")
      width(15)
      b=Turtle()
      speed(0)
      penup(),forward(300-k*10),left(170)                                     
      forward(5*k),pendown()
      forward(5)
      penup(),right(170),backward(300-k*15),pendown()
def tire():
      deplace(-320,-280)
      mer()
      i=0
      j=1
      k=1
      while i<36:
             if i%2==0:
                 missile(j)           
                 j=j+1
             else:
                  antimissile(k)
                  k=k+1          
             i=i+1
      color("green")
      c=Turtle
      deplace(52,310)
      width(50)
      forward(2)
      penup()
      backward(2)
      pendown()
      color("orange")
      forward(2)
      ht()
      color("black")
      write("            OK .. Key !")
      mainloop()

                                   En activant tire() on a :

>>> 
>>> tire()
>>> 

                                  Puis à la fin :                                   

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

   EXERCICE 3:

   Donner un script, en Python 2.7, qui organise en ligne droite une course entre un départ et une

   arrivéeavec Jean-Claude ALESI en vert et TOTO en rouge.

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

   REPONSE:

                    On peut envisager:

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def depart_arrivee():
      deplace(-320,0)
      speed(0)
      width(25)
      left(90)
      color("black")
      forward(200)
      write("         Départ:         En vert  ALESI.       En rouge TOTO .")
      backward(200)
      right(90)
      penup(),forward(450),pendown()
      color("blue")
      left(90)
      forward(200)
      write("      Arrivée")
      backward(200)
      right(90)
      penup(),backward(450),pendown()   
def jeanclaude(j):
      a=Turtle()
      color("green")
      speed(0)
      left(90)
      penup(),forward(150),pendown()
      right(90)
      width(15)
      penup(), forward(11*j),pendown()
      forward(3)
      penup(),backward(11*j),
      right(90),forward(150),
      left(90)
      pendown()    
def Toto(k):   
      b=Turtle()
      color("red")
      speed(0)
      penup(),forward(k*12)
      pendown()
      forward(6)
      penup(),backward(k*12)
      pendown()
def course():
      deplace(-320,0)
      speed(0)
      depart_arrivee()
      i=0
      j=1
      k=1
      while i<42:
              if i%2==0:
                   jeanclaude(j)           
                   j=j+1
              else:
                    Toto(k)
                    k=k+1          
              i=i+1
      c=Turtle
      deplace(52,310)
      ht()
      color("black")
      deplace(110,-35)
      write("   BRAVO TOTO !")
      deplace(100,-55)
      write("Jean-Claude dans le bac à sable..!")
      deplace(-240,-80)    
      write(" VOUS VENEZ DE VOIR UNE COURSE SANS TRUCQUAGE, EN DIRECT ...! ")
      mainloop()

                                En activant course() il vient :

>>> 
>>>  course()
>>>

                         Puis :

           " Toute ressemblance avec des personnages ayant existé ne serait que pure coïncidence "

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

   EXERCICE 4:

   Donner, en Python 2.7, un script qui organise un petit feu d'artifice.

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

   REPONSE :

                     On peut proposer :

from turtle import*
from random import*
from math import*
def deplace(x,y):
      penup(),goto(x,y),pendown()
def temporisateur():
      for g in range(2*10**6):
           g=g+1
def sol():
      deplace(-220,-307)
      speed(0)
      width(19) 
      color("black")
      forward(400)
      backward(200)
      bgcolor("blue")
def jet1(j):
      a=Turtle()
      color("violet")
      speed(0)
      left(80)
      width(4)
      penup(), forward(11*j),pendown()
      forward(3)
      penup(),backward(11*j),
      right(80)
      pendown()
    
def jet2(k): 
      b=Turtle()
      width(4)
      color("violet")
      speed(0)
      left(45)
      penup(),forward(k*12)
      pendown()
      forward(6)
      penup(),backward(k*12)
      pendown()
      right(45)   
def feu():
      deplace(-120,-294)
      speed(0)
      width(4)
      sol()
      i=0
      j=1
      k=1
      while i<22:
             if i%2==0:
                 jet1(j)           
                 j=j+1
             else:
                  jet2(k)
                  k=k+1          
             i=i+1
      c=Turtle
      deplace(63,-100)
      color("yellow")
      fillcolor("yellow")
      begin_fill()
      circle(40)
      end_fill()
    
      deplace( 170,-130)
      color("orange")
      fillcolor("orange")
      begin_fill()
      circle(60)
      end_fill()

      temporisateur()
      temporisateur()
      temporisateur()
    
      deplace(70,-105)
      color("green")
      fillcolor("green")
      begin_fill()
      circle(80)
      end_fill()

      temporisateur()
      temporisateur()
      deplace( 175,-130)
      color("red")
      fillcolor("red")
      begin_fill()
      circle(90)
      end_fill()
    
      temporisateur()
      temporisateur()
      temporisateur()
    
      deplace(63,-140)
      color("green")
      fillcolor("green")
      begin_fill()
      circle(200)
      end_fill()
    
      temporisateur()
      temporisateur()
      temporisateur()

      deplace(85,-190)
      E=["yellow","red","green","orange","blue","yellow"]
      for i in range(6):
           color(E[i])
           fillcolor(E[i])
           begin_fill()
           circle(250)
           end_fill()
      temporisateur(),temporisateur(),temporisateur()
      bgcolor("violet")                        # La couleur du fond
      color("violet")
      fillcolor("violet")
      begin_fill()
      circle(250)
      end_fill()
      width(30)
      color("white")
      write(" C'EST   FINI   LES   PETITS  ")
      ht()
      mainloop()

                                         En activant feu() il vient:

>>> 
>>>  feu()
>>>

                                                          Puis :

                             Ensuite:

                              Etc....

                             Pour finir:                        

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

    EXERCICE 5:

                  Donner , en Python 2.7, un script qui fait décrire à deux souris, comme deux trains,

                 deux cercles tangents en sens contraires, l'un vert, l'autre rouge.

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

   REPONSE:

              On peut proposer :
from turtle import*
from random import**
from math import*
def deplace(x,y):
       penup(),goto(x,y),pendown()
def train1(j):
       a=Turtle()
       color("green"),speed(0),width(8)
       penup()
       left(60)
       circle(100,10*j)
       pendown()
       circle(100,10)
       penup()
       circle(100,-10*(j+1))
       pendown()
       right(60)
        
def train2(k):   
       b=Turtle()
       width(8),color("red"),speed(0)
       right(130)
       penup()
       circle(100,-10*k)
       pendown()
       circle(100,-10)
       penup()
       circle(100,10*(k+1))       
       pendown()   
       left(130)  
def commande():
       deplace(0,0)
       speed(0)
       ht()
       width(4)   
       i=0
       j=1
       k=1
       while i<75:
                if i%2==0:
                     train1(j)           
                      j=j+1
                else:
                        train2(k)
                         k=k+1          
       i=i+1
       mainloop()
                                                      En activant commande(à on obtient:

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

                                               Puis:

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

              EXERCICE 6:

                  Donner, en Python 2.7, un script qui, à l'aide de deux souris t1 et t2 , 

                  construit deux cercles en sens contraires, l'un bleu , l'autre rouge

                 sans point commun puis affiche un message.

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

     REPONSE:

     On peut proposer:

import turtle
import time

             # création de deux clones de tortues

t1=turtle.Turtle()
t2=turtle.Turtle()
             # précision des positions au début
t1.goto(0,0)
t2.penup()
t2.goto(150,115)
t2.pendown()

                        # instructions pour chaque tortue par petites touches
def Dessin_tortue_t1():   
      t1.speed(0)
      t1.width(3)
      t1.color("red")
      t1.forward(4)                   # Les  4 au lieu de 1 accélèrent le tracé 
      t1.left(4)  
def Dessin_tortue_t2():
      t2.speed(0)
      t2.width(3)
      t2.color("blue")
      t2.forward(4)
      t2.right(4)                         
              # Dessin alterné par petites touches Sans Reculer
for i in range(90):
      print  Dessin_tortue_t1()
      print  Dessin_tortue_t2()
   
turtle.penup()
turtle.goto(0,-50)
turtle.pencolor("brown")
turtle.write("TRAVAILLEURS     TRAVAILLEUSES ......")
turtle.pendown()
turtle.mainloop(

                          Le démarrage après F5 et la sauvegarde est sans intervention:

                            On a :

>>> 
None
None
None
None
None
None
None
None
None
                       ....................................
None
None
>>> 

                              On obtient à la fin :

        Remarque: On a utilisé la seconde méthode.

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

  EXERCICE 7:

             Utiliser, dans le menu time de Python 2.7 ,

              time.sleep( nombre de secondes ) pour différer l'exécution de nombre de secondes

             une partie d'un script.

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

         REPONSE:

            On peut proposer :

import time
def sit():
       print  " Bonjour "
       time.sleep(5)
       print  " Adieu "

                                     On fait :

 >>> sit()
 Bonjour 
 Adieu                            
>>>             

               Il y a 5 secondes entre les deux mots.

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

  EXERCICE 7:

        Donner un script , en Python 2.7 , qui trace, presque en simultané, deux

         rectangles de mêmes dimensions , l'un rouge, l'autre bleu.

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

            REPONSE:

        On peut par analogie proposer:

import turtle
import time

             # création de deux clones de tortues

t1=turtle.Turtle()
t2=turtle.Turtle()
             # précision des positions au début et caractéristiques. Conditions initiales
t1.goto(0,0)
t1.speed(0), t1.width(3), t1.color("red")

t2.penup()
t2.goto(200,300)
t2.pendown()

t2.speed(0), t2.width(3), t2.color("blue")
                       # instructions pour chaque tortue
def Dessin_tortue_t1():   
       t1.forward(3)      
def Dessin_tortue_t2():
       t2.forward(3)                         
    # Dessin presque simultané, tantôt l'une tantôt l'autre par petites touches
for i in range (2):
      for i in range(50):
           print Dessin_tortue_t1()
           print Dessin_tortue_t2()
      t1.left(90)   
      t2.right(90)
      for i in range(100):
           print  Dessin_tortue_t1()
           print  Dessin_tortue_t2()
      t1.left(90)   
      t2.right(90)
turtle.mainloop()

                                 On a:

>>> 
None
None
None
None
None
None
None
None
           .......
None
None
None
>>> 

                     Puis on finalement :

            Chacune des souris a avancé, sans jamais reculer, à tour de rôle, par petites touches successives.

            Ce qui donne bien l'illusion de l'aspect simultané du tracé.   

            Mais en réalité c'est alterné.  

            On peut, dans les conditions initiales au début, décider de la verticalité ou de l'horizontalité

           de chacun des deux rectangles.

           Par exemple:   en mettant  , t1.left(90)  après  t1.color("red")

            le rectangle rouge sera horizontal.

             Remarque: On a utilisé la seconde méthode.

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

     EXERCICE 8:

            Que fait le programme suivant ?        ( non exigible en BTS SIO en Algo )            

import turtle as t                                    # On importe le module turtle comme t , c-à-d nommé  t 
from threading import Thread              
import thread                                                       # On importe  le sous module thread 
import time

               # Création-initialisation  d'un écran avec Tkinter pour faire les dessins
def Ecran():                
       global cadre
       cadre=Tkinter.Tk()
       fond=Tkinter.Canvas(cadre,width=600,height=600)              # création d'une fenêtre 600 x 600
       fond.pack()
       sc=t.TurtleScreen(fond)            #   écran ou screen  dans la fenêtre fond, ( TurtleScreen()  sous class de turtle )
       sc.bgcolor("white")                               # couleur  à l'intérieur de l'écran dans  la fenêtre
       return sc                                                      #   sc veut dire screen

def cercle(cx,cy,pas,couleur):          # (cx, cy) coords du point de départ, pas = longueur du pas
       global sc                                       #  L'écran de la tortue fait par TurtleScreen() qui est une class
                                                              # global pour pouvoir y accéder de l'extérieur
       n=32
       tr=t.RawTurtle(sc)                     #     tr est une tortue  de la sous class   RawTurtle()  
       tr.width(5)
       tr.color(couleur) 
       tr.up()
       tr.goto(cx,cy)                             # souris mise en position initiale voulue
       tr.down()
       tr.speed(0)                                # vitesse maxi de la souris
       angle=360.0/n
       for i in range(4*n):                   # avancer du pas puis tourner de angle pour avoir un cercle
             tr.forward(pas)
             tr.left(angle)
sc= Ecran()
def Edit_thread(nom,a):                                          
      return Thread(name=nom,target=cercle,args=a)
def commande():
       t1=Edit_thread("toto",(-40,30,25,"red"))                   # création d'un thread pour la souris toto rouge 
       t2=Edit_thread("fafa",(50,-70,25,"green"))               # création d'un thread pour la souris fafa
       t1.start()                                                                        # demande de démarrage du thread t1
       t2.start()                                                                         # demande de démarrage du thread t2   
     
commande()

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

                REPONSE:

           On obtient en simultané :

              Remarque : c'est la troisième méthode dans un cas simple où les deux cercles sont de même 

                              dimension

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