Bonjour

à moins d'être des spécialistes en musicologie, il est nécessaire de donner la partie de l'énoncé (tout ce qui est avant cette question-ci) qui définit ce qu'est une "gamme Pythagoricienne " !!

(et aussi ce que tu as fait, essayé, qu'est ce qui te bloque précisément, les résultats de questions précédentes, quelles formules ont été obtenues etc)

effectivement, désolée je viens tout juste de m'inscrire et je ne connaissais pas toutes modalités !
voici l'énoncé :
Une octave est un intervalle musical dans lequel le rapport des fréquences entre l'extrémité et l'origine est égal à 2. On décide ici de simplifier les calculs en fixant à 1 la fréquence f0 de l'origine de l'octave, qui correspond à une note de référence (440 Hz pour le La du diapason). L'octave est donc représentée par l'intervalle musical [1 ; 2]. Après le rapport 2 qui définit l'octave, le rapport le plus simple est la quinte pure, rapport égal à 3/2. L'échelle pythagoricienne est fondée sur ces deux seuls intervalles, l'octave et la quinte pure, à partir desquels sont construites toutes les notes de la gamme, selon le cycle des quintes.

voici les questions :
1. Proposer un algorithme qui affiche en sortie, pour un nombre de quintes n donné, la liste des fréquences de la gamme pythagoricienne associée.
2. Comment modifier l'algorithme obtenu pour que la gamme de n notes boucle presque parfaitement à 10-p près avec p entier naturel. Quelle valeur de n trouve-t-on pour p = 2 ? pour p = 3

voici ce que j'ai fait:
j'ai pensé à créer une suite géométrique qui pour un nombre de quintes donné, associait la fréquence: Un= (3/2)**n  car une quinte est un rapport de 3/2 entre deux fréquences. Je ne sais pas si mon intuition est bonne, puisque la consigne est de créer une fonction python qui affiche en sortie, pou nombre de quintes donné n, la liste des fréquence de la gamme pythagoricienne associée...
merci par avance

j'ai trouvé un schéma pour expliquer comment fonctionne les quintes. je ne comprends pas et je ne sais pas comment faire pour créer un programme python qui pourrait répondre à la question...
merci

OK, là on sait où on va et de quoi on parle.
dans ton 1er message tu donnais un programe "à trous" pour donner les valeurs de la gamme
l'as tu complété ?

"On décide ici de simplifier les calculs en fixant à 1 la fréquence f0 de l'origine de l'octave"
donc L=[1] le premier élément de la liste est 1

ensuite
un calcul sur a puis L.append(a) va ajouter la valeur de a à la fin de la liste
comment est calculée cette valeur d'après les explications sur la succession des notes ?

ensuite (une fois ce programme là au point !)

Comment modifier l'algorithme obtenu pour que la gamme de n notes boucle presque parfaitement à 10-p près

sans rien modifier, on peut l'utiliser avec des valeurs diverses de n et "lire" la dernière valeur de la liste jusqu'à avoir entre 1 et 1,01 (à 10^-2 ou 1.001 à 10^-3)
ou entre 0.99 et 1 (resp. 0.999 et 1) etc

ce procédé "manuel" va te donner des idées pour créer une boucle sur n

merci pour votre réponse.
si j'ai bien compris ce que vous m'avez dit, je dois effectuer un calcul sur a ? si c'est le cas, vu qu'on parle de quintes, le calcul à effectuer sur a serait a*3/2 ?

presque

a = quelque chose qui ne dépend pas de a encore inconnu à ce moment !
mais du dernier élément de la liste qui s'appelle L[??]

donc cette ligne là sera : a = L[??]*3/2

d'accord, si c'est a=L[??]*3/2, alors ca serait la liste de toutes les fréquences qu'il faut mettre à la place de "??" ?

ou alors, vu que on sait que L=1, ca serait la dernière fréquence de la liste ? donc par rapport au schéma sur les quintes, ca serait 243/128 ?

mais non, la dernière trouvée seulement !

du dernier élément de la liste

le premier coup c'est L[0], qui vaut 1 et on va donc calculer a = 1* 3/2 = 3/2

le deuxième coup ce sera L[1] qu'on aura calculé le coup d'avant et mis dans la liste : [1, 1.5]
on va donc calculer a = 1.5 * 3/2 =...
etc

donc par quoi de variable faut il remplacer ces "??" ?

ah d'accord ! il faudrait donc remplacer ?? par:
(a-1)* 3/2 ? puisque ce serait la valeur du nombre précédant a multiplié par 3/2 non ?

le nombre qui est dans la liste L
L[0], L[1], L[2] etc

alors que i varie justement de 0 à etc
c'est L[i] écrit comme ça

a =L[i]*3/2

j'ai l'impression que tu "découvres" ce que sont des listes en Python et comment ça s'utilise ...
et même pire que tu as des problèmes pour comprendre comment marchent des variables en général
écrire :

a = (a-1)* 3/2 alors que la valeur de a est encore inconnue ??? ça va donner quoi comme résultat ?
un crash...

non effectivement, nous venons de commencer les listes sur python, donc j'ai encore du mal...
je ne comprends juste pas pourquoi ca serait "i" et qu'est ce qu'il signifie.

def cyclepytha(n):
    L=[1]
    for i in range(n):
        a=L[i]*3/2
        if a>=2:
            a=...
        L.append(a)
    return L

merci beaucoup, c'est bien plus clair, je commence à comprendre comment fonctionne le langage python pour cet exercice.
mais comment faut-il compléter le deuxième trou?
si je comprends bien, on nous dit que si a est supérieur ou égal à deux, alors on doit dire quelle valeur va prendre a. Or dans la question il me semble que le nombre n de quinte n'est pas précisé, il est dit " pour un n de quintes donné, je devrai donc remplacer 2 par n ?
et si c'est le ac, comment dois-je compléter la suite ?
merci de votre réponse

dans le dessin parfaitement clair que tu as donné à 14:39 que fait on du 9/4 ? (qui est > 2)

9/4 est supérieur à 2 et se trouve dans la deuxième octave. d'après l'énoncé, une octave est une intervalle entre deux sons de rapport 2. or si j'ai bien compris, comme il ne se situe pas dans la première octave, mais dans la deuxième vu que 9/4> 2 il va falloir créer une deuxième boucle pour lorsque n>2 c'est ça ?
cela veut dire qu'il faudrait écrire:
a=L[i]*1/2  ?

tu ne comprends pas ce qui est fait dans ce graphique

le 9/4 on ne le garde pas, on le "ramène" dans la 1ère octave en le multipliant par 1/2
et c'est le 9/8 la vraie note.
la succession des notes c'est les flèches bleues
1, 3/2, 9/8, etc (et rien que celles là)

d'accord. mais alors, si on ramène les notes qui sont dans la deuxième octave en les multipliant par 1/2, c'est ce que l'on doit écrire dans la deuxième trou ? puisqu'il faut les ramener dans la première octave...
je ne comprend pas, si l'on ne doit pas écrire a=L[i]*1/2 dans le deuxième trou, doit ont ne pas les garder ? que doit-on écrire alors ?
merci

ah si, tu comprenais ,
mais tu le traduis mal (tu te mélanges les pinceaux dans les variables)

L[i] c'est la valeur précédente (3/2 !!)
à ce moment (dans le "si a > 2") le 9/4 il est dans a et rien que dans a
donc c'est tout simplement a = a/2

effectivement je viens de comprendre... j'ai l'impression qu'il va falloir m'améliorer en python ! merci beaucoup en tout cas.
encore une question, par rapport à votre réponse à la question 2, on serait pas obliger de modifier l'algorithme, mais si nous devons le modifier, qu'est-ce que l'on devrait faire ?
merci

question 2 : bein si, il va falloir le modifier,
parce que des tas d'essais à la main , et de comparaisons de valeurs à la main , ça ne va pas le faire

ça donne juste en idée du but à atteindre

il va falloir faire une boucle sur n
une boucle tant que (while)
tant que la dernière valeur obtenue est "loin" de 1 et de 2

ça donnerait le squelette :

def bouclepytha(p):
    L=[ ?? ]
    n = 1
    # tant que la dernière valeur est encore loin de 1 ou de 2 :
    while  ???? :
        a=L[n]*3/2
        if a>=2:    # ça c'est pareil : ramener à l'octave
            a=a/2
        L.append(a)
        n = n+1
    return n

d'accord. cela veut-il dire que la boucle while, donc que l'opération doit se répéter tant que la dernière valeur obtenue est loin de 1 et 2 ?
il faudrait donc mettre
while a> ou a< 1 (ou) 2
afin que la boucle continue de calculer jusqu'a atteindre 1 ou 2 ?
et ici, quelle serait l'idée pour L[???] ?
merci

la première valeur est 1
elle n'est pas "loin de 1 et de 2"
donc l'initialisation de la liste ne peut pas être juste L = [1] (la seule valeur 1)
ça ne marcherait pas car la dernière (et la seule) valeur dans la liste serait 1
elle est déja "près" (et même égale ...) de 1
on s'arrêterait instantanément.

attention à ne pas confondre :
[ a, b , c] qui est une liste
la variable L qui est ici ici une liste, contenant tout un tas de valeurs,
ou une seule : [1]
ou même aucune : [ ]
l'initialisation de cette variable à une liste (de 0, 1 ou plusieurs éléments
L = [ ] liste vide
L = [3] liste de un élément qui vaut 3
L =[ a, b, c] liste de 3 éléments qui valent a, b et c (les valeurs qu'ont à cet instant les variables a, b, c)
etc
et L[ n] qui est l'accès à l'élément de rang n de la liste
par exemple si on a initialisé la liste L par L= [1, 4, 9, 16]
L[0} vaut 1, L[2] vaut 9 etc

il y a aussi des fonctions de modifications de la liste
par exemple L.append(..) qui ajoute un élément supplémentaire à la fin de la liste
si L = [1, 4, 9, 16]
L.append(35) va ajouter un élément et la liste deviendra [1, 4, 9, 16, 35]

et d'autres fonctions ou opérations de modifications de liste, voir la doc Python

quant à "près de", l'énoncé lui même dit "à 10^-p près"
c'est à dire que si p = 2 par exemple,
"près de 1" ca veut dire entre 1 et 1.01 car 10^-2 = 0.01
et "près de 2" entre 1.99 et 2

donc des inégalités dans le test du while
inégalités qui feront intervenir le paramètre d'entrée p !
et sans se tromper dans le sens des inégalités pour une boucle while :

tant que on n'est pas près de ..

d'accord! donc comme on doit rapprocher au maximum a de 10**-p, il faut que la boucle calcule tant que a n'est pas proche ou égal à a.
il faut donc écrire:
while a!=10**-p
c'est cela ?

*  tant que a n'est pas proche ou égal à 10**-p  je voulais dire

mais qu'est ce que a ?
toujours le même problème : la première fois a n'a pas de valeur,
il n'est donc pas possible de le comparer à quoi que ce soit.

"la dernière valeur" elle n'est pas dans a
a est une variable de travail qui sert à calculer des éléments de la liste
elle est dans un élément de L
lequel ?

et puis il faut traduire correctement ce que veut dire "pas près de "
au besoin faire un dessin d'intervalles sur la droite des réels :

quelle inégalité mathématique traduit le fait qu'une valeur est dans le vert ?
(c'est à dire pour que le test du while reponde "true", "vrai, on continue"

une valeur absolue ?

ou alors plutôt une intervalle

un intervalle oui
lequel (écrit mathématiquement) et comment le traduire par des inégalités ?

ce serait ]1+10**-p ; 2-10**-p[
non?

et en traduisant par des inégalités, ce serait
1+10**-p<a< 2-10**-p
?

oui pour les inégalités

mais ce n'est toujours pas a   que l'on doit teste
deja dit et je répète : au moment du premier passage sur l'instruction "while", a   n'a aucune valeur et on ne peut pas faire un test dessus
a   ne prendra des valeurs que plus tard.

les fréquences, elles sont dans la liste L et nulle part ailleurs
en particulier celles qu'on y a mises lors de l'initialisation
L = [ ...] au tout début

relire ce que j'en ai dit

c'est donc L=[i] ?

soit
while   1+10**-p< L=[i]< 2-10**-p

??
il manque deux "trous"
l'initialisation de la liste L = [ ...... ]
L = [ i ] ne va pas marcher : i n'a aucune valeur
(et il n'y a même plus de variable i du tout)
l'initialisation c'est avec des valeurs numériques

dans le 1er programme on mettait au départ une seule valeur, la valeur 1 :
L = [1]
maintenant :

      while 1+10**(-p) < ???? < 2-10**(-p)

faut-il donc mettre 10**-p ?
sinon je ne vois pas ...

solution avec des commentaires
médite et cherche à comprendre les bases de la programmation (que ce soit en Python ou autre)
la notion de variable et d'opérations sur les variables,
les affectations : variable = valeur , variable = calcul
les tests ...
les listes, groupes de données tableaux etc

# fonction renvoyant le nombre de notes avant
# de revenir à 10**(-p) près de la 1ère
#
def bouclepytha(p):
    # on ne commence que à partir de L[1] = 1.5
    # car L[0] = 1 est déja = 1, on s'arrêterait immédiatement !
    L = [1, 3/2] # les deux  premières valeurs
    n = 1 # la dernière valeur de la liste c'est L[n] = L[1] = 1.5
    # tant que la dernière valeur est encore loin de 1 ou de 2
    while 1+10**(-p) < L[n] < 2-10**(-p):
        # L[n] est le dernier élément de la liste
        a = L[n]*3/2
        if a >= 2:
            a = a/2
        L.append(a)
        n = n+1
        # ici on a encore L[n] qui est le dernier élément (nouveau) de la liste
        # "invariant de boucle" : c'est vrai au début de chaque boucle
        #  c'est vrai avant de reboucler
    return n, L[n] # renvoie aussi la dernière valeur
# on pourrait retourner n et la liste L complète ; return  n, L
# mais ça fait beaucoup trop de valeurs
ou seulement n : return  n mais avoir la dernière valeur est intéressant

merci beaucoup pour votre aide. les commentaires m'ont bien permis de comprendre comment j'aurais dû faire et à comprendre mes erreurs. je vais m'entraîner davantage sur python. encore merci, bonne nuit