PYTHON 2 FEUILLE n° 24 dix sur TURTLE

                                   PYTHON 2.7        FEUILLE n° 24  Dix                 BTS SIO          juin 2019

           Cours:               DES    BIPS ,   DES SONNERIES ,  DES SONS  

                     # En même temps que Python 2.7 , de nombreux modules ont été installés

                        comme  time , turtle  ,  decimal , binascii ,  math  , random, wave , winsound

                         .......etc.   On peut donc les importer  quand on en a besoin.

                           Aucune nouvelle installation de modules n'est nécéssaire  pour jouer un son.

                     #   Pour faire un seul  bip  il suffit de considérer:

from time import*
from Tkinter import*
def bip():      
      fen = Tk()
      sleep(0)                  # Suspend l'exécution 0 secondes
      fen.bell()
      fen.quit()

                                 Il y a une petite fenêtre vide, sans intérêt, qui s'ouvre quand on active bip()

                           On entend un seul bip.

                    # Pour générer plusieurs bips, il suffit de considérr un boucle for

from time import*
from Tkinter import*
def bips():      
       fen = Tk()
       for i in range(5):             # pour engendrer cinq bips identiques
             sleep(1)                    # Suspend l'exécution1 seconde.   Donc on a 1 secondes entre chaque bip
             fen.bell()
       fen.quit()

                                           Cela génère cinq bips quand on active bips() .

                     # On peut mêler une fenêtre Turtle avec des dessins et des bips.

                       Par exemple on peut faire un compte à rebours:

from turtle import*
from time import
from random import*
from Tkinter import*

def deplace(x,y):
       penup(), goto(x,y),pendown()
def compte():
       ht()   
       fen = Tk()
       deplace(-50,150)
       width(10)
       write(" 10 SECONDES " )
       deplace(0,80)
       for i in range(11):     
             sleep(1)                   # Suspend l'exécution 1 seconde
             a=10-i
             penup(), forward(20),pendown()
             width(10)
             write(a)       
             fen.bell()
       fen.quit()

                                   En activant compte() il vient :

>>> 
>>>compte
>>> 

                                       Puis :

 

                                     Decompteturtle

                               Chaque apparition d'un entier fait un bip.

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

     EXERCICE1 :

       Donner un script , en Python 2.7, qui trace des cercles concentriques de plus en plus grand , en expansion.

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

   REPONSE:

from turtle import*
from random import*
def deplace(x,y):
       penup(),goto(x,y),pendown()
def evol():
       r=3
       ht()
       circle(r)
       speed(0)
       E=["yellow","green"]
       for i in range(30):
             deplace(0,-5*i)
             if i%2==0:
                  width(1)
                  color(E[0])
                  circle(r+5*i)
             else:
                   width(3)
                   color(E[1])
                   circle(r+5*i)
       mainloop()

                                En activant evol() on obtient:

>>> 
>>> evol()
>>> 

                                Puis à la fin :

                                  Decoturtle

                                     Il y a expansion des cercles concentriques verts  jusqu'au plus grand.

     Autre possibilité:

from turtle import*
from random import*
def deplace(x,y):
       penup(),goto(x,y),pendown()
def evol(x,y):
       deplace(x,y)           # Le centre du premier xercle a pour coord( x, y+r)
       r=3
       ht()
       circle(r)
       speed(0)
       E=["yellow","green"]
       for i in range(30):
             penup(),right(90),forward(5),left(90), pendown()
             if i%2==0:
                   width(1)
                  color(E[0])
                  circle(r+5*i)
             else:
                    width(3)
                    color(E[1])
                    circle(r+5*i)
       mainloop()

                     On obitient le même résultat mais en décidant du centre de coord ( x, y + r ) du premier cercle.

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

       EXERCICE 2 :

          Donner un script, en Python 2.7, qui reprend ces cercles évolutifs dan un 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():
       speed(0)
       deplace(-220,-307)
       width(19) , color("black"), forward(400), backward(200)
       bgcolor("blue")
def jet1(j,angle):                        # Départ du   premier  tir
       a=Turtle()
       speed(0),color("violet")  
       left(angle)        
       width(4)
       penup(), forward(11*j),pendown()
       forward(3)
       penup(),backward(11*j),
       right(angle)
       pendown()   
def jet2(k,angle):                        # second tir 
       b=Turtle()
       speed(0),  width(4), color("violet")    
       left(angle)              
       penup(),forward(k*12),pendown()
       forward(6)
       penup(),backward(k*12),pendown()
       right(angle)
def evol(x,y,couleur1,couleur2):
       speed(0)
       deplace(x,y)
       r=0
       ht()
       circle(r)    
       E=[couleur1,couleur2]
       for i in range(14):
             penup(),right(90),forward(5),left(90), pendown()
             if i%2==0:
                  width(1)
                  color(E[0])
                  circle(r+5*i)
            else:
                   width(3)
                   color(E[1])
                   circle(r+5*i)
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,80)           
                      j=j+1
                else:
                       jet2(k,45)
                      k=k+1          
                i=i+1
       c=Turtle  
       for j in range(2):
             evol(55+60*j,-105+60*j,"yellow","orange")
             evol(130,-130+60*j,"red","yellow")  
             evol(55+60*j,-105+60*j,"green","green")
             evol(160+40*j,-130+0,"yellow","orange")
             evol(130,-130+60*j,"red","orange")
   
       clear()
       bgcolor("blue")
       deplace(-120,-294)
       speed(0), width(4)
       sol()
       i=0
       j=1
       k=1
       while i<22:
                if i%2==0:
                     jet1(j,140)           
                     j=j+1
                else:
                      jet2(k,90)
                      k=k+1          
                i=i+1
       for j in range(2):
             evol(-140+60*j,-140+60*j,"green","orange")
             evol(-45,-90+60*j,"red","yellow")  
       color("white")
       deplace(-20,-200)
       write(" FIN DU FEU D'ARTIFICE ")
       ht()
       mainloop()

                                                               En activant feu() on obtient :

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

                      Puis:

                                          Debutgrandfeuturtle

                        La fin est:

                              Grandfeuturtle

 

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

   EXERCICE 3:

           Ecrire un script , en Python 2.7, qui présente un compte à rebours de 10 secondes avant 

            une explosion d'étoile en expansion.

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

               REPONSE:

             On peut proposer:

from Tkinter import*
from time import
from turtle import*
from random import*
def deplace(x,y):
        penup(), goto(x,y),pendown()
def evol(x,y,couleur1,couleur2):
       deplace(x,y)
       r=1
       ht()
       circle(r)
       speed(0)
       E=[couleur1,couleur2]
       for i in range(40):
             penup(),right(90),forward(5),left(90), pendown()
             if i%2==0:
                  width(2)
                  color(E[0])
                  circle(r+5*i)
             else:
                    width(2)
                    color(E[1])
                    circle(r+5*i)
def commande():
       ht()
       deplace(-50,150)
       width(10)
       write(" VOUS DISPOSEZ DE 10 SECONDES AVANT HIROSHIMA MON AMOUR...." )
       fen = Tk()
       deplace(0,80)
       for i in range(11):     
             sleep(1)
             a=10-i
             penup(), forward(20),pendown()
             width(10)
             write(a)       
             fen.bell()
       deplace(-200,10)
       write(" ZERO .   ")
       width(4) 
       bgcolor("orange")
       evol(100,-120,"blue","yellow")
       evol(100,-120,"red","red")
       bgcolor("green")
       fen.quit()

                                       En activant commande() il vient:

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

                                                Puis:

                    Hiroshimaturtle 1     

                    Puis:                                

                    Hiroshimafinturtle

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

   EXERCICE 4:

      Donner un script , en Python 2. 7, qui fait un petit air de bips.

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

            REPONSE :

      On peut proposer:

from time import*
from Tkinter import*
from random import*
def bip(j):      
       fen = Tk()    
       for i in range( 3):
             sleep(0.2)  
             fen.bell()
       fen.quit()
       fen=Tk()
       for i in range(3):
             sleep(0.5)  
             fen.bell()
       for i in range(2):
             sleep(0.6)  
             fen.bell()
       fen=Tk()
def commande():
       for j in range(2):
             bip(j)

                                                      En activant commande() on obtient :

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

                                            Puis deux fois , une séries de trois bips puis une série de trois bips plus lents

                                          puis une serie de deux bips plus lents

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

   EXERCICE 5:

        Donner un script , en Python 2.7, qui semble faire vibrer un téléphone qui sonne.

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

   REPONSE:

              On peut proposer :

from turtle import*           # Tous ces modules sont déjà téléchargés en même temps que  Python 2.7
import wave                      # Module pour le son      
import math                     # Pour pouvoir utiliser la fonction  x
 → sin( w x ) pour un son sinusoïdal
import binascii                # Nécessaire pour le module wave qui utilise le système binaire
import winsound            # Pour avoir la lecture audio ( en sortie vers la carte son de l'ordinateur)
winsound.PlaySound("son.wav",winsound.SND_FILENAME)           # Lance  aussitôt  "son.wav"  
def deplace(x,y):
    penup(),goto(x,y),pendown()
def telephone(x,y,couleur):
       deplace(x,y)
       ht()   
       width(10),speed(0)
       fillcolor(couleur)
       begin_fill()
       forward(200),right(90),forward(80),right(90),forward(50)
       right(90),forward(30),left(90),forward(100)
       left(90),forward(30),right(90),forward(50),right(90),forward(80),right(90)
       end_fill()
def vibration():
       bgcolor("grey")
       ht()
       E=["red","grey"]
       for i in range(7):
             if i%2==0:
                   telephone(0,0,E[0])
             else:
                   telephone(0,0,E[1])
       deplace(0,80)
       width(5)
       color("black")
       write(" ALLO !  ALLO !   Y  A QUIN QUIN !")
       deplace(0,30)
       write(" ALORS ! VOUS N'ENTENDEZ PAS ! ")  
       mainloop()
vibration()                                          # Pour le déclenchement automatique après la sonnerie prioritaire
mainloop()

def sonnerie():                                   # Pour imiter une sonnerie de téléphone
       NomFichier = "son.wav"                #  C'est le nom du fichier que lance winsound
       BRUIT = wave.open(NomFichier,"w")     # Instanciation  ( Réserver un espace mémoire à l'objet BRUIT )
       nbCanal = 2                                                            #  Deux canaux pour la stéréo
       nbOctet = 1                                                           # Taille d'un échantillon :      1 octet = 8 bits
       fech = 44100                                                         # Fréquence d'échantillonnage
       frequenceG =440.0                                             # Fréquence du son du canal de gauche (Hz) 
       frequenceD =880.0                                              # Fréquence du son du canal de droite (Hz) 
       niveauG =1.0                                                         # Niveau du son du canal de gauche (0 à 1)  
       niveauD =0.5                                                         # Niveau du son du canal de droite (0 à 1)
       duree = 2.5                                                            # Durée du BRUIT en secondes 
       nbEchantillon = int(duree*fech)                        # Il y a de nombreux cœfficients multiplicateurs .
       amplitudeG = 127.5*niveauG                             # Ils servent à  amplifier,  donc à rendre audible le son
       amplitudeD = 127.5*niveauD

       for i in range(0,nbEchantillon):                                              
             valG = wave.struct.pack("B",int(128.0 + amplitudeG*math.sin(2.0*math.pi*frequenceG*i/fech)))                       
             valD = wave.struct.pack("B",int(128.0 + amplitudeD*math.sin(2.0*math.pi*frequenceD*i/fech))) 

                                  Le lancement est automatique car on a mis à la ligne vibration()

                      On obtient :

                                  Telephoneturtle

               On entend la sonnerie, puis le téléphone apparaît et semble vibrer, enfin le texte devient visible

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