mirror of
https://gitlab.rlp.net/pgp/pgp1-python-einfuehrung
synced 2024-11-16 13:48:11 +00:00
Fixed typos and removed outdated content
This commit is contained in:
MoBit
parent
6283e5ab96
commit
03c4920516
5 changed files with 379 additions and 368 deletions
193
Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb
Executable file → Normal file
193
Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb
Executable file → Normal file
|
|
@ -6,9 +6,9 @@
|
|||
"source": [
|
||||
"# Vorbereitung Kapitel 1. Einstieg in die Welt von Python:\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",
|
||||
"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",
|
||||
"* einfache Rechnungen mit Python durchführt\n",
|
||||
"* \"Mathematische\" Funktionen definiert\n",
|
||||
|
|
@ -16,7 +16,7 @@
|
|||
"* Daten in Form von Graphen richtig darstellt\n",
|
||||
"* eine Ausgleichsgerade von Datenpunkten berechnen kann.\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": [
|
||||
"## Grundlagen zu Python bzw. Jupyter Notebooks:\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",
|
||||
"\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."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -44,11 +43,11 @@
|
|||
"\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",
|
||||
"* 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",
|
||||
" 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",
|
||||
" 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",
|
||||
" 4. Nun können Sie die Summe aus zwei beliebigen ganzen Zahlen mit Hilfe des Syntax\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, 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",
|
||||
" 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 mithilfe des Syntax\n",
|
||||
" ```python\n",
|
||||
" 3 + 5\n",
|
||||
" ```\n",
|
||||
|
|
@ -58,17 +57,17 @@
|
|||
" \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",
|
||||
" 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",
|
||||
" 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",
|
||||
" 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",
|
||||
" 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), indem Sie diese anklicken. \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 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",
|
||||
" \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/> "
|
||||
]
|
||||
},
|
||||
|
|
@ -77,13 +76,13 @@
|
|||
"metadata": {},
|
||||
"source": [
|
||||
"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",
|
||||
"* **Strg** + **Shift** + **Minus** Splittet eine Zelle an der Position eures Cursors \n",
|
||||
"* **F** für \"Find and Replace\" (nützlich wenn ihr zum Beispiel ein Variablennamen austauschen wollt)\n",
|
||||
"* **I** + **I** Um den *\"Kernel\"* zu stoppen (wichtig falls ihr mal eine unendliche LOOP gebaut habt)\n",
|
||||
"* **Strg** + **Shift** + **Minus** splittet eine Zelle an der Position des Cursors\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 Sie mal eine unendliche LOOP gebaut haben)\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."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -242,7 +241,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -299,7 +298,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -345,7 +344,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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. "
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -400,7 +399,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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..."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -436,7 +435,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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 []:). "
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -496,7 +495,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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. "
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -559,7 +558,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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",
|
||||
"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",
|
||||
|
|
@ -583,7 +582,7 @@
|
|||
"\n",
|
||||
"$$s(t) = \\frac{1}{2}\\cdot a \\cdot t^2 + v_0 \\cdot t + s_0$$\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",
|
||||
"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",
|
||||
|
|
@ -591,12 +590,12 @@
|
|||
"* ... 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",
|
||||
"\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",
|
||||
"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",
|
||||
"**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",
|
||||
"print(Variablennamen1, Variablennamen2, Variablennamen3 ...)\n",
|
||||
"```\n",
|
||||
|
|
@ -628,12 +627,7 @@
|
|||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 18,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-25T09:07:53.967603Z",
|
||||
"start_time": "2020-08-25T09:07:53.954643Z"
|
||||
}
|
||||
},
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
|
|
@ -664,11 +658,13 @@
|
|||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"metadata": {
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Zeichenketten\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",
|
||||
"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",
|
||||
|
|
@ -704,7 +700,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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: "
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -809,7 +805,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -852,7 +848,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -863,7 +859,7 @@
|
|||
" \n",
|
||||
"#### Aufgabe 2.b.: Beschleunigte Bewegung Zusatz\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",
|
||||
"* Die Angabe der richtigen Einheiten.\n",
|
||||
"* Das Runden der berechneten Werte der Anzahl an signifikanten Stellen entsprechend. "
|
||||
|
|
@ -872,12 +868,7 @@
|
|||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 24,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-25T09:08:13.614302Z",
|
||||
"start_time": "2020-08-25T09:08:13.607319Z"
|
||||
}
|
||||
},
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
|
|
@ -907,9 +898,11 @@
|
|||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"metadata": {
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Das Definieren von Funktionen:\n",
|
||||
"## Definieren von Funktionen:\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",
|
||||
"\n",
|
||||
|
|
@ -937,9 +930,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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",
|
||||
"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}$:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -965,7 +958,7 @@
|
|||
],
|
||||
"source": [
|
||||
"# 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 "
|
||||
]
|
||||
|
|
@ -974,7 +967,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -988,7 +981,7 @@
|
|||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def komplxe_function(a, b, c, d):\n",
|
||||
"def complex_function(a, b, c, d):\n",
|
||||
" result = a + b\n",
|
||||
" result = result * c\n",
|
||||
" result = result / d\n",
|
||||
|
|
@ -1017,14 +1010,14 @@
|
|||
}
|
||||
],
|
||||
"source": [
|
||||
"komplxe_function(1, 2, 3, 4)"
|
||||
"complex_function(1, 2, 3, 4)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1044,7 +1037,7 @@
|
|||
"traceback": [
|
||||
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
||||
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
|
||||
"\u001b[0;32m<ipython-input-29-0ac921c19f1a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
|
||||
"\u001b[0;32m/tmp/ipykernel_27250/1049141082.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
|
||||
"\u001b[0;31mNameError\u001b[0m: name 'result' is not defined"
|
||||
]
|
||||
}
|
||||
|
|
@ -1057,7 +1050,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1071,7 +1064,7 @@
|
|||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"result = komplxe_function(1, 2, 3, 4)"
|
||||
"result = complex_function(1, 2, 3, 4)"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1103,9 +1096,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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",
|
||||
"* Computer in der Wissenschaft \n",
|
||||
"* Computer in der Wissenschaft\n",
|
||||
"* Programmieren für Physiker\n",
|
||||
"* Einführung in die Programmierung\n",
|
||||
"\n",
|
||||
|
|
@ -1138,18 +1131,13 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Lösung:"
|
||||
"### Lösung:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 32,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-25T09:09:05.968956Z",
|
||||
"start_time": "2020-08-25T09:09:05.958982Z"
|
||||
}
|
||||
},
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
|
|
@ -1193,7 +1181,7 @@
|
|||
"metadata": {},
|
||||
"source": [
|
||||
"### 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:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1238,7 +1226,7 @@
|
|||
" in Ohm.\n",
|
||||
" \n",
|
||||
" Returns:\n",
|
||||
" float: Die Berechnete Spannung in V.\n",
|
||||
" float: Die berechnete Spannung in V.\n",
|
||||
" '''\n",
|
||||
" return Widerstand * Strom/1000"
|
||||
]
|
||||
|
|
@ -1249,7 +1237,7 @@
|
|||
"source": [
|
||||
"## Messtabellen in Python:\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",
|
||||
"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:"
|
||||
]
|
||||
|
|
@ -1310,9 +1298,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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",
|
||||
"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`)."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1373,7 +1361,7 @@
|
|||
"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",
|
||||
"\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:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1419,7 +1407,7 @@
|
|||
}
|
||||
],
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1502,7 +1490,7 @@
|
|||
}
|
||||
],
|
||||
"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)"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1527,7 +1515,7 @@
|
|||
}
|
||||
],
|
||||
"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"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1552,7 +1540,7 @@
|
|||
}
|
||||
],
|
||||
"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"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1606,7 +1594,7 @@
|
|||
}
|
||||
},
|
||||
"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:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1644,7 +1632,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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. "
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1681,7 +1669,7 @@
|
|||
],
|
||||
"source": [
|
||||
"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"
|
||||
]
|
||||
|
|
@ -1692,7 +1680,7 @@
|
|||
"source": [
|
||||
"Zwei weitere nützliche Befehle im Zusammenhang von Listen ist die `len`- und `range`-Funktion. \n",
|
||||
"\n",
|
||||
"`len` gibt euch die Länge einer Liste zurück "
|
||||
"`len` gibt die Länge einer Liste zurück "
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1732,7 +1720,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"`range` erstellt euch ganzzahlige Werte zwischen zwei ganzen Zahlen "
|
||||
"`range` erstellt ganzzahlige Werte zwischen zwei ganzen Zahlen"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1808,7 +1796,7 @@
|
|||
" \n",
|
||||
"#### Aufgabe 4.a.: Erstellen von Messwerttabellen:\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",
|
||||
"| Messwertnummer | Spannung [V] | Strom [mA] | Fehler der Spannung [V] | Fehler des Stroms [mA] |\n",
|
||||
"|----------------|--------------|------------|-------------------------|---------------------------|\n",
|
||||
|
|
@ -1820,12 +1808,12 @@
|
|||
"| 6 | 11.94 | 95 | 0.17 | 10 |\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",
|
||||
"**Tipp:**\n",
|
||||
"\n",
|
||||
"1. Sie haben bereits die Funktionen für die Leistung in Aufgabe 3 definiert und könnt sie hier erneut verwenden. \n",
|
||||
"2. Das Slicen von verschachtelten Listen funktioniert genauso wie bei normalen Listen: \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",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"spalte0 = daten[0] #<-- Wählt die Spalte 0 an \n",
|
||||
|
|
@ -1834,7 +1822,7 @@
|
|||
"daten[0][2] \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>"
|
||||
]
|
||||
},
|
||||
|
|
@ -1848,12 +1836,7 @@
|
|||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 52,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-25T09:09:57.232469Z",
|
||||
"start_time": "2020-08-25T09:09:57.215516Z"
|
||||
}
|
||||
},
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
|
|
@ -1901,13 +1884,13 @@
|
|||
" \n",
|
||||
"#### Vorbereitungsaufgabe 1.: Werte der Schiefen Ebene in Pyhton übertragen:\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",
|
||||
"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",
|
||||
"**Tipp:**\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>"
|
||||
]
|
||||
},
|
||||
|
|
@ -1915,7 +1898,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Lösungen:"
|
||||
"### Lösung:"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1934,8 +1917,8 @@
|
|||
" Zurückgelegte Strecke bei einer gleichbeschleunigten Bewegung.\n",
|
||||
" \n",
|
||||
" Args:\n",
|
||||
" t (float): Vergangene Zeit in Sekunden.\n",
|
||||
" a (float): Beschleunigung der Bewegung in m/s**2\n",
|
||||
" t (float): Vergangene Zeit in s\n",
|
||||
" a (float): Beschleunigung der Bewegung in m/(s**2)\n",
|
||||
" '''\n",
|
||||
" return 0.5 * a * t**2 "
|
||||
]
|
||||
|
|
@ -1943,7 +1926,7 @@
|
|||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
|
|
@ -1957,7 +1940,7 @@
|
|||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.8"
|
||||
"version": "3.9.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
|
|
|
|||
100
Herleitung_Methode_der_kleinsten_Quadrate.ipynb
Normal file
100
Herleitung_Methode_der_kleinsten_Quadrate.ipynb
Normal 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
|
||||
}
|
||||
|
|
@ -6,25 +6,25 @@
|
|||
"source": [
|
||||
"# Einführung Jupyter-Notebooks\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",
|
||||
"## Jupyter Notebooks ausführen\n",
|
||||
"## Jupyter-Notebooks ausführen\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",
|
||||
"### ZDV Jupyter Hub\n",
|
||||
"### ZDV JupyterHub\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",
|
||||
"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",
|
||||
"\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",
|
||||
"### Lokale Installation\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",
|
||||
"## Ein neues Notebook-Dokument anlegen\n",
|
||||
"\n",
|
||||
|
|
@ -36,7 +36,7 @@
|
|||
"\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",
|
||||
"## Die Notebook Benutzeroberfläche\n",
|
||||
"## Die Notebook-Benutzeroberfläche\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",
|
||||
"\n",
|
||||
|
|
@ -48,11 +48,11 @@
|
|||
"\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",
|
||||
"**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",
|
||||
"## Aufbau eines Notebook Dokuments\n",
|
||||
"## Aufbau eines Notebook-Dokuments\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",
|
||||
"### Code-Zellen\n",
|
||||
"\n",
|
||||
|
|
@ -79,7 +79,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"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",
|
||||
"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",
|
||||
"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",
|
||||
"Es existiert also eine ganze Bandbreite an Formatierungsmöglichkeiten. Hier einige Beispiele:\n",
|
||||
"\n",
|
||||
|
|
@ -131,11 +131,11 @@
|
|||
" return 2 * x\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"**Formeln mit Hilfe des Latex-Syntax:**\n",
|
||||
"**Formeln mithilfe des LaTeX-Syntax:**\n",
|
||||
"\n",
|
||||
"$ f(x) = \\int\\limits_0^\\infty e^{-x} \\, dx $\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",
|
||||
"**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",
|
||||
"\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",
|
||||
"metadata": {},
|
||||
"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",
|
||||
"1. Speichert euer Notebook ab in dem ihr 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",
|
||||
"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. 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",
|
||||
"\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",
|
||||
"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",
|
||||
"\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": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
|
|
@ -203,9 +198,9 @@
|
|||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.7.6"
|
||||
"version": "3.9.6"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
|
|||
386
Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb
Executable file → Normal file
386
Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb
Executable file → Normal file
File diff suppressed because one or more lines are too long
11
README.md
11
README.md
|
|
@ -1,18 +1,17 @@
|
|||
# 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:
|
||||
|
||||
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:
|
||||
|
||||
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 JupyterHub (https://jupyterhub.zdv.uni-mainz.de) zur Bearbeitung Ihrer Notebooks verwenden. 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" >
|
||||
|
||||
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.
|
||||
|
|
|
|||
Loading…
Reference in a new issue