Anwendung: Musik | Informatik G23c

Das Python-Modul mingus ermöglicht Zugriff auf Musik-Theorie und -Notation und erlaubt es mit Python Musik-Anwendungen zu programmieren.

# Installation und Einstieg

Startaufgabe

Starte Thonny und installiere die Module mingus und pygame (siehe Thonny, Paketverwaltung)
Speichere die Datei PygameMidiSequencer.py (opens new window) in deinem Skriptverzeichnis ab.
Erstelle eine neue Datei test.py im selben Verzeichnis mit dem folgenden Code:

Code

from PygameMidiSequencer import PygameMidiSequencer
from time import sleep

from mingus.core import chords, progressions, intervals
from mingus.core.scales import NaturalMinor
from mingus.containers import NoteContainer, Note

pgs = PygameMidiSequencer()

# define and play 1 note
n = Note("C")
pgs.play_Note(n)
sleep(2)
pgs.stop_Note(n)
sleep(1)

# define and play 3 notes
nc = NoteContainer(["A", "C", "E"])
pgs.play_NoteContainer(nc)
sleep(2)
pgs.stop_NoteContainer(nc)
sleep(1)

# define progression and get chords in C
progression = ["I", "IV", "V7"]
my_chords = progressions.to_chords(progression, "C")

# play chords
for chord in my_chords:
    nc = NoteContainer(chord)
    pgs.play_NoteContainer(nc)
    sleep(1)
    pgs.stop_NoteContainer(nc)

# play single notes of chords
for chord in my_chords:
    c = NoteContainer(chord)
    for n in c:
        pgs.play_Note(n)
        sleep(0.2)
        pgs.stop_Note(n)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

Teste das Programm und schaue dir die einzelnen Teile an

# einzelne Noten

Details: http://bspaans.github.io/python-mingus/ (opens new window)

from PygameMidiSequencer import PygameMidiSequencer
from time import sleep

from mingus.containers import Note

pgs = PygameMidiSequencer()

n = Note("C")
pgs.play_Note(n)
sleep(2)
pgs.stop_Note(n)

1
2
3
4
5
6
7
8
9
10
11

# mehrere Noten

Sollen mehrere Noten gleichzeitig abgespielt werden oder notiert werden, dann verwendet man einen NoteContainer:

from PygameMidiSequencer import PygameMidiSequencer
from time import sleep

from mingus.containers import NoteContainer

pgs = PygameMidiSequencer()

nc = NoteContainer(["A", "C", "E"])
pgs.play_NoteContainer(nc)
sleep(2)
pgs.stop_NoteContainer(nc)

1
2
3
4
5
6
7
8
9
10
11

# Intervalle

http://bspaans.github.io/python-mingus/doc/wiki/tutorialIntervals.html (opens new window)

Im folgenden Beispiel wird eine A-Pentatonik als Liste aufgebaut, indem ausgehend vom Grundton die entsprechenden absoluten Intervalle hinzugefügt werden:

from PygameMidiSequencer import PygameMidiSequencer
from time import sleep
import random

from mingus.core import intervals
from mingus.containers import Note

pgs = PygameMidiSequencer()

pentatonic = []   # Minor pentatonic scale
base = "A"
pentatonic.append(base)
pentatonic.append(intervals.minor_third(base))
pentatonic.append(intervals.perfect_fourth(base))
pentatonic.append(intervals.perfect_fifth(base))
pentatonic.append(intervals.minor_seventh(base))

while True:
    n = Note(random.choice(pentatonic))
    print(n)
    pgs.play_Note(n)
    sleep(0.2)
    pgs.stop_Note(n)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Akkorde

Details: http://bspaans.github.io/python-mingus/doc/wiki/tutorialChords#get-chords-from-shorthand (opens new window)

Akkorde können verschieden generiert werden. Eine praktische Möglichkeit ist das Unterprogramm from_shorthand():

from PygameMidiSequencer import PygameMidiSequencer
from time import sleep

from mingus.containers import NoteContainer
from mingus.core import chords

pgs = PygameMidiSequencer()

chord1 = chords.from_shorthand("C")
print(chord1)
nc1 = NoteContainer(chord1)
pgs.play_NoteContainer(nc1)
sleep(1)
pgs.stop_NoteContainer(nc1)

chord2 = chords.from_shorthand("CM7")
print(chord2)
nc2 = NoteContainer(chord2)
pgs.play_NoteContainer(nc2)
sleep(1)
pgs.stop_NoteContainer(nc2)

chord3 = chords.from_shorthand("C7")
print(chord3)
nc3 = NoteContainer(chord3)
pgs.play_NoteContainer(nc3)
sleep(1)
pgs.stop_NoteContainer(nc3)

chord4 = chords.from_shorthand("F/C")
print(chord4)
nc4 = NoteContainer(chord4)
pgs.play_NoteContainer(nc4)
sleep(1)
pgs.stop_NoteContainer(nc4)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# Skalen

Details: http://bspaans.github.io/python-mingus/doc/wiki/refMingusCoreScales (opens new window)

from PygameMidiSequencer import PygameMidiSequencer
from time import sleep

from mingus.core import scales
from mingus.containers import Note

pgs = PygameMidiSequencer()

scale = scales.MelodicMinor("C")
print(scale)
notes = scale.ascending()
for note in notes:
    n = Note(note)
    print(n)
    pgs.play_Note(n)
    sleep(0.5)
    pgs.stop_Note(n)

notes = scale.descending()
for note in notes:
    n = Note(note)
    print(n)
    pgs.play_Note(n)
    sleep(0.5)
    pgs.stop_Note(n)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Klangfolgen

Details: http://bspaans.github.io/python-mingus/doc/wiki/tutorialChords#get-chords-from-shorthand (opens new window)

Klangfolgen können als Liste definiert werden und mit dem Unterprogramm to_chords() in einer gewünschten Tonart in Akkorde umgewandelt werden:

from PygameMidiSequencer import PygameMidiSequencer
from time import sleep

from mingus.core import chords, progressions
from mingus.containers import NoteContainer

pgs = PygameMidiSequencer()

progression = ["I", "vi", "ii", "V"]

my_chords = progressions.to_chords(progression, "C")
for chord in my_chords:
    print(chord)
    nc = NoteContainer(chord)
    pgs.play_NoteContainer(nc)
    sleep(1)
    pgs.stop_NoteContainer(nc)

sleep(2)

my_chords = progressions.to_chords(progression, "D")
for chord in my_chords:
    print(chord)
    nc = NoteContainer(chord)
    pgs.play_NoteContainer(nc)
    sleep(1)
    pgs.stop_NoteContainer(nc)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Ideen

Aufgabe «Projekt»

Schau dir die untenstehenden Ideen an und versuche eine davon umzusetzen. Gehe dabei schrittweise vor, so dass du immer wieder ein funktionsfähiges Programm hast, welches du ausbauen kannst. Dokumentiere dein Vorgehen. Vielleicht hast du ja eigene Ideen für ein kleines Projekt!

# Übungshilfe

Schreibe ein Programm, das eine Akkordfolge in einer bestimmten Tonart abspielt. Tonart und Akkorde sollten einach anpassbar sein.
In einem weiteren Schritt könnte man etwas Rythmus reinbringen und z.B. zuerste jeweils die Bassnote spielen, oder den Akkord als Arpeggio spielen.

# Improvisation

Schreibe ein Programm, das eine Akkordfolge (z.B. ein Bluesschema) spielt und dazu soliert, indem zufällige Noten aus einer passenden Skala (z.B. Pentatonik) gespielt werden.

← Einleitung Anwendung: BG →