diff --git a/BeispielDatenPGP2a.txt b/BeispielDatenPGP2a.txt deleted file mode 100644 index 39472ae..0000000 --- a/BeispielDatenPGP2a.txt +++ /dev/null @@ -1,14 +0,0 @@ -Messwertnummer Hallspannung UH Probenspannung Up Probenstrom Ip Probentemperatur Tp Flussdichte B -n/# UH/mV Up/V Ip/mA Tp/°C B/T - -1 -9,9 -2,73 -53 24,0 -0,006864 -2 -6,6 -2,03 -40 24,0 -0,006927 -3 -4,7 -1,51 -29 24,1 -0,006867 -4 -3,4 -1,09 -21 24,1 -0,006842 -5 -1,8 -0,57 -11 23,8 -0,006892 -6 -0,2 -0,04 -1 24,1 -0,006860 -7 0,9 0,52 10 24,0 -0,006849 -8 2,2 1,09 22 24,0 -0,006892 -9 3,3 1,62 32 24,1 -0,006869 -10 4,3 2,15 42 24,2 -0,006851 -11 6,3 2,55 50 24,3 -0,006860 diff --git a/Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb b/Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb index ecc1c71..286550c 100755 --- a/Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb +++ b/Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb @@ -1343,669 +1343,6 @@ "source": [ "Wie ihr sehen könnt konnten wir mit Hilfe der Startwerte den Fit so beeinflussen, dass curve_fit dieses mal das \"richtige\" Minimum finden konnte. Daher empfehle ich euch bei komplexeren Problem sich immer erst die Messdaten an zugucken und ein paar Startwerte für den Fit zu raten/schätzen. " ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Zusatz: Arbeiten mit Numpy-Arrays: \n", - "\n", - "In den obigen Beispielen haben wir oftmals viele Zeilen Code definieren müssen bevor wir etwas berechnen konnten. Viele der von uns definierten Funktionen existieren bereits und sind in anderen Packages enthalten. Ein sehr nützliches Package, ist dass das **Numpy**-Package. Hierbei sind insbesondere die **Numpy-arrays** eine tolle Sache, welche viele Prozesse vereinfacht. Im nachfolgenden möchte ich euch anhand der Beispielaufgabe noch zeigen, wie Numpy-arrays funktionieren. Sofern ihr mehr lernen möchtet gibt es viele Turotials zu Numpy im Internet bzw. auf Youtube." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.386308Z", - "start_time": "2019-10-26T11:51:01.376046Z" - } - }, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.419390Z", - "start_time": "2019-10-26T11:51:01.393231Z" - } - }, - "outputs": [], - "source": [ - "h = np.array([0.095, 0.112, 0.134, 0.148, 0.17, 0.188, 0.21, 0.235, 0.25, 0.276]) # [m]\n", - "t = np.array([[2.65, 2.4, 2.17, 2.06, 1.91, 1.8, 1.68, 1.6, 1.52, 1.46], # Messwerte 1 [s]\n", - " [2710, 2360, 2190, 2060, 1900, 1780, 1690, 1690, 1530, 1440], # Messwerte 2 [ms]\n", - " [2.66, 2.36, 2.19, 2.06, 1.9, 1.8, 1.68, 1.59, 1.52, 1.44]]) # Messwerte 3 [s]\n", - "delta_t = np.array([0.1]*len(h)) # [s]\n", - "delta_h = np.array([5]*len(h)) # [mm]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Das Arbeiten mit Numpy-arrays funktioniert ähnlich wie mit Listen, d.h. das Slicing ist das Gleich:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.449147Z", - "start_time": "2019-10-26T11:51:01.427515Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2 2\n", - "[3, 4, 5] [3 4 5]\n" - ] - } - ], - "source": [ - "l = [1,2,3,4,5,6]\n", - "a = np.array([1,2,3,4,5,6])\n", - "\n", - "print(l[1], a[1])\n", - "print(l[2:5], a[2:5])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Oder unsere Zeitdaten, welche wir als eine Matrix gespeichert haben:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.464975Z", - "start_time": "2019-10-26T11:51:01.451057Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[2.65e+00, 2.40e+00, 2.17e+00, 2.06e+00, 1.91e+00, 1.80e+00,\n", - " 1.68e+00, 1.60e+00, 1.52e+00, 1.46e+00],\n", - " [2.71e+03, 2.36e+03, 2.19e+03, 2.06e+03, 1.90e+03, 1.78e+03,\n", - " 1.69e+03, 1.69e+03, 1.53e+03, 1.44e+03],\n", - " [2.66e+00, 2.36e+00, 2.19e+00, 2.06e+00, 1.90e+00, 1.80e+00,\n", - " 1.68e+00, 1.59e+00, 1.52e+00, 1.44e+00]])" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.480589Z", - "start_time": "2019-10-26T11:51:01.467966Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([2.17, 2.06])" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t[0][2:4] # <-- Erste spalte, die Werte 2 bis 4" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Jedoch ist die große Stärke von Numpy-arrays, dass diese sich ähnlich wie Vektoren bzw. Matrizen verhalten. Zum Beispiel beim multiplizieren von einem \"Vektor\" mit einem Skala:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.496039Z", - "start_time": "2019-10-26T11:51:01.483657Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005,\n", - " 0.005])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "delta_h = delta_h * 10**(-3) # wir hatten delta_h in mm definiert und hier wandeln wir es in m um.\n", - "delta_h" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Das gleiche gilt für Matrizen:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.528955Z", - "start_time": "2019-10-26T11:51:01.500058Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[2.65e+00, 2.40e+00, 2.17e+00, 2.06e+00, 1.91e+00, 1.80e+00,\n", - " 1.68e+00, 1.60e+00, 1.52e+00, 1.46e+00],\n", - " [2.71e+03, 2.36e+03, 2.19e+03, 2.06e+03, 1.90e+03, 1.78e+03,\n", - " 1.69e+03, 1.69e+03, 1.53e+03, 1.44e+03],\n", - " [2.66e+00, 2.36e+00, 2.19e+00, 2.06e+00, 1.90e+00, 1.80e+00,\n", - " 1.68e+00, 1.59e+00, 1.52e+00, 1.44e+00]])" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t # <-- Spalte 2 hatte ich in ms definiert ..." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.544328Z", - "start_time": "2019-10-26T11:51:01.531697Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[2.65, 2.4 , 2.17, 2.06, 1.91, 1.8 , 1.68, 1.6 , 1.52, 1.46],\n", - " [2.71, 2.36, 2.19, 2.06, 1.9 , 1.78, 1.69, 1.69, 1.53, 1.44],\n", - " [2.66, 2.36, 2.19, 2.06, 1.9 , 1.8 , 1.68, 1.59, 1.52, 1.44]])" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t[1] = t[1] * 10**(-3) #... wir wollen aber s\n", - "t" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Natürlich können wir auch zwei \"Vektoren\"/arrays mit gleicher länge miteinander Multiplizieren oder addieren:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.576225Z", - "start_time": "2019-10-26T11:51:01.550197Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3, 6, 9])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.array([1,2,3]) * np.array([3,3,3]) # Etwas anders als in der Mathematik, \n", - " # hier bekommt ihr kein Skala sondern \n", - " # nur die Produkte der Einträge" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.591616Z", - "start_time": "2019-10-26T11:51:01.579409Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([4, 5, 6])" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.array([1,2,3]) + np.array([3,3,3]) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Diese nützlichen Features der arrays lassen uns Funktionen viel einfacher definieren und anwenden. Anstatt " - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.606751Z", - "start_time": "2019-10-26T11:51:01.596368Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.0907004206977808,\n", - " 0.11507952238214755,\n", - " 0.13598012562087386,\n", - " 0.15274995390312052,\n", - " 0.17893109576554916,\n", - " 0.20155495845308732,\n", - " 0.22875746846189743,\n", - " 0.24497309776645806,\n", - " 0.2793351818514591,\n", - " 0.30972665269221794]" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "result = []\n", - "for time in t_mean:\n", - " result.append(fallhoehe(time, 9.81))\n", - "result" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Können wir ganz einfach schreiben:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.622410Z", - "start_time": "2019-10-26T11:51:01.612577Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.09070042, 0.11507952, 0.13598013, 0.15274995, 0.1789311 ,\n", - " 0.20155496, 0.22875747, 0.2449731 , 0.27933518, 0.30972665])" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t_mean = np.array(t_mean) # <-- erst müssen wir natürlich unsere liste\n", - " # in ein array umwandeln\n", - "\n", - "fallhoehe(t_mean, 9.81)\n", - "# Was equivalent ist zu einem Produkt zwischen einem \"Skala\" und einem \"Vetor\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Es gibt auch andere tolle Funktionen die mit dem numpy-Package kommen. Zum Beispiel eine Funktion für den Mittelwert und die Standardabweichung: " - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.637953Z", - "start_time": "2019-10-26T11:51:01.628234Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.5 1.118033988749895\n" - ] - } - ], - "source": [ - "a = np.array([1,2,3,4])\n", - "print(np.mean(a), np.std(a))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Erinnert ihr euch, dass wir dieses mal die Zeitwerte als eine Art n x m Matrix gespeichert haben (wobei n=3 und m=10)? `np.mean` und `np.std` erlauben euch das errechnen von den Werten entlang einer Bestimmten \"Achse\" eures arrays:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.652909Z", - "start_time": "2019-10-26T11:51:01.642746Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1.9266666666666665" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.mean(t) # <-- gibt den Mittelwert über alle Werte" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.668197Z", - "start_time": "2019-10-26T11:51:01.659999Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2.67333333 2.37333333 2.18333333 2.06 1.90333333 1.79333333\n", - " 1.68333333 1.62666667 1.52333333 1.44666667] [2.67333333 2.37333333 2.18333333 2.06 1.90333333 1.79333333\n", - " 1.68333333 1.62666667 1.52333333 1.44666667]\n" - ] - } - ], - "source": [ - "t_mean_array = np.mean(t, axis=0) # <-- Mittelwert entlang der ersten n-achse \n", - "print(t_mean, t_mean_array)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.683366Z", - "start_time": "2019-10-26T11:51:01.675594Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.925, 1.935, 1.92 ])" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.mean(t, axis=1) # <-- Mittelwert entlang der m-achse" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Das gleiche können wir für unsere Standardabweichung machen:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.698582Z", - "start_time": "2019-10-26T11:51:01.687401Z" - } - }, - "outputs": [], - "source": [ - "t_std_array = np.std(t, axis=0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Der Part über das fitten bleibt unverändert, jedoch können wir im Anschluss auch unser $\\chi^2$ wieder einfacher berechnen: " - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:01.730408Z", - "start_time": "2019-10-26T11:51:01.701959Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "21.616487152931544 21.616487152931523\n" - ] - } - ], - "source": [ - "chi_array = np.sum( (fallhoehe(t_mean_array, parameter[0]) - h)**2/delta_h**2)\n", - "print(chi_array, chi)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Beim plotten selbst können wir noch die Funktion `np.arange` nutzen um uns das Leben etwas zu erleichtern. Im obigen Beispiel hatte ich unsere Fitfunktion mittels der `range`-Funktion geplottet." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:02.292584Z", - "start_time": "2019-10-26T11:51:01.732446Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "time = [i/10 for i in range(1,30)] #<-- Erstellen von Zeitwerten zwischen 0.1 und 3 in 0.1 Schritten \n", - " # um eine glatte Kurve zu plotten.\n", - "plt.plot(time, \n", - " [fallhoehe(t, parameter[0]) for t in time],\n", - " label=f'Fitparamter:\\ng: ({parameter[0]:.2f}+/-{(covariance_matrix[0][0])**(1/2):.2f}) m/s$^2$\\n'\n", - " f'$\\chi^2/$ndof: {chi:.0f}/{ndof}')\n", - "\n", - "plt.xlim(1.4, 2.7)\n", - "plt.ylim(0, 0.4)\n", - "plt.grid()\n", - "plt.xlabel('Gemessene Rollzeit $t$ [s]', fontsize=10)\n", - "plt.ylabel('Starthöhe $h$ [m]', fontsize=10)\n", - "plt.legend(fontsize=10)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Mit `np.arange` geht dies einfacher: " - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:02.810212Z", - "start_time": "2019-10-26T11:51:02.295731Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "time_array = np.arange(0.1,3,0.1)\n", - "plt.plot(time, \n", - " [fallhoehe(t, parameter[0]) for t in time],\n", - " label=f'Fitparamter:\\ng: ({parameter[0]:.2f}+/-{(covariance_matrix[0][0])**(1/2):.2f}) m/s$^2$\\n'\n", - " f'$\\chi^2/$ndof: {chi:.0f}/{ndof}')\n", - "\n", - "plt.xlim(1.4, 2.7)\n", - "plt.ylim(0, 0.4)\n", - "plt.grid()\n", - "plt.xlabel('Gemessene Rollzeit $t$ [s]', fontsize=10)\n", - "plt.ylabel('Starthöhe $h$ [m]', fontsize=10)\n", - "plt.legend(fontsize=10)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-26T11:51:02.825450Z", - "start_time": "2019-10-26T11:51:02.812329Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9] [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\n", - " 1.9 2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9]\n" - ] - } - ], - "source": [ - "print(time, time_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Ich hoffe der Zusatz hilft euch. Viel Spaß im PGP!" - ] } ], "metadata": { @@ -2013,6 +1350,18 @@ "display_name": "Python 3", "language": "python", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" } }, "nbformat": 4, diff --git a/Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten__Zusatz_.ipynb b/Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten_Zusatz.ipynb similarity index 67% rename from Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten__Zusatz_.ipynb rename to Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten_Zusatz.ipynb index d073454..5ba10f7 100644 --- a/Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten__Zusatz_.ipynb +++ b/Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten_Zusatz.ipynb @@ -39,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2019-10-03T10:04:09.176914Z", @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2019-10-03T10:05:45.212389Z", @@ -66,11 +66,11 @@ "evalue": "Some errors were detected !\n Line #2 (got 1 columns instead of 11)\n Line #4 (got 6 columns instead of 11)\n Line #5 (got 6 columns instead of 11)\n Line #6 (got 6 columns instead of 11)\n Line #7 (got 6 columns instead of 11)\n Line #8 (got 6 columns instead of 11)\n Line #9 (got 6 columns instead of 11)\n Line #10 (got 6 columns instead of 11)\n Line #11 (got 6 columns instead of 11)\n Line #12 (got 6 columns instead of 11)\n Line #13 (got 6 columns instead of 11)\n Line #14 (got 6 columns instead of 11)", "output_type": "error", "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;31m# Notebook befindet reicht es den Dateinamen anzuegebn. Ansonsten\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m# müsst ihr den gesamten Pfad angeben.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgenfromtxt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpfad\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# <-- Einlesen der txt-Datei\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\site-packages\\numpy\\lib\\npyio.py\u001b[0m in \u001b[0;36mgenfromtxt\u001b[1;34m(fname, dtype, comments, delimiter, skip_header, skip_footer, converters, missing_values, filling_values, usecols, names, excludelist, deletechars, replace_space, autostrip, case_sensitive, defaultfmt, unpack, usemask, loose, invalid_raise, max_rows, encoding)\u001b[0m\n\u001b[0;32m 2073\u001b[0m \u001b[1;31m# Raise an exception ?\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2074\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0minvalid_raise\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2075\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0merrmsg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2076\u001b[0m \u001b[1;31m# Issue a warning ?\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2077\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mValueError\u001b[0m: Some errors were detected !\n Line #2 (got 1 columns instead of 11)\n Line #4 (got 6 columns instead of 11)\n Line #5 (got 6 columns instead of 11)\n Line #6 (got 6 columns instead of 11)\n Line #7 (got 6 columns instead of 11)\n Line #8 (got 6 columns instead of 11)\n Line #9 (got 6 columns instead of 11)\n Line #10 (got 6 columns instead of 11)\n Line #11 (got 6 columns instead of 11)\n Line #12 (got 6 columns instead of 11)\n Line #13 (got 6 columns instead of 11)\n Line #14 (got 6 columns instead of 11)" + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m# Notebook befindet reicht es den Dateinamen anzuegebn. Ansonsten\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# müsst ihr den gesamten Pfad angeben.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenfromtxt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpfad\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# <-- Einlesen der txt-Datei\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/numpy/lib/npyio.py\u001b[0m in \u001b[0;36mgenfromtxt\u001b[0;34m(fname, dtype, comments, delimiter, skip_header, skip_footer, converters, missing_values, filling_values, usecols, names, excludelist, deletechars, replace_space, autostrip, case_sensitive, defaultfmt, unpack, usemask, loose, invalid_raise, max_rows, encoding)\u001b[0m\n\u001b[1;32m 2101\u001b[0m \u001b[0;31m# Raise an exception ?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2102\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0minvalid_raise\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2103\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merrmsg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2104\u001b[0m \u001b[0;31m# Issue a warning ?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2105\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Some errors were detected !\n Line #2 (got 1 columns instead of 11)\n Line #4 (got 6 columns instead of 11)\n Line #5 (got 6 columns instead of 11)\n Line #6 (got 6 columns instead of 11)\n Line #7 (got 6 columns instead of 11)\n Line #8 (got 6 columns instead of 11)\n Line #9 (got 6 columns instead of 11)\n Line #10 (got 6 columns instead of 11)\n Line #11 (got 6 columns instead of 11)\n Line #12 (got 6 columns instead of 11)\n Line #13 (got 6 columns instead of 11)\n Line #14 (got 6 columns instead of 11)" ] } ], @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2019-10-03T10:28:02.193780Z", @@ -114,7 +114,7 @@ " [ 11., nan, nan, 50., nan, nan]])" ] }, - "execution_count": 27, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -163,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2019-10-03T10:39:26.259305Z", @@ -187,7 +187,7 @@ " [ 11. , 6.3, nan, 50. , nan, nan]])" ] }, - "execution_count": 25, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -208,7 +208,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2019-10-03T10:59:09.375845Z", @@ -243,7 +243,7 @@ " -6.860e-03]])" ] }, - "execution_count": 21, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -263,12 +263,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Ihr könnt sehen wir haben alle Messwerte erfolgreich eingelesen auch wenn diese hier etwas gewöhnungsbedürftig in einer scientific-Schreibweise angegeben sind. Bei dieser Schreibweise steht z.B. 3.2e+01 für $3.2 \\cdot 10^1$. Jetzt können wir wie gewohnt damit Arbeiten:" + "Ihr könnt sehen wir haben alle Messwerte erfolgreich eingelesen auch wenn diese hier etwas gewöhnungsbedürftig in einer scientific-Schreibweise angegeben sind. Bei dieser Schreibweise steht z.B. 3.2e+01 für $3.2 \\cdot 10^1$. \n", + "\n", + "Außerdem sind unsere Daten nicht in Form einer Liste sondern in sogennanten nump arrays abgespeichert. Mit diesen Arrays können wir wie gewohnt Arbeiten und noch mehr:" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2019-10-03T11:08:26.231136Z", @@ -287,6 +289,13 @@ "# wordurch ihr die jweiligen Spalten als Zeilen bekommt." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mehr zu numpy arrays erfahrt ihr etwas weiter unten in diesem Notebook." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -371,13 +380,557 @@ " Hallspannung.append(hallspannung)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zusatz: Arbeiten mit Numpy-Arrays: \n", + "\n", + "In unseren Aufgaben haben oftmals viele Zeilen Code definieren müssen bevor wir etwas berechnen konnten. Viele der von uns definierten Funktionen existieren bereits und sind in anderen Packages enthalten. Ein sehr nützliches Package, ist dass das **Numpy**-Package. Hierbei sind insbesondere die **Numpy-arrays** eine tolle Sache, welche viele Prozesse vereinfacht. Im nachfolgenden möchte ich euch anhand der Beispielaufgabe noch zeigen, wie Numpy-arrays funktionieren. Sofern ihr mehr lernen möchtet gibt es viele Turotials zu Numpy im Internet bzw. auf Youtube." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Dies sind die gleichen Messdaten wie in dem Beispiel zum fitten der Schiefenebene in \n", + "# Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb\n", + "h = np.array([0.095, 0.112, 0.134, 0.148, 0.17, 0.188, 0.21, 0.235, 0.25, 0.276]) # [m]\n", + "t = np.array([[2.65, 2.4, 2.17, 2.06, 1.91, 1.8, 1.68, 1.6, 1.52, 1.46], # Messwerte 1 [s]\n", + " [2710, 2360, 2190, 2060, 1900, 1780, 1690, 1690, 1530, 1440], # Messwerte 2 [ms]\n", + " [2.66, 2.36, 2.19, 2.06, 1.9, 1.8, 1.68, 1.59, 1.52, 1.44]]) # Messwerte 3 [s]\n", + "delta_t = np.array([0.1]*len(h)) # [s]\n", + "delta_h = np.array([5]*len(h)) # [mm]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das Arbeiten mit Numpy-arrays funktioniert ähnlich wie mit Listen, d.h. das Slicing ist das Gleich:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2 2\n", + "[3, 4, 5] [3 4 5]\n" + ] + } + ], + "source": [ + "l = [1,2,3,4,5,6]\n", + "a = np.array([1,2,3,4,5,6])\n", + "\n", + "print(l[1], a[1])\n", + "print(l[2:5], a[2:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Oder unsere Zeitdaten, welche wir als eine Matrix gespeichert haben:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2.65e+00, 2.40e+00, 2.17e+00, 2.06e+00, 1.91e+00, 1.80e+00,\n", + " 1.68e+00, 1.60e+00, 1.52e+00, 1.46e+00],\n", + " [2.71e+03, 2.36e+03, 2.19e+03, 2.06e+03, 1.90e+03, 1.78e+03,\n", + " 1.69e+03, 1.69e+03, 1.53e+03, 1.44e+03],\n", + " [2.66e+00, 2.36e+00, 2.19e+00, 2.06e+00, 1.90e+00, 1.80e+00,\n", + " 1.68e+00, 1.59e+00, 1.52e+00, 1.44e+00]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2.17, 2.06])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t[0, 2:4] # <-- Erste spalte, die Werte 2 bis 4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Jedoch ist die große Stärke von Numpy-arrays, dass diese sich ähnlich wie Vektoren bzw. Matrizen verhalten. Zum Beispiel beim multiplizieren von einem \"Vektor\" mit einem Skala:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([5.e-06, 5.e-06, 5.e-06, 5.e-06, 5.e-06, 5.e-06, 5.e-06, 5.e-06,\n", + " 5.e-06, 5.e-06])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Mit listen hätte das ganze so ausgesehen:\n", + "delta_h_liste = [dh * 10**(-3) for dh in delta_h]\n", + "\n", + "# Jetzt können wir einfach schreiben:\n", + "delta_h = delta_h * 10**(-3) # wir hatten delta_h in mm definiert und hier wandeln wir es in m um.\n", + "delta_h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das gleiche gilt für Matrizen:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2.65e+00, 2.40e+00, 2.17e+00, 2.06e+00, 1.91e+00, 1.80e+00,\n", + " 1.68e+00, 1.60e+00, 1.52e+00, 1.46e+00],\n", + " [2.71e+03, 2.36e+03, 2.19e+03, 2.06e+03, 1.90e+03, 1.78e+03,\n", + " 1.69e+03, 1.69e+03, 1.53e+03, 1.44e+03],\n", + " [2.66e+00, 2.36e+00, 2.19e+00, 2.06e+00, 1.90e+00, 1.80e+00,\n", + " 1.68e+00, 1.59e+00, 1.52e+00, 1.44e+00]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t # <-- Spalte 2 hatte ich in ms definiert ..." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2.65, 2.4 , 2.17, 2.06, 1.91, 1.8 , 1.68, 1.6 , 1.52, 1.46],\n", + " [2.71, 2.36, 2.19, 2.06, 1.9 , 1.78, 1.69, 1.69, 1.53, 1.44],\n", + " [2.66, 2.36, 2.19, 2.06, 1.9 , 1.8 , 1.68, 1.59, 1.52, 1.44]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t[1] = t[1] * 10**(-3) #... wir wollen aber s\n", + "t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Natürlich können wir auch zwei \"Vektoren\"/arrays mit gleicher länge miteinander Multiplizieren oder addieren:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3, 6, 9])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([1,2,3]) * np.array([3,3,3]) # Etwas anders als in der Mathematik, \n", + " # hier bekommt ihr kein Skalar sondern \n", + " # nur die Produkte der Einträge" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4, 5, 6])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([1,2,3]) + np.array([3,3,3]) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Oder auch die einzelnen Einträge quadrieren:" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 4, 9])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([1, 2, 3])**2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Diese nützlichen Features der arrays lassen uns Funktionen viel einfacher definieren und anwenden. Anstatt " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def fallhoehe(t, g):\n", + " return 0.5 * g * t**2" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[34.4453625,\n", + " 28.2528,\n", + " 23.097154500000002,\n", + " 20.814858,\n", + " 17.8939305,\n", + " 15.892200000000003,\n", + " 13.843872,\n", + " 12.556800000000003,\n", + " 11.332512000000001,\n", + " 10.455497999999999]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result = []\n", + "t_spalte1 = t[0]\n", + "for time in t_spalte1:\n", + " result.append(fallhoehe(time, 9.81))\n", + "result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Können wir ganz einfach schreiben:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([34.4453625, 28.2528 , 23.0971545, 20.814858 , 17.8939305,\n", + " 15.8922 , 13.843872 , 12.5568 , 11.332512 , 10.455498 ])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fallhoehe(t[0], 9.81)\n", + "# Dies liegt daran, das wir innerhalb unsrer Funktion ein Produkt zwischen einem \"Skalar\" und einem \"Vetor\" bilden." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Es gibt auch andere tolle Funktionen die mit dem numpy-Package kommen. Zum Beispiel eine Funktion für den Mittelwert und die Standardabweichung: " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5 1.118033988749895\n" + ] + } + ], + "source": [ + "a = np.array([1,2,3,4])\n", + "print(np.mean(a), np.std(a))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die Zeitwerte hatten wir als eine Art n x m Matrix gespeichert. Viele der Funktionen von numpy erlauben es uns diese nur über bestimmte Spalten oder Zeilen anzuwenden. Im folgenden möchten wir das ganze anhand von `np.mean` und `np.std` uns anschauen. \n", + "\n", + "Gucken wir uns zunächst nochmal die genaue n x m Form von t an: " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 10)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "t ist also eine 3 x 10 Matrix. Gucken wir uns noch die verschiedenen Ergebnisse an:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.9266666666666665" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(t) # <-- gibt den Mittelwert über alle Werte" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2.67333333, 2.37333333, 2.18333333, 2.06 , 1.90333333,\n", + " 1.79333333, 1.68333333, 1.62666667, 1.52333333, 1.44666667])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(t, axis=0) # <-- Mittelwert entlang der ersten n-achse -> 10-Werte entlang der m-Achse " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.mean(t, axis=1) # <-- Mittelwert entlang der m-achse -> 3 Werte entlang der n-Achse" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das gleiche geht auch mit der Standardabweichung:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.02624669, 0.01885618, 0.00942809, 0. , 0.00471405,\n", + " 0.00942809, 0.00471405, 0.04496913, 0.00471405, 0.00942809])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.std(t, axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Beim plotten selbst können wir noch die Funktion `np.arange` nutzen um uns das Leben etwas zu erleichtern. Bisher mussten wir uns Gleitkommazahlen immer sehr aufwendig erstellen. " + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "x = [i/10 for i in range(10)]\n", + "plt.plot(x, [i**2 for i in x], marker='o')\n", + "\n", + "# Mit numpy:\n", + "x = np.arange(0, 1, 0.1)\n", + "plt.plot(x, x**2, marker='x')" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Das Auge plottet mit:\n", "\n", - "In diesem Notebook möchte ich noch ein paar weitere nützlichen Befehle rund ums Thema **Plotten** zeigen. Hierbei handelt es sich nur um verschiedene Beispiele wie ihr eure Plots noch etwas weiter ausschmücken könnt. Nehmen wir hierfür wieder unseren Spannungsplot aus Kapitel 1.:" + "In diesem Abschnitt möchte ich noch ein paar weitere nützlichen Befehle rund ums Thema **Plotten** zeigen. Hierbei handelt es sich nur um verschiedene Beispiele wie ihr eure Plots noch etwas weiter ausschmücken könnt. Nehmen wir hierfür wieder unseren Spannungsplot aus Kapitel 1.:" ] }, { @@ -866,6 +1419,13 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ich hoffe der Zusatz hilft euch. Viel Spaß im PGP!" + ] } ], "metadata": { @@ -884,7 +1444,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.6" } }, "nbformat": 4,