PYTHON 2 FEUILLE n° 24 quatro sur TURTLE

                                                PYTHON 2.7    FEUILLE  n°  24   Quatro sur Turtle        Mai 2019

      COURS:

                      # Dans Turtle, pour remplir un contour fermé, on peut utiliser 

                      les lignes suivantes:

                            pencolor(  La couleur du stylo )
                            fillcolor(   La couleur  de remplissage)
                            begin_fill()                  
   Pour le début du coloriage
                             ...............            La désignation du contour fermé   comme par exemple

                                                     circle(50) pour un cercle de rayon 50
                            end_fill()                                 
  Pour la fin du coloriage

                      # Dans Turtle on peut aussi  pour remplir un contour fermé utiliser 

                         encore plus brièvement  les lignes suivantes:   

              
                              
  color(    La couleur du stylo ,   La couleur  de remplissage )  
                               begin_fill()                  
   Pour le début du coloriage
                               ...............        La désignation du contour fermé   comme par exemple

                                                circle(50) pour un cercle de rayon 50
                              end_fill()                
  Pour la fin du coloriage     

                   # Pour avoir un arc de cercle de rayon r et d'angle au centre h 

                      on utilise      circle(r,h)     

                   # Rappel: round(  .... a ... ,   2 ) permet     d'avoir le float a avec deux décimales.

                                round( 3.1416 , 2 ) = 3.14 

               # Avec le module math :

                             Pour avoir en radians la mesure  J d'un angle géométrique

                            dont on a la tangente  k =tan(J)  , il suffit de faire    J = atan(k)

                            Ensuite pour  convertir les  J radians  en degrés on utilise   degrees( J )

                           Par exemple:

                              Soit                 tan(J ) ≈    0.93

                                                     round( atan(0.93), 2)  ≈ 0.75             en radians 

                                                    round( degrees( J ), 2)  ≈  42.97        en degrés

                               Pour un triangle de base 300 et de hauteur correspondante 140

                               ses angles de base     mesures chacun    42.97 degrés
 

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

     EXERCICE 1:

         Donner un xcrip, en Python 2.7, trace un disque après avoir demandé

        son rayon , la couleur du bord , la couleur intérieure.

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

       REPONSE:

                    On peut proposer :

from turtle import*
from random import*

def disqueplein():
        e=input("Donner l'épaisseur du trait:  ")
        a=raw_input("Donner la couleur du bord:  ")
        b=raw_input("Donner la couleur intérieure:  ")
        r=input("Donner son rayon:  ")
        width(e)
        pencolor(a)
        fillcolor(b)
        begin_fill()
        circle(r)

        end_fill() 

           On obtient quand on active disqueplein()

>>> disqueplein()
Donner l'épaisseur du trait:  3
Donner la couleur du bord:  blue
Donner la couleur intérieure:  yellow
Donner son rayon:  120
>>>

          Disqueturtle 1

   Autre possibilité:

from turtle import*
from random import*
def disqueopaque():
       r=input("Donner le rayon du cercle:  ")
       e=input("Donner l'épaisseur du trait:  ")
       a=raw_input("Donner la couleur du bord:  ")
       b=raw_input("Donner la couleur de l'intérieur:  ")
       width(e)
       color(a,b)                           # Le deux couleurs sont indiquées en même temps
       begin_fill()
       circle(r)
       end_fill()

            On obtient par exemple en activant disqueopaque() 

>>> disqueopaque()
Donner le rayon du cercle:  120
Donner l'épaisseur du trait:  3
Donner la couleur du bord:  blue
Donner la couleur de l'intérieur:  yellow
>>> 

              On a alors une figure identique

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

    EXERCICE 2:

     Donner un script , en Python 2.7, qui permet d'avoir un arc de cercle 

    de rayon r et d'angle au centre  h que l'on demandera de saisir.

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

   REPONSE:

   On peut proposer

from turtle import*
from random import*
def arc():
    r=input("Donner le rayon du cercle:  ")
    e=input("Donner l'épaisseur du trait:  ")
    a=raw_input("Donner la couleur du bord:  ")

    h=input("Donner l'angle au centre de l'arc :  ")
    width(e)
    color(a)
    circle(r,h)

           On obtient enactivant arc()

>>> arc()
Donner le rayon du cercle:  120
Donner l'épaisseur du trait:  3
Donner la couleur du bord:  blue
Donner l'angle au centre de l'arc :  90
>>> 

                  Puis la figure:

                   Arcturtle90

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

               EXERCICE 3

  Donner un script , en Python 2.7, qui permet d'avoir la surface colorée 

  complrise entre un arc et sa corde, de rayon r et d'angle au centre  h

   que l'on demandera de saisir.

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

        REPONSE:

from turtle import*
from random import*
def domaine():
       r=input("Donner le rayon du cercle:  ")
       e=input("Donner l'épaisseur du trait:  ")
       a=raw_input("Donner la couleur du bord:  ")
       b=raw_input("Donner la couleur de l'intérieur:  ")
       h=input("Donner l'angle au centre de l'arc :  ")
       width(e)
       color(a,b)
       begin_fill()
       circle(r,h)
       end_fill()

                En activant domaine() il vient 

 >>> domaine()     
Donner le rayon du cercle:   120
Donner l'épaisseur du trait:  3     
Donner la couleur du bord  blue
Donner la couleur de l'interieur :  yellow

Donner l'angle au centre de l'arc :  90

  >>>                 

                         Puis

             Domaineturtle

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

   EXERCICE 4:

     Donner un script, en Python 2.7,  qui dessine une cible de cercles bleus sur du jaune.

                     Cibleturtle 1

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

    REPONSE:

     On peut proposer:

from turtle import*
from random import*

def cible():
      width(2)
      i=100
      while i>20:
             a=str(100-i)
             color("blue","yellow")
             begin_fill()
             circle(i)
             end_fill()
             penup()
             goto(0,120-i)
             pendown()
             i=i-20

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

    EXERCICE 5:

   En vous inspirant de la FEUILLE n° 24 ter précédente , donner un script , en Python 2.7,

    quand on saisit les instructions, par exemple   N  F100 120G20 R90 F100 2Q45 F50 90A50   , 

    dessine, automatiquement  dans l"écran de Turtle le tracé correspondant.

     Convention:    120G20  provoque  le déplacement de la souris comme

                                         goto( 120 , 20 ) le fait mais sans le tracer.

                            2Q45      provoque le tracé d'un disque plein de couleur  bleu et de rayon 45

                           90A50      provoque le tracé d'un arc d'angle au centre  90  et de rayon 50

     Rappel

      On conviendra pour cet exercice seulement que:

      1 est pour " red" , 2 pour "blue" , 3 pour "yellow", 4 pour "green",

      5 pour orange" , 6 pour "brown" ,  7 pour purple, 8 pour black.

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

  REPONSE:

         On peut considérer :

from turtle import*
from random import*
def couleur(m):                               # Inchangé
      speed(0)
      if m==8:
        pencolor("black")
      elif m==1:
           pencolor("red")
      elif m==2:
           pencolor("blue")
      elif m==3:
           pencolor("yellow")
      elif m==4:
           pencolor("green")
      elif m==5:
           pencolor("orange")
      elif m==6:
           pencolor("brown")
      elif m==7:
           pencolor("purple")
      else:
            print " Couleur  inconnue"
            input()                     
def couleurplein(s):                       # On a rajouté ce script pour la couleur de remplissage
      if s==8:
        fillcolor("black")
      elif s==1:
           fillcolor("red")
      elif s==2:
           color("blue")
      elif s==3:
           fillcolor("yellow")
      elif s==4:
           fillcolor("green")
      elif s==5:
           fillcolor("orange")
      elif s==6:
           fllcolor("brown")
      elif s==7:
           fllpencolor("purple")
      else:
           print " Couleur  inconnue"
           input()            
def instruction():

      x=0
      y=0    
      D=raw_input("instruction de la forme N W3 C1 F20 3G15 : ")
      W=D.split(" ")
      for elem in W:                                     # Inchangé
           if len(elem)==1:
              print elem
              trajet(elem,0,x,y)
            
           elif "G" in elem:                         # Inchangé
                 i=elem.index("G")
                 deb=elem[:i]
                 fin=elem[i+1:]
                 for j in range(600):
                      if str(j) == deb:
                         x=j                      
                      if str(j)==fin:
                         y=j                     
                         print elem
                 a=elem[i]                
                 trajet(a,0,x,y)
           elif "Q" in elem:                        # Rajouté pour la demande du tracé d'un disque plein
                 i=elem.index("Q")
                 deb=elem[:i]
                 fin=elem[i+1:]
                 for j in range(1000):
                      if str(j) == deb:
                        x=j                      
                      if str(j)==fin:
                        y=j                            #  x sera sa couleur     y sera son rayon     
                 print elem
                 a=elem[i]                
                 trajet(a,0,x,y)
           elif "A" in elem:                       # Rajouté pour le tracé l'arc demandé
                 i=elem.index("A")
                 deb=elem[:i]
                 fin=elem[i+1:]
                 for j in range(600):
                      if str(j) == deb:
                        x=j                               # x est son angle et y son rayon
                      if str(j)==fin:
                        y=j                     
                 print elem
                 a=elem[i]                
                 trajet(a,0,x,y)        
           else:
                fin=elem[1:]                                     # Inchangé
                for j in range(600):
                     if str(j)==fin:
                    m=j
                print elem[0],m
                trajet(elem[0],m,x,y)    

def trajet(a,m,x,y):
      if a=="F":
        forward(m)
      elif a=="C":
           couleur(m)
      elif a=="O":
        circle(m)
      elif a=="Q":                        # Rajouté pour avoir un disque plein
            couleurplein(x)
            begin_fill()
            circle(y)
            end_fill()
      elif a=="A":                     # Rajouté pour avoir un arc 
           circle(y,x)
      elif a =="E":
           width(m)
      elif a=="G":
           penup()
           goto(x,y)
           pendown() 
      elif a=="R":
          right(m)
      elif a=="L":
           left(m)
      elif a=="B":
           backward(m)
      elif a=="U":
           penup()
       elif a=="D":

            pendown
       elif a=="N":
            reset()        
       else:
             print " Cela ne veut rien dire"
             input() 

                         Par exemple en activant instruction() il vient :

>>> instruction()
instruction de la forme N W3 C1 F20 3G15 : N E2 F50 R90 C1 180P50 R90 C8 F100 R90

C1 180P50 R90 C8 F30 L90 F50 L90 F380 L90 F50 55G0 3Q45 255G0 3Q45
N
E 2
F 50
R 90
C 1
180A50
R 90
C 8
F 100
R 90
C 1
180A50
R 90
C 8
F 30
L 90
F 50
L 90
F 380
L 90
F 50
55G0
3Q45
255G0
3Q45

>>>
 

                   On obtient :

                     Tutureturtle

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

        EXERCICE 6 

           Donner un script , en Python 2.7, qui permet de tracer avec Turtlr un triangle isocèle

            quand on saisit la longueur de sa base et la longueur de la hauteur correspondante.

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

       REPONSE:

                       On peut envisager d'utiliser  Pythagore  m = √(h^2 +( c / 2)^2 )

                      puis h / ( c / 2)  qui est la tangente de l'angle de base 

                      Alors arctan de cette tangente donne la mesure de  l'angle de base 

                      On dispose des longueurs des cotés et des angles.

from turtle import*
from random import*
from math import*
def triangleiso(c,h):
      reset()
      speed(0)                            # 0 est la plus grande vitesse . 10 est la plus lente
      l=round(c/2,2)                     # l est la longueur du demi coté de base avec deux décimales
      u=round(h**2,2)                  
      v=round(l**2)
      p=u+v 
      m=round(p**0.5,2)               # m est la longueur des deux cotés égaux 
      k=round(h/l,2)                     # k est la tangente de l'angle de base 
      q=round(atan(k),2)               # q est la mesure en radians de l'angle de base à l'aide de arctan
      j=degrees(q)                       #  j est la mesure des angles égaux en degrés

      width(3)
      color("green")
      forward(c)
      penup()
      back(c)
      pendown()
      left(j)
      forward(m)
      penup()
      back(m)
      right(j)
      forward(c)
      pendown()
      right(180+j)
      forward(m)

                   En activant triangleiso( 300,150 ) on obtient :

>>> triangleiso(300,100)
>>> 

                      Puis 

                    Triisoturtle1

        Autre possibilité:

from turtle import*
from random import*
from math import*
def triangleiso(c,h):
       reset()
       speed(0)                            # 0 est la plus grande vitesse . 10 est la plus lente
       l=round(c/2,2)                     # l est la longueur du demi coté de base avec deux décimales
       u=round(h**2,2)                  
       v=round(l**2)
       p=u+v 
       m=round(p**0.5,2)               # m est la longueur des deux cotés égaux à l'aide de Pythagore
       k=round(h/l,2)                     # k est la tangente de l'angle de base 
       q=round(atan(k),2)               # q est la mesure en radians de l'angle de base à l'aide de arctan
       j =degrees(q)                       #  j est la mesure des angles égaux en degrés

       width(3)
       color("green")
       left(j)
       forward(m)
       right(2*j)
       forward(m)
       right(180-j)
       forward(c)

                       On obtient en activant la même figure . 

                                            Triisoturtle2

                                    La souris est revenu au départ.

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