Aufzeichnung der Höllenstunden, die Python-Anfängern auferlegt wurden

**【Charakter】 M: (= Mentor = ich in Kyoto) Kannst du es von Tokio aus sehen? F: (= Tokio-Student = Absolvent eines Python-Anfängerkurses) **

print("Sah")

Sah

M: Python hat viele Unterrichtsvideos und Nachschlagewerke, aber wenn Sie ein wenig stolpern, können Sie nicht weitermachen (es gibt), also ist es gut, sie zu verwenden, aber ich frage mich, ob Sie diesen Ort zusammen nutzen sollten.

**Erzählung: Dies ist eine Aufzeichnung von Einzelstunden in der Hölle der Python-Programmierung, die mit den Freigabefunktionen von Google Colaboratory durchgeführt wurden. Der Zweck besteht im Wesentlichen darin, das Programmieren zu lernen, aber als Geschichte wird ein tiefer Einblick in die musikalische Skala und die Akkorde entwickelt. ** ** **

M: Beispiel: Können Sie einen Graphen von y = sin (x) (0 ≤ x ≤ 4π) zeichnen?

Es ist eine nicht wesentliche Aufgabe, also werde ich sie auflösen. (Als eine Methode)

import numpy as np
#numpy ist eine numerische Berechnungsbibliothek, die etwas intelligenter als Mathematik ist und auch für Matrixoperationen verwendet werden kann.
#Da numpy ein langer Name ist, verwenden wir np, um die Verwendung zu vereinfachen.
import matplotlib.pyplot as plt
#Da ita von Anfang an nicht in colab enthalten ist, verwende ich eine Grafikbibliothek namens matplotlib.

x = np.arange(0, 4 * np.pi, 0.1)  #Von 0 bis 4π 0.Holen Sie sich 1-Schritt-Daten (wie ein Array).
y = np.sin(x)
plt.plot(x, y)

# Q:
print(x)

[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.   1.1  1.2  1.3
  1.4  1.5  1.6  1.7  1.8  1.9  2.   2.1  2.2  2.3  2.4  2.5  2.6  2.7
  2.8  2.9  3.   3.1  3.2  3.3  3.4  3.5  3.6  3.7  3.8  3.9  4.   4.1
  4.2  4.3  4.4  4.5  4.6  4.7  4.8  4.9  5.   5.1  5.2  5.3  5.4  5.5
  5.6  5.7  5.8  5.9  6.   6.1  6.2  6.3  6.4  6.5  6.6  6.7  6.8  6.9
  7.   7.1  7.2  7.3  7.4  7.5  7.6  7.7  7.8  7.9  8.   8.1  8.2  8.3
  8.4  8.5  8.6  8.7  8.8  8.9  9.   9.1  9.2  9.3  9.4  9.5  9.6  9.7
  9.8  9.9 10.  10.1 10.2 10.3 10.4 10.5 10.6 10.7 10.8 10.9 11.  11.1
 11.2 11.3 11.4 11.5 11.6 11.7 11.8 11.9 12.  12.1 12.2 12.3 12.4 12.5]

M: [Antwort 0001] => Gut! matplotlib.pyplot.plot () ist kein wirklich glatter Graph, Es ist wie eine Methode zum Verbinden von Koordinaten und Koordinaten mit Linien, dh zum Zeichnen eines "gefalteten Liniendiagramms". Wenn Sie das Häkchen von x erhöhen (z. B. 1), sieht es so aus. ↓

 x = np.arange(0, 4 * np.pi, 1)
 y = np.sin(x)
 print(x)
 plt.plot(x, y)

F: Ich verstehe.

M: [Ausgabe 0001] Der Graph der obigen Sinusfunktion Lassen Sie es uns beheben und den Zyklus halbieren. (Ändern Sie nicht den Definitionsbereich)

#　Q:[Antwort 0001]
x = np.arange(0, 4 * np.pi, 0.1)
y = np.sin(2 * x)
plt.plot(x, y)

M: [Problem 0002] Fügen wir dem ursprünglichen Diagramm von Aufgabe 0001 die Daten hinzu, die sowohl die Periode als auch die Amplitude halbiert haben.

#　Q:[Antwort 0002](WasistDatenaddition?IchdenkeesisteineÜberlagerung)
x = np.arange(0, 4 * np.pi, 0.1) 
y1 = np.sin(x)
y2 = 0.5 * (np.sin(2 * x))

y = y1 + y2
plt.plot(x, y)

M: [Problem 0003] In der ursprünglichen Grafik von Aufgabe 0001 Mehrere Perioden und Amplituden auf 1 / i eingestellt Fügen wir die Datenreihen hinzu. I ist jedoch eine ganze Zahl von 2 bis 9. Sobald Sie das getan haben, versuchen Sie, i auf 99 einzustellen.

#　M:[Antwort 0003] ①
#Plötzlich Hinweis
import numpy as np
import matplotlib.pyplot as plt 
x = np.arange(0, 4 * np.pi, 0.1) 
y = np.zeros(len(x)) 
#y ist eine Nullserie mit der gleichen Länge wie x
#len steht für Länge
print(y) 
#Hier haben wir 9 Serien in y
#Sie sollten sie nicht der Reihe nach hinzufügen.
#(Es gibt verschiedene Methoden)

for i in range(1,10):
  y_temp = (np.sin(i * x)) / i
  y += y_temp


plt.plot(x, y)

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
 0. 0. 0. 0. 0. 0.]
![output_18_1.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/216556/a4797ca9-5a0f-e2c9-9bdb-2487cfec49b9.png)

#　Q:[Antwort 0003] ②
y2 = np.zeros(len(x))　#= Zeile später hinzugefügt
for i in range(1,100):
  y_temp = (np.sin(i * x)) / i
  y2 += y_temp

plt.plot(x, y2)

M: Hmm, wunderbar! Oh warte eine Minute! ② ist bedauerlich! Wenn Sie y vor der Schleife nicht mit Null initialisieren, wird das Ergebnis von ① vererbt! Weil die Amplitude zu groß ist! Ist es übrigens nicht möglich, auf y_temp zu verzichten? Also lasst uns nur ② reparieren.

Und wenn du das kannst [Problem 0004] Versuchen wir in Aufgabe 0003② i nur mit ungeraden Zahlen! F: Wirklich, ② korrigiert! Sie können es sicherlich ohne y_temp tun! Ich frage mich, ob es zur Geschichte der Fourier-Transformation führen wird. Ich habe es in Physik oder Mathematik gemacht!

#　Q:[Antwort 0004]
y_0004 = np.zeros(len(x))
for i in range(1,100, 2):
  y_0004 += (np.sin(i * x)) / i

plt.plot(x, y_0004)

M: Es führt zu Physik, Mathematik und Musik. Wenn der Grundton do ist, ist die 2. Harmonische eine Oktave höher do, die 3. Harmonische ist eine obere, die 4. Harmonische ist eine 2 Oktave höher do, und die 5. Harmonische ist eine obere mi, dh der konstituierende Klang des C-Dur-Akkords. (Andere Werte sind jedoch ungefähre Werte.) Wenn Sie auf einer Gitarre Harmonische an der 12. Bundposition spielen, erhalten Sie 2. Harmonische, und wenn Sie sich an der 7. Bundposition befinden, erhalten Sie 3. Harmonische, und wenn Sie sich an der 5. Bundposition befinden, erhalten Sie 4. Harmonische. (Tut der Entertainer am 7. Bund etwas?) Tatsächlich liegt der Klang der Gitarre nahe an der gezackten Welle (Aufgabe 0003). Wenn Sie also eine offene Saite normal spielen, klingt sie mit Harmonischen, die ganzzahlige Vielfache sind. Die gezackte Welle kommt der harmonischen Komposition vieler Musikinstrumente wie Violinen und Trompeten außer Gitarren nahe. Andererseits wird die Rechteckwelle (Problem 0004), dh die Wellenform mit vielen ungeraden Harmonischen, zum Ton von Holzröhreninstrumenten wie Blockflöten, Flöten und Oboen. Wellenformen mit ungeraden Harmonischen umfassen nicht nur rechteckige Wellen, sondern auch dreieckige Wellen. https://ja.wikipedia.org/wiki/%E4%B8%89%E8%A7%92%E6%B3%A2_(%E6%B3%A2%E5%BD%A2)
Im Allgemeinen hat eine Wellenform mit nur ungeraden Harmonischen einen symmetrischen Halbzyklus.

M: [Ausgabe 0005] Unter der Annahme, dass die x-Koordinate der Gitarrenmutter 0 und die x-Koordinate der Brücke 1 ist, ist die x-Koordinate jedes Bundes

• 12 Bünde: 1/2,
• 24 Bünde: 1 - ((1/2) Quadrat) = 3/4 (obwohl es keine 24 Bünde gibt)
• 1 Bund: 1 - ((1/2) 12 Wurzel)
• 2 Bünde: 1 - (((1/2) 12 Wurzel) im Quadrat)

Und so weiter. (... Ist es wahr?)

Das folgende Programm sollte die Position von der Gitarrenmutter bis zum 12. Bund darstellen (die y-Koordinate ist auf 0 festgelegt). A und x werden falsch berechnet und die Bünde sind gleichmäßig verteilt.

① Können Sie die Bundposition wie in der Realität festlegen?

(2) Sollte die in der Nähe des 7. Bundes verwendete Oberschwingungsspielmethode leicht zur Mutterseite oder zur Brückenseite verschoben werden?

# M:
import numpy as np
import matplotlib.pyplot as plt
 
a = 1 / 12
n = 13
x = [1 - a * i for i in range(n)] 
y = [0] * n 
print(x)
plt.plot(x, y, "o")

[1.0, 0.9166666666666666, 0.8333333333333334, 0.75, 0.6666666666666667, 0.5833333333333334, 0.5, 0.41666666666666674, 0.33333333333333337, 0.25, 0.16666666666666674, 0.08333333333333337, 0.0]

# Q:
import numpy as np
import matplotlib.pyplot as plt
 
a = (1/2)**(1 / 12)
n = 13
x = [1 - a ** i for i in range(n)] 
y = [0] * n 
print(x)
plt.plot(x, y, "o")

[0.0, 0.05612568731830647, 0.10910128185966061, 0.1591035847462854, 0.2062994740159002, 0.25084646156165913, 0.2928932188134523, 0.3325800729149827, 0.3700394750525633, 0.40539644249863926, 0.43876897584531327, 0.4702684528203521, 0.4999999999999998]

s: Die 3. Harmonische wird erzeugt durch x = 0,333 ... Andererseits ist die Position des 7. Bundes x = 0,3325 ... Daher sollte es leicht zur Brückenseite verschoben werden. M: Sehr gut gemacht! Warum ist der 7. Bund nicht genau 1/3 der Länge der Saite?

Die Antwort lautet: "Dafür gibt es keinen Grund."

Die Position des 7. Bunds 1- (1/2) ** (7/12) ist wahrscheinlich eine unvernünftige Zahl (das heißt, es ist nicht 1/3), nicht wahr?

Wahrscheinlich kein Beweis dafür, dass es 1/3 sein wird.

War es historisch gesehen die Zeit von Herrn Bach? Um die Musik frei zu transponieren, war es notwendig, die Frequenz der Skala als Sequenz mit gleichem Verhältnis zu gestalten.

Das heißt, das Verhältnis benachbarter Frequenzen wird konstant gemacht. Do: Do # = Do #: Les = Les: Les # = ・ ・ ・ Als ich dann zufällig eine Oktave in 12 Sequenzen mit gleichem Verhältnis teilte (dies wird als Durchschnittsgesetz bezeichnet), bemerkte ich, dass es an einigen Stellen einige angenehme Tonhöhen gab.

Zum Beispiel fühlt sich Domiso gut (in Harmonie), wenn er zusammen gespielt wird. Bei näherer Betrachtung betrug das Frequenzverhältnis von Domiso "ungefähr" 4: 5: 6.

Andererseits gibt es auch ein Tondesign, das das Domiso zwangsweise zu einem engen Verhältnis (dh einer rationalen Zahl) wie 4: 5: 6 macht, und dies wird als "echter Ton" bezeichnet. (Die Wurzeln sind Mr. Pitagoras.) Im echten Ton wird es jedoch selten verwendet, da beim Wechseln (oder Anbringen eines Kapodasters) eine Neuabstimmung erforderlich ist.

M: [Problem 0006] Implementieren wir eine Funktion sin_wave, die beliebige Sinuswellendaten erzeugt, indem jeweils Frequenz, Amplitude, Anzahl der Sekunden und minimales Datenintervall angegeben werden. (Die Funktion hier ist keine mathematische Funktion, die y aus x findet.)

# M:
import numpy as np
import matplotlib.pyplot as plt

def sin_wave(frequency, amplitude, duration, tick):
    # sine_wave:Eine Funktion, die beliebige Sinuswellendaten erzeugt
    #   frequency:Frequenz(Hz),  
    #   amplitude:Amplitude(V,Das heißt, Bolzen), 
    #   duration :Anzahl der Sekunden von Daten, 
    #   tick     :Minimales Datenintervall(Sekunden), 

    #Hier umsetzen.
    # s:
    x = np.arange(0, duration, tick)
    y = amplitude * (np.sin(2 * np.pi * x * frequency))

    return x, y

x, y = sin_wave(frequency=10, amplitude=3, duration=2, tick=0.01)
plt.plot(x, y)

M: Herausforderung 0006 = Meistens gut!

Im Allgemeinen sollten Berechnungen, die zu Konstanten führen, aus der Schleife genommen werden. Wenn Sie beispielsweise die Frequenz 2 * np.pi * x [i] * in einer for-Schleife verwenden möchten, die i dreht

npf = 2 * np.pi *  frequency
for i in range(0,duration,tick):
    y[i] = amplitude * (np.sin(npf * x[i]))

Es wird schneller sein.

Im Fall der Verwendung der Vektoroperation von numpy ohne Verwendung für diese Zeit kann sich die Geschwindigkeit jedoch nicht wesentlich ändern, wenn die Implementierung von numpy intelligent ist.

M: [Problem 0007] Zeichnen Sie mit der Funktion sin_wave die drei konstituierenden Klänge der Grundform des Hauptakkords von A und insgesamt vier Reihen, die sie in verschiedenen Farbgraphen überlagern (der Farbparameter des Diagramms ist "r"). Machen wir es "," g "," b "," k ") und zeichnen es auf ein Koordinatensystem.

Die Zeit beträgt jedoch 0,02 Sekunden, das minimale Datenintervall beträgt 1 / 10.000 Sekunden, die Frequenz des Grundtons von A beträgt 220 Hz und die Amplitude der konstituierenden Töne beträgt 1 V.

F: Ich habe es intuitiv gemacht </ font>

# Q:
x, y1 = sin_wave(frequency=220, amplitude=1, duration=0.02, tick=0.0001)
plt.plot(x, y1, color="r")
x, y2 = sin_wave(frequency=220*2**(1/3), amplitude=1, duration=0.02, tick=0.0001)
plt.plot(x, y2, color="g")
x, y3 = sin_wave(frequency=220*2**(7/12), amplitude=1, duration=0.02, tick=0.0001)
plt.plot(x, y3, color="b")

plt.plot(x, y1+y2+y3, color="k")

# M:Antwortbeispiel
plt.figure(figsize=(40, 10), dpi=72)
root = 2 ** (1 / 12)
for i, s in enumerate([[0, "r"], [4, "g"], [7, "b"]]):
    x, y = sin_wave(220 * (root ** s[0]), 1, 0.05, 0.0001)
    plt.plot(x, y, color=s[1], lw=2)
    y_sum = y if i == 0 else y_sum + y
plt.plot(x, y_sum, color="k", lw=5)
plt.plot([0, 0.05], [0, 0], color="k")

# Q:
plt.figure(figsize=(40, 10), dpi=72)
for i, s in enumerate([[1, "r"], [1.25, "g"], [1.5, "b"]]):
    x, y = sin_wave(220 * (s[0]), 1, 0.05, 0.0001)
    plt.plot(x, y, color=s[1], lw=2)
    y_sum = y if i == 0 else y_sum + y
plt.plot(x, y_sum, color="k", lw=5)
#y = [0] * len(x)
#plt.plot(x, y, color="k")
plt.plot([0, 0.05], [0, 0], color="k")