PYTHON 2.7 FEUILLE N°24 11 MUSIC 14 Juin 2019
<< Les intellectuels résolvent les problèmes, les génies les évitent >> Albert. Einstein.
COURS : La MUSIQUE en Fête .
# On peut avec winsound, déjà rencontré, jouer toutes les notes de la gamme
y compris les dièses, comme sur le clavier d'un piano, très facilement,
mais avec certaines limites , en particulier une précision de 1Hz seulement,
en raison des fréquences acceptées qui ne peuvent être que des entiers,
entre 37 accepté et 32767, c'est-à dire à partir de 37 Hz et au plus 32767 Hz.
# On a besoin de la notion de dictionnaire pour stocker des données.
C'est simplement comme une liste dans laquelle, les termes sont formés
d'un string : une valeur.
Au lieu de crochets aux extrémités il y a des petites accolades.
dictionnaire= { string1 : valeur1 , string2 : valeur2 , ..... , ..... }
Ensuite quand on demande string1 on obtient valeur1 associée.
Par exemple:
{ 'Albert' : 19 , 'Pascal' :16, 'Alexandra' : 20 }
est un dictionnaire qui a permis de stocker
les noms de trois étudiants avec une note associée.
Ainsi :
def bil():
Bilan={ 'Albert' : 19 ,'Pascal' :16,'Alexandra' : 20 }
print Bilan['Albert']
Quand on active bil() on obtient:
>>>
>>> bil()
19
>>>
Généralités:
Le clavier d'un piano comporte des séries de 12 touches :
do , dodièse , ré , rédièse , mi , fa , fadièse , sol , soldièse , la , ladièse , si
Chaque série de 12 touches donc de 12 notes est une octave.
Vers la gauche on a , les notes les plus basses ( de fréquences les plus basses ) ,
et vers la droite on a , les notes les plus hautes ( de fréquences les plus élevées).
Sur un synthétiseur il n'y a souvent que quatre octaves.
Mais sur un piano il peut y avoir 7 octaves complètes et parfois des touches en supplément.
On peut les numéroter. ( la numérotation n'est pas la même pour tout le monde )
Par exemple:
Nous considérons:
• Le dictionnaire des notes de l'octave n°4 où chaque note est associée à une fréquence en Hz est.
octave4= {'do': 523.3,'dodiese':554.4, 're': 587.3,'rediese':622.3,'mi':659.3,'fa':698.5,'fadiese': 740.0,'sol':784.0,'soldiese':830.6,'la':880.0,'ladiese':932.3,'si':987.8}
• Le dictionnaire des notes de l'octave n°3 où chaque note est associée à une fréquence en Hz est.
octave3= {'do': 261.6,'dodiese':277.2, 're': 293.7,'rediese':311.1,'mi':329.6,'fa':349.2,'fadiese': 370.0,'sol':392.0,'soldiese':415.3 , 'la':440.0 ,'ladiese':466.2,'si':493.9}
Ce 'la' est celui du diapason
• Le dictionnaire des notes de l'octave n°2 où chaque note est associée à une fréquence en Hz est:
octave2={'do': 130.8,'dodiese':138.6, 're': 146.8,'rediese':155.6,'mi':164.8,'fa':174.6,'fadiese': 185.0,'sol':196.0,'soldiese':207.7,'la':220.0,'ladiese':233.1,'si':246.9}
• Le dictionnaire des notes de l'octave n°1 où chaque note est associée à une fréquence en Hz est:
octave1= {'do': 65.41,'dodiese':69.30, 're': 73.42,'rediese':77.78,'mi':82.41,'fa':87.31,'fadiese': 92.50,'sol':9.0,'soldiese':103.8,'la':110.0,'ladiese':116.5,'si':123.5}
• Le dictionnaire des notes de l'octave n°0 où chaque note est associée à une fréquence en Hz est:
octave0={'do': 32.7,'dodiese':34.65, 're':36.71,'rediese':38.89,'mi':41.2,'fa':43.65,'fadiese': 46.25,'sol':49.0,'soldiese':51.91,'la':55.0,'ladiese':58.27,'si':61.74}
On peut considérer, pour jouer un air de musique, une liste, de certaines des notes ,
en demandant à l'ordinateur d'aller dans l'un des dictionnaires,c'est-à-dire dans l'une des octaves,
afin de reconnaitre les fréquences de ces notes à jouer. On peut "panacher".
Dans les débuts on va se limiter à l'octave n°4.
Concrètement voici un script qui joue les notes à la suite do , ré , mi , fa , sol , la , si .
( Les fréquences ont été arrondies pour avoir des entiers. Il s'agit donc d'une approche.)
( De plus les fréquences acceptées sont d'au moins de 37 Hz.
Par exemple la fréquence 33 du do de l'octave0 est trop faible pour être acceptée. )
C'est comme un clavier où l'on n'a pas cette touche do, ni la suivante, le do dièse.
Le ré, arrondi à 37 Hz , lui , peut passer. )
import math
import binascii
import winsound
def lagamme():
Dictionnaire_des_Notes = {'do': 523,'dodiese':554, 're': 587,'rediese':622,'mi':659,'fa':698,'fadiese': 740,'sol':784,'soldiese':831,'la':880,'ladiese':932,'si':988}
gamme =['do', 're' ,'mi','fa','sol','la','si'] # C'est la liste des notes qu'on veut jouer . On peut n'en mettre qu'une seule.
for i in gamme:
winsound.Beep(Dictionnaire_des_Notes[i],400) # Si on met 300 au lieu de 400 c'est plus rapide
En activant lagamme() on obtient:
>>>
>>> lagamme()
>>>
Puis on entend les 7 notes de la gamme
Pour entendre aussi les dièses il suffit de les mettre aussi dans la liste gamme
# Pour modifier le tempo c'est-àdire , la vitesse d'exécution des notes ,
dans winsound.Beep( ...................... , tempo ) on agit sur le tempo.
Plus il est petit plus ça va vite, plus il est grand plus c'est lent.
# Pour répéter trois fois la même note , par exemple trois fois le do à la suite
on prend comme liste des notes qu'on veut voir jouer ['do']*3 + la liste des autres notes
# Attention:
Ici , les fréquences considérées sont celles de l'octave n°4.
Pour certaines musiques il faudra considérer les notes avec d'autres fréquences
par exemple d'octave n°3 ou 1 voire 0.
Alors comme on joue sur plusieurs octaves on peut mettre dans le script
un dictionnaire-réservoir réduits aux seules notes-fréquences que l'on va considérer
pour la musique que l'on veut faire. Cela allège le script.
------------------------------------------------------------------------------------------------------------------------
EXERCICE 1:
Donner un script , en Python 2.7, qui joue les notes:
sol , sol, si , si , la, si, la . ( Poursuivre éventuellement. )
-------------------------------------------------------------------------------------------------
REPONSE:
On peut proposer :
import math
import binascii
import winsound
def fontaine():
octave4 = {'do': 523, 're': 587,'mi':659,'fa':698,'sol':784,'la':880,'si':988} # On n'a pas de dièse ici
chanson1 =['sol']*2 +['si']*2 +['la', 'si', 'la']
chanson2= ['sol']*2+ ['si']*2 +['la','si']
chanson3=['si']*2+['la','sol','si']
for i in chanson1:
winsound.Beep(octave4[i], 500) # Le tempo est un peu plus lent car on a pris 500
for i in chanson2:
winsound.Beep(octave4[i], 500) # Le fait de casser en plusieurs chansons crée des respirations
for i in chanson3: # et permet aussi de changer le tempo
winsound.Beep(octave4[i], 500)
En activant fontaine() il vient:
>>>
>>> fontaine()
>>>
Puis on entend les notes
Remaque : Vous pouvez imaginer d'autres morceaux à présent.
-----------------------------------------------------------------------------------------------------
EXERCICE 2:
<< Ah ! Les crocrocro, les crocrocro
Les crocodiles
Sur les bords du Nil, ils sont partis
N'en parlons plus >>
Mettre en musique avec un script Python 2. 7 , le début du refrain.
------------------------------------------------------------------------------------
REPONSE :
On peut considérer éventuellement les notes suivantes:
fa , la , la , la
fa, la , la , la
fa, la , la , la
import math
import binascii
import winsound
def crocrocro():
octave4 = {'do': 523, 're': 587,'mi':659,'fa':698,'sol':784,'la':880,'si':988}
chanson1 =['fa']+['la']*3
for j in range(3):
for i in chanson1:
winsound.Beep(octave4[i], 350)
En activant crocrocro() il vient
>>>
>>> crocrocro()
>>>
Puis le début du refrain.
--------------------------------------------------------------------------
EXERCICE 3:
Que donne le script ,en Python 2.7, suivant ?
import math
import binascii
import winsound
def music():
reservoir={'do':523,'re':587,'mi':659,'rebas':37} # 'rebas' est le ré de l'octave0 , les autres notes sont de l'octave4
chanson=['do']*3+['re','mi','rebas','re','rebas','do','mi','re','re','do']
for i in chanson:
winsound.Beep(reservoir[i],300)[
---------------------------------------------------------------------------------------------------------------
REPONSE:
Quand on active music() ,on obtient finalement le début de : Au clair de la lune....
-----------------------------------------------------------
EXERCICE 4:
Que donne le script ,en Python 2.7, suivant ?
import math
import binascii
import winsound
def partisans():
reservoir={'do':62,'re':294,'mi':330,'fa':349,'fadiese':370,'sol':392,,'la':440,'si':494,}
chanson1 =['re','sol','sol']
chanson2=['la','si','si','la','sol','sol','fadiese','mi','re','fadiese','mi','re']
for i in chanson1:
winsound.Beep(reservoir[i], 600)
for i in chanson2:
winsound.Beep(reservoir[i], 500)
------------------------------------------------------------------------
REPONSE :
Quand on active partisans(), il donne le début de l'air des partisans.
-------------------------------------------------------------------------------------------
EXERCICE 5:
Donner un script , en Python 2.7, qui donne les accords de do
do , mi , sol , la dièse
-------------------------------------------------------------------------------------------------
REPONSE :
On peut envisager avec les octaves n° 3 et n°4, les plus courantes:
( les autres octaves sont mises pour des essais )
import math
import binascii
import winsound
def accord_de_do():
octave4 = {'do': 523,'dodiese':554, 're': 587,'rediese':622,'mi':659,'fa':698,'fadiese': 740,'sol':784,'soldiese':831,'la':880,'ladiese':932,'si':988}
octave3={'do': 262,'dodiese':277, 're': 294,'rediese':311,'mi':330,'fa':349,'fadiese': 370,'sol':392,'soldiese':415 , 'la':440 ,'ladiese':466,'si':494}
#octave2={'do': 131,'dodiese':139, 're': 147,'rediese':156,'mi':165,'fa':175,'fadiese': 185,'sol':196,'soldiese':208,'la':220,'ladiese':233,'si':247}
#octave1= {'do': 65,'dodiese':69, 're': 73,'rediese':78,'mi':82,'fa':87,'fadiese': 92,'sol':98,'soldiese':103,'la':110,'ladiese':116,'si':123}
#octave0={'do': 33,'dodiese':35, 're':37,'rediese':39,'mi':41,'fa':44,'fadiese': 46,'sol':49,'soldiese':52,'la':55,'ladiese':58,'si':62}
accord1=['do','mi','sol','ladiese']
for i in accord1:
winsound.Beep(octave3[i],1100)
for i in accord1:
winsound.Beep(octave4[i],1100)
En activant accord_de_do() il vient :
>>>
>>> accord_de_do()
>>>
Puis on entend les deux séries de quatre notes avec un long tempo.
--------------------------------------------------------------------------------------------------------