SPE TES

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 :

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 :

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:

La fin est:

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

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:

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

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 :

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

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

Mentions légales Gestion des cookies