mo8it/pgp1-python-einfuehrung
1
0
Fork 0
mirror of https://gitlab.rlp.net/pgp/pgp1-python-einfuehrung synced 2024-11-16 13:48:11 +00:00
Code Releases Activity

Removed deprecated information, checked spelling and seperated least squares

Browse source
This commit is contained in:
MoBit 2021-08-27 13:22:24 +02:00
parent 6fc55db1d7
commit d1fa395227
7 changed files with 1992 additions and 307 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

149
Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb
View file

@ -6,9 +6,9 @@
"source": [ "source": [
"# Vorbereitung Kapitel 1. Einstieg in die Welt von Python:\n", "# Vorbereitung Kapitel 1. Einstieg in die Welt von Python:\n",
"\n", "\n",
"In unserer heutigen digitalen Welt sind Computer nicht mehr aus unserem Alltag wegzudenken. Ob in der Finanzwelt, Industrie aber auch in der Wissenschaft erledigen Computer in Sekundenschnelle komplizierte Rechnungen und helfen dem Anwender komplizierte Sachverhalte vereinfacht wieder zu geben. Daher empfiehlt es sich insbesondere als Physiker zumindest die Grundlagen einer beliebigen Programmiersprache zu beherrschen. \n", "In unserer heutigen digitalen Welt sind Computer nicht mehr aus unserem Alltag wegzudenken. Ob in der Finanzwelt, Industrie aber auch in der Wissenschaft erledigen Computer in Sekundenschnelle komplizierte Rechnungen und helfen dem Anwender komplizierte Sachverhalte vereinfacht wiederzugeben. Daher empfiehlt es sich insbesondere als Physiker zumindest die Grundlagen einer beliebigen Programmiersprache zu beherrschen.\n",
"\n", "\n",
"Im folgenden werden wir uns gemeinsam die Grundzüge der Programmiersprache **Python** erarbeiten. Ein besonderes Augenmerk liegt hierbei auf den verschiedenen Herausforderungen die das analysieren von experimentellen Daten mit sich bringt. Um Sie bestens auf die Anforderungen im **physikalische Grundpraktikum (PGP)** vorzubereiten lernen wir im Folgenden wie man:\n", "Im folgenden werden wir uns gemeinsam die Grundzüge der Programmiersprache **Python** erarbeiten. Ein besonderes Augenmerk liegt hierbei auf den verschiedenen Herausforderungen, die das Analysieren von experimentellen Daten mit sich bringt. Um Sie bestens auf die Anforderungen im **physikalischen Grundpraktikum (PGP)** vorzubereiten, lernen wir im Folgenden wie man:\n",
"\n", "\n",
"* einfache Rechnungen mit Python durchführt\n", "* einfache Rechnungen mit Python durchführt\n",
"* \"Mathematische\" Funktionen definiert\n", "* \"Mathematische\" Funktionen definiert\n",
@ -16,7 +16,7 @@
"* Daten in Form von Graphen richtig darstellt\n", "* Daten in Form von Graphen richtig darstellt\n",
"* eine Ausgleichsgerade von Datenpunkten berechnen kann.\n", "* eine Ausgleichsgerade von Datenpunkten berechnen kann.\n",
"\n", "\n",
"Damit Sie das neu erlernte Wissen direkt vertiefen können, wird dieses Notebook an verschiedenen Stellen kleinere Aufgaben für Sie bereit halten. Die Aufgaben sind durch orangefarbene Boxen hervorgehoben. Es gilt alle Aufgaben zu bearbeiten! " "Damit Sie das neu erlernte Wissen direkt vertiefen können, wird dieses Notebook an verschiedenen Stellen kleinere Aufgaben für Sie bereithalten. Die Aufgaben sind durch orangefarbene Boxen hervorgehoben. Es gilt alle Aufgaben zu bearbeiten!"
] ]
}, },
{ {
@ -25,8 +25,7 @@
"source": [ "source": [
"## Grundlagen zu Python bzw. Jupyter Notebooks:\n", "## Grundlagen zu Python bzw. Jupyter Notebooks:\n",
"\n", "\n",
"Bevor wir mit dem eigentlichen Programmieren beginnen wollen, müssen wir uns jedoch erst einmal mit unserem so genannten Interpreter (**Jupyter Notebook**) vertraut machen. Bei der Programmiersprache **Python** handelt es sich um eine so genannte **Interpretersprache**. Dies bedeutet, dass eingegebene Befehle, ähnlich wie bei einem Taschenrechner, direkt ausgeführt werden.\n", "Bevor wir mit dem eigentlichen Programmieren beginnen, müssen wir uns erst einmal mit unserem so genannten Interpreter (**Jupyter Notebook**) vertraut machen. Bei der Programmiersprache **Python** handelt es sich um eine so genannte **Interpretersprache**. Dies bedeutet, dass eingegebene Befehle, ähnlich wie bei einem Taschenrechner, direkt ausgeführt werden."
"\n"
] ]
}, },
{ {
@ -44,11 +43,11 @@
"\n", "\n",
"Im folgenden wollen wir erst einmal mit den Grundlagen des Notebooks vertraut machen. Insbesondere wollen wir lernen, wie wir eine Markdown- und eine Code-Zelle erstellen, bearbeiten und ausführen. \n", "Im folgenden wollen wir erst einmal mit den Grundlagen des Notebooks vertraut machen. Insbesondere wollen wir lernen, wie wir eine Markdown- und eine Code-Zelle erstellen, bearbeiten und ausführen. \n",
"\n", "\n",
"* Erstellt zunächst eine Code-Zelle unterhalb dieser Aufgaben Zelle und berechnen Sie die Summe zweier beliebiger ganzer Zahlen. Gehen Sie dabei wie folgt vor:\n", "* Erstellen Sie zunächst eine Code-Zelle unterhalb dieser Aufgaben-Zelle und berechnen Sie die Summe zweier beliebiger ganzer Zahlen. Gehen Sie dabei wie folgt vor:\n",
" 1. Klicken Sie die Zelle dieser Aufgabe an, so dass die Zelle eine blaue Umrandung bekommt (je nach Bildschirmauflösung könnt Sie nur links einen blauen Balken erkennen). Sie befinden sich nun im so genannten \"Command Modus\". In diesem Modus könnt Sie mit Hilfe der Pfeiltasten durch das Notebook navigieren oder die Struktur des Notebooks bzw. seiner Zellen mit Hilfe von Tasten/Tastenkombinationen modifizieren.\n", " 1. Klicken Sie die Zelle dieser Aufgabe an, sodass die Zelle eine blaue Umrandung bekommt (je nach Bildschirmauflösung könnten Sie nur links einen blauen Balken erkennen). Sie befinden sich nun im so genannten \"Command Modus\". In diesem Modus können Sie mit Hilfe der Pfeiltasten durch das Notebook navigieren oder die Struktur des Notebooks bzw. seiner Zellen mit Hilfe von Tasten/Tastenkombinationen modifizieren.\n",
" 2. Benutzen Sie nun die Taste **B** um eine Code-Zelle unterhalb (**B**elow) dieser Zelle zu erstellen. Sie werden feststellen, dass Ihr Navigator direkt zu der neu erstellten Zelle springt (blaue Umrandung).\n", " 2. Benutzen Sie nun die Taste **B**, um eine Code-Zelle unterhalb (**B**elow) dieser Zelle zu erstellen. Sie werden feststellen, dass Ihr Navigator direkt zu der neu erstellten Zelle springt (blaue Umrandung).\n",
" 3. Um nun diese neu erstellte Code-Zelle zu editieren, klicken Sie diese mit dem Mauszeiger an. Die Zellenumrandung sollte von Blau auf Grün wechseln. Dies zeigt an, dass Sie sich nun im Editiermodus für dieses Zelle befinden.\n", " 3. Um nun diese neu erstellte Code-Zelle zu editieren, klicken Sie diese mit dem Mauszeiger an. Die Zellenumrandung sollte von Blau auf Grün wechseln. Dies zeigt an, dass Sie sich nun im Editiermodus für diese Zelle befinden.\n",
" 4. Nun können Sie die Summe aus zwei beliebigen ganzen Zahlen mit Hilfe des Syntax\n", " 4. Nun können Sie die Summe aus zwei beliebigen ganzen Zahlen mithilfe des Syntax\n",
" ```python\n", " ```python\n",
" 3 + 5\n", " 3 + 5\n",
" ```\n", " ```\n",
@ -58,17 +57,17 @@
" \n", " \n",
"* Erstellen Sie nun eine Markdown-Zelle oberhalb ihrer Code-Zelle. Hierfür müssen Sie wie folgt vorgehen: \n", "* Erstellen Sie nun eine Markdown-Zelle oberhalb ihrer Code-Zelle. Hierfür müssen Sie wie folgt vorgehen: \n",
" 1. Klicken Sie die zuvor erstellte Code-Zelle an. Die Zelle sollte eine grüne Umrandung anzeigen, da Sie sich nach wie vor im Editiermodus befinden.\n", " 1. Klicken Sie die zuvor erstellte Code-Zelle an. Die Zelle sollte eine grüne Umrandung anzeigen, da Sie sich nach wie vor im Editiermodus befinden.\n",
" 2. Drücken Sie die **ESC**-Taste um vom Editier- in den Command-Modus zu wechseln (blaue Umrandung).\n", " 2. Drücken Sie die **ESC**-Taste, um vom Editier- in den Command-Modus zu wechseln (blaue Umrandung).\n",
" 3. Drücken Sie nun die Taste **A** um eine neue Code-Zelle oberhalb (**A**bove) Ihrer angewählten Zelle zu erstellen. Der Navigator wird wieder automatisch zu der neu erstellten Zelle springen.\n", " 3. Drücken Sie nun die Taste **A**, um eine neue Code-Zelle oberhalb (**A**bove) Ihrer angewählten Zelle zu erstellen. Der Navigator wird wieder automatisch zu der neu erstellten Zelle springen.\n",
" 4. Drücken Sie nun die Taste **M** um die Code-Zelle in eine Markdown-Zelle zu verwandeln. Sie werden feststellen, dass eine Markdown-Zelle im Vergleich zu einer Code Zelle kein \"In []:\"-Anzeige links der Zelle hat. \n", " 4. Drücken Sie nun die Taste **M**, um die Code-Zelle in eine Markdown-Zelle zu verwandeln. Sie werden feststellen, dass eine Markdown-Zelle im Vergleich zu einer Code-Zelle kein \"In []:\"-Anzeige links der Zelle hat. \n",
" 5. Wechseln Sie nun in der Markdown-Zelle in den Editiermodus (grüne Umrandung) in dem Sie diese anklicken. \n", " 5. Wechseln Sie nun in der Markdown-Zelle in den Editiermodus (grüne Umrandung), indem Sie diese anklicken. \n",
" 6. Fügen Sie nun die folgenden Objekte in die Markdown-Zelle mit dem entsprechenden Syntax ein:\n", " 6. Fügen Sie nun die folgenden Objekte in die Markdown-Zelle mit dem entsprechenden Syntax ein:\n",
" * Eine level 1 und level 2 Überschrift\n", " * Eine level 1 und level 2 Überschrift\n",
" * Eine numerische Aufzählung (1. 2. und 3.) wobei 1. ein fett gedrucktes Wort 2. ein kursive geschriebenes Wort und 3. ein Wort im true type beinhalten soll. \n", " * Eine numerische Aufzählung (1. 2. und 3.) wobei 1. ein fett gedrucktes Wort 2. ein kursive geschriebenes Wort und 3. ein Wort im true type beinhalten soll.\n",
" * Fügen Sie dem zweiten Aufzählungspunkt (2.) drei nicht nummerierte Unterpunkte hinzu.\n", " * Fügen Sie dem zweiten Aufzählungspunkt (2.) drei nicht nummerierte Unterpunkte hinzu.\n",
" \n", " \n",
"**Hinweise:**\n", "**Hinweise:**\n",
"In *Kapitel 0* wurden Ihnen bereits alle benötigten Formatierungen angezeigt. Sie können diese nachgucken in dem Sie in das Notebook *Kapitel 0* wechseln und die entsprechende Markdown-Zelle mittels Doppelklick anwählen. \n", "In *Kapitel 0* wurden Ihnen bereits alle benötigten Formatierungen angezeigt. Sie können diese nachgucken, indem Sie in das Notebook *Kapitel 0* wechseln und die entsprechende Markdown-Zelle mittels Doppelklick anwählen. \n",
"<div/> " "<div/> "
] ]
}, },
@ -77,13 +76,13 @@
"metadata": {}, "metadata": {},
"source": [ "source": [
"Neben diesen nützlichen Befehlen gibt es noch weitere tolle Kürzel wie zum Beispiel:\n", "Neben diesen nützlichen Befehlen gibt es noch weitere tolle Kürzel wie zum Beispiel:\n",
"* **D + D** um eine Zelle zu **löschen** \n", "* **D + D**, um eine Zelle zu **löschen** \n",
"* **Y** verwandelt eine aktuelle **Markdown**-Zelle in eine **Code**-Zelle\n", "* **Y** verwandelt eine aktuelle **Markdown**-Zelle in eine **Code**-Zelle\n",
"* **Strg** + **Shift** + **Minus** Splittet eine Zelle an der Position eures Cursors \n", "* **Strg** + **Shift** + **Minus** splittet eine Zelle an der Position des Cursors\n",
"* **F** für \"Find and Replace\" (nützlich wenn ihr zum Beispiel ein Variablennamen austauschen wollt)\n", "* **F** für \"Find and Replace\" (nützlich wenn Sie zum Beispiel einen Variablennamen austauschen wollen)\n",
"* **I** + **I** Um den *\"Kernel\"* zu stoppen (wichtig falls ihr mal eine unendliche LOOP gebaut habt)\n", "* **I** + **I**, um den *\"Kernel\"* zu stoppen (wichtig falls Sie mal eine unendliche LOOP gebaut haben)\n",
"\n", "\n",
"Des weiteren können Sie [hier](https://www.cheatography.com/weidadeyue/cheat-sheets/jupyter-notebook/) eine Auflistung weiterer Jupyter-Befehle finden." "Des Weiteren können Sie [hier](https://www.cheatography.com/weidadeyue/cheat-sheets/jupyter-notebook/) eine Auflistung weiterer Jupyter-Befehle finden."
] ]
}, },
{ {
@ -198,7 +197,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Wie in der Mathematik können wir auch bei Python Klammern verwenden um die Rechenreihenfolge zu ändern:" "Wie in der Mathematik können wir auch bei Python Klammern verwenden, um die Rechenreihenfolge zu ändern:"
] ]
}, },
{ {
@ -233,7 +232,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Um unsere Rechnungen besser zu strukturieren, können wir Zahlen auch Variablen zuordnen. Hierzu verwenden wir das Gleichheitszeichen um einer Variablen (*links*) einem Wert (*rechts*) zuzuordnen." "Um unsere Rechnungen besser zu strukturieren, können wir Zahlen auch Variablen zuordnen. Hierzu verwenden wir das Gleichheitszeichen, um einer Variablen (*links*) einem Wert (*rechts*) zuzuordnen."
] ]
}, },
{ {
@ -268,7 +267,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Variablen können neben einfach Buchstaben auch mittels komplexere Ausdrücke dargestellt werden. " "Variablen können neben einfachen Buchstaben auch mittels komplexerer Ausdrücke dargestellt werden. "
] ]
}, },
{ {
@ -312,7 +311,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Bei der Definition von Variablen ist es wichtig auf die Reihenfolge zu achten. Dies gilt nicht nur innerhalb einer Zelle..." "Bei der Definition von Variablen ist es wichtig, auf die Reihenfolge zu achten. Dies gilt nicht nur innerhalb einer Zelle..."
] ]
}, },
{ {
@ -337,7 +336,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"... sondern auch für die Reihenfolge in der die Code-Zellen ausgeführt werden (Angezeigt durch In []:). " "... sondern auch für die Reihenfolge, in der die Code-Zellen ausgeführt werden (Angezeigt durch In []:). "
] ]
}, },
{ {
@ -386,7 +385,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Ein weiterer Vorteil (bzw. auch Nachteil) ist, dass Python eine so genannte *dynamische* Datentypenvergabe nutzt. Um besser zu verstehen was dies bedeutet, gucken wir uns das nachfolgende Beispiel an. " "Ein weiterer Vorteil (bzw. auch Nachteil) ist, dass Python eine so genannte *dynamische* Datentypenvergabe nutzt. Um besser zu verstehen, was dies bedeutet, gucken wir uns das nachfolgende Beispiel an. "
] ]
}, },
{ {
@ -427,7 +426,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"In der oberen Zelle ist **c** vom Datentyp `int` (*Integer*) was einer Ganzenzahl entspricht. In der unteren Zelle jedoch ist **c** vom Datentyp `float` (*Floating Point Number*) also eine Gleitkommazahl. Dies liegt daran, das wir in der unteren Zelle **b** als Gleitkommazahl definiert haben. Um uns Arbeit abzunehmen hat Python für uns im Hintergrund dynamisch entschieden, dass somit **c** ebenfalls vom Typ `float` sein muss. \n", "In der oberen Zelle ist **c** vom Datentyp `int` (*Integer*), was einer Ganzenzahl entspricht. In der unteren Zelle jedoch ist **c** vom Datentyp `float` (*Floating Point Number*) also eine Gleitkommazahl. Dies liegt daran, das wir in der unteren Zelle **b** als Gleitkommazahl definiert haben. Um uns Arbeit abzunehmen, hat Python für uns im Hintergrund dynamisch entschieden, dass somit **c** ebenfalls vom Typ `float` sein muss. \n",
"\n", "\n",
"Neben den primitiven Datentypen `float` und `int` gibt es noch die wichtigen Datentypen `str` (*string*) was einer Zeichenkette entspricht (z.B. Buchstaben, Wörter und Sätze), `complex` für Komplexe Zahlen und `bool` für Wahrheitswerte. Was genau Wahrheitswerte sind und wofür diese verwendet werden, werden Sie noch im **PGP2** lernen. \n", "Neben den primitiven Datentypen `float` und `int` gibt es noch die wichtigen Datentypen `str` (*string*) was einer Zeichenkette entspricht (z.B. Buchstaben, Wörter und Sätze), `complex` für Komplexe Zahlen und `bool` für Wahrheitswerte. Was genau Wahrheitswerte sind und wofür diese verwendet werden, werden Sie noch im **PGP2** lernen. \n",
"\n", "\n",
@ -451,7 +450,7 @@
"\n", "\n",
"$$s(t) = \\frac{1}{2}\\cdot a \\cdot t^2 + v_0 \\cdot t + s_0$$\n", "$$s(t) = \\frac{1}{2}\\cdot a \\cdot t^2 + v_0 \\cdot t + s_0$$\n",
"\n", "\n",
"beschrieben werden. Hierbei beschreibt $t$ die verstrichene Zeit, $a$ die Beschleunigung, $v_0$ die Startgeschwindigkeit und $s_0$ die Startposition des Objekts. Ersteklen Sie unterhalb der Aufgabe eine neue Code-Zelle und berechnen Sie die folgenden Werte:\n", "beschrieben werden. Hierbei beschreibt $t$ die verstrichene Zeit, $a$ die Beschleunigung, $v_0$ die Startgeschwindigkeit und $s_0$ die Startposition des Objekts. Erstellen Sie unterhalb der Aufgabe eine neue Code-Zelle und berechnen Sie die folgenden Werte:\n",
"\n", "\n",
"Wie lange bräuchte ein Stift, welcher in einer Höhe von $s_0 = 1.2\\,$m losgelassen wird ($v_0 = 0\\,\\text{m}/\\text{s}$)... \n", "Wie lange bräuchte ein Stift, welcher in einer Höhe von $s_0 = 1.2\\,$m losgelassen wird ($v_0 = 0\\,\\text{m}/\\text{s}$)... \n",
"\n", "\n",
@ -459,12 +458,12 @@
"* ... im Schwerefeld des Mondes $(g_\\text{M} = - 1.62\\,\\text{m}/\\text{s}^2)$ ...\n", "* ... im Schwerefeld des Mondes $(g_\\text{M} = - 1.62\\,\\text{m}/\\text{s}^2)$ ...\n",
"* ... im Schwerefeld der Sonne $(g_\\text{S} = - 274\\,\\text{m}/\\text{s}^2)$ ...\n", "* ... im Schwerefeld der Sonne $(g_\\text{S} = - 274\\,\\text{m}/\\text{s}^2)$ ...\n",
"\n", "\n",
"... bis er auf dem Boden aufschlägt? (Reibungseffekt sind zu vernachlässigen)\n", "... bis er auf dem Boden aufschlägt? (Reibungseffekte sind zu vernachlässigen)\n",
"\n", "\n",
"Mit welcher Geschwindigkeit (in km/h) schlägt der Stift auf die Sonnenoberfläche auf ?\n", "Mit welcher Geschwindigkeit (in km/h) schlägt der Stift auf die Sonnenoberfläche auf?\n",
"\n", "\n",
"**Hinweis:** \n", "**Hinweis:** \n",
"Sofern ihr alle Berechnungen innerhalb einer Zelle ausführen wollt, könnt ihr mit Hilfe der `print`-Funktion eure Ergebnisse \"ausdrucken\"/anzeigen lassen. Geht dabei wie folgt vor:\n", "Sofern Sie alle Berechnungen innerhalb einer Zelle ausführen wollen, können Sie mithilfe der `print`-Funktion die Ergebnisse \"ausdrucken\"/anzeigen lassen. Gehen Sie dabei wie folgt vor:\n",
"```python\n", "```python\n",
"print(Variablennamen1, Variablennamen2, Variablennamen3 ...)\n", "print(Variablennamen1, Variablennamen2, Variablennamen3 ...)\n",
"```\n", "```\n",
@ -482,7 +481,7 @@
"source": [ "source": [
"## Zeichenketten\n", "## Zeichenketten\n",
"\n", "\n",
"Wie eben bereits erwähnt, gibt es neben den Zahlen-Datentypen `int`, `float` und `complex` auch noch den Datentyp einer Zeichenkette `str`. Zeichenketten werden in Programmiersprachen vielseitig verwendet z.B. bei einer Nutzereingabe (z.B. einem Passwort), Dateiname bei einer Installation, oder bei Textrückgaben von Programmen. Letzteres haben Sie bereits in Aufgabe 2 a. mit Hilfe der `print`-Funktion gesehen.\n", "Wie eben bereits erwähnt, gibt es neben den Zahlen-Datentypen `int`, `float` und `complex` auch noch den Datentyp einer Zeichenkette `str`. Zeichenketten werden in Programmiersprachen vielseitig verwendet z.B. bei einer Nutzereingabe (z.B. einem Passwort), Dateiname bei einer Installation, oder bei Textrückgaben von Programmen. Letzteres haben Sie bereits in Aufgabe 2 a. mithilfe der `print`-Funktion gesehen.\n",
"\n", "\n",
"Für das PGP-1 wollen wir uns zunächst darauf beschränken, dass Zeichenketten in so genannten **Formatstrings** dazu genutzt werden können, schönere `print` Rückgaben zu erzeugen, bzw. wir mit Zeichenketten Achsenbeschriftungen an Graphen anbringen können. \n", "Für das PGP-1 wollen wir uns zunächst darauf beschränken, dass Zeichenketten in so genannten **Formatstrings** dazu genutzt werden können, schönere `print` Rückgaben zu erzeugen, bzw. wir mit Zeichenketten Achsenbeschriftungen an Graphen anbringen können. \n",
"\n", "\n",
@ -507,7 +506,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Hierbei kann eine Zeichenkette auch alle Symbole enthalten die euer Interpreter unterstützt. In Jupyter sind dies alle gewohnten Zeichen wie Buchstaben, Zahlen, Sonderzeichen und Leerzeichen: " "Hierbei kann eine Zeichenkette auch alle Symbole enthalten, die euer Interpreter unterstützt. In Jupyter sind dies alle gewohnten Zeichen wie Buchstaben, Zahlen, Sonderzeichen und Leerzeichen: "
] ]
}, },
{ {
@ -584,7 +583,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"... oder sofern Sie eine Rückgabe lieber über mehrere Zeilen ausgeben lassen möchten, könnt Sie dies wie folgt machen:" "... oder sofern Sie eine Rückgabe lieber über mehrere Zeilen ausgeben lassen möchten, können Sie dies wie folgt machen:"
] ]
}, },
{ {
@ -616,7 +615,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Hierbei zeigt `:` an, dass sie eine spezielle Formatierung verwenden möchten. Die Zahl hinter dem `.` gibt an wie viele Nachkommastellen Sie anzeigen lassen möchten. Das `f` bedeutet, dass es sich bei der Zahl um eine Gleitkommazahl handelt." "Hierbei zeigt `:` an, dass sie eine spezielle Formatierung verwenden möchten. Die Zahl hinter dem `.` gibt an, wie viele Nachkommastellen Sie anzeigen lassen möchten. Das `f` bedeutet, dass es sich bei der Zahl um eine Gleitkommazahl handelt."
] ]
}, },
{ {
@ -627,7 +626,7 @@
" \n", " \n",
"#### Aufgabe 2.b.: Beschleunigte Bewegung Zusatz\n", "#### Aufgabe 2.b.: Beschleunigte Bewegung Zusatz\n",
" \n", " \n",
"Lassen Sie nun Ihre berechneten Werte aus Aufgabe 2 mit Hilfe von `print` erneut ausgeben. Nutzen Sie jedoch dieses Mal **Formatstrings** für eine schönere und bedeutungsvollere Rückgabe. Achten Sie dabei ins besonders auf:\n", "Lassen Sie nun Ihre berechneten Werte aus Aufgabe 2 mithilfe von `print` erneut ausgeben. Nutzen Sie jedoch dieses Mal **Formatstrings** für eine schönere und bedeutungsvollere Rückgabe. Achten Sie dabei ins besonders auf:\n",
"\n", "\n",
"* Die Angabe der richtigen Einheiten.\n", "* Die Angabe der richtigen Einheiten.\n",
"* Das Runden der berechneten Werte der Anzahl an signifikanten Stellen entsprechend. " "* Das Runden der berechneten Werte der Anzahl an signifikanten Stellen entsprechend. "
@ -637,7 +636,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"## Das Definieren von Funktionen:\n", "## Definieren von Funktionen:\n",
"\n", "\n",
"Anstatt Berechnungen wie bei einem Taschenrechner immer wieder manuell einzugeben, ermöglicht uns eine Programmiersprache das Definieren von Funktionen. Funktionen können hierbei ähnlich wie mathematische Funktionen definiert und behandelt werden. Im folgenden wollen wir uns dies im Fall des Ohmschen Gesetzes, welches durch \n", "Anstatt Berechnungen wie bei einem Taschenrechner immer wieder manuell einzugeben, ermöglicht uns eine Programmiersprache das Definieren von Funktionen. Funktionen können hierbei ähnlich wie mathematische Funktionen definiert und behandelt werden. Im folgenden wollen wir uns dies im Fall des Ohmschen Gesetzes, welches durch \n",
"\n", "\n",
@ -665,9 +664,9 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Bitte beachten Sie, dass die Rückgabe `return` der Funktion mit Hilfe der Tab-Taste eingerückt wurde. Dieser Syntax wird von Python vorgegeben uns muss eingehalten werden.\n", "Bitte beachten Sie, dass die Rückgabe `return` der Funktion mit Hilfe der Tab-Taste eingerückt wurde. Dieser Syntax wird von Python vorgegeben und muss eingehalten werden.\n",
"\n", "\n",
"Diese Funktion können wir nun auf Messdaten anwenden. Z.B. wir Messen bei einem Widerstand von $1\\,\\text{k}\\Omega$ einen Strom von $10\\,\\text{mA}$:" "Diese Funktion können wir nun auf Messdaten anwenden. Wir Messen z.B. bei einem Widerstand von $1\\,\\text{k}\\Omega$ einen Strom von $10\\,\\text{mA}$:"
] ]
}, },
{ {
@ -682,7 +681,7 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"# Leider müssen wir hier auf die Einheiten selbst achten.\n", "# Leider müssen wir hier auf die Einheiten selbst achten.\n",
"# Deshalb ist es ratsam sich die Einheiten zu den Werten zu notieren.\n", "# Deshalb ist es ratsam, sich die Einheiten zu den Werten zu notieren.\n",
"U = Spannung(1000, 0.01) # in V \n", "U = Spannung(1000, 0.01) # in V \n",
"U " "U "
] ]
@ -691,7 +690,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Neben mathematischen Funktionen, können Funktionen in einer Programmiersprache auch viel allgemeinere Aufgaben erfüllen bzw. komplexe Algorithmen beinhalten. Hierfür benötigen wir meist mehr als nur eine Zeile. Um Python verständlich zu machen, dass mehre Zeilen zu einer Funktion gehören müssen wir die entsprechenden Zeilen wir zuvor den `return`-Befehl einrücken. " "Neben mathematischen Funktionen, können Funktionen in einer Programmiersprache auch viel allgemeinere Aufgaben erfüllen bzw. komplexe Algorithmen beinhalten. Hierfür benötigen wir meist mehr als nur eine Zeile. Um Python verständlich zu machen, dass mehre Zeilen zu einer Funktion gehören müssen wir die entsprechenden Zeilen wie zuvor den `return`-Befehl einrücken."
] ]
}, },
{ {
@ -705,7 +704,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def komplxe_function(a, b, c, d):\n", "def complex_function(a, b, c, d):\n",
" result = a + b\n", " result = a + b\n",
" result = result * c\n", " result = result * c\n",
" result = result / d\n", " result = result / d\n",
@ -723,14 +722,14 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"komplxe_function(1, 2, 3, 4)" "complex_function(1, 2, 3, 4)"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Bitte beachten Sie, das Variablen welche in einer Funktion definiert und genutzt werden auch nur dort zur Verfügung stehen. Versuchen Sie die entsprechenden Variablen im regulär im Notebook zu verwenden werden Sie einen Fehler bekommen." "Bitte beachten Sie, dass Variablen, welche in einer Funktion definiert und genutzt werden, auch nur dort zur Verfügung stehen. Versuchen Sie, die entsprechenden Variablen im Notebook zu verwenden, werden Sie einen Fehler bekommen."
] ]
}, },
{ {
@ -751,7 +750,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Sollten Sie das Ergebnis dennoch in einer Variablen speichern wollen können Sie dies natürlich machen:" "Sollten Sie das Ergebnis dennoch in einer Variablen speichern wollen, können Sie dies natürlich machen:"
] ]
}, },
{ {
@ -765,7 +764,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"result = komplxe_function(1, 2, 3, 4)" "result = complex_function(1, 2, 3, 4)"
] ]
}, },
{ {
@ -786,9 +785,9 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Für das Grundpraktikum sind längere und kompliziertere Funktionen eher die ausnahme. Sie werden in Veranstaltungen wie \n", "Für das Grundpraktikum sind längere und kompliziertere Funktionen eher die Ausnahme. Sie werden in Veranstaltungen wie \n",
"\n", "\n",
"* Computer in der Wissenschaft \n", "* Computer in der Wissenschaft\n",
"* Programmieren für Physiker\n", "* Programmieren für Physiker\n",
"* Einführung in die Programmierung\n", "* Einführung in die Programmierung\n",
"\n", "\n",
@ -822,7 +821,7 @@
"metadata": {}, "metadata": {},
"source": [ "source": [
"### Tipp: \n", "### Tipp: \n",
"Es ist ratsam gleich von Anfang an Funktionen zu dokumentieren. Hierzu dienen in Python die sogenannten `Doc-Strings`. Sie beinhalten Informationen über die Funktion selbst, ihre verwendeten Parameter und ihrer Ausgabe. Zum Beispiel für das Ohmschen Gesetzes würde ein solcher Doc-String wie folgt aussehen:" "Es ist ratsam, gleich von Anfang an Funktionen zu dokumentieren. Hierzu dienen in Python die sogenannten `Doc-Strings`. Sie beinhalten Informationen über die Funktion selbst, ihre verwendeten Parameter und ihre Ausgabe. Zum Beispiel für das Ohmschen Gesetzes würde ein solcher Doc-String wie folgt aussehen:"
] ]
}, },
{ {
@ -856,7 +855,7 @@
" in Ohm.\n", " in Ohm.\n",
" \n", " \n",
" Returns:\n", " Returns:\n",
" float: Die Berechnete Spannung in V.\n", " float: Die berechnete Spannung in V.\n",
" '''\n", " '''\n",
" return Widerstand * Strom/1000" " return Widerstand * Strom/1000"
] ]
@ -867,7 +866,7 @@
"source": [ "source": [
"## Messtabellen in Python:\n", "## Messtabellen in Python:\n",
"\n", "\n",
"Damit uns eine Programmiersprache wie Python Arbeit abnehmen kann, sollte es auch möglich sein größere Datenmengen, wie z.B. die Werte einer Messtabelle, in einer Variablen zu speichern. Python bietet hierfür mehrer verschiedene Konzepte an. Jedes dieser Konzepte hat unterschiedlichen Stärken und Schwächen. Die gängigsten Methoden sind listen, tuple, bzw. sogenannte numpy.arrays und pandas.dataframes. Aufgrund der limitierten Zeit im PGP 1 werden wir uns hier lediglich mit zwei dieser vier Methoden auseinander setzen. \n", "Damit uns eine Programmiersprache wie Python Arbeit abnehmen kann, sollte es auch möglich sein, größere Datenmengen, wie z.B. die Werte einer Messtabelle, in einer Variablen zu speichern. Python bietet hierfür verschiedene Konzepte an. Jedes dieser Konzepte hat unterschiedliche Stärken und Schwächen. Die gängigsten Methoden sind list, tuple, bzw. sogenannte numpy.arrays und pandas.dataframes. Aufgrund der limitierten Zeit im PGP 1 werden wir uns hier lediglich mit zwei dieser vier Methoden auseinander setzen. \n",
"\n", "\n",
"Fangen wir zunächst mit Listen an. Eine Liste ist eine Ansammlung von Werten, welche alle den gleichen oder ganz unterschiedliche Datentypen haben können. Eine Liste kann auf zwei unterschiedliche Art und Weisen erstellt werden:" "Fangen wir zunächst mit Listen an. Eine Liste ist eine Ansammlung von Werten, welche alle den gleichen oder ganz unterschiedliche Datentypen haben können. Eine Liste kann auf zwei unterschiedliche Art und Weisen erstellt werden:"
] ]
@ -906,9 +905,9 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Sobald wir eine liste erstellt haben, können wir eine ganze Reihe von unterschiedlichen Manipulationen durchführen um sie nach unserem Belieben zu verändern.\n", "Sobald wir eine liste erstellt haben, können wir eine ganze Reihe von unterschiedlichen Manipulationen durchführen, um sie nach unserem Belieben zu verändern.\n",
"\n", "\n",
"Wir können zum Beispiel die bestehende Liste um ein Wert erweitern (`append`) oder einen zusätzlichen Wert an eine beliebige Stelle in der Liste hinzufügen (`insert`)." "Wir können zum Beispiel die bestehende Liste um einen Wert erweitern (`append`) oder einen zusätzlichen Wert an eine beliebige Stelle in der Liste hinzufügen (`insert`)."
] ]
}, },
{ {
@ -947,7 +946,7 @@
"source": [ "source": [
"Ups, was ist denn in der letzten Zelle passiert? Wert4 wurde ja garnicht an Stelle 4 der Liste gesetzt, Python scheint nicht zählen zu können... \n", "Ups, was ist denn in der letzten Zelle passiert? Wert4 wurde ja garnicht an Stelle 4 der Liste gesetzt, Python scheint nicht zählen zu können... \n",
"\n", "\n",
"Leider zählt Python doch richtig. In Python läuft der Index von Objekten in einer Liste immer von 0,1,2,3...n. Dies können wir auch ganz einfach überprüfen in dem wir unsere Liste in verschiedene \"Scheiben\" schneiden (so genanntes slicing). Dies geht wie folgt:" "Leider zählt Python doch richtig. In Python läuft der Index von Objekten in einer Liste immer von 0,1,2,3...n. Dies können wir auch ganz einfach überprüfen, indem wir unsere Liste in verschiedene \"Scheiben\" schneiden (so genanntes slicing). Dies geht wie folgt:"
] ]
}, },
{ {
@ -982,7 +981,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"NeueWerte[0] # Hier seht ihr, dass der erste Wert den Index 0 hat." "NeueWerte[0] # Hier sehen Sie, dass der erste Wert den Index 0 hat."
] ]
}, },
{ {
@ -1032,7 +1031,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"NeueWerte[2:5] # Ihr seht Python behandelt den letzten Wert wie in einem offenen Intervall [2,5)" "NeueWerte[2:5] # Python behandelt den letzten Wert wie in einem offenen Intervall [2,5)"
] ]
}, },
{ {
@ -1046,7 +1045,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"NeueWerte[2:] # Hier werden alle Werte mit dem Index >= 2 zurück gegeben" "NeueWerte[2:] # Hier werden alle Werte mit dem Index >= 2 zurückgegeben"
] ]
}, },
{ {
@ -1060,7 +1059,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"NeueWerte[-3:] # Mit negativen Zahlen fangt ihr vom Ende der Liste an" "NeueWerte[-3:] # Mit negativen Zahlen fangen Sie vom Ende der Liste an"
] ]
}, },
{ {
@ -1093,7 +1092,7 @@
} }
}, },
"source": [ "source": [
"Anders als `append` welches die zweite Liste als ganzes an die erste Liste anfügt:" "Anders als `append`, welches die zweite Liste als Ganzes an die erste Liste anfügt:"
] ]
}, },
{ {
@ -1115,7 +1114,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Aber aufgepasst bei `append` wird eure Liste, an welche ihr die Daten anhängt (hier Messwerte1), direkt geändert (dies gilt auch für `insert`), während ihr beim `+` Operator die Variable überschreiben müsst, damit die Änderung wirksam wird. " "Aber aufgepasst, bei `append` wird die Liste, an welche Sie die Daten anhängen (hier Messwerte1), direkt geändert (dies gilt auch für `insert`), während Sie beim `+` Operator die Variable überschreiben müssen, damit die Änderung wirksam wird. "
] ]
}, },
{ {
@ -1130,7 +1129,7 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"Messwerte1 = Messwerte1 + NeueWerte\n", "Messwerte1 = Messwerte1 + NeueWerte\n",
"# Tipp dies könnt ihr auch einfach mit Hilfe von\n", "# Tipp: Dies können Sie auch einfach mithilfe von\n",
"# Messwerte1 += NeueWerte\n", "# Messwerte1 += NeueWerte\n",
"Messwerte1" "Messwerte1"
] ]
@ -1141,7 +1140,7 @@
"source": [ "source": [
"Zwei weitere nützliche Befehle im Zusammenhang von Listen ist die `len`- und `range`-Funktion. \n", "Zwei weitere nützliche Befehle im Zusammenhang von Listen ist die `len`- und `range`-Funktion. \n",
"\n", "\n",
"`len` gibt euch die Länge einer Liste zurück " "`len` gibt die Länge einer Liste zurück "
] ]
}, },
{ {
@ -1163,7 +1162,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"`range` erstellt euch ganzzahlige Werte zwischen zwei ganzen Zahlen " "`range` erstellt ganzzahlige Werte zwischen zwei ganzen Zahlen"
] ]
}, },
{ {
@ -1217,7 +1216,7 @@
" \n", " \n",
"#### Aufgabe 4.a.: Erstellen von Messwerttabellen:\n", "#### Aufgabe 4.a.: Erstellen von Messwerttabellen:\n",
"\n", "\n",
"Erstellen Sie für jede Spalte der nachfolgende Messtabelle eine Liste, welche die Messdaten beinhaltet. Benutzen Sie anschließend den `append` Befehl um die Daten jeder Spalte an eine weitere Liste namens *daten* anzuhängen. \n", "Erstellen Sie für jede Spalte der nachfolgenden Messtabelle eine Liste, welche die Messdaten beinhaltet. Benutzen Sie anschließend den `append` Befehl, um die Daten jeder Spalte an eine weitere Liste namens *daten* anzuhängen. \n",
"\n", "\n",
"| Messwertnummer | Spannung [V] | Strom [mA] | Fehler der Spannung [V] | Fehler des Stroms [mA] |\n", "| Messwertnummer | Spannung [V] | Strom [mA] | Fehler der Spannung [V] | Fehler des Stroms [mA] |\n",
"|----------------|--------------|------------|-------------------------|---------------------------|\n", "|----------------|--------------|------------|-------------------------|---------------------------|\n",
@ -1229,12 +1228,12 @@
"| 6 | 11.94 | 95 | 0.17 | 10 |\n", "| 6 | 11.94 | 95 | 0.17 | 10 |\n",
"\n", "\n",
"\n", "\n",
"Verwenden Sie anschließend das Slicing um die umgesetzte Leistung im Widerstand für die Meswerte 3 und 5 zu berechnen.\n", "Verwenden Sie anschließend das Slicing, um die umgesetzte Leistung im Widerstand für die Meswerte 3 und 5 zu berechnen.\n",
"\n", "\n",
"**Tipp:**\n", "**Tipp:**\n",
"\n", "\n",
"1. Sie haben bereits die Funktionen für die Leistung in Aufgabe 3 definiert und könnt sie hier erneut verwenden. \n", "1. Sie haben bereits die Funktionen für die Leistung in Aufgabe 3 definiert und können sie hier erneut verwenden. \n",
"2. Das Slicen von verschachtelten Listen funktioniert genauso wie bei normalen Listen: \n", "2. Das Slicen von verschachtelten Listen funktioniert genauso wie bei normalen Listen:\n",
"\n", "\n",
"```python\n", "```python\n",
"spalte0 = daten[0] #<-- Wählt die Spalte 0 an \n", "spalte0 = daten[0] #<-- Wählt die Spalte 0 an \n",
@ -1243,7 +1242,7 @@
"daten[0][2] \n", "daten[0][2] \n",
"```\n", "```\n",
"\n", "\n",
"3. Geben Sie an wie sich die Messwertnummer zum Listenindex verhält.\n", "3. Geben Sie an, wie sich die Messwertnummer zum Listenindex verhält.\n",
"<div>" "<div>"
] ]
}, },
@ -1267,13 +1266,13 @@
" \n", " \n",
"#### Vorbereitungsaufgabe 1.: Werte der Schiefen Ebene in Pyhton übertragen:\n", "#### Vorbereitungsaufgabe 1.: Werte der Schiefen Ebene in Pyhton übertragen:\n",
"\n", "\n",
"Am Python-Versuchstag selbst wollen wir anhand der Messdaten zur Bestimmung der Fallbeschleunigung auf Planet ?? das fitten von Funktionen mittels $\\chi^2$ üben. Als Vorbereitung hierfür sollen Sie die Messdaten der gemessenen Zeiten und Höhen so wie ihre Fehler als Listen in Python eintippen. \n", "Am Python-\"Versuchstag\" selbst wollen wir anhand der Messdaten zur Bestimmung der Fallbeschleunigung auf Planet X das Fitten von Funktionen mittels $\\chi^2$ üben. Als Vorbereitung hierfür sollen Sie die Messdaten der gemessenen Zeiten und Höhen so wie ihre Fehler als Listen in Python eintippen. \n",
"\n", "\n",
"Darüber hinaus definieren Sie sich eine Funktion $h(t)$ welche proportional zu $g_{??}$ ist. Diese Funktion soll am Ende des Versuchstages gegen die Messdaten in einem Höhe-gegen-Zeit Diagramm gefittet werden.\n", "Darüber hinaus definieren Sie sich eine Funktion $h(t)$ welche proportional zu $g_{??}$ ist. Diese Funktion soll am Ende des Tages gegen die Messdaten in einem Höhe-gegen-Zeit Diagramm gefittet werden.\n",
" \n", " \n",
"**Tipp:**\n", "**Tipp:**\n",
" \n", " \n",
"Um welche Art von Bewegung handelt es sich bei einem Freienfall im luftleeren Raum?\n", "Um welche Art von Bewegung handelt es sich bei einem freien Fall im luftleeren Raum?\n",
"<div>" "<div>"
] ]
}, },
@ -1287,7 +1286,7 @@
], ],
"metadata": { "metadata": {
"kernelspec": { "kernelspec": {
"display_name": "Python 3", "display_name": "Python 3 (ipykernel)",
"language": "python", "language": "python",
"name": "python3" "name": "python3"
}, },
@ -1301,9 +1300,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.7.6" "version": "3.9.6"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 2 "nbformat_minor": 4
} }

100
Herleitung_Methode_der_kleinsten_Quadrate.ipynb Normal file
View file

@ -0,0 +1,100 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "f3b16f1a-521e-4caf-828e-85251faf2c6c",
"metadata": {},
"source": [
"Dieses Dokument beinhaltet die Herleitung der Methode der kleinsten Quadrate, die im Kapitel 1 beim Fitten benutzt wird."
]
},
{
"cell_type": "markdown",
"id": "a144903b-e362-40de-8af0-7da7b39fe260",
"metadata": {},
"source": [
"### Methode der kleinsten Quadrate\n",
"\n",
"Im folgenden wolllen wir die **Methode der kleinsten Quadrate (Least Squares)** näher beleuchten. Diese Methode wird oft benutzt, um eine Funktion $\\lambda(x; \\ $**$\\phi$**$)$ mit den Funktionsparametern $\\mathbf{\\phi}$ an die gemessenen Punkte **$(x,y)$** anzupassen. Um jedoch die **Methode der kleinsten Quadrate** zu verstehen, wollen wir sie erst einmal anschaulich und mathematisch herleiten. Dabei stüzen wir uns im Folgenden auf eine Herleitung aus dem Buch **\"Statistical Data Analysis\"** von **Glen Cowan**.\n",
"\n",
"In unserem Grundpraktikum haben wir bereits gelernt, dass Messwerte durch Zufallszahlen $x_i$ representiert werden und einer gewissen **Wahrscheinlichkeitsdichtefunktion (probability density function)** $f(x)$ unterliegen.\n",
"\n",
"<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/PorbDensFun.png\" alt=\"{{ Beispiel PDF }}\" width=70%>\n",
"</figure>\n",
"\n",
"\n",
"Eine **pdf** gibt an, mit welcher **Wahrscheinlichkeit ein Wert $x_i$** innerhalb eines **infinitesimalen Intervals $\\text{d}x_i$** zu finden ist. Des Weitren gilt, dass die Gesamtwahrscheinlichkeit gegeben ist durch $\\int_S f(x) dx = 1$. \n",
"\n",
"Nun betrachten wir folgendes Beispiel: In unserem Labor messen wir genau drei mal die Raumtemperartur T. Auch hier gilt, dass unsere Messung der einzelnen $T_i$ einer gewissen **Wahrscheinlichkeitsdichtefunktion** folgen. Betrachten Sie nun das folgende Bild; Welche **Wahrscheinlichkeitsdichtefunktion** passt besser zu den gezeigten Daten und **Warum?**\n",
"\n",
"<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/ProbMaxTemp.png\" alt=\"{{ Beispiel PDF }}\" width=100%>\n",
"</figure>\n",
"\n",
"Die rechte Verteilung spiegelt unsere Messdaten besser wieder. Dies können wir auch mathematisch ausdrücken. Für $N$ voreinander unabhängige Zufallszahlen bzw. Messpunkte (in unserem Beispiel $N = 3$) ist die Gesamtwahrscheinlichkeit gegeben durch das Produkt der einzelnen Wahrscheinlichkeitsdichten $f(x_i, \\theta)$ multipliziert mit dem jeweiligen infinitesimalen element $dx_i$\n",
"\n",
"$$\\prod_{i = 1}^{N} f(x_i,\\theta) \\ dx_i \\text{ für alle } x_i \\text{ in } [x_i, x_i + dx_i]$$\n",
"\n",
"wobei $x_i$ in unserem Beispiel den Messpunkten $T_i$ und $f(x_i,\\theta)$ unserer Gausverteilung mit $\\theta = (\\mu, \\sigma)$ entspricht. Sprich sofern unsere Werte gut von der jeweiligen **Wahrscheinlichkeitsdichtefunktion** repräsentiert werden, d.h. wir die richtigen Parameter $\\theta$ gewählt haben (wie im rechten oberen Plot), gilt \n",
"\n",
"$$ \\prod_{i = 1}^{N} f(x_i,\\theta) dx_i$$ \n",
"\n",
"ist **maximal**. Da die einzelnen $dx_i$ von unseren Parametern $\\theta$ unabhängig sind, gilt die gleiche Argumentation auch für \n",
"\n",
"$$ \\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N) = \\prod_{i = 1}^{N} f(x_i,\\theta)$$ \n",
"\n",
"wobei $\\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N)$ die sogenannte **likely hood function** darstellt.\n",
"\n",
"Wie kommen wir nun von der **likely hood function** auf unsere **Methode der kleinsten Quadrate** und das Fitten einer Funktion $\\lambda(x; \\ $**$\\phi$**$)$ an die gemessenen Punkte **$(x,y)$**? Dazu brauche wir noch einen Zwischenschritt. Oftmals ist es einfacher, statt die **likely hood function** zu maximieren, die so genannte **log likely hood function**\n",
"\n",
"$$ \\log( \\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N)) = \\sum_{i = 1}^{N} \\log(f(x_i,\\theta))$$\n",
"\n",
"zu maximieren. Dies ist im Grunde das Gleiche, da der Logarithmus eine monoton-steigende Funktion ist. Auch in unserem Fall der **Methode der kleinsten Quadrate** benötigen wir die **log likely hood function**. \n",
"\n",
"Stellen Sie sich nun vor, wir haben eine Messung mit $N$ voneinander unabhängigen Messpunkten (x,y). Des Weiteren nehmen wir an, dass alle $x_i$ ohne Fehler sind und dass unsere $y_i$ gaußförmig um einen unbekannten Wahrenwert $\\lambda_i$ (sprich $\\lambda_i$ entspricht dem Erwartungswert $\\mu_i$ unserer Gaußverteilung) mit einer bekannten Varianz $\\Delta y_i^2$ verteilt sind (Diese Annahme lässt sich mit dem zentralen Grenzwertsatz begründen, so lange der Fehler sich aus der Summe kleiner Fehler zusammensetzt). Die dazugehörige **likely hood function** ist dann gegeben durch:\n",
"\n",
"$$ \\mathcal{L}(y_1 ... y_N; \\lambda_1 ... \\lambda_N, \\Delta y_1 ... \\Delta y_N)) = \\prod_{i = 1}^{N}\\frac{1}{\\sqrt{2 \\pi \\Delta y_i^2}} \\cdot \\exp \\bigg( \\frac{ -(y_i - \\lambda_i)^2}{2 \\cdot \\Delta y_i^2}\\bigg)$$\n",
"\n",
"Beziehungsweise die **log likely hood function** mit $\\lambda_i = \\lambda(x_i; \\phi)$ ergibt sich zu\n",
"\n",
"$$ \\log(\\mathcal{L}(y, \\theta)) \\approx -\\frac{1}{2} \\sum_{i = 1}^{N}\\bigg( \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}\\bigg)$$\n",
"\n",
"wobei die konstanten Terme, welche nicht von unserer Funktion $\\lambda(x_i; \\phi)$ abhängen, vernachlässigt worden sind. Durch den Faktor $-\\frac{1}{2}$ ist das Maximieren dieser **log likely hood function** gleich dem Minimieren von\n",
"\n",
"$$ \\chi(\\phi_1 ... \\phi_N)^2 = \\sum_{i = 1}^{N} \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}$$\n",
"\n",
"Diese Funktion ist unsere gesuchte **Methode der kleinsten Quadrate**. Mit ihrer Hilfe kann eine beliebige Funktion $\\lambda(x; \\phi)$, welche liniear in ihren Parametern $\\phi$ ist, an unsere Messdaten $(x,y\\pm\\Delta y)$ gefittet werden. Dabei stellt der Fitprozess selbst lediglich ein Minimierungsproblem dar. Im Folgenden sind unsere Annahmen noch einmal grafisch in einem Beispiel dargestellt.\n",
"\n",
"<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/LeastSquare.png\" alt=\"{{ Least Square Beispiel }}\" width=100%>\n",
"</figure>\n",
"\n",
"Es gibt verschiedene Arten von Algorithmen um Minimierungsprobleme zu lösen. Wie diese genau aufgebaut sind, lernen Sie in anderen Progrmmierveranstaltungen wie zum Beispiel *Programmieren für Physiker* oder *Computer in der Wissenschaft*. Zum Glück haben uns bereits in Python andere Menschen diese Arbeit abgenommen und wir können aus dem Package `scipy.optimize` die Funktion `curve_fit` verwenden.\n",
"\n",
"Hierbei stellt `curve_fit` eine Methode dar, Fit-Funktionen nach der obigen vorgestellten Methode der *kleinsten Quadraten* zu bestimmen. Dies hat zur Folge, dass lediglich die y-Fehler der Messwerte für den Fit verwendet werden können."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.6"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

57
Kapitel_0._Ihr_erstes_Notebook.ipynb
View file

@ -6,25 +6,25 @@
"source": [ "source": [
"# Einführung Jupyter-Notebooks\n", "# Einführung Jupyter-Notebooks\n",
"\n", "\n",
"In diesem Notebook wollen wir Sie mit den Grundlagen und Aufbau des Jupyter-Servers und des Jupyter-Notebooks vertraut machen. Bitte lesen Sie die folgenden Abschnitte aufmerksam durch und vervollständigen Sie die Installation des Kursmaterials am ende des Notebooks.\n", "In diesem Notebook wollen wir Sie mit den Grundlagen und Aufbau des Jupyter-Servers und des Jupyter-Notebooks vertraut machen. Bitte lesen Sie die folgenden Abschnitte aufmerksam durch und vervollständigen Sie die Installation des Kursmaterials am Ende des Notebooks.\n",
"\n", "\n",
"## Jupyter Notebooks ausführen\n", "## Jupyter-Notebooks ausführen\n",
"\n", "\n",
"In diesem Abschnitt wollen wir Ihnen erklären wie Sie auf den Jupyter-Server zugreifen können.\n", "In diesem Abschnitt wollen wir Ihnen erklären, wie Sie auf den Jupyter-Server zugreifen können.\n",
"\n", "\n",
"### ZDV Jupyter Hub\n", "### ZDV JupyterHub\n",
"\n", "\n",
"Sie können auch den durch die ZDV angebotenen Jupyter Hub (https://jupyterhub.zdv.uni-mainz.de/hub/login) zur Bearbeitung Ihrer Notebooks verwenden. **Falls Sie das Jupyterhub von außerhalb des Uni-Netzwerks erreichen wollen, müssen Sie eine VPN-Verbindung zum Uni-Netzwerk aufbauen, oder über eine Remotedesktop-Verbindung arbeiten.** Wir empfehlen Ihnen letzteres. Eine Erklärung wie Sie eine Remotedesktop-Verbindung aufbauen finden Sie auf den [Seiten der ZDV](https://www.zdv.uni-mainz.de/remotedesktop-arbeiten-am-entfernten-arbeitsplatz/). Sollten Sie das Arbeiten über VPN bevorzugen so finden Sie eine Anleitung für die gebräuchlichsten Betriebssysteme [hier]( https://www.zdv.uni-mainz.de/vpn-netz-zugang-von-ausserhalb-des-campus/). \n", "Sie können auch den durch die ZDV angebotenen Jupyter Hub (https://jupyterhub.zdv.uni-mainz.de) zur Bearbeitung Ihrer Notebooks verwenden.\n",
"\n", "\n",
"Um Zugang zum Jupyter-Hub zu erhalten, müssen Sie sich zunächst mit Ihrem Uni-Account anmelden. Danach erscheint eine Auswahlseite, auf der Sie die Art der Jupyter Umgebung auswählen. Für das Praktikum ist die Standardumgebung die richtige Wahl, s. Bild unten.\n", "Um Zugang zum Jupyter-Hub zu erhalten, müssen Sie sich zunächst mit Ihrem Uni-Account anmelden. Danach erscheint eine Auswahlseite, auf der Sie die Art der Jupyter Umgebung auswählen. Für das Praktikum ist die Standardumgebung die richtige Wahl, s. Bild unten.\n",
"\n", "\n",
"![images/Screenshot_ZDV_JupyterHub.png](images/Screenshot_ZDV_JupyterHub.png)\n", "![images/Screenshot_ZDV_JupyterHub.png](images/Screenshot_ZDV_JupyterHub.png)\n",
"\n", "\n",
"Klicken Sie auf die Schaltfläche **Spawn**, dann öffnet sich, wie bei der lokalen Installation, das Notebook Dashboard.\n", "Klicken Sie auf die Schaltfläche **Spawn**, dann öffnet sich das Notebook Dashboard.\n",
"\n", "\n",
"### Lokale Installation\n", "### Lokale Installation\n",
"\n", "\n",
"Sofern Sie nach diesem Kurs lieber mit einer lokalen Version von Jupyter arbeiten möchten, empfehlen wir Ihnen die Installation via Anaconda. Folgen Sie hierfür dem folgenden [Link](https://www.anaconda.com/distribution/). Wählen Sie zunächst das von Ihnen verwendete Betriebssystem aus und installieren Sie die Python Version 3.7 (64-Bit).\n", "Sofern Sie nach diesem Kurs lieber mit einer lokalen Version von Jupyter arbeiten möchten, empfehlen wir Ihnen die Installation via Anaconda. Folgen Sie hierfür dem folgenden [Link](https://www.anaconda.com/distribution/). Wählen Sie zunächst das von Ihnen verwendete Betriebssystem aus und installieren Sie die letzte Python Version (64-Bit). Bei diesem Python-Kurs wird eine lokale Installation nicht gebraucht.\n",
"\n", "\n",
"## Ein neues Notebook-Dokument anlegen\n", "## Ein neues Notebook-Dokument anlegen\n",
"\n", "\n",
@ -36,7 +36,7 @@
"\n", "\n",
"Ein offenes Notebook hat genau eine interaktive Sitzung, die mit einem Kernel verbunden ist, der den vom Benutzer gesendeten Code ausführt und die Ergebnisse zurückgibt. Dieser Kernel bleibt aktiv, wenn das Webbrowser-Fenster geschlossen ist, und das erneute Öffnen desselben Notebooks über das Dashboard stellt die Verbindung zwischen der Webanwendung und demselben Kernel wieder her.\n", "Ein offenes Notebook hat genau eine interaktive Sitzung, die mit einem Kernel verbunden ist, der den vom Benutzer gesendeten Code ausführt und die Ergebnisse zurückgibt. Dieser Kernel bleibt aktiv, wenn das Webbrowser-Fenster geschlossen ist, und das erneute Öffnen desselben Notebooks über das Dashboard stellt die Verbindung zwischen der Webanwendung und demselben Kernel wieder her.\n",
"\n", "\n",
"## Die Notebook Benutzeroberfläche\n", "## Die Notebook-Benutzeroberfläche\n",
"\n", "\n",
"Wenn Sie ein neues Notebook-Dokument erstellen, werden Ihnen der Name des Notebooks, eine Menüleiste, eine Symbolleiste und eine leere Codezelle angezeigt.\n", "Wenn Sie ein neues Notebook-Dokument erstellen, werden Ihnen der Name des Notebooks, eine Menüleiste, eine Symbolleiste und eine leere Codezelle angezeigt.\n",
"\n", "\n",
@ -48,11 +48,11 @@
"\n", "\n",
"**Symbolleiste**: Die Symbolleiste bietet eine schnelle Möglichkeit, die am häufigsten verwendeten Operationen innerhalb des Notebooks durchzuführen, indem Sie auf ein Symbol klicken.\n", "**Symbolleiste**: Die Symbolleiste bietet eine schnelle Möglichkeit, die am häufigsten verwendeten Operationen innerhalb des Notebooks durchzuführen, indem Sie auf ein Symbol klicken.\n",
"\n", "\n",
"**Codezelle**: der Standardtyp der Zelle; lesen Sie weiter, um eine Erklärung der Zellen zu erhalten.\n", "**Codezelle**: Der Standardtyp der Zelle; lesen Sie weiter, um eine Erklärung der Zellen zu erhalten.\n",
"\n", "\n",
"## Aufbau eines Notebook Dokuments\n", "## Aufbau eines Notebook-Dokuments\n",
"\n", "\n",
"Das Notebook besteht aus einer Folge von Zellen. Eine Zelle ist ein mehrzeiliges Texteingabefeld, dessen Inhalt mit Shift-Enter oder durch Anklicken der Schaltfläche \"Play\" in der Symbolleiste oder Cell, Run in der Menüleiste ausgeführt werden kann. Das Ausführungsverhalten einer Zelle wird durch den Zellentyp bestimmt. Es gibt drei Arten von Zellen: Codezellen, Abschriftenzellen und Rohzellen. Jede Zelle beginnt damit, eine Codezelle zu sein, aber ihr Typ kann über ein Dropdown-Menü in der Symbolleiste (das zunächst \"Code\" sein wird) oder über Tastenkombinationen geändert werden.\n", "Das Notebook besteht aus einer Folge von Zellen. Eine Zelle ist ein mehrzeiliges Texteingabefeld, dessen Inhalt mit **Shift + Enter** oder durch Anklicken der Schaltfläche \"Play\" in der Symbolleiste oder Cell, Run in der Menüleiste ausgeführt werden kann. Das Ausführungsverhalten einer Zelle wird durch den Zellentyp bestimmt. Es gibt drei Arten von Zellen: Codezellen, Abschriftenzellen und Rohzellen. Jede Zelle beginnt damit, eine Codezelle zu sein, aber ihr Typ kann über ein Dropdown-Menü in der Symbolleiste (das zunächst \"Code\" sein wird) oder über Tastenkombinationen geändert werden.\n",
"\n", "\n",
"### Code-Zellen\n", "### Code-Zellen\n",
"\n", "\n",
@ -79,7 +79,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Um diese Code-Zelle auszuführen, müssen Sie die jeweilige Celle anwählen und die Tastenkombination: **STRG + ENTER** oder **SHIFT + ENTER** verwenden. Das Ergebnis wird direkt unterhalb der Zelle angezeigt." "Um diese Code-Zelle auszuführen, müssen Sie die jeweilige Zelle anwählen und die Tastenkombination: **STRG + ENTER** oder **SHIFT + ENTER** verwenden. Das Ergebnis wird direkt unterhalb der Zelle angezeigt."
] ]
}, },
{ {
@ -97,7 +97,7 @@
"\n", "\n",
"Sie können den Berechnungsprozess versiert dokumentieren, indem Sie beschreibenden Text mit Code abwechseln und Rich Text verwenden. In IPython wird dies durch die Markierung von Text mit der Markdown-Sprache erreicht. Die entsprechenden Zellen werden als Markdown-Zellen bezeichnet. Die Markdown-Sprache bietet eine einfache Möglichkeit, dieses Textmarkup durchzuführen, d.h. festzulegen, welche Teile des Textes hervorgehoben werden sollen (Kursivschrift), Fett, Formularlisten usw.\n", "Sie können den Berechnungsprozess versiert dokumentieren, indem Sie beschreibenden Text mit Code abwechseln und Rich Text verwenden. In IPython wird dies durch die Markierung von Text mit der Markdown-Sprache erreicht. Die entsprechenden Zellen werden als Markdown-Zellen bezeichnet. Die Markdown-Sprache bietet eine einfache Möglichkeit, dieses Textmarkup durchzuführen, d.h. festzulegen, welche Teile des Textes hervorgehoben werden sollen (Kursivschrift), Fett, Formularlisten usw.\n",
"\n", "\n",
"Innerhalb von Markdown-Zellen können Sie mathematische Ausdrücke auch auf einfache Weise mit der Standard-LaTeX-Notation einbinden: `$...$` für Inline-Mathematik und `$$...$$` für angezeigte Mathematik. Wenn die Markdown-Zelle ausgeführt wird, werden die LaTeX-Abschnitte automatisch in der HTML-Ausgabe als Gleichungen mit hochwertiger Typografie dargestellt. Möglich wird dies durch MathJax, das eine große Teilmenge der LaTeX-Funktionalität unterstützt. \n", "Innerhalb von Markdown-Zellen können Sie mathematische Ausdrücke auch auf einfache Weise mit der Standard-LaTeX-Notation einbinden: `$...$` für Inline-Mathematik und `$$...$$` für angezeigte Mathematik. Wenn die Markdown-Zelle ausgeführt wird, werden die LaTeX-Abschnitte automatisch in der HTML-Ausgabe als Gleichungen mit hochwertiger Typografie dargestellt.\n",
"\n", "\n",
"Es existiert also eine ganze Bandbreite an Formatierungsmöglichkeiten. Hier einige Beispiele:\n", "Es existiert also eine ganze Bandbreite an Formatierungsmöglichkeiten. Hier einige Beispiele:\n",
"\n", "\n",
@ -131,11 +131,11 @@
" return 2 * x\n", " return 2 * x\n",
"```\n", "```\n",
"\n", "\n",
"**Formeln mit Hilfe des Latex-Syntax:**\n", "**Formeln mithilfe des LaTeX-Syntax:**\n",
"\n", "\n",
"$ f(x) = \\int\\limits_0^\\infty e^{-x} \\, dx $\n", "$ f(x) = \\int\\limits_0^\\infty e^{-x} \\, dx $\n",
"\n", "\n",
"(Latex werdet Sie verstärkt im F-Praktikum kennen lernen)\n", "(LaTeX werden Sie verstärkt im F-Praktikum kennenlernen)\n",
"\n", "\n",
"\n", "\n",
"**Bilder:**\n", "**Bilder:**\n",
@ -143,7 +143,7 @@
"![The Python logo](https://www.python.org/static/community_logos/python-powered-w-200x80.png \"Das Python Logo\")\n", "![The Python logo](https://www.python.org/static/community_logos/python-powered-w-200x80.png \"Das Python Logo\")\n",
"\n", "\n",
"\n", "\n",
"Darüber hinaus bietet uns das Jupyter Notebook noch diverse weitere Optionen an welche unseren harten Alltag vereinfachen. Bevor wir hier jedoch mehr ins Detail gehen möchten sollten wir die Installation des Kursmaterials abschließen. Hierzu führen Sie die nachfolgende Zelle aus." "Darüber hinaus bietet uns das Jupyter Notebook noch diverse weitere Optionen an, welche unseren harten Alltag vereinfachen. Bevor wir hier jedoch mehr ins Detail gehen, sollten wir die Installation des Kursmaterials abschließen. Hierzu führen Sie die nachfolgende Zelle aus:"
] ]
}, },
{ {
@ -164,32 +164,27 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Hier durch werden einige Styleoptionen installiert welche die von euch zu bearbeiten Aufgaben optisch hervorheben. Nachdem ihr die Optionen installiert habt müsst ihr euer Jupyter-Server neustarten geht hierfür wie folgt vor (**lest erst die ganze Anweisung!**): \n", "Hierdurch werden einige Styleoptionen installiert, welche die von Ihnen zu bearbeitenden Aufgaben optisch hervorheben. Nachdem Sie die Optionen installiert haben müssen Sie den Jupyter-Server neustarten. Gehen Sie hierfür wie folgt vor (**Lesen Sie zuerst die ganze Anweisung!**):\n",
"\n", "\n",
"1. Speichert euer Notebook ab in dem ihr auf das kleine Disketensmbol in der obigen Menüleiste klickt.\n", "1. Speicheren Sie das Notebook ab, in dem Sie auf das kleine Disketensmbol in der obigen Menüleiste klickt.\n",
"2. Anschließend müssen wir das aktuelle Notebook schließen. Geht hier für auf **File** --> **Close and Halt**. Jetzt müssen wir nur noch unseren Server neustarten. Klicken Sie hierfür in der oberen rechten Ecke auf die Schaltfläche **Control Panel** und anschließend auf die Fläche **Stop My Server**. \n", "2. Anschließend müssen wir das aktuelle Notebook schließen. Gehen Sie hierfür auf **File** --> **Close and Halt**. Jetzt müssen wir nur noch unseren Server neustarten. Klicken Sie hierfür in der oberen rechten Ecke auf die Schaltfläche **Control Panel** und anschließend auf die Fläche **Stop My Server**.\n",
"\n", "\n",
"![images/Screenshot_ZDV_JupyterHub.png](images/JupyterServerNeustarten.png)\n", "![images/Screenshot_ZDV_JupyterHub.png](images/JupyterServerNeustarten.png)\n",
"\n", "\n",
"3. Anschließend können Sie mit der Schaltfläche **Start My Server** den Jupyter-Server neustarten. Wählen Sie wieder das **default environment** aus uns spawnen Sie den Server.\n", "3. Anschließend können Sie mit der Schaltfläche **Start My Server** den Jupyter-Server neustarten. Wählen Sie wieder das **default environment** aus und spawnen Sie den Server.\n",
"\n", "\n",
"![images/Screenshot_ZDV_JupyterHub.png](images/Screenshot_ZDV_JupyterHub.png)\n", "![images/Screenshot_ZDV_JupyterHub.png](images/Screenshot_ZDV_JupyterHub.png)\n",
"4. Öfnnen Sie nun das Notebook **Aufgaben_zur_Vorbereitung_von_Kapitel_1** und bearbeiten Sie dieses als Vorbereitung für den Versuchstag. Sofern die Installation der Styleoptionen erfolgreich war sollten ihnen die Aufgaben wie folgt dargestellt werden:\n", "4. Öfnnen Sie nun das Notebook **Aufgaben_zur_Vorbereitung_von_Kapitel_1** und bearbeiten Sie dieses als Vorbereitung für den Versuchstag. Sofern die Installation der Styleoptionen erfolgreich war sollten ihnen die Aufgaben wie folgt dargestellt werden:\n",
"\n", "\n",
"![images/Screenshot_ZDV_JupyterHub.png](images/Aufgaben_Style_Beispiel.png)" "![images/Screenshot_ZDV_JupyterHub.png](images/Aufgaben_Style_Beispiel.png)\n",
"\n",
"Wird Jupyterlab statt Jupyter genutzt, dann kann es sein, dass die besondere Formatierung nicht funktioniert. Dies ist kein Problem, da es sich dabei um eine optische Verbesserung handelt."
] ]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
} }
], ],
"metadata": { "metadata": {
"kernelspec": { "kernelspec": {
"display_name": "Python 3", "display_name": "Python 3 (ipykernel)",
"language": "python", "language": "python",
"name": "python3" "name": "python3"
}, },
@ -203,9 +198,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.7.6" "version": "3.9.6"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 2 "nbformat_minor": 4
} }

266
Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb
View file

@ -11,13 +11,13 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"In Ihrer Vorbereitung haben Sie bisher die folgenden Konzepte kennen gelernt:\n", "In Ihrer Vorbereitung haben Sie bisher die folgenden Konzepte kennengelernt:\n",
"\n", "\n",
"* Aufbau eines Jupyter-Notebooks (Aufgabe 1).\n", "* Aufbau eines Jupyter-Notebooks (Aufgabe 1).\n",
"* Einfache Rechenoperationen (Aufgabe 2 a.)\n", "* Einfache Rechenoperationen (Aufgabe 2 a.)\n",
"* Einfache Zeichenketten (engl. Strings) und formatierte Strings (Aufgabe 2 b.).\n", "* Einfache Zeichenketten (engl. Strings) und formatierte Strings (Aufgabe 2 b.).\n",
"* Das definieren von Funktionen (Aufgabe 3.)\n", "* Das Definieren von Funktionen (Aufgabe 3.)\n",
"* Das definieren von Messtabellen.\n", "* Das Definieren von Messtabellen.\n",
"\n", "\n",
"Hierauf wollen wir an unserem heutigen Versuchstag aufbauen." "Hierauf wollen wir an unserem heutigen Versuchstag aufbauen."
] ]
@ -28,7 +28,7 @@
"source": [ "source": [
"## Arbeiten mit Messreihen:\n", "## Arbeiten mit Messreihen:\n",
"\n", "\n",
"Bisher hat uns das programmieren eher mehr Arbeit gemacht als uns welche abgenommen. Zeitersparnis bekommen wir sofern wir viele Rechnungen hintereinander ausführen müssen. Hierfür gibt es die **for**-Schleife. Diese Schleife führt die gleichen Zeilen eins Codes wiederholt für die Elemente in einer Liste aus:" "Bisher hat uns das programmieren eher mehr Arbeit gemacht als uns welche abgenommen. Zeitersparnis bekommen wir, wenn wir viele Rechnungen hintereinander ausführen müssen. Hierfür gibt es die **for**-Schleife. Diese Schleife führt die gleichen Zeilen eins Codes wiederholt für die Elemente in einer Liste aus:"
] ]
}, },
{ {
@ -54,7 +54,9 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Bei einer Schleife ist darauf zu achten, dass der Anweisungsblock welcher wiederholt ausgeführt werden soll mit 4x Leerzeichen eingrückt wurde. Dies entspricht einmal <img src=\"images/Tab-Key.png\" alt=\"Tab-Taste\" width=\"100\"/>" "Bei einer Schleife ist darauf zu achten, dass der Anweisungsblock, welcher wiederholt ausgeführt werden soll, mit 4x Leerzeichen eingrückt wurde. Dies entspricht einmal die **Tab-Taste**:\n",
"\n",
"<img src=\"images/Tab-Key.png\" alt=\"Tab-Taste\" width=\"80\"/>"
] ]
}, },
{ {
@ -106,7 +108,7 @@
" in Ohm.\n", " in Ohm.\n",
" \n", " \n",
" Returns:\n", " Returns:\n",
" float: Die Berechnete Spannung in V.\n", " float: Die berechnete Spannung in V.\n",
" '''\n", " '''\n",
" return Widerstand * Strom/1000" " return Widerstand * Strom/1000"
] ]
@ -123,7 +125,7 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"Stromwerte = [101, 105, 98, 87, 112] # mA\n", "Stromwerte = [101, 105, 98, 87, 112] # mA\n",
"Spannungswerte = []# Einheit? <-- Deshlab Docstrings und Help!\n", "Spannungswerte = [] # Einheit? <-- Deshalb Docstrings und Help!\n",
"Widerstand = 100 # Ohm\n", "Widerstand = 100 # Ohm\n",
"\n", "\n",
"for Strom in Stromwerte:\n", "for Strom in Stromwerte:\n",
@ -137,7 +139,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Python ermöglicht uns auch eine kompaktere Schreibweise die so genannte \"list comprehension\": " "Python ermöglicht uns auch eine kompaktere Schreibweise, die so genannte \"list comprehension\": "
] ]
}, },
{ {
@ -159,7 +161,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Wir können auch über mehre Daten gleichzeitig loopen. Hierzu kann die `zip` Anweisung genutzt werden. `zip` verbindet hierbei die einzelnen Elemente einer Liste wie bei einem Reißverschluss miteinander:" "Wir können auch über mehrere Daten gleichzeitig \"loopen\". Hierzu kann die `zip` Anweisung genutzt werden. `zip` verbindet hierbei die einzelnen Elemente einer Liste wie bei einem Reißverschluss miteinander:"
] ]
}, },
{ {
@ -184,7 +186,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Dies kann zum Beispiel dann hilfreich sein wenn sich mehr als eine Variable ändern soll, z.B. bei einer Messreihe für die Schallgeschwindigkeit in Luft:" "Dies kann zum Beispiel dann hilfreich sein, wenn sich mehr als eine Variable ändern soll, z.B. bei einer Messreihe für die Schallgeschwindigkeit in Luft:"
] ]
}, },
{ {
@ -248,7 +250,7 @@
"<div class=task>\n", "<div class=task>\n",
" \n", " \n",
"#### Aufgabe 4.b.: Werte berechnen:\n", "#### Aufgabe 4.b.: Werte berechnen:\n",
"Kopiert eure Aufgabe 4.a. aus der Vorbereitung in das Notebook und berechnet nun für die Messwerte aus Aufgabe 4 a. die Leistung $P$ und den Widerstand $R$ sowie deren Fehler. Nutzt hierfür die ausführliche schrebweise der **for**-Schleife im Fall des Widerstands $R$ und den list-comprehension Syntax für die Leistung $P$. Fügt die berechneten Werte als neue Spalten and die Liste *daten* an. \n", "Kopieren Sie Ihre Lösung von Aufgabe 4.a. aus der Vorbereitung in das Notebook und berechnen Sie nun für die Messwerte aus Aufgabe 4 a. die Leistung $P$ und den Widerstand $R$ sowie deren Fehler. Nutzen Sie hierfür die ausführliche schrebweise der **for**-Schleife im Fall des Widerstands $R$ und den list-comprehension Syntax für die Leistung $P$. Fügen Sie die berechneten Werte als neue Spalten an die Liste *daten* an. \n",
"<div>" "<div>"
] ]
}, },
@ -284,7 +286,7 @@
" \n", " \n",
"daten.append(widerstand)\n", "daten.append(widerstand)\n",
"\n", "\n",
"# Jetzt seid ihr gefragt:\n", "# Jetzt sind Sie gefragt:\n",
"\n" "\n"
] ]
}, },
@ -292,17 +294,17 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"## Das Darstellen von Messdaten mittels `matplotlib`:\n", "## Darstellung von Messdaten mittels `Matplotlib`:\n",
"Das Plotten von Daten ist eines der wichtigsten Mittel um eine Fülle von Informationen kompakt und verständlich seinem Gegenüber darzubieten. Gute Plots zu erstellen kann eine regelrechte Kunst sein und ist für ein gutes Paper, bzw. eine gute Bachelor- bzw. Masterarbeit unverzichtbar. \n", "Das Plotten von Daten ist eines der wichtigsten Mittel, um eine Fülle von Informationen kompakt und verständlich seinem Gegenüber darzubieten. Gute Plots zu erstellen kann eine regelrechte Kunst sein und ist für ein gutes Paper, bzw. eine gute Bachelor- bzw. Masterarbeit unverzichtbar. \n",
"\n", "\n",
"<figure class=\"image\">\n", "<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/Xenon1tResults1yearx1texposure.png\" alt=\"{{ Xenon1t results 2018 }}\" width=50%>\n", "<img src=\"images/MaterialPythonkurs092018/Xenon1tResults1yearx1texposure.png\" alt=\"{{ Xenon1t results 2018 }}\" width=50%>\n",
"<figcaption>Resultate des XENON1T Dunkle Materie Experiments. Die Graphik wurde mittels Matplotlib in Python erstellt. </figcaption>\n", "<figcaption>Resultate des XENON1T Dunkle Materie Experiments. Die Graphik wurde mittels Matplotlib in Python erstellt. </figcaption>\n",
"</figure>\n", "</figure>\n",
"\n", "\n",
"Jede Programmiersprache verfügt über zusätzliche Pakete (im Englischen \"packages\") welche die Funktionalität der verwendeten Programmiersprache erweitern. **Matplotlib** ist ein umfangreiches Package, welches das Zeichnen von 2D und 3D Grafiken ermöglicht. Alle Parameter und Einstellungen einer Grafik werden entsprechend des Python-Codes eingestellt. Dadurch wird das Erstellen der Grafik reproduzierbar und man kann schnell dieselbe Grafik mit neuen Daten füttern.\n", "Jede Programmiersprache verfügt über zusätzliche Pakete (im Englischen \"packages\"), welche die Funktionalität der verwendeten Programmiersprache erweitern. **Matplotlib** ist ein umfangreiches Package, welches das Zeichnen von 2D und 3D Grafiken ermöglicht. Alle Parameter und Einstellungen einer Grafik werden entsprechend des Python-Codes eingestellt. Dadurch wird das Erstellen der Grafik reproduzierbar und man kann schnell dieselbe Grafik mit neuen Daten füttern.\n",
"\n", "\n",
"Es ist unmöglich alle Möglichkeiten und Einstellungen die euch **Matplotlib** bietet auswendig zu kennen. Mit der Zeit werdet ihr ein solides Grundwissen der gängisten Befehle haben. Für alles weitere hilft euch die [Dokumentation und ihre Beispiele](http://matplotlib.org/). Des Weiteren ist insbesondere hier die **IPython Hilfe** und das **automatische Vervollständigen von Befehlen** besonders hilfreich.\n", "Es ist unmöglich, alle Möglichkeiten und Einstellungen, die **Matplotlib** bietet, auswendig zu kennen. Mit der Zeit werden Sie ein solides Grundwissen der gängisten Befehle haben. Für alles Weitere hilft die [Matplotlib-Dokumentation mit ihren Beispielen](http://matplotlib.org/). Des Weiteren ist insbesondere hier die **IPython-Hilfe** und die **automatische Vervollständigung von Befehlen** besonders hilfreich.\n",
"\n", "\n",
"Für das Praktikum wollen wir uns zunächst lediglich drei unterschiedliche Arten von Plots angucken:\n", "Für das Praktikum wollen wir uns zunächst lediglich drei unterschiedliche Arten von Plots angucken:\n",
"\n", "\n",
@ -315,7 +317,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Zunächst müssen wir Python mitteilen, dass wir das **Matplotlib** package nutzen möchten:" "Zunächst müssen wir Python mitteilen, dass wir das **Matplotlib** package nutzen wollen:"
] ]
}, },
{ {
@ -336,7 +338,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"`import` läd für und aus dem package matplotlib das Modul `pyplot`. Mit Hilfe des Zusatzes `as plt` wird ein alias erstellt. Dieser Alias erspart uns im nachfolgenden Arbeit, wie wir im nachfolgenden Beispiel sehen können:" "`import` läd für uns aus dem package matplotlib das Modul `pyplot`. Mit Hilfe des Zusatzes `as plt` wird ein \"alias\" (Abkürzung) erstellt. Dieser Alias erspart uns im Nachfolgenden Arbeit, wie wir im nachfolgenden Beispiel sehen können:"
] ]
}, },
{ {
@ -360,16 +362,16 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Hätten wir den Alias nicht definiert hätten wir den folgenden etwas länglichen Code benötigt:\n", "Hätten wir den Alias nicht definiert, hätten wir den folgenden etwas länglichen Code benötigt, den Sie niemals nutzen sollten:\n",
"\n", "\n",
"```python\n", "```python\n",
"matplotlib.pyplot.plot([1,2,3,4,5], [1,2,3,4,5])\n", "matplotlib.pyplot.plot([1,2,3,4,5], [1,2,3,4,5])\n",
"matplotlib.pyplot.show()\n", "matplotlib.pyplot.show()\n",
"```\n", "```\n",
"\n", "\n",
"Innerhalb der Python-Community haben sich ein paar Standards etabliert an welche man sich halten sollte. So ist für `matplotlib.pyplot` der Alias `plt` zu verwenden. \n", "Innerhalb der Python-Community haben sich ein paar Standards etabliert, an welche man sich halten sollte. So ist für `matplotlib.pyplot` der Alias `plt` zu verwenden.\n",
"\n", "\n",
"Im oberen Beispiel habt ihr nun auch bereits gesehen wie wir einfache Liniengrafiken erstellen können. Dabei sieht der Plot noch etwas blass aus. Dies können wir mit ein paar zusätzlichen Befehlen ändern." "Im oberen Beispiel haben Sie nun auch bereits gesehen, wie wir einfache Liniengrafiken erstellen können. Dabei sieht der Plot noch etwas blass aus. Dies können wir mit ein paar zusätzlichen Befehlen und Argumenten ändern."
] ]
}, },
{ {
@ -387,9 +389,9 @@
"ydaten = [1,2,2,4,5]\n", "ydaten = [1,2,2,4,5]\n",
"\n", "\n",
"plt.plot(xdaten, ydaten, # <-- Wie eben die x und y daten\n", "plt.plot(xdaten, ydaten, # <-- Wie eben die x und y daten\n",
" color = 'red', # <-- Farbe der Linie\n", " color='red', # <-- Farbe der Linie\n",
" linestyle='dashed', # <-- Linientyp\n", " linestyle='dashed', # <-- Linientyp\n",
" label='Spannungskurve' # <-- Name der Linie\n", " label='Spannungskurve', # <-- Name der Linie\n",
" )\n", " )\n",
"plt.xlabel('X-Achse') # <-- Beschriftung der x-Achse\n", "plt.xlabel('X-Achse') # <-- Beschriftung der x-Achse\n",
"plt.ylabel('Y-Achse') # <-- Beschiftung der y-Achse\n", "plt.ylabel('Y-Achse') # <-- Beschiftung der y-Achse\n",
@ -410,15 +412,14 @@
"* `'--'`: gestrichelte Linie\n", "* `'--'`: gestrichelte Linie\n",
"* `'-.'`: Strich-Punktlinie\n", "* `'-.'`: Strich-Punktlinie\n",
"* `':'`: Punktlinie\n", "* `':'`: Punktlinie\n",
"* `'steps'`: Treppenfunktion\n",
"\n", "\n",
"**Color**:\n", "**Color**:\n",
"* red, blue, yellow, \n", "* red, blue, yellow, ...\n",
"* RGB Werte von 0 bis 1 (statt von 0 bis 255): (1, 1, 1), (1, 0.2, 0.4)\n", "* RGB Werte von 0 bis 1 (statt von 0 bis 255): (1, 1, 1), (1, 0.2, 0.4)\n",
"\n", "\n",
"Darüber hinaus gibt es auch noch andere nützliche Styleoptionen wie `alpha` was die Transparenz eurer Linie ändert (Werte zwischen 0-1), oder `linewidth`-Option mit dessen Hilfe ihr die Linienbreite ändern könnt. \n", "Darüber hinaus gibt es auch noch andere nützliche Styleoptionen wie `alpha`, was die Transparenz der Linie ändert (Werte zwischen 0-1), oder die `linewidth`-Option, mit dessen Hilfe Sie die Linienbreite ändern können.\n",
"\n", "\n",
"Auch die anderen Befehle welche wir verwendetet haben verfügen über zusätzliche Optionen:" "Auch die anderen Befehle, welche wir verwendetet haben, verfügen über zusätzliche Optionen:"
] ]
}, },
{ {
@ -436,12 +437,12 @@
"ydaten = [1,2,2,4,5]\n", "ydaten = [1,2,2,4,5]\n",
"\n", "\n",
"plt.plot(xdaten, ydaten, \n", "plt.plot(xdaten, ydaten, \n",
" color = 'red', \n", " color='red', \n",
" linestyle='dashed', \n", " linestyle='dashed', \n",
" label='Graph 1' \n", " label='Graph 1' \n",
" )\n", " )\n",
"plt.xlabel('X-Achse',\n", "plt.xlabel('X-Achse',\n",
" color = (0,1,0) # <-- Beschriftungsfrabe\n", " color=(0,1,0) # <-- Beschriftungsfrabe\n",
" ) \n", " ) \n",
"\n", "\n",
"plt.ylabel('Y-Achse', \n", "plt.ylabel('Y-Achse', \n",
@ -509,7 +510,7 @@
"source": [ "source": [
"def cubic(x):\n", "def cubic(x):\n",
" '''\n", " '''\n",
" Funktion welche den cubischen Wert einer Zahl zurück gibt.\n", " Eine Funktion, die den cubischen Wert einer Zahl zurück gibt.\n",
" '''\n", " '''\n",
" return x**3\n", " return x**3\n",
"\n", "\n",
@ -523,6 +524,7 @@
"\n", "\n",
"plt.plot(x1, y1, label='Werte 1', linestyle='dashed')\n", "plt.plot(x1, y1, label='Werte 1', linestyle='dashed')\n",
"plt.plot(x2, y2, label='Werte 2')\n", "plt.plot(x2, y2, label='Werte 2')\n",
"\n",
"plt.xlabel('x-Werte')\n", "plt.xlabel('x-Werte')\n",
"plt.ylabel('y-Werte')\n", "plt.ylabel('y-Werte')\n",
"plt.legend()\n", "plt.legend()\n",
@ -535,7 +537,7 @@
"source": [ "source": [
"### Errorbarplot\n", "### Errorbarplot\n",
"\n", "\n",
"In der Physik gehören zu jedem gemessen Wert ein Messunsicherheit/Messfehler. Diese Fehler sollten natürlich auch in unseren Grafiken korrekt dargestellt werden. Hierfür können wir den `errorbar`-Plot verwenden." "In der Physik gehören zu jedem gemessen Wert eine Messunsicherheit / ein Messfehler. Diese Fehler sollten natürlich auch in unseren Grafiken korrekt dargestellt werden. Hierfür können wir den `errorbar`-Plot verwenden."
] ]
}, },
{ {
@ -555,6 +557,7 @@
"strom_error = [14, 9, 12, 8, 7, 11] # gemessener schwankender Fehler[mA]\n", "strom_error = [14, 9, 12, 8, 7, 11] # gemessener schwankender Fehler[mA]\n",
"\n", "\n",
"# plt.errorbar() # <--- Wie verwende ich den errorbar plot?\n", "# plt.errorbar() # <--- Wie verwende ich den errorbar plot?\n",
"\n",
"plt.ylabel('Spannung [V]')\n", "plt.ylabel('Spannung [V]')\n",
"plt.xlabel('Strom [mA]')\n", "plt.xlabel('Strom [mA]')\n",
"plt.show()" "plt.show()"
@ -566,25 +569,25 @@
"source": [ "source": [
"<div class=task>\n", "<div class=task>\n",
" \n", " \n",
"#### Aufgabe 5.: Erstelle eine `errorbar`-Plot :\n", "#### Aufgabe 5.: Erstellen einer `errorbar`-Plot:\n",
"\n", "\n",
"Editiert die obere Zelle so, dass ihr mit Hilfe des Befehls \n", "Editieren Sie die obere Zelle so, dass Sie mithilfe des Befehls \n",
"\n", "\n",
"```python\n", "```python\n",
"plt.errorbar()\n", "plt.errorbar()\n",
"```\n", "```\n",
"\n", "\n",
"einen Errorbarplot erstellt. Verwende hier für die IPython help-funktion um den exakten Syntax zu erfahren. \n", "einen Errorbarplot erstellen. Verwenden Sie hierfür die IPython-Hilfe-Funktion, um die exakte Syntax zu erfahren. \n",
"\n", "\n",
"**Erinnerung:**\n", "**Erinnerung:**\n",
"Ihr könnt die IPython-Hilfe aufrufen in dem ihr euren Cursor innerhalb das Wort errorbar von plt.errorbar bewegt und die Tastenkombination shift + tab verwendet. Lest nun nach wie ihr die x- und y-Werte und deren Fehler an die Funktion übergeben müsst.\n" "Sie können die IPython-Hilfe aufrufen, indem Sie den Cursor innerhalb des Worts errorbar von plt.errorbar bewegen und die Tastenkombination **Shift + Tab** verwenden. Lesen Sie nun nach, wie Sie die x- und y-Werte und deren Fehler an die Funktion übergeben müssen."
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Leider ist diese Standardvariante des Errorbar plots noch nicht das was wir möchten. Die Messwerte sind linear interpoliert und die errorbars sehen noch etwas eigenartig aus. Dies können wir jedoch im Handumdrehen ändern. Kümmern wir uns zunächst um die Plotmarker:" "Leider ist diese Standardvariante des Errorbar-Plots noch nicht das, was wir möchten. Die Messwerte sind linear interpoliert und die errorbars sehen noch etwas eigenartig aus. Dies können wir jedoch im Handumdrehen ändern. Kümmern wir uns zunächst um die Plotmarker:"
] ]
}, },
{ {
@ -619,7 +622,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"All die Optionen welche wir hier für die Plotmarker verwendet haben können wir auch in der normalen `plt.plot`-Anweisung verwenden. Dabei gibt es eine ganze fülle an unterschiedlichen [marker Symbole](http://matplotlib.org/api/markers_api.html):\n", "All die Optionen, welche wir hier für die Plotmarker verwendet haben, können wir auch in der normalen `plt.plot`-Anweisung verwenden. Dabei gibt es eine ganze Fülle an unterschiedlichen [Marker-Symbole](http://matplotlib.org/api/markers_api.html):\n",
" \n", " \n",
"* `+`: Plus\n", "* `+`: Plus\n",
"* `o`: Kreis\n", "* `o`: Kreis\n",
@ -630,7 +633,7 @@
"* `h`: Hexagon\n", "* `h`: Hexagon\n",
"* `1`, `2`, `3`, `4`: nach unten, oben, links, rechts zeigendes Dreieck\n", "* `1`, `2`, `3`, `4`: nach unten, oben, links, rechts zeigendes Dreieck\n",
" \n", " \n",
"Nach dem wir uns um unsere Marker gekümmert haben müssen wir nun auch noch unsere Fehlerbalken enstprechend anpassen:" "Nach dem wir uns um unsere Marker gekümmert haben, müssen wir nun auch noch unsere Fehlerbalken enstprechend anpassen:"
] ]
}, },
{ {
@ -657,7 +660,7 @@
" ecolor='k', # <-- Ändert die Linienfarbe der errorbars\n", " ecolor='k', # <-- Ändert die Linienfarbe der errorbars\n",
" elinewidth=2, # <-- Ändert die Fehlerbalkenbreite\n", " elinewidth=2, # <-- Ändert die Fehlerbalkenbreite\n",
" capsize=5, # <-- Ändert die Breite der Endkappen der Fehlerbalken\n", " capsize=5, # <-- Ändert die Breite der Endkappen der Fehlerbalken\n",
" capthick=2 # <-- Ändert die Dicke der Endkappen\n", " capthick=2, # <-- Ändert die Dicke der Endkappen\n",
" ) \n", " ) \n",
"\n", "\n",
"plt.ylabel('Spannung [V]')\n", "plt.ylabel('Spannung [V]')\n",
@ -671,7 +674,7 @@
"source": [ "source": [
"### Histogramme:\n", "### Histogramme:\n",
"\n", "\n",
"Ein weiterer Plottyp welcher häufig Verwendung findet ist das Histogramm. Um unser Histogramm mit Pseudozufallszahlen zu bestücken müssen wir diese erst erzeugen. Hierfür können wir das `numpy`-Modul verwenden. `numpy` ist ein weiteres Standardmodul welches viele nützliche Funktionen mit sich bringt. Hier wollen wir uns jedoch nur auf das erstellen von Zufallszahlen beschränken. " "Ein weiterer Plottyp, welcher häufig Verwendung findet, ist das Histogramm. Um unser Histogramm mit Pseudozufallszahlen zu bestücken, müssen wir diese erst erzeugen. Hierfür können wir das `numpy`-Modul verwenden. `numpy` ist ein weiteres Standardmodul, welches viele nützliche Funktionen mit sich bringt. Hier wollen wir uns jedoch nur auf die Erstellung von Zufallszahlen beschränken. "
] ]
}, },
{ {
@ -688,6 +691,13 @@
"import numpy as np" "import numpy as np"
] ]
}, },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`np` ist eine konvetionelle Abkürkung."
]
},
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
@ -699,7 +709,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"rnd_numbers = np.random.normal(0,1,1000) # <-- Hier werden 1000 gausförmig verteile Zufallszahlen\n", "rnd_numbers = np.random.normal(0, 1, 1000) # <-- Hier werden 1000 gausförmig verteile Zufallszahlen\n",
" # mit einem Mittelwert von 0 und einer Standardabweichung \n", " # mit einem Mittelwert von 0 und einer Standardabweichung \n",
" # von 1 erzeugt." " # von 1 erzeugt."
] ]
@ -708,7 +718,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Das histgrom lässt sich ganz einfach mit der `plt.hist`-Anweisung erstellt." "Das Histgromm lässt sich ganz einfach mit der `plt.hist`-Anweisung erstellt:"
] ]
}, },
{ {
@ -733,7 +743,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Auch für Histogramme gibt es viele unterschiedlichen Optionen welche ihr entweder mit Hilfe der Help-Funktion oder den Beispielen in der [Matplolibdokumentation](http://matplotlib.org/) herrausfinden könnt." "Auch für Histogramme gibt es viele unterschiedliche Optionen, welche Sie entweder mithilfe der Help-Funktion oder anhand der Beispiele in der [Matplolib-Dokumentation](http://matplotlib.org/) herrausfinden können."
] ]
}, },
{ {
@ -752,7 +762,7 @@
"\n", "\n",
"plt.hist(rnd_numbers, \n", "plt.hist(rnd_numbers, \n",
" bins=13, \n", " bins=13, \n",
" range=(-3,5), # <-- Achtung im Gegensatz zur range-Anweisung ist \n", " range=(-3,5), # <-- Achtung: Im Gegensatz zur range-Anweisung ist \n",
" # das Intervall hier geschlossen [-3, 5]\n", " # das Intervall hier geschlossen [-3, 5]\n",
" histtype='step', # Ändert den Balkentyp in Stufen\n", " histtype='step', # Ändert den Balkentyp in Stufen\n",
" linestyle='dashed',\n", " linestyle='dashed',\n",
@ -760,7 +770,7 @@
" )\n", " )\n",
"\n", "\n",
"plt.hist(rnd_numbers2, \n", "plt.hist(rnd_numbers2, \n",
" bins=13, \n", " bins=13,\n",
" range=(-3,5),\n", " range=(-3,5),\n",
" alpha=0.5, # Ändert die Transparenz der Balken \n", " alpha=0.5, # Ändert die Transparenz der Balken \n",
" label='Verteilung 2'\n", " label='Verteilung 2'\n",
@ -776,7 +786,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Bei Histogrammen solltet ihr immer darauf achten, dass euer binning sinnvoll gewählt ist. Weder zu viele noch zu wenig Bins führen zu einer sinnvollen Darstellung eurer Daten." "Bei Histogrammen sollten Sie immer darauf achten, dass das \"binning\" sinnvoll gewählt ist. Weder zu viele noch zu wenige Bins führen zu einer sinnvollen Darstellung Ihrer Daten."
] ]
}, },
{ {
@ -804,7 +814,7 @@
"plt.hist(rnd_numbers, \n", "plt.hist(rnd_numbers, \n",
" bins=3, \n", " bins=3, \n",
" range=(-3,3),\n", " range=(-3,3),\n",
" label='Zu wenig bins'\n", " label='Zu wenige bins'\n",
" )\n", " )\n",
"\n", "\n",
"plt.legend()\n", "plt.legend()\n",
@ -817,9 +827,9 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Nach dem wir jetzt die verschiedenen Plottypen mit ihren unterschiedlichen Optionen kennen gelernt haben möchten wir diese natürlich auch speichern können. Dies können wir auf zwei unterschiedliche Arten machen.\n", "Nach dem wir jetzt die verschiedenen Plottypen mit ihren unterschiedlichen Optionen kennengelernt haben, möchten wir diese natürlich auch speichern können. Dies können wir auf zwei unterschiedliche Arten machen.\n",
"\n", "\n",
"Entweder ihr macht mit eurer Maus einen Rechtsklick auf eure Grafik und wählt \"Grafik speichern als\" aus, oder ihr verwendet statt der `plt.show`- die `plt.savefig`-Anweisung dafür." "Entweder Sie machen mit Ihrer Maus einen Rechtsklick auf die Grafik und wählen \"Grafik speichern als\" aus, oder Sie verwenden statt der `plt.show`- die `plt.savefig`-Anweisung dafür, wobei Letzteres empfohlen ist."
] ]
}, },
{ {
@ -830,17 +840,17 @@
" \n", " \n",
"#### Aufgabe 6.: Erstellen einer gauss'schen Wahrscheinlichkeitsdichte:\n", "#### Aufgabe 6.: Erstellen einer gauss'schen Wahrscheinlichkeitsdichte:\n",
"\n", "\n",
"Im folgenden wollen wir ein Plot mit einer gauss'schen Wahrscheinlichkeitsdichte erstellen. Geht hierfür wie folgt vor:\n", "Im folgenden wollen wir ein Plot mit einer gauss'schen Wahrscheinlichkeitsdichte erstellen. Gehen Sie hierfür wie folgt vor:\n",
"\n", "\n",
"1. Erstellt euch 500000 pseudo-Zufallszahlen, welche einer Gaußverteilung mit $µ=5$ und $sigma=2$ folgen.\n", "1. Erstellen Sie 500000 pseudo-Zufallszahlen, welche einer Gaußverteilung mit $µ=5$ und $sigma=2$ folgen.\n",
"2. Tragt die Zufallszahlen in ein Histogramm ein und normiert dieses so dass die Gesamtfläche eins beträgt. **Tipp: `plt.hist` hat hierfür einen optionalen Parameter benutzt die Help oder das Internet um herrauszufinden welcher es ist.**\n", "2. Tragen Sie die Zufallszahlen in ein Histogramm ein und normieren Sie dieses, sodass die Gesamtfläche 1 beträgt. **Tipp: `plt.hist` hat hierfür einen optionalen Parameter. Benutzen Sie die Help oder das Internet, um herrauszufinden, welcher es ist.**\n",
"3. Wählt ein geeignete `range` und ein `binning` von 100 für das Histogram.\n", "3. Wählen Sie eine geeignete `range` und ein `binning` von 100 für das Histogram.\n",
"4. Plottet anschließend die dazugehörige Gaußverteilung als Funktion. Geht dabei wie folgt vor:\n", "4. Plotten Sie anschließend die dazugehörige Gaußverteilung als Funktion. Gehen Sie dabei wie folgt vor:\n",
" 1. Erstellt eine Gaußfunktion. *Erinnerung:* eine Gaußverteilung ist gegeben durch:\n", " 1. Erstellen Sie eine Gaußfunktion. *Erinnerung:* eine Gaußverteilung ist gegeben durch:\n",
" $$g(x, \\mu, \\sigma) = \\frac{1}{\\sqrt{2 \\pi} \\, \\sigma} \\exp\\bigg( \\frac{ -(x - \\mu)^2}{2 \\sigma^2}\\bigg) $$\n", " $$g(x, \\mu, \\sigma) = \\frac{1}{\\sqrt{2 \\pi} \\, \\sigma} \\exp\\bigg( \\frac{ -(x - \\mu)^2}{2 \\sigma^2}\\bigg) $$\n",
" **Tipp:** Das Numpy package beinhaltet die Zahlen pi und die Exponentialfunktion bereit. Ihr könnt diese über `np.pi` und `np.exp()` verwenden. \n", " **Tipp:** Das Numpy-Paket beinhaltet die Zahlen $\\pi$ und die Exponentialfunktion. Sie können diese über `np.pi` und `np.exp()` verwenden. \n",
" 2. Erstellt euch eine liste von x-Werten in der von euch gewählten range in 0.1er Schritten. Verwendetet hierfür die `range`-Funktion zusammen mit der listcomprehension.\n", " 2. Erstellen Sie eine Liste von x-Werten in der von Ihnen gewählten range in 0.1er Schritten. Verwenden Sie hierfür die `range`-Funktion zusammen mit der list-comprehension.\n",
" 3. Erstellt den plot.\n", " 3. Erstellen Sie den plot.\n",
"Das Ergebnis sollte wie folgt aussehen:\n", "Das Ergebnis sollte wie folgt aussehen:\n",
"\n", "\n",
"<figure class=\"image\">\n", "<figure class=\"image\">\n",
@ -856,74 +866,9 @@
"\n", "\n",
"### Methode der kleinsten Quadrate\n", "### Methode der kleinsten Quadrate\n",
"\n", "\n",
"Im folgenden wolllen wir die **Methode der kleinsten Quadrate (Least Squares)** näher beleuchten. Diese Methode wird oft benutzt um eine Funktion $\\lambda(x; \\ $**$\\phi$**$)$ mit den Funktionsparametern $\\mathbf{\\phi}$ an die gemessenen Punkte **$(x,y)$** anzupassen. Um jedoch die **Methode der kleinsten Quadrate** zu verstehen wollen wir sie erst einmal anschaulich und mathematisch herleiten. Dabei stüzen wir uns im folgenden auf eine Herleitung aus dem Buch **\"Statistical Data Analysis\"** von **Glen Cowan**.\n", "Die Herleitung dieser Methode befindet sich im separaten Notebook `Herleitung_Methode_der_kleinsten_Quadarate.ipynb`.\n",
"\n", "\n",
"In unserem Grundpraktikum haben wir bereits gelernt, dass Messwerte durch Zufallszahlen $x_i$ representiert werden und einer gewissen **Wahrscheinlichkeitsdichtefunktion (probability density function)** $f(x)$ unterliegen. \n", "Diese Methode ist in der Funktion `curve_fit` implementiert."
"\n",
"<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/PorbDensFun.png\" alt=\"{{ Beispiel PDF }}\" width=70%>\n",
"</figure>\n",
"\n",
"\n",
"Eine **pdf** gibt an mit welcher **Wahrscheinlichkeit ein Wert $x_i$** innerhalb eines **infinitesimalen Intervals $\\text{d}x_i$** zu finden ist. Des Weitren gilt das die Gesamtwahrscheinlichkeit gegeben ist durch $\\int_S f(x) dx = 1$. \n",
"\n",
"Nun betrachten wir folgendes Beispiel: In unserem Labor messen wir genau drei mal die Raumtemperartur T. Auch hier gilt, dass unsere Messung der einzelnen $T_i$ einer gewissen **Wahrscheinlichkeitsdichtefunktion** folgen. Betrachtet nun das folgende Bild; welche **Wahrscheinlichkeitsdichtefunktion** passt besser zu den gezeigten Daten und **Warum?**\n",
"\n",
"<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/ProbMaxTemp.png\" alt=\"{{ Beispiel PDF }}\" width=100%>\n",
"</figure>\n",
"\n",
"Die rechte Verteilung spiegelt unsere Messdaten besser wieder. Dies können wir auch mathematisch ausdrücken. Für $N$ voreinander unabhängige Zufallszahlen bzw. Messpunkte (in unserem Beispiel $N = 3$) ist die Gesamtwahrscheinlichkeit gegeben durch das Produkt der einzelnen Wahrscheinlichkeitsdichten $f(x_i, \\theta)$ multipliziert mit dem jeweiligen infinitesimalen element $dx_i$\n",
"\n",
"$$\\prod_{i = 1}^{N} f(x_i,\\theta) \\ dx_i \\text{ für alle } x_i \\text{ in } [x_i, x_i + dx_i]$$\n",
"\n",
"wobei $x_i$ in unserem Beispiel den Messpunkten $T_i$ und $f(x_i,\\theta)$ unserer Gausverteilung mit $\\theta = (\\mu, \\sigma)$ entspricht. Sprich sofern unsere Werte gut von der jeweiligen **Wahrscheinlichkeitsdichtefunktion** repräsentiert werden, d.h. wir die richtigen Parameter $\\theta$ gewählt haben (wie im rechten oberen Plot), gilt \n",
"\n",
"$$ \\prod_{i = 1}^{N} f(x_i,\\theta) dx_i$$ \n",
"\n",
"ist **maximal**. Da die einzelnen $dx_i$ von unseren Parametern $\\theta$ unabhängig sind gilt die gleiche Argumentation auch für \n",
"\n",
"$$ \\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N) = \\prod_{i = 1}^{N} f(x_i,\\theta)$$ \n",
"\n",
"wobei $\\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N)$ die sogenannte **likely hood function** darstellt."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie kommen wir nun von der **likely hood function** auf unsere **Methode der kleinsten Quadrate** und dem fitten einer Funktion $\\lambda(x; \\ $**$\\phi$**$)$ an die gemessenen Punkte **$(x,y)$**? Dazu brauche wir noch einen Zwischenschritt. Oftmals ist es einfacher statt die **likely hood function** zu maximieren die so genannte **log likely hood function**\n",
"\n",
"$$ \\log( \\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N)) = \\sum_{i = 1}^{N} \\log(f(x_i,\\theta))$$\n",
"\n",
"zu maximieren. Dies ist im Grunde das Gleiche, da der logarithmus eine monoton-steigende Funktion ist. Auch in unserem Fall der **Methode der kleinsten Quadrate** benötigen wir die **log likely hood function**. \n",
"\n",
"Stellt euch nun vor wir haben eine Messung mit $N$ voneinander unabhängigen Messpunkten (x,y). Des Weiteren nehmen wir an, dass alle $x_i$ ohne Fehler sind und das unsere $y_i$ gaußförmig um einen unbekannten Wahrenwert $\\lambda_i$ (sprich $\\lambda_i$ entspricht dem Erwartungswert $\\mu_i$ unserer Gaußverteilung) mit einer bekannten Varianz $\\Delta y_i^2$ verteilt sind (Diese Annahme lässt sich mit dem zentralen Grenzwertsatz begründen, so lange der Fehler sich aus der Summe kleinen Fehlern zusammensetzt). Die dazugehörige **likely hood function** ist dann gegeben durch:\n",
"\n",
"$$ \\mathcal{L}(y_1 ... y_N; \\lambda_1 ... \\lambda_N, \\Delta y_1 ... \\Delta y_N)) = \\prod_{i = 1}^{N}\\frac{1}{\\sqrt{2 \\pi \\Delta y_i^2}} \\cdot \\exp \\bigg( \\frac{ -(y_i - \\lambda_i)^2}{2 \\cdot \\Delta y_i^2}\\bigg)$$\n",
"\n",
"Beziehungsweise die **log likely hood function** mit $\\lambda_i = \\lambda(x_i; \\phi)$ ergibt sich zu\n",
"\n",
"$$ \\log(\\mathcal{L}(y, \\theta)) \\approx -\\frac{1}{2} \\sum_{i = 1}^{N}\\bigg( \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}\\bigg)$$\n",
"\n",
"wobei die konstanten Terme welche nicht von unserer Funktion $\\lambda(x_i; \\phi)$ abhängen vernachlässigt worden sind. Durch den Faktor $-\\frac{1}{2}$ ist das maximieren dieser **log likely hood function** gleich dem minnimieren von\n",
"\n",
"$$ \\chi(\\phi_1 ... \\phi_N)^2 = \\sum_{i = 1}^{N} \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}$$\n",
"\n",
"Diese Funktion ist unsere gesuchte **Methode der kleinsten Quadrate**. Mit ihrer Hilfe kann eine beliebige Funktion $\\lambda(x; \\phi)$, welche liniear in ihren Parametern $\\phi$ ist, an unsere Messdaten $(x,y\\pm\\Delta y)$ gefittet werden. Dabei stellt der Fitprozess selbst lediglich ein Minimierungsproblem dar. Im folgenden sind unsere Annahmen noch einmal grafisch in einem Beispiel dargestellt.\n",
"\n",
"<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/LeastSquare.png\" alt=\"{{ Least Square Beispiel }}\" width=100%>\n",
"</figure>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es gibt verschiedene Arten von Algorithmen um Minimierungsprobleme zu lösen. Wie diese genau Aufgebaut sind lernt ihr in anderen Progrmmierkursen wie zum Beispiel *Programmieren für Physiker* oder *Computer in der Wissenschaft*. Zum Glück haben uns bereits in Python andere Menschen diese Arbeit abgenommen und wir können aus dem Package `scipy.optimize` die Funktion `curve_fit` verwenden. \n",
"\n",
"Hierbei stellt curve_fit eine Methode dar, Fit-Funktionen nach der obigen vorgestellten Methode der *kleinsten Quadraten* zu bestimmen. Dies hat zur Folge, dass lediglich die y-Fehler eurer Messwerte für den Fit verwendet werden können. "
] ]
}, },
{ {
@ -944,7 +889,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Gucken wir uns einen Fit ohne Messfehler an um die Funktion etwas näher kennen zu lernen." "Gucken wir uns einen Fit ohne Messfehler an um die Funktion etwas näher kennenzulernen."
] ]
}, },
{ {
@ -959,7 +904,7 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"# Und jetzt fitten wir:\n", "# Und jetzt fitten wir:\n",
"para, pcov = curve_fit(Spannung, # <-- Funktion die an die Messdaten gefittet werden soll\n", "para, pcov = curve_fit(Spannung, # <-- Funktion, die an die Messdaten gefittet werden soll\n",
" strom, # <-- gemessenen \"X\"-Werte\n", " strom, # <-- gemessenen \"X\"-Werte\n",
" spannung # <-- gemessenen \"Y\"-Werte \n", " spannung # <-- gemessenen \"Y\"-Werte \n",
" )\n", " )\n",
@ -974,7 +919,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Ihr seht `curve_fit` gibt uns zwei unterschiedliche Listen zurück. Die erste Liste `para` beinhaltet die berechneten Fitparameter. `pcov` hingegen ist eine [Kovarianzmatrix](https://de.wikipedia.org/wiki/Kovarianzmatrix) auf deren Diagonalen ihr die Varianzen ($\\sigma^2$) der einzelnen Parameter findet (auf der Nebendiagonalen befinden sich die Kovarianzen). D.h. bei einer Funktion mit drei Parametern `def f(x, p1, p2, p3):` würde `para` und `pcov` allgemein so aussehen:\n", "Sie sehen `curve_fit` gibt uns zwei unterschiedliche Listen zurück. Die erste Liste `para` beinhaltet die berechneten Fitparameter. `pcov` hingegen ist eine [Kovarianzmatrix](https://de.wikipedia.org/wiki/Kovarianzmatrix) auf deren Diagonalen Sie die Varianzen ($\\sigma^2$) der einzelnen Parameter finden (auf der Nebendiagonalen befinden sich die Kovarianzen). D.h. bei einer Funktion mit drei Parametern `def f(x, p1, p2, p3):` würde `para` und `pcov` allgemein so aussehen:\n",
"\n", "\n",
"```\n", "```\n",
"para = [p1, p2, p3]\n", "para = [p1, p2, p3]\n",
@ -982,13 +927,13 @@
" [cov_2,1, cov_2,2, cov_2,3],\n", " [cov_2,1, cov_2,2, cov_2,3],\n",
" [cov_3,1, cov_3,2, cov_3,3]]\n", " [cov_3,1, cov_3,2, cov_3,3]]\n",
"```\n", "```\n",
"wobei `cov_i,i` wie bereits erwähnt die einzelnen Kovarianzen bzw. Varianzen sind. Aber was genau macht jetzt curve_fit eigentlich um auf diese Werte zu kommen? Wie bereits erklärt basiert `curve_fit` auf der Methode der kleinsten Quadrate. D.h. die Funktion probiert etliche verschiedene Varianten eurer Parameter durch bis es die Kombination gefunden hat bei der das $\\chi^2$ klein wird. Gucken wir uns doch mal ein paar Zwischenschritte für unser Beispiel des ohm'schen Widerstandes an: \n", "wobei `cov_i,i` wie bereits erwähnt die einzelnen Kovarianzen bzw. Varianzen sind. Aber was genau macht jetzt curve_fit eigentlich, um auf diese Werte zu kommen? Wie bereits erklärt, basiert `curve_fit` auf der Methode der kleinsten Quadrate. D.h. die Funktion probiert etliche verschiedene Varianten Ihrer Parameter durch, bis es die Kombination gefunden hat, bei der das $\\chi^2$ klein wird. Gucken wir uns mal ein paar Zwischenschritte für unser Beispiel des ohm'schen Widerstandes an: \n",
"\n", "\n",
"<figure class=\"image\">\n", "<figure class=\"image\">\n",
"<img src=\"images/MaterialPythonkurs092018/Fitting_gif.gif\" alt=\"{{ Least Square Beispiel }}\" width=100%>\n", "<img src=\"images/MaterialPythonkurs092018/Fitting_gif.gif\" alt=\"{{ Least Square Beispiel }}\" width=100%>\n",
"</figure>\n", "</figure>\n",
"\n", "\n",
"Nach dem wir nun wissen, was genau `curve_fit` macht wollen wir unser Resultat etwas schöner darstellen:" "Nach dem wir nun wissen, was genau `curve_fit` macht, wollen wir unser Resultat etwas schöner darstellen:"
] ]
}, },
{ {
@ -1015,7 +960,7 @@
" [Spannung(value, para[0]) for value in strom], \n", " [Spannung(value, para[0]) for value in strom], \n",
" ls ='dashed',\n", " ls ='dashed',\n",
" color='orange',\n", " color='orange',\n",
" label = f'Fitgerade mit R = {para[0]:0.2f} +/- {pcov[0,0]**(1/2):0.2f} ohm'\n", " label = f'Fitgerade mit R = {para[0]:0.2f} +/- {pcov[0,0]**(1/2):0.2f} Ohm'\n",
" )\n", " )\n",
"\n", "\n",
"plt.legend()\n", "plt.legend()\n",
@ -1028,7 +973,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Das Ergebnis sieht bereits ganz gut aus, allerdings kennt hier unsere Funktion `curve_fit` die Fehler unserer Messwerte noch garnicht. Da dies sehr unphysikalisch ist lasst uns das ganze nochmal mit Unsicherheiten wiederholen: " "Das Ergebnis sieht bereits ganz gut aus, allerdings kennt hier unsere Funktion `curve_fit` die Fehler unserer Messwerte noch gar nicht. Da dies sehr unphysikalisch ist, wiederholen wir das Ganze nochmal mit Unsicherheiten:"
] ]
}, },
{ {
@ -1046,17 +991,18 @@
" strom, \n", " strom, \n",
" spannung,\n", " spannung,\n",
" sigma=spannung_error, # <-- Diesesmal mit Fehler\n", " sigma=spannung_error, # <-- Diesesmal mit Fehler\n",
" absolute_sigma=True # <-- Diesen Option müssen wir auf Wahr setzen, da \n", " absolute_sigma=True # <-- Diese Option müssen wir auf True (wahr) setzen, da \n",
" # wir in der Regel absolute und keine relativen \n", " # wir in der Regel absolute und keine relativen \n",
" # Unsicherheiten messen.\n", " # Unsicherheiten messen.\n",
" )\n", " )\n",
"\n", "\n",
"plt.plot(strom, \n", "plt.plot(strom,\n",
" [Spannung(value, para2[0]) for value in strom], \n", " [Spannung(value, para2[0]) for value in strom], \n",
" ls ='dashed',\n", " ls ='dashed',\n",
" color='orange',\n", " color='orange',\n",
" label = f'Fitgerade mit R = {para2[0]:0.2f} +/- {pcov2[0,0]**(1/2):0.2f} ohm'\n", " label = f'Fitgerade mit R = {para2[0]:0.2f} +/- {pcov2[0,0]**(1/2):0.2f} ohm'\n",
" )\n", " )\n",
"\n",
"plt.errorbar(strom, \n", "plt.errorbar(strom, \n",
" spannung,\n", " spannung,\n",
" xerr=strom_error,\n", " xerr=strom_error,\n",
@ -1084,11 +1030,11 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Wie ihr sehen könnt ist der Wert für den Widerstand zwar gleich geblieben, jedoch die Unsicherheit des Wertes hat sich erhöht.\n", "Wie Sie sehen können, ist der Wert für den Widerstand zwar gleich geblieben, jedoch die Unsicherheit des Wertes hat sich erhöht.\n",
"\n", "\n",
"Wie gut denkt ihr fittet unsere obige Funktion unsere Messdaten? Sehr gut? Gut? Befriedigend? Oder doch eher schlecht? Wäre es nicht gut ein Maß für die Güte des Fits zu haben? Wie könnte ein solches Maß aussehen?\n", "Wie gut fittet unsere obige Funktion unsere Messdaten? Sehr gut? Gut? Befriedigend? Oder doch eher schlecht? Wäre es nicht gut, ein Maß für die Güte des Fits zu haben? Wie könnte ein solches Maß aussehen?\n",
"\n", "\n",
"Ihr habt das entscheiden Kriterium bereits kennen gelernt, bei der Methode der kleinsten Quadrate geht es darum das $\\chi^2$ zu minimieren sprich klein zu machen. Gucken wir uns hierzu erst noch einmal an wie sich das $\\chi^2$ berechnet:\n", "Sie haben das entscheidende Kriterium bereits kennengelernt, bei der Methode der kleinsten Quadrate geht es darum, das $\\chi^2$ zu minimieren. Gucken wir uns hierzu erst noch einmal an, wie sich das $\\chi^2$ berechnet:\n",
"\n", "\n",
"$$ \\chi(\\phi_1 ... \\phi_N)^2 = \\sum_{i = 1}^{N} \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}$$\n", "$$ \\chi(\\phi_1 ... \\phi_N)^2 = \\sum_{i = 1}^{N} \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}$$\n",
"\n", "\n",
@ -1096,7 +1042,7 @@
"\n", "\n",
"$$ \\chi(R)^2 = \\sum_{i = 1}^{N} \\frac{ (U_i - u(I_i; R))^2}{\\Delta U_i^2}$$\n", "$$ \\chi(R)^2 = \\sum_{i = 1}^{N} \\frac{ (U_i - u(I_i; R))^2}{\\Delta U_i^2}$$\n",
"\n", "\n",
"wobei hier groß $U$ unsere gemessenen Spannung und klein $u$ unsere Funktion entspricht." "wobei hier groß $U$ unsere gemessene Spannung und klein $u$ unsere Funktion entspricht."
] ]
}, },
{ {
@ -1119,7 +1065,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Wie vergleicht sich dieses $\\chi^2$ nun mit einer Funktion welche unsere Daten schlechter beschreibt. Zum Beispiel sofern wir die Spannung über die Funktion \n", "Wie vergleicht sich dieses $\\chi^2$ nun mit einer Funktion, welche unsere Daten schlechter beschreibt? Zum Beispiel sofern wir die Spannung über die Funktion\n",
"\n", "\n",
"$$ U(R,I) = R \\cdot I $$\n", "$$ U(R,I) = R \\cdot I $$\n",
"\n", "\n",
@ -1142,8 +1088,6 @@
"def Spannung2(I, R):\n", "def Spannung2(I, R):\n",
" return R * I**2\n", " return R * I**2\n",
"\n", "\n",
"\n",
"\n",
"para3, pcov3 = curve_fit(Spannung2, \n", "para3, pcov3 = curve_fit(Spannung2, \n",
" strom, \n", " strom, \n",
" spannung,\n", " spannung,\n",
@ -1151,7 +1095,7 @@
" absolute_sigma=True \n", " absolute_sigma=True \n",
" )\n", " )\n",
"\n", "\n",
"chi_2_new = [ (u - Spannung2(I, *para3))**2/du**2 for I,u,du in zip(strom, spannung, spannung_error)]\n", "chi_2_new = [(u - Spannung2(I, *para3))**2/du**2 for I,u,du in zip(strom, spannung, spannung_error)]\n",
"chi_2_new = sum(chi_2_new)\n", "chi_2_new = sum(chi_2_new)\n",
"print(f'Chi-qudrat nach URI: {chi_2:.2f}\\nChi-qudrat nach URI-Parabel: {chi_2_new:.2f}')" "print(f'Chi-qudrat nach URI: {chi_2:.2f}\\nChi-qudrat nach URI-Parabel: {chi_2_new:.2f}')"
] ]
@ -1160,15 +1104,15 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"Wie ihr sehen könnt ist das $\\chi^2$ für unsere zweite Funktion etwas größer als für das klassische ohm'sche Gesetzt. Somit würden wir unsere zweiten Ansatz verwerfen. \n", "Wie Sie sehen können, ist das $\\chi^2$ für unsere zweite Funktion etwas größer als für das klassische ohm'sche Gesetzt. Somit würden wir unseren zweiten Ansatz verwerfen.\n",
"\n", "\n",
"Damit man für einen gegebene Datensatz nicht hunderte von verschiedene Funktionen durchprobieren muss gibt es für das $\\chi^2$ eine allgemeine Faustregel, welche den berechneten $\\chi^2$-Wert mit der Anzahl unserer Freiheitsgrade vergleicht. Die Anzahl an Freiheitsgrade ist allgemeinhin gegeben als *Anzahl der Messwerte - Anzahl der Funktionsparameter* ($m - n$).\n", "Damit man für einen gegebenen Datensatz nicht hunderte von verschiedenen Funktionen durchprobieren muss, gibt es für das $\\chi^2$ eine allgemeine Faustregel, welche den berechneten $\\chi^2$-Wert mit der Anzahl unserer Freiheitsgrade vergleicht. Die Anzahl an Freiheitsgrade ist allgemeinhin gegeben als *Anzahl der Messwerte - Anzahl der Funktionsparameter* ($m - n$).\n",
"\n", "\n",
"1. Sofern $\\chi^2/\\text{ndof} >> 1$: sollte die Hypothese bzw. die Fitfunktion angezweifelt werden. Sie beschreibt in diesem Fall die Messdaten nur unzureichend. (Bzw. sollte $\\chi^2/\\text{ndof} > 1$ kann dies auch bedeuten, dass eure Unsicherheiten unterschätzt sind)\n", "1. Sofern $\\chi^2/\\text{ndof} >> 1$: sollte die Hypothese bzw. die Fitfunktion angezweifelt werden. Sie beschreibt in diesem Fall die Messdaten nur unzureichend. (Bzw. sollte $\\chi^2/\\text{ndof} > 1$ kann dies auch bedeuten, dass die Unsicherheiten unterschätzt sind)\n",
"2. Sofern $\\chi^2/\\text{ndof} \\approx 1$: beschreibt die Hypothese bzw. die Fitfunktion die Daten wie erwartet und wird nicht abgelehnt. \n", "2. Sofern $\\chi^2/\\text{ndof} \\approx 1$: beschreibt die Hypothese bzw. die Fitfunktion die Daten wie erwartet und wird nicht abgelehnt. \n",
"3. Falls $\\chi^2/\\text{ndof} << 1$ beschreibt die Hypothese bzw. die Fitfunktion die Daten wesentlich besser als erwartet. In diesem Fall heißt es nicht, dass unsere Hypothese falsch ist, aber man sollte überprüfen ob die gemessenen Fehler nicht überschätzt worden sind (oder eine Korrelation zwischen denn Messfehlern vor liegt). \n", "3. Falls $\\chi^2/\\text{ndof} << 1$ beschreibt die Hypothese bzw. die Fitfunktion die Daten wesentlich besser als erwartet. In diesem Fall heißt es nicht, dass unsere Hypothese falsch ist, aber man sollte überprüfen, ob die gemessenen Fehler nicht überschätzt worden sind (oder eine Korrelation zwischen den Messfehlern vorliegt). \n",
"\n", "\n",
"Sofern ihr eine Arbeit schreibt und eure **Goodness-of-the-Fit** ($\\chi^2/\\text{ndof}$) angeben wollt so gebt immer beides an, das $\\chi^2$ und die Anzahl an Freiheitsgraden ndof. Beide Werte getrennt habne einen größeren Informationsgehalt als der Resultierende Quotient (genaueres lernt ihr in z.B. in der Vorlesung *Statistik, Datenanalyse und Simulationen* im Master)." "Sofern Sie eine Arbeit schreiben und Ihre **Goodness-of-the-Fit** ($\\chi^2/\\text{ndof}$) angeben wollen, so geben Sie immer beides an, das $\\chi^2$ und die Anzahl an Freiheitsgraden ndof. Beide Werte getrennt haben einen größeren Informationsgehalt als der resultierende Quotient (Genaueres lernen Sie z.B. in der Vorlesung *Statistik, Datenanalyse und Simulationen* im Master)."
] ]
}, },
{ {
@ -1179,31 +1123,17 @@
" \n", " \n",
"#### Aufgabe 7.: PGP Auswertung:\n", "#### Aufgabe 7.: PGP Auswertung:\n",
"\n", "\n",
"Jetzt seid ihr ein letztes mal gefordert. In dieser Aufgabe wollen wir alles was wir heute gelernt haben nochmal reflektieren und anwenden. Erstellt hierfür ein neues Jupyter-Notebook und bearbeitet die Aufgaben im Skript. Sofern ihr Fragen bzw. Probleme habt vergesst nicht auf die folgenden Hilfsmöglichkeiten zurückzugreifen:\n", "Jetzt sind Sie ein letztes mal gefordert. In dieser Aufgabe wollen wir alles, was wir heute gelernt haben, nochmal reflektieren und anwenden. Erstellen Sie hierfür ein neues Jupyter-Notebook und bearbeiten Sie die Aufgaben im Skript. Sofern Sie Fragen bzw. Probleme haben, vergessen Sie nicht auf die folgenden Hilfsmöglichkeiten zurückzugreifen:\n",
"\n", "\n",
"1. Verwenden der IPython-Hilfe unter Verwendung der shift + tab Tasten.\n", "1. Verwendung der IPython-Hilfe unter Verwendung der **Shift + Tab** Tasten.\n",
"2. Die ausführlichen Dokumentation von Python und das Angebot etlicher nützlicher Hilfsbeiträge in verschiedenen Foren (z.B. stackoverflow) im Internet.\n", "2. Die ausführliche Dokumentation von Python und das Angebot etlicher nützlicher Hilfsbeiträge in verschiedenen Foren (z.B. stackoverflow) im Internet.\n",
"3. Fragt bei den Assistenten nach während der Stunde nach bzw. nutzt den Emailkontakt auf der [gitlab Seite](https://gitlab.rlp.net/hoek/pgp1-python-einfuehrung/tree/master). \n" "3. Fragen Sie beim Assistenten nach: **`mobitar@students.uni-mainz.de`**"
] ]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# dwenz@students.uni-mainz.de"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
} }
], ],
"metadata": { "metadata": {
"kernelspec": { "kernelspec": {
"display_name": "Python 3", "display_name": "Python 3 (ipykernel)",
"language": "python", "language": "python",
"name": "python3" "name": "python3"
}, },
@ -1217,9 +1147,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.7.6" "version": "3.9.6"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 2 "nbformat_minor": 4
} }

7
README.md
View file

@ -1,18 +1,17 @@
# PGP1 Python Einfuehrung # PGP1 Python Einfuehrung
Im folgenden findet ihr die Installationsanweisungen für Python und des Kursmaterials. Sofern ihr Fragen habt, bzw. Hilfe benötigt könnt ihr an eine der nachfolgenden Personen eine Email schreiben: Im folgenden finden Sie die Installationsanweisungen für Python und das Kursmaterial. Sofern Sie Fragen haben, bzw. Hilfe benötigen, können Sie an diese Personen eine Email schreiben:
* Daniel Wenz: dwenz@students.uni-mainz.de Mo (Mohamad Bitar): mobitar@students.uni-mainz.de
## Kursmaterial installieren: ## Kursmaterial installieren:
Die installation des Kursmaterials geschieht vollständig automatisch. Einfach den Anweisungen im PGP-Skript folgen und diesen Link verwenden: [Kursmaterial Installieren](https://jupyterhub.zdv.uni-mainz.de/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgitlab.rlp.net%2Fpgp%2Fpgp1-python-einfuehrung&urlpath=tree%2Fpgp1-python-einfuehrung%2F&branch=master) Die installation des Kursmaterials geschieht vollständig automatisch. Einfach den Anweisungen im PGP-Skript folgen und diesen Link verwenden: [Kursmaterial Installieren](https://jupyterhub.zdv.uni-mainz.de/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgitlab.rlp.net%2Fpgp%2Fpgp1-python-einfuehrung&urlpath=tree%2Fpgp1-python-einfuehrung%2F&branch=master)
## Einloggen auf dem Jupyterhub: ## Einloggen auf dem Jupyterhub:
Sie können auch den durch die ZDV angebotenen Jupyter Hub (https://jupyterhub.zdv.uni-mainz.de/hub/login) zur Bearbeitung Ihrer Notebooks verwenden :thumbsup: . Hier müssen Sie sich zunächst mit Ihrem Uni-Account anmelden. Danach erscheint eine Auswahlseite, auf der Sie die Art der Jupyter Umgebung auswählen. Für das Praktikum ist die Standardumgebung die richtige Wahl, s. Bild unten. Sie können auch den durch die ZDV angebotenen Jupyter Hub (https://jupyterhub.zdv.uni-mainz.de/hub/login) zur Bearbeitung Ihrer Notebooks verwenden :thumbsup: . Hier müssen Sie sich zunächst mit Ihrem Uni-Account anmelden. Danach erscheint eine Auswahlseite, auf der Sie die Art der Jupyter Umgebung auswählen. Für das Praktikum ist die Standardumgebung die richtige Wahl, s. Bild unten.
<img src = "./images/Screenshot_ZDV_JupyterHub.png" > <img src = "./images/Screenshot_ZDV_JupyterHub.png" >
Klicken Sie auf die Schaltfläche **Spawn**, dann öffnet sich, wie bei der lokalen Installation, das Notebook Dashboard. Klicken Sie auf die Schaltfläche **Spawn**, dann öffnet sich das Notebook Dashboard.

1644
poetry.lock generated Normal file
View file

File diff suppressed because it is too large Load diff

18
pyproject.toml Normal file
View file

@ -0,0 +1,18 @@
[tool.poetry]
name = "pgp1-python-einfuehrung"
version = "1.1.0"
description = ""
authors = []
[tool.poetry.dependencies]
python = ">=3.9,<3.10"
jupyterlab = "^3.1.9"
matplotlib = "^3.4.3"
numpy = "^1.21.2"
scipy = "^1.7.1"
[tool.poetry.dev-dependencies]
[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"