mirror of
https://gitlab.rlp.net/pgp/pgp1-python-einfuehrung
synced 2024-11-16 13:48:11 +00:00
Now with the correct filename
This commit is contained in:
Daniel Wenz
parent
fcacb7beb1
commit
80e5d77da1
1 changed files with 808 additions and 0 deletions
808
Vorbereitung_Kapitel_1.ipynb
Normal file
808
Vorbereitung_Kapitel_1.ipynb
Normal file
|
|
@ -0,0 +1,808 @@
|
||||||
|
{
|
||||||
|
"cells": [
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"# 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",
|
||||||
|
"\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 Experimentdaten mit sich bringt. Um euch bestens auf die Anforderungen im **physikalische Grundpraktikum (PGP)** vorzubereiten lernen wir im Folgenden wie man:\n",
|
||||||
|
"\n",
|
||||||
|
"* einfache Rechnungen mit Python durchführt\n",
|
||||||
|
"* \"Mathematische\" Funktionen definiert\n",
|
||||||
|
"* Funktionen auf größere Zahlenmengen anwendet\n",
|
||||||
|
"* Daten in Form von Graphen richtig darstellt\n",
|
||||||
|
"* eine Ausgleichsgerade von Datenpunkten berechnen kann.\n",
|
||||||
|
"\n",
|
||||||
|
"Damit ihr das neu gelernte Wissen direkt vertiefen könnt, wird dieses Notebook an verschiedenen Stellen kleinere Aufgaben für euch bereit halten."
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"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",
|
||||||
|
"Zum Beispiel beim berechnen von: "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.802747Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.777288Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"3 + 2"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"Unser Interpreter, das **Jupyter Notebook**, stellt hierbei einen komfortable Interpreterumgebung dar. Diese erlaubt es uns neben **Code**-Zellen auch Texte und Formeln in so genannten **Markdown**-Zellen darzustellen. Hierbei existiert eine ganze Bandbreite an Formatierungsmöglichkeiten. Zum Beispiel:\n",
|
||||||
|
"\n",
|
||||||
|
"**Überschriften:**\n",
|
||||||
|
"\n",
|
||||||
|
"# Level 1.\n",
|
||||||
|
"## Level 2.\n",
|
||||||
|
"### Level 3.\n",
|
||||||
|
"\n",
|
||||||
|
"**Aufzählungen: **\n",
|
||||||
|
"\n",
|
||||||
|
"* Mit normalen\n",
|
||||||
|
"* Aufzählungspunkten\n",
|
||||||
|
" 1. oder \n",
|
||||||
|
" 2. Numerierungen\n",
|
||||||
|
" * Auf unterschiedlichen\n",
|
||||||
|
" 1. Ebenen\n",
|
||||||
|
"\n",
|
||||||
|
"**Schriftarten:**\n",
|
||||||
|
"\n",
|
||||||
|
"**Fett**\n",
|
||||||
|
"\n",
|
||||||
|
"*Italic (Kursive)*\n",
|
||||||
|
"\n",
|
||||||
|
"`True type`\n",
|
||||||
|
"\n",
|
||||||
|
"bzw. Syntax highlighting\n",
|
||||||
|
"\n",
|
||||||
|
"```python \n",
|
||||||
|
"def EasyFunc(x):\n",
|
||||||
|
" return 2 * x\n",
|
||||||
|
"```\n",
|
||||||
|
"\n",
|
||||||
|
"**Formeln mit Hilfe des Latex-Syntax:**\n",
|
||||||
|
"\n",
|
||||||
|
"$ f(x) = \\int\\limits_0^\\infty e^{-x} \\, dx $\n",
|
||||||
|
"\n",
|
||||||
|
"(Latex werdet ihr beim F-Praktikum kennen lernen)\n",
|
||||||
|
"\n",
|
||||||
|
"\n",
|
||||||
|
"**Bilder:**\n",
|
||||||
|
"\n",
|
||||||
|
"![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. "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2018-11-17T13:26:34.382179Z",
|
||||||
|
"start_time": "2018-11-17T13:26:34.350979Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"source": [
|
||||||
|
"<div class=task>\n",
|
||||||
|
" \n",
|
||||||
|
"#### Aufgabe 1.: Zum Vertraut werden mit dem Jupyter Notebook\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",
|
||||||
|
"\n",
|
||||||
|
"* Erstellt zunächst eine Code-Zelle unterhalb dieser und berechnet die Summe zweier beliebiger Ganzen Zahlen. Geht dabei wie folgt vor:\n",
|
||||||
|
" 1. Klickt die Zelle dieser Aufgabe an so, dass sie eine blaue Umrandung bekommt (je nach Bildschirmauflösung könnt ihr nur links einen blauen Balken erkennen). Ihr befindet euch nun im so genannten \"Command Modus\". In diesem Modus könnt ihr mit den Pfeiltasten eurer Tastatur durch das Notebook navigieren, oder die Struktur des Notebooks bzw. seiner Zellen mit Hilfe von Tasten/Tastenkombinationen modifizieren.\n",
|
||||||
|
" 2. Benutzt nun die Taste **B** um eine Code-Zelle unterhalb (**B**elow) dieser Zelle zu erstellen. Ihr werdet Feststellen das eurer Navigator direkt zu der neu erstellten Zelle springt (blaue Umrandung).\n",
|
||||||
|
" 3. Um nun diese neu erstellte Code-Zelle zu editieren, klickt ihr diese mit dem Mauszeiger an. Eure Zellenumrandung sollte von Blau auf Grün wechseln. Dies zeigt an, dass ihr euch nun im Editiermodus für diese Zelle befindet.\n",
|
||||||
|
" 4. Nun könnt ihr die Summe aus zwei beliebige Ganzen Zahlen mit Hilfe des Syntaxes\n",
|
||||||
|
" ```python\n",
|
||||||
|
" 3 + 5\n",
|
||||||
|
" ```\n",
|
||||||
|
" berechnen.\n",
|
||||||
|
" 5. Um diese Code-Zelle auszuführen müsst ihr anschließend die Tastenkombination: **STRG + ENTER** oder **SHIFT + ENTER** benutzen.\n",
|
||||||
|
" \n",
|
||||||
|
" \n",
|
||||||
|
"* Erstellt nun eine Markdown-Zelle überhalt eurer Code-Zelle. Geht dabei wie folgt vor: \n",
|
||||||
|
" 1. Klickt eure zuvor erstellte Code-Zelle an. Sie sollte eine grüne Umrandung anzeigen, da ihr euch hier nach wie vor im Editiermodus befindet.\n",
|
||||||
|
" 2. Drückt die **ESC**-Taste um vom Editier- in den Command-Modus zu wechseln (blaue Umrandung.)\n",
|
||||||
|
" 3. Drückt nun die Taste **A** um eine neue Code-Zelle überhalb (**A**bove) eurer angewählten Zelle zu erstellen. Eurer Navigator wird wieder automatisch zu der neu erstellten Zelle springen.\n",
|
||||||
|
" 4. Drückt nun die Taste **M** um die Code-Zelle in eine Markdown-Zelle zu verwandeln. Ihr werdet feststellen, dass eine Markdown-Zelle im Vergleich zu einer Code Zelle kein \"In []:\" auf der linken Seite stehen hat. \n",
|
||||||
|
" 5. Wechselt nun in der Markdown-Zelle in den Editiermodus (grüne Umrandung) in dem ihr sie anklickt. \n",
|
||||||
|
" 6. Fügt nun die folgenden Dinge in die Markdown-Zelle mit dem entsprechenden Syntax ein:\n",
|
||||||
|
" * Eine level 1 und level 2 Überschift\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ügt dem zweiten Aufzählungspunkt (2.) drei nicht nummerierte Unterpunkte hinzu.\n",
|
||||||
|
" \n",
|
||||||
|
"**Hinweise:**\n",
|
||||||
|
"Um die Aufgabe mit der Markdown-Zelle zu lösen, könnt ihr den benötigten Syntax in der Zelle überhalb dieser Aufgabe nach gucken. Wechselt hierzu in der entsprechenden Markdown-Zelle in den Editiermodus in dem ihr sie mit einem Doppelklick anwählt. \n",
|
||||||
|
"<div/>"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"Neben diesen nützlichen Befehlemm gibt es noch weitere tolle Kürzel wie zum Beispiel:\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",
|
||||||
|
"\n",
|
||||||
|
"Des weiteren könnt ihr [hier](https://www.cheatography.com/weidadeyue/cheat-sheets/jupyter-notebook/) eine Auflistung weiterer Jupyter-Befehle finden."
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"## Python als Taschenrechner:\n",
|
||||||
|
"\n",
|
||||||
|
"Neben dem einfachen summieren zweier Zahlen ermöglicht uns Python natürlich auch das verwendet weiterer Operatoren. Hierbei haben die Operatoren ähnlich wie in der Mathematik gewisse Prioritäten (*Punkt vor Strich*). Die Operation mit dem niedrigeren Prioritätswert wird zu erst ausgeführt. \n",
|
||||||
|
"\n",
|
||||||
|
"<table border=\"1\" class=\"docutils\">\n",
|
||||||
|
"<colgroup>\n",
|
||||||
|
"<col width=\"25%\">\n",
|
||||||
|
"<col width=\"40%\">\n",
|
||||||
|
"<col width=\"11%\">\n",
|
||||||
|
"<col width=\"24%\">\n",
|
||||||
|
"</colgroup>\n",
|
||||||
|
"<thead valign=\"bottom\">\n",
|
||||||
|
"<tr class=\"row-odd\"><th class=\"head\">Operator</th>\n",
|
||||||
|
"<th class=\"head\">Ergebnis</th>\n",
|
||||||
|
"<th class=\"head\">Priorität</th>\n",
|
||||||
|
"</tr>\n",
|
||||||
|
"</thead>\n",
|
||||||
|
"<tbody valign=\"top\">\n",
|
||||||
|
"<tr class=\"row-even\"><td><tt class=\"docutils literal\"><span class=\"pre\">x</span> <span class=\"pre\">+</span> <span class=\"pre\">y</span></tt></td>\n",
|
||||||
|
"<td>Die Summe von <em>x</em> und <em>y</em></td>\n",
|
||||||
|
"<td>6</td>\n",
|
||||||
|
"</tr>\n",
|
||||||
|
"<tr class=\"row-odd\"><td><tt class=\"docutils literal\"><span class=\"pre\">x</span> <span class=\"pre\">-</span> <span class=\"pre\">y</span></tt></td>\n",
|
||||||
|
"<td>Differenz von <em>x</em> und <em>y</em></td>\n",
|
||||||
|
"<td>5</td>\n",
|
||||||
|
"</tr>\n",
|
||||||
|
"<tr class=\"row-even\"><td><tt class=\"docutils literal\"><span class=\"pre\">x</span> <span class=\"pre\">*</span> <span class=\"pre\">y</span></tt></td>\n",
|
||||||
|
"<td>Produkt von <em>x</em> und <em>y</em></td>\n",
|
||||||
|
"<td>4</td>\n",
|
||||||
|
"</tr>\n",
|
||||||
|
"<tr class=\"row-odd\"><td><tt class=\"docutils literal\"><span class=\"pre\">x</span> <span class=\"pre\">/</span> <span class=\"pre\">y</span></tt></td>\n",
|
||||||
|
"<td>Quotient von <em>x</em> und <em>y</em></td>\n",
|
||||||
|
"<td>3</td>\n",
|
||||||
|
"</tr>\n",
|
||||||
|
"<tr class=\"row-odd\"><td><tt class=\"docutils literal\"><span class=\"pre\">x</span> <span class=\"pre\">%</span> <span class=\"pre\">y</span></tt></td>\n",
|
||||||
|
"<td>Rest von <tt class=\"docutils literal\"><span class=\"pre\">x</span> <span class=\"pre\">/</span> <span class=\"pre\">y</span></tt></td>\n",
|
||||||
|
"<td>2</td>\n",
|
||||||
|
"</tr>\n",
|
||||||
|
"<tr class=\"row-odd\"><td><tt class=\"docutils literal\"><span class=\"pre\">x</span> <span class=\"pre\">**</span> <span class=\"pre\">y</span></tt></td>\n",
|
||||||
|
"<td><em>x</em> bei der Potenz von <em>y</em></td>\n",
|
||||||
|
"<td>1</td>\n",
|
||||||
|
"</tr>\n",
|
||||||
|
"</tbody>\n",
|
||||||
|
"</table>\n",
|
||||||
|
"\n",
|
||||||
|
"Hier ein paar Beispiele:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.835098Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.820977Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"2 / 3 - 2"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.854156Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.838216Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"3**2 * 2 - 8 "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.869444Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.856320Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"3**2**2"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"Wie in der Mathematik können wir auch bei Python Klammern verwenden um die Rechenreihenfolge zu ändern:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.885272Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.871522Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"3**2 * 2 - 8 "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.902760Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.887994Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"3**2 * (2 - 8 ) "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"Um unsere Rechnungen besser zu Strukturieren können wir Zahlen auch Variablen zu ordnen. Hierzu verwenden wir das Gleichheitszeichen um einer Variablen (*links*) einem Wert (*rechts*) zu zuordnen."
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.919994Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.905749Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a = 5"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.936549Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.922748Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.951900Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.939383Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"variable = 2"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.968598Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.953574Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a * variable"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"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..."
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:44.986417Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.970615Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a = 4\n",
|
||||||
|
"b = 3\n",
|
||||||
|
"a = 7\n",
|
||||||
|
"\n",
|
||||||
|
"a * b"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"... sondern auch für die Reihenfolge in der die Code-Zellen ausgeführt werden (Angezeigt durch In []:). "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.001728Z",
|
||||||
|
"start_time": "2019-09-30T05:49:44.989743Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a = 7"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.017219Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.003744Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a = 4"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.034800Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.019707Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a * b"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"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. "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.050615Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.036793Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a = 2\n",
|
||||||
|
"b = 5\n",
|
||||||
|
"c = a * b\n",
|
||||||
|
"c"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.067030Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.052096Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a = 2\n",
|
||||||
|
"b = 5.0\n",
|
||||||
|
"c = a * b\n",
|
||||||
|
"c "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"In der oberen Zelle ist **c** vom Datentyp `int` (*Integer*) was einer Ganzen Zahl entspricht. In der unteren Zelle jedoch ist **c** vom Datentype `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 type `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 für was diese verwendet werden, werdet ihr noch im **PGP2** lernen. \n",
|
||||||
|
"\n",
|
||||||
|
"Für das **PGP1** sind erstmal nur die typen `int`, `float` und `str` von Bedeutung."
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2018-11-25T16:19:02.118966Z",
|
||||||
|
"start_time": "2018-11-25T16:19:02.087766Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"source": [
|
||||||
|
"<div class=task>\n",
|
||||||
|
" \n",
|
||||||
|
"#### Aufgabe 2.a.: Beschleunigte Bewegung\n",
|
||||||
|
"\n",
|
||||||
|
"Die zurückgelegte Distanz eines Objekts welches eine beschleunigte Bewegung ausführt (z.B. der freie Fall einer Kugel in einem Gravitationsfeld), kann mit Hilfe von \n",
|
||||||
|
"\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. Verwende Variablen um die folgenden Werte zu berechnen:\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",
|
||||||
|
"* ... im Schwerefeld der Erde $(g_\\text{E} = - 9.81\\,\\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",
|
||||||
|
"\n",
|
||||||
|
"... bis sie auf dem Boden aufschlägt? (Reibungseffekt sind zu vernachlässigen)\n",
|
||||||
|
"\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",
|
||||||
|
"```python\n",
|
||||||
|
"print(Variablennamen1, Variablennamen2, Variablennamen3 ...)\n",
|
||||||
|
"```\n",
|
||||||
|
"oder\n",
|
||||||
|
"```python\n",
|
||||||
|
"print(Variablennamen1) \n",
|
||||||
|
"print(Variablennamen2)\n",
|
||||||
|
"print(Variablennamen3)\n",
|
||||||
|
"```"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"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 (wie dem Passwort), Dateiname bei einer Installation, oder bei Textrückgaben von Programmen. Letzteres haben wir bereits in Aufgabe 2 mit Hilfe 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 Zeichnketten Achsenbeschriftungen an Graphen anbringen können. \n",
|
||||||
|
"\n",
|
||||||
|
"Zunächst erst aber einmal eine einfache Zeichenkette:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.100616Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.084372Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"'Dies ist eine Zeichenkette'"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"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: "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.117423Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.102607Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"s1 = '0123456789'\n",
|
||||||
|
"s2 = 'äöü'\n",
|
||||||
|
"s3 = '*+~`´?ß-@€'\n",
|
||||||
|
"s4 = 'python 3.7>'\n",
|
||||||
|
"\n",
|
||||||
|
"print(s1,s2,s3,s4)"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"Einen **Formatstring** können wir über zwei Arten generieren (**Muss checken welche Python version im Hub genutzt wird**):"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.133467Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.120240Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"a = 'eins'\n",
|
||||||
|
"b = 2\n",
|
||||||
|
"\n",
|
||||||
|
"print('Dies ist Syntaxvariante {}'.format(a))\n",
|
||||||
|
"print()\n",
|
||||||
|
"print(f'Dies ist Syntaxvariante {b}') "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"Neben dem Einfügen von Strings oder Zahlen in eine Zeichenkette können wir die eingefügten Werte auch formatieren:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.149030Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.135899Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"pi = 3.1415926535\n",
|
||||||
|
"\n",
|
||||||
|
"print(f'Dies ist pi auf 4 signifikante Stellen gerundet: {pi:.4}')\n",
|
||||||
|
"print()\n",
|
||||||
|
"print('Dies ist pi auf 4 signifikante Stellen gerundet: {:.4}'.format(pi))"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"... oder sofern ihr eine Rückgabe lieber über mehrere Zeilen ausgeben lassen wollt könnt ihr dieswie folgt machen:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.164689Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.153880Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"U = 12.0 #V\n",
|
||||||
|
"dU = 0.1 #V\n",
|
||||||
|
"I = 0.30 #mA\n",
|
||||||
|
"dI = 0.01 #mA\n",
|
||||||
|
"\n",
|
||||||
|
"R = U/I #kOhm \n",
|
||||||
|
"dR = R * ((dU / U)**2 + (dI / I)**2)**0.5\n",
|
||||||
|
"\n",
|
||||||
|
"print(f'''An einem Widerstand R wurden die folgenden Werte gemessen:\n",
|
||||||
|
"Spannung: {U}+/-{dU} V\n",
|
||||||
|
"Strom: {I}+/-{dI} mA\n",
|
||||||
|
"Hierraus resultiert ein Widerstand von {R}+/-{dR:.2} kOhm ''') "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"<div class=task>\n",
|
||||||
|
" \n",
|
||||||
|
"#### Aufgabe 2.b.: Beschleunigte Bewegung Zusatz\n",
|
||||||
|
" \n",
|
||||||
|
"Lasst euch eure berechneten Werte aus Aufgabe 2 mit Hilfe von `print` erneut ausgeben. Nutzt jedoch diese Mal **Formatstrings** für eine schönere und bedeutungsvollere Rückgabe. Achtet dabei besonders auf:\n",
|
||||||
|
"\n",
|
||||||
|
"* Die Angabe der richtigen Einheiten\n",
|
||||||
|
"* Das Runden der berechneten Werte der Anzahl an signifikanten Stellen entsprechend "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"## Das 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 Gesetzt welches durch \n",
|
||||||
|
"\n",
|
||||||
|
"$U(R, I) = R \\cdot I$ \n",
|
||||||
|
"\n",
|
||||||
|
"beschrieben wird angucken. Hierbei wird die Spannung $U$ durch die Variablen $R$ und $I$ beschrieben. Dies gilt auch analog für Funktionen in einer Programmiersprache:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.198018Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.182648Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"def Spannung(Widerstand, Strom): # U(R,I)\n",
|
||||||
|
" return Widerstand * Strom # Wiedergabe der Funktion"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"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}$:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.213392Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.200009Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"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",
|
||||||
|
"U = Spannung(1000, 0.01) # in V \n",
|
||||||
|
"U "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"Neben mathematischen Funktionen, können Funktionen in einer Programmiersprache auch viel allgemeinere Aufgaben erfüllen bzw. komplexe Algorithmen beinhalten. Hierzu lernt ihr jedoch noch mehr in anderen Programmierkursen. Wie zum Beispiel:\n",
|
||||||
|
"\n",
|
||||||
|
"* Computer in der Wissenschaft \n",
|
||||||
|
"* Programmieren für Physiker\n",
|
||||||
|
"* Einführung in die Programmierung"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"<div class=task>\n",
|
||||||
|
" \n",
|
||||||
|
"#### Aufgabe 3. Umgang mit dem Ohmschen Gesetzt:\n",
|
||||||
|
"\n",
|
||||||
|
"Bei einem $500\\,\\Omega$ Widerstand wird eine Spannung von 5, 10, 20 und 50 Volt angelegt, wie hoch sollte der jeweils entsprechende Strom ausfallen und welche Leistung wird in dem Widerstand umgesetzt ? \n",
|
||||||
|
"\n",
|
||||||
|
"Des Weiteren nehmt an, dass euer Widerstand einen Fehler von $+/-20\\,\\Omega$ und eure angelegte Spannung eine Ungenauigkeit von $10\\,\\%$ aufweist. Wie groß wäre der Fehler des gemessen Stroms bei der Messung mit $50\\,$V? Benutzt hierfür die Gaus'sche Fehlerfortpflanzung und definiert die entsprechende Funktion in Python.\n",
|
||||||
|
"\n",
|
||||||
|
"**Tipp:**\n",
|
||||||
|
"\n",
|
||||||
|
"Die Leistung welche in einem ohmschen Widerstand umgesetzt wird lässt durch\n",
|
||||||
|
"\n",
|
||||||
|
"$P(U, I ) = U \\cdot I $\n",
|
||||||
|
"\n",
|
||||||
|
"berechnen, wobei $U$ die angelegte Spannung ist und $I$ der elektrische Strom welcher durch den Widerstand fließt. \n",
|
||||||
|
"<div>"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"### Tipp: \n",
|
||||||
|
"Es ist ratsam gleich von Anfang an Funktionen zu dokumentieren. Hierzu wird in Python der sogenannte `Doc-Strings`. Sie beinhalten Informationen über die Funktion selbst ihre Verwendeten Parameter und ihrer Ausgabe. Zum Beispiel für unser Beispiel des Ohmschen Gesetzt:"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": null,
|
||||||
|
"metadata": {
|
||||||
|
"ExecuteTime": {
|
||||||
|
"end_time": "2019-09-30T05:49:45.228841Z",
|
||||||
|
"start_time": "2019-09-30T05:49:45.213392Z"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"def Spannung(Strom, Widerstand):\n",
|
||||||
|
" '''\n",
|
||||||
|
" Diese Funktion berechnet die Spannung eines Ohmschen \n",
|
||||||
|
" Widerstands.\n",
|
||||||
|
" \n",
|
||||||
|
" Args:\n",
|
||||||
|
" Strom (float): Der gemessene Strom in mA.\n",
|
||||||
|
" Widerstand (float): Der Wert des verwendeten Widerstands\n",
|
||||||
|
" in Ohm.\n",
|
||||||
|
" \n",
|
||||||
|
" \n",
|
||||||
|
" Returns:\n",
|
||||||
|
" float: Die Berechnete Spannung in V.\n",
|
||||||
|
" '''\n",
|
||||||
|
" return Widerstand * Strom/1000"
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"metadata": {
|
||||||
|
"kernelspec": {
|
||||||
|
"display_name": "Python 3",
|
||||||
|
"language": "python",
|
||||||
|
"name": "python3"
|
||||||
|
},
|
||||||
|
"language_info": {
|
||||||
|
"codemirror_mode": {
|
||||||
|
"name": "ipython",
|
||||||
|
"version": 3
|
||||||
|
},
|
||||||
|
"file_extension": ".py",
|
||||||
|
"mimetype": "text/x-python",
|
||||||
|
"name": "python",
|
||||||
|
"nbconvert_exporter": "python",
|
||||||
|
"pygments_lexer": "ipython3",
|
||||||
|
"version": "3.7.3"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"nbformat": 4,
|
||||||
|
"nbformat_minor": 2
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue