1
votes

Itérer des éléments dans une liste en utilisant un modèle?

Je crée un programme qui imprime l'échelle de musique que l'utilisateur souhaite utiliser (c'est-à-dire la gamme de do majeur) La gamme majeure utilise un motif demi-ton qui est 2 - 2 - 1 - 2 - 2 - 2 - 1

Je suis nouveau, donc je ne suis pas sûr de mes autres options. Désolé pour l'ignorance!

keys = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]

i = 0
while i < len(keys):
    print(keys[i])
    i += 2


# Output after being run:

C
D
E
F#
G#
A#

# Expected output
C
D
E
F
G
A
B

Je m'excuse si cela est mal expliqué.


5 commentaires

Je ne connais pas grand chose à l ' Echelle de Do majeur , mais vous imprimez uniquement les éléments sans cardinal ( # ), est-ce un motif ou juste une coïncidence?


C'est le modèle. Disons que je voulais utiliser D Major au lieu de C Major. Je commencerais à D et utiliserais le modèle, ce qui me donnerait: D, E, F #, G, A, B, C #


Si c'est un modèle, pourquoi ne pas utiliser sinon "#" dans la clé pour faire quelque chose? Désolé pour mon manque de qualités musicales!


@PedroLobito Parce qu'il n'est pas nécessaire que ce soit en do majeur. Le PO a publié cela à titre d'exemple seulement.


@Selcuk Ok, j'ai compris ce que veut OP après avoir vu votre réponse.


3 Réponses :


1
votes

Une façon de le faire serait de conserver les incréments dans un tableau eux-mêmes, et d'itérer dessus:

# ...
for increment in steps:
    print(keys[i % len(keys)])
    i += increment

Si vous vouliez commencer par une note autre que C, vous besoin d'éviter les erreurs "index hors limites" en prenant le reste de i / len (clés) :

keys = # ...
steps = [2, 2, 1, 2, 2, 2, 1]

i = 0
for increment in steps:
    print(keys[i])
    i += increment


3 commentaires

Ouah merci. C'est assez incroyable. Alors que faire si je voulais commencer à un indice différent de 0 (aka «C»). Et si je voulais commencer à l'index 4 (alias «E»)?


Jetez un œil à ma réponse, que j'ai postée spécifiquement pour remédier à cette situation ...


L'approche de @ larsks fonctionnerait, ou vous pourriez simplement prendre le reste de i divisé par le nombre de clés. (Je mettrai à jour ma réponse pour l'inclure.)



0
votes

Vous devez définir le modèle quelque part pour y parvenir. Une liste est une structure de données appropriée à cet effet, par exemple:

...
i = 2  # D
for p in pattern_major:
    print(keys[i])
    i = (i + p) % len(keys)

Maintenant, cela ne fonctionnera que pour C majeur car il manquera de clés si vous commencez avec une clé différente. Pour le rendre circulaire, essayez ceci (pour le ré majeur, par exemple):

keys = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
pattern_major = [2, 2, 1, 2, 2, 2, 1]
i = 0
for p in pattern_major:
    print(keys[i])
    i += p


0 commentaires

1
votes

Les réponses existantes ici sont en grande partie correctes, mais ne fonctionneront que pour la clé de C. Si vous deviez commencer par une autre note, votre code échouerait avec:

D
E
F#
G
A
B
C#

C'est parce qu'à partir de, disons, D et en suivant le modèle d'incrémentation, vous finissez par tomber de la fin du tableau keys . Une façon de résoudre ce problème consiste à ajouter le tableau keys à lui-même, comme ceci:

selected_key = 'D'
keys = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
major_scale = [2, 2, 1, 2, 2, 2, 1]

mark = keys.index(selected_key)
for inc in major_scale:
    print((keys + keys)[mark])  # <-- Here is where we double the keys array
    mark += inc                 #      to avoid falling off the end.

Ce qui précède donnerait:

XXX


3 commentaires

Putain de merde je t'aime pour tes connaissances !! C'était exactement ce dont j'avais besoin: D


Cela vous dérange-t-il d'expliquer cela? Désolé si c'est trop demander ... Je veux juste comprendre pourquoi tu as fait ce que tu as fait! @larsks


Je fais juste en sorte que le tableau keys ressemble à ["C", "C #", "D", "D #", "E", "F", "F #", "G", "G #", "A", "A #", "B", "C", "C #", "D", "D #", "E", "F", "F #", "G "," G # "," A "," A # "," B "] , de sorte que si vous commencez par, disons, D et montez sur une échelle majeure, vous pouvez aller passé B et continuez vers C # sans manquer d'éléments. Cela se produit dans l'expression (clés + clés) ; avec des listes, + ajoute les deux listes ensemble.