1683 lines
41 KiB
Plaintext
1683 lines
41 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "079afb70-639e-4955-8ca7-1c290cbf08a9",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-7057e40105900012",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"# 2. Programmierübung: Python Tutorial\n",
|
||
"\n",
|
||
"<div style=\"display:flex;\">\n",
|
||
" <div style=\"text-align: left\">\n",
|
||
" Willkommen zur zweiten Programmierübung Einführung in Python 3.\n",
|
||
" </div>\n",
|
||
" <img style=\"float: right; margin: 0px 15px 15px 0px\" src=\"https://www.python.org/static/img/python-logo-large.c36dccadd999.png?1576869008\" width=\"100\" />\n",
|
||
"</div>\n",
|
||
"\n",
|
||
"Wenn du Fragen oder Verbesserungsvorschläge zum Inhalt oder Struktur der Notebooks hast, dann kannst du mir gerne eine E-Mail an Phil Keier ([p.keier@hbk-bs.de](mailto:p.keier@hbk-bs.de?subject=[SigSys]%20Feedback%20Programmierübung&)) schreiben.\n",
|
||
"\n",
|
||
"Link zu einem Python Spickzettel: [hier](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/PythonForDataScience.pdf)\n",
|
||
"\n",
|
||
"Der Großteil des Python-Tutorials stammt aus der Veranstaltung _Deep Learning Lab_ und von [www.python-kurs.eu](https://www.python-kurs.eu/python3_kurs.php) und wurde für _Signale und Systeme_, sowie _Einführung in die Programmierung für Nicht Informatiker_ angepasst."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "85fd88de-a9ee-4149-8bed-1b8ebc0bbad4",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-26e0f96baeb79aac",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"# Kontrollstruckturen\n",
|
||
"\n",
|
||
"## Sequentielles - For Loop\n",
|
||
"\n",
|
||
"Python verwendet eine spezielle Form der for-Schleife – genauer gesagt den sogenannten for-each loop.\n",
|
||
"\n",
|
||
"Inzwischen hat nahezu jede gängige Programmiersprache dieses Konzept auf ihre eigene Weise umgesetzt. Python geht dabei jedoch einen Schritt weiter und nutzt den for-each loop als Standard. Sprachen wie JavaScript oder C/C++ verwenden hingegen standardmäßig eine Zählschleife: Dabei wird meist von 0 bis zu einem definierten Grenzwert n hochgezählt.\n",
|
||
"\n",
|
||
"Ein anschauliches Beispiel dafür liefert JavaScript:\n",
|
||
"\n",
|
||
"```js\n",
|
||
"for (let i = 0; i < arr.length; i++) {\n",
|
||
" // do something\n",
|
||
"} \n",
|
||
"```\n",
|
||
"\n",
|
||
"Lesbar ist dieser Code wie folgt:\n",
|
||
"„Für ein `i` mit dem Startwert `0 (let i = 0)`, führe die Schleife aus, solange `i` kleiner als die Länge des Arrays `arr` ist `(i < arr.length)`, und erhöhe `i` nach jedem Schleifendurchlauf um `1 (i++)`.“\n",
|
||
"\n",
|
||
"In Python würde derselbe Code folgendermaßen aussehen:\n",
|
||
"\n",
|
||
"```python\n",
|
||
"for i in range(0,len(arr)):\n",
|
||
" # do something\n",
|
||
"```\n",
|
||
"\n",
|
||
"Das lässt sich so lesen:\n",
|
||
"„Für jedes `(for each) i` im Bereich von `0 bis arr.length`, führe etwas aus.“\n",
|
||
"\n",
|
||
"Der zentrale Unterschied besteht darin, dass Python nicht zwingend über Zahlen iterieren muss – es kann über beliebige Mengen oder Sammlungen laufen. Der Clou liegt also darin, dass die Schleife völlig unabhängig davon funktioniert, wie die zugrunde liegende Menge aussieht.\n",
|
||
"\n",
|
||
"Widmen wir uns nun einer praktischen Aufgabe:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "7215a3e7-a240-43ec-914c-10221d8b28b0",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-80add6da9914f961",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe \n",
|
||
"\n",
|
||
"*3 Punkte*\n",
|
||
"\n",
|
||
"Schreibe eine Funktion `sum_up` mit Eingabeparameter `n`, welcher die Zahlen von `1...n` aufsummiert.\n",
|
||
"\n",
|
||
"Nutze dafür einen `for-loop`.\n",
|
||
"\n",
|
||
"**Beispiel**:\n",
|
||
"\n",
|
||
"$$n = 5$$ \n",
|
||
"$$sum\\_up(5) \\rightarrow 1 \\rightarrow 1 + 2 = 3 \\rightarrow 3 + 3 = 6 \\rightarrow 6 + 4 = 10 \\rightarrow 10 + 5 = 15$$\n",
|
||
"\n",
|
||
"Hinweis: die Funktion `range()` zählt standardmässig von `0...n-1`. Schauen Sie sich gerne dazu die offizielle Dokumentation an [PEP 204](https://peps.python.org/pep-0204/#list-ranges)."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 1,
|
||
"id": "5426ddf1-2d2f-4c92-b007-2f6eca61703f",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-d43ef87a62b03cdf",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"# BEGIN SOLUTION\n",
|
||
"def sum_up(n: int) -> int:\n",
|
||
" count = 0\n",
|
||
" for i in range(1,n+1):\n",
|
||
" count += i\n",
|
||
" return count\n",
|
||
"# END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 2,
|
||
"id": "3c38a839-3ab0-466c-98f9-189c35fc5025",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-cff511e86dce0377",
|
||
"locked": true,
|
||
"points": 3,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"15\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"print(sum_up(5))\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"for n in range(3,12):\n",
|
||
" assert sum(range(n+1)) == sum_up(n)\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "4e6dfa94-18b9-4fb2-830a-83202d034752",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-02370acddb67290d",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"Nachdem wir nun gelernt haben, wie man mithilfe der eingebauten Funktion `range()` zählen kann, schauen wir uns im Folgenden einige Beispiele dafür an, wie in Python eigentlich iteriert werden sollte.\n",
|
||
"\n",
|
||
"#### Beispiel 1 - Iterieren über eine Liste:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 3,
|
||
"id": "db89c7c5-6efc-49bb-be92-414a7334ed84",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-dd3ea63dd3b1d927",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"1\n",
|
||
"4\n",
|
||
"9\n",
|
||
"16\n",
|
||
"25\n",
|
||
"36\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"square_numbers = [1,4,9,16,25,36]\n",
|
||
"for number in square_numbers:\n",
|
||
" print(number)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "6413a239-c334-491e-8062-7f78f75182fe",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-9bc7f123a8fb7680",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"#### Beispiel 2 - Iterieren über ein Dictionary:\n",
|
||
"\n",
|
||
"Erweitern wir Beispiel 1 und arbeiten nun mit einem Dictionary. Dieses besteht – wie Sie noch aus dem ersten Tutorial wissen – stets aus „Key-Value“-Paaren.\n",
|
||
"Mithilfe der eingebauten Funktion `.items()` erhalten wir ein Tuple aus diesen Werten zurück, das zunächst entpackt werden muss.\n",
|
||
"\n",
|
||
"Hier kommt der for-Loop ins Spiel: Durch die gleichzeitige Deklaration von zwei Variablen können die einzelnen Key-Value-Paare direkt verarbeitet werden.\n",
|
||
"(Achtung: Mit `.items()` werden die Paare in der Form `(key, value)` zurückgegeben!)\n"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 4,
|
||
"id": "116ce552-a5c0-4c9c-8d89-fe1f3e40bdba",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-72122af8e519273b",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"1 -> 1\n",
|
||
"2 -> 4\n",
|
||
"3 -> 9\n",
|
||
"4 -> 16\n",
|
||
"5 -> 25\n",
|
||
"6 -> 36\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"square_numbers_dict = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}\n",
|
||
"\n",
|
||
"for key, value in square_numbers_dict.items():\n",
|
||
" print(key, \"->\" , value)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "b4e748de-0603-41c9-8282-86e92923e358",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-52b4d0167c7fb9ba",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"#### Beispiel 3 - Iteration mit Zählen:\n",
|
||
"\n",
|
||
"Die Built-In Funktion `enumerate()` [PEP 279](https://peps.python.org/pep-0279/) ermöglicht das Zählen und gleichzeitige iterieren über eine Liste.\n",
|
||
"Dabei wird wieder ein Tuple zurückgegeben welches die Form '(index, value)' annimmt.\n",
|
||
"\n",
|
||
"Die eingebaute Funktion `enumerate()` [PEP 279](https://peps.python.org/pep-0279/) ermöglicht es, gleichzeitig zu zählen und über eine Liste zu iterieren.\n",
|
||
"Dabei wird – ähnlich wie bei `.items()` – ein Tuple zurückgegeben, das die Form `(index, value)` besitzt."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 5,
|
||
"id": "8cbf9142-2cf3-4579-9e19-799ee9b25a54",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-29953c29ed4bcdcf",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"0 -> a\n",
|
||
"1 -> b\n",
|
||
"2 -> c\n",
|
||
"3 -> d\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"alphabet = [\"a\", \"b\", \"c\", \"d\"]\n",
|
||
"for index, buchstabe in enumerate(alphabet):\n",
|
||
" print(index, \"->\", buchstabe)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "4add1ce5-e462-4be3-8bd7-9960d86ae780",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-b64ce270167d3025",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"Mit den traditionellen Mitteln lässt sich derselbe Output erzeugen.\n",
|
||
"Die Verwendung von `enumerate()` ist jedoch deutlich eleganter und übersichtlicher:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 6,
|
||
"id": "d2e8274b-00d4-4042-adbf-937aea8f0e7e",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-8b2e3cb4e0c977f2",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"0 -> a\n",
|
||
"1 -> b\n",
|
||
"2 -> c\n",
|
||
"3 -> d\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"alphabet = [\"a\", \"b\", \"c\", \"d\"]\n",
|
||
"for index in range(len(alphabet)):\n",
|
||
" print(index, \"->\", alphabet[index])"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "7a8dc614-3c49-4455-a12d-a856e1db40af",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-9ffa970f1cdac592",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"#### Beispiel 4 - Iteration ohne Zähler:\n",
|
||
"\n",
|
||
"Der Unterstrich `_` wird in Python häufig als Platzhalter für ungenutzte Variablen verwendet.\n",
|
||
"Bei for-Loops kennzeichnet er Schleifen, deren Zählvariable nicht weiterverwendet wird:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 10,
|
||
"id": "786461b8-ecf9-4afb-8b93-6186f53f6e97",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-8316e1e4eaa0ea0b",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Python is Nice!\n",
|
||
"Python is Nice!\n",
|
||
"Python is Nice!\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"for _ in range(3):\n",
|
||
" print(\"Python is Nice!\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "b504f072-53ce-4d03-9f72-b4d4ba85ae74",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-5e8d9fc47a709ba4",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe\n",
|
||
"\n",
|
||
"*2 Punkte*\n",
|
||
"\n",
|
||
"Gegeben ist das Dictionary `dict2`.\n",
|
||
"Ändere jeden Wert in diesem Dictionary entsprechend der Formel $f(x) = x^3-1$ mittels `for-loop`.\n",
|
||
"\n",
|
||
"Hinweis: Lass dich dabei nicht von den Schlüsseln verwirren – entscheidend sind ausschließlich die Werte."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 7,
|
||
"id": "64972ce6-b087-4fb1-b1a8-faa1a3e2690c",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"dict2 = {\"a\": 56, 5: 12, \"python\": 9, 3.14: 1.141414}"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 8,
|
||
"id": "abd323c0-5e1b-4c14-a65a-9d54a06f3a80",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-0361320c63b2cb03",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"### BEGIN SOLUTION\n",
|
||
"dict2 = {key: value**3-1 for key, value in dict2.items()}\n",
|
||
"### END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 9,
|
||
"id": "7e0f9ac4-c5d4-44b6-a2fc-db98e2b46356",
|
||
"metadata": {
|
||
"editable": true,
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-82eec3cba623ab8f",
|
||
"locked": true,
|
||
"points": 2,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"{'a': 175615, 5: 1727, 'python': 728, 3.14: 0.48706374396146557}\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"print(dict2)\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"d = {\"a\": 56, 5: 12, \"python\": 9, 3.14: 1.141414}\n",
|
||
"d = {key: value**3-1 for key, value in d.items()}\n",
|
||
"assert d == dict2\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "7fd320aa-6bb5-4b9b-9593-2df69cb2ca1e",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-cb8f33d1ae55a6a4",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"## List Comprehension\n",
|
||
"\n",
|
||
"Seit dem Proposal von [PEP 202](https://peps.python.org/pep-0202/) verfügt Python über die sogenannte List Comprehension.\n",
|
||
"\n",
|
||
"Für diese Vorlesung ist es nicht erforderlich, dass Sie die Syntax bereits aktiv anwenden können – Sie sollten jedoch zumindest verstehen, wie sie funktioniert.\n",
|
||
"\n",
|
||
"Angenommen, wir betrachten folgende mathematische Beschreibung einer Menge: $$\\{x^2 \\vert x \\in \\mathbb{N}\\}$$\n",
|
||
"\n",
|
||
"Dies beschreibt die Funktion $f(x) = x^2$ für alle natürlichen Zahlen.\n",
|
||
"\n",
|
||
"In Python lässt sich genau diese Menge in einer einzigen Zeile abbilden.\n",
|
||
"Dazu wird die List Comprehension verwendet, deren allgemeine Syntax wie folgt aussieht:\n",
|
||
"\n",
|
||
"```python\n",
|
||
"[<value> for value in <iterable>]\n",
|
||
"```\n",
|
||
"\n",
|
||
"Schauen wir uns dazu an wie wir die Quadrat Zahlen von `1...6` also `1...36` erzeugen."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 29,
|
||
"id": "7bcdc9d9-cc5b-49be-8cfb-ca40eb3b7796",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-4fd6f801463c5ea6",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"[1, 4, 9, 16, 25, 36]\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"squared = [n*n for n in range(1,7)]\n",
|
||
"print(squared)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "b6dcb24c-e01e-4522-8ac4-074adfe6105a",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-c6922240434c9d3a",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"Probieren Sie sich gerne selber aus.\n",
|
||
"\n",
|
||
"### Zusatzaufgabe \n",
|
||
"\n",
|
||
"*Keine Punkte*\n",
|
||
"\n",
|
||
"Erstelle eine Liste mittels `List Comprehension`, welche die Zahlen `1...6` auf deren kubische Zahl `1...216` also der Funktion $f(x) = x^3$ abbildet."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 30,
|
||
"id": "522f3228-1797-4ca2-9103-44fce48dfd4a",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-1dc645632c5f653a",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"cubics = []\n",
|
||
"### BEGIN SOLUTION\n",
|
||
"cubics = [n**3 for n in range(1,7)]\n",
|
||
"### END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 31,
|
||
"id": "7dc19b9f-116b-4741-a798-a66d495d477e",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-4e441b6db861559e",
|
||
"locked": true,
|
||
"points": 0,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"[1, 8, 27, 64, 125, 216]\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"print(cubics)\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"c = [n**3 for n in range(1,7)]\n",
|
||
"assert c == cubics\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "5b1355f0-29ed-4318-92f2-51f151c7946e",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-7d9eebd920496d59",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"# System Interactions\n",
|
||
"\n",
|
||
"Im folgenden Abschnitt beschäftigen wir uns mit der Eingabe von Daten in ein Programm.\n",
|
||
"Dies kann entweder manuell durch den Benutzer erfolgen oder über Dateien geschehen."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "976a7ad0-856d-4fb6-bba8-485668df22a2",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-e2df7221e04e8c54",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"In der Praxis möchten wir häufig größere Datenmengen einlesen.\n",
|
||
"Dazu verwenden wir die eingebaute Funktion `open` ([Python Docs - Open](https://docs.python.org/3/library/functions.html?highlight=open#open)). Obwohl die Dokumentation zahlreiche Parameter aufführt, werden im Normalfall nur zwei benötigt:\n",
|
||
"1. Der Name der Datei\n",
|
||
"2. Der Modus, in dem die Datei geöffnet werden soll (als String angegeben)\n",
|
||
"\n",
|
||
"Zum Bearbeiten von Dateien nutzen wir in Python den Kontext-Manager – also das `with`-Statement.\n",
|
||
"Bei externen Daten ist es besonders wichtig, die Datei nach der Bearbeitung wieder zu schließen, um Datenverlust oder unnötige Speichernutzung zu vermeiden.\n",
|
||
"\n",
|
||
"Der Lebenszyklus einer Datei in einem Programm sieht daher immer wie folgt aus:\n",
|
||
"\n",
|
||
"`Datei öffnen` -> `Datei Bearbeiten` -> `Datei schließen`\n",
|
||
"\n",
|
||
"Tritt in einem dieser drei Schritte ein Fehler auf, kann die Datei im Arbeitsspeicher hängen bleiben. In diesem Fall muss der Computer unter Umständen neu gestartet werden, um den belegten Speicher wieder freizugeben.\n",
|
||
"\n",
|
||
"Daher gibt es Kontext-Manager. Sie garantieren, dass das Schließen der Datei immer erfolgt – selbst bei auftretenden Fehlern.\n",
|
||
"\n",
|
||
"Die Syntax folgt dabei der folgenden Struktur:\n",
|
||
"\n",
|
||
"```python\n",
|
||
"with <kontext> as <var-name>:\n",
|
||
" # do something\n",
|
||
"```\n",
|
||
"\n",
|
||
"Dabei ist `<kontext>` ein Objekt (für uns eine Datei) und `<var-name>` die Zuweisung zu einer Variablen. Für die Funktion `open` (im Lesemodus) sieht der Kontext wie folgt aus:\n",
|
||
"\n",
|
||
"```python\n",
|
||
"with open(\"filename.txt\", \"r\") as f:\n",
|
||
" f.readlines() # do something with f\n",
|
||
"```"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "a345cdf5-d1a0-4bd8-9f77-06e6d4562e00",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-58fb9b7e476f3ef2",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe\n",
|
||
"\n",
|
||
"*2 Punkte*\n",
|
||
"\n",
|
||
"Erstelle und Öffne eine Datei `testfile.txt` mit der `open` Funktion, nutze dafür das `with`-Statement.\n",
|
||
"\n",
|
||
"Schreibe in diese Datei 100 mal den String `\"Python\\n\"`. "
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 32,
|
||
"id": "f11f7a0b-bcca-4db0-a6ca-bf95c70c7303",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-0735bb589edcc6a8",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"# BEGIN SOLUTION\n",
|
||
"with open('testfile.txt', 'w') as f:\n",
|
||
" for _ in range(100):\n",
|
||
" f.write(\"Python\\n\")\n",
|
||
"# END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 33,
|
||
"id": "c91e07bb-fc41-42c1-8b42-0aca56c57c35",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-2592f8b51914455e",
|
||
"locked": true,
|
||
"points": 2,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"with open('testfile.txt', 'r') as f:\n",
|
||
" lines = f.readlines()\n",
|
||
" assert len(lines) == 100\n",
|
||
" for line in lines:\n",
|
||
" assert line == 'Python\\n'\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "4adb5400-8749-4790-ae49-68a8622b4a3d",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-39769ee8cbf2157d",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe\n",
|
||
"\n",
|
||
"*2 Punkte*\n",
|
||
"\n",
|
||
"Öffne die zuvor erstellte Datei `testfile.txt` im Lesemodus und weiße den Inhalt der `.readlines()` Funktion der Variabeln `lines` zu. "
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 34,
|
||
"id": "adf300e9-ee63-4da1-a6f3-c768fa2b5fc9",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-0a3b9e01dd66e134",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"lines = None\n",
|
||
"# BEGIN SOLUTION\n",
|
||
"with open('testfile.txt', 'r') as f:\n",
|
||
" lines = f.readlines()\n",
|
||
"# END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 35,
|
||
"id": "229499d6-bb33-492b-af5d-a26ab3b3f5d4",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-aa7c104b5f3f2572",
|
||
"locked": true,
|
||
"points": 2,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Anzahl der gelesenen Zeilen: 100\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"print(\"Anzahl der gelesenen Zeilen:\", len(lines))\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"with open('testfile.txt', 'r') as f:\n",
|
||
" assert f.readlines() == lines\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "47d92dde-16a1-4c11-a452-cadd74255db2",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-be695e1423a6ccf4",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"## Import Statement\n",
|
||
"\n",
|
||
"<img style=\"float: center;\" src=\"https://preview.redd.it/00824ycw3hwy.jpg?width=960&crop=smart&auto=webp&s=58a493191f1a6990d28bcbb6650b9f59749c5a9b\" width=800/> \n",
|
||
"\n",
|
||
"Da wir nicht immer das Rad neu erfinden wollen, greifen wir auf Bibliotheken anderer Entwickler zurück.\n",
|
||
"\n",
|
||
"Dazu verwendet man das Keyword `import`, gefolgt von dem Modul, das man einbinden möchte.\n",
|
||
"Ein anschauliches Beispiel ist das Modul `numpy`:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 18,
|
||
"id": "ced37c65-87d2-48d0-a0ba-4674dcaf104c",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-7d19506e181bcda9",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"import numpy"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "f5506975-e1cd-434a-8ef1-05a7a06992df",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-b7d981325bea8b84",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"Möchte man nun eine Funktion aus dem Modul nutzen folgt die Syntax der Strucktur `<module>.<funktion | variable>`.\n",
|
||
"\n",
|
||
"Dazu folgendes Numpy Beispiel:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 19,
|
||
"id": "69c68b31-d0f7-469b-ae54-eef871ec6ad6",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-25ad372a576a793e",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"data": {
|
||
"text/plain": [
|
||
"array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n",
|
||
" 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
|
||
" 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,\n",
|
||
" 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,\n",
|
||
" 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,\n",
|
||
" 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])"
|
||
]
|
||
},
|
||
"execution_count": 19,
|
||
"metadata": {},
|
||
"output_type": "execute_result"
|
||
}
|
||
],
|
||
"source": [
|
||
"numpy.array(range(100))"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "7c5d65db-d1e8-4cad-884e-bb595c57d445",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-0176c541098f7c21",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe\n",
|
||
"\n",
|
||
"*3 Punkte*\n",
|
||
"\n",
|
||
"Importiere Pythons Built-In Library `random` und rufe zuerst aus dem Modul die Funktion `seed` auf mit dem Eingabewert `42`, und weiße danach der Variable `rand` den Wert des Funktionsaufrufes von `randint(1,100)` zu. "
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 36,
|
||
"id": "0d80bc9f-6923-4e3f-8a70-909548e693a6",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-8ccc5fe1848176c8",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"rand = None\n",
|
||
"# BEGIN SOLUTION\n",
|
||
"import random\n",
|
||
"random.seed(42)\n",
|
||
"rand = random.randint(1,100)\n",
|
||
"# END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 37,
|
||
"id": "ada0211b-03bf-463a-b932-2bad621d5559",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-d7817c3dd1ee34f9",
|
||
"locked": true,
|
||
"points": 3,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"82\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"print(rand)\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"assert rand == 82\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "f7b3bdcc-825e-4607-8804-a5ce3d39ace5",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-2cc1d2ed682d1b0e",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"Das bereits bekannte Keyword `as` kann auch beim Import von Modulen verwendet werden, um diesen einen Alias zu geben.\n",
|
||
"Das ist besonders hilfreich, wenn Module lange Namen haben.\n",
|
||
"\n",
|
||
"So wird zum Beispiel numpy im Internet häufig mit np abgekürzt. Ein Beispiel:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 38,
|
||
"id": "f115eae9-500b-448e-a1be-e3b43ffad0fd",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-60f357d6dda4a8d3",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"data": {
|
||
"text/plain": [
|
||
"array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n",
|
||
" 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
|
||
" 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,\n",
|
||
" 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,\n",
|
||
" 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,\n",
|
||
" 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])"
|
||
]
|
||
},
|
||
"execution_count": 38,
|
||
"metadata": {},
|
||
"output_type": "execute_result"
|
||
}
|
||
],
|
||
"source": [
|
||
"import numpy as np\n",
|
||
"np.array(range(100))"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "f7570244-0fea-4683-a19c-069f6ba619dd",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-94fb7e92492a12f7",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe\n",
|
||
"\n",
|
||
"*1 Punkt*\n",
|
||
"\n",
|
||
"Importiere die Built-In Library `datetime` als `dt`."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 39,
|
||
"id": "e7e6c246-6dc4-4555-a202-73887b5f8249",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-59dc2ded4f59471f",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"# BEGIN SOLUTION\n",
|
||
"import datetime as dt\n",
|
||
"# END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 40,
|
||
"id": "b03ee34b-8520-4106-a23f-4419e54dcfcc",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-d77ffdb7f9ba178d",
|
||
"locked": true,
|
||
"points": 1,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"2025-11-13 12:40:25.172727\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"print(dt.datetime.now()) # UTC Time also Standard Greenwich Zeit\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"assert 'dt' in dir()\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "1cc39ffb-1207-4aa8-a4fe-51df2335fea6",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-c55653efe0a77419",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"Möchte man nur eine Bestimmte Funktion aus einem Modul haben nutzt man die `import from` Syntax. Beispiel Pretty Print:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 42,
|
||
"id": "638e6c20-7bba-4862-9acc-34031bae8514",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-f84e2596969633f5",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"{0: 1,\n",
|
||
" 1: 2,\n",
|
||
" 2: 4,\n",
|
||
" 3: 8,\n",
|
||
" 4: 16,\n",
|
||
" 5: 32,\n",
|
||
" 6: 64,\n",
|
||
" 7: 128,\n",
|
||
" 8: 256,\n",
|
||
" 9: 512,\n",
|
||
" 10: 1024,\n",
|
||
" 11: 2048,\n",
|
||
" 12: 4096,\n",
|
||
" 13: 8192,\n",
|
||
" 14: 16384,\n",
|
||
" 15: 32768,\n",
|
||
" 16: 65536,\n",
|
||
" 17: 131072,\n",
|
||
" 18: 262144,\n",
|
||
" 19: 524288,\n",
|
||
" 20: 1048576,\n",
|
||
" 21: 2097152,\n",
|
||
" 22: 4194304,\n",
|
||
" 23: 8388608,\n",
|
||
" 24: 16777216}\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"from pprint import pprint\n",
|
||
"pprint({n: 2**n for n in range(25)})"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "c1e077c1-59a5-411b-bf71-32ea66dc731d",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-0ac2347c47ff5774",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe\n",
|
||
"\n",
|
||
"*2 Punkte*\n",
|
||
"\n",
|
||
"Importiere die Funktion `sqrt` aus dem Built-In Modul `math`.\n",
|
||
"Berechne $\\sqrt4$. Speicher das Ergebnis in der variablen `s4`."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 43,
|
||
"id": "81838f9b-558c-49b3-90ef-647e28380a97",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-7c1ea8bca61d5c12",
|
||
"locked": false,
|
||
"schema_version": 3,
|
||
"solution": true,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [],
|
||
"source": [
|
||
"# BEGIN SOLUTION\n",
|
||
"from math import sqrt\n",
|
||
"s4 = sqrt(4)\n",
|
||
"# END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 44,
|
||
"id": "6d984a74-a93d-4865-b6d1-d2dec8586907",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": true,
|
||
"grade_id": "cell-83c667de468e9ef8",
|
||
"locked": true,
|
||
"points": 2,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"2.0\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"print(s4)\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"assert 'sqrt' in dir()\n",
|
||
"assert int(s4) == 2\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "6edf5dce-17d2-4a5f-9d96-2c7c3091de88",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-814b3bfa4b6e049a",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"Es ist auch möglich, in der `from ... import ...`-Syntax das Keyword `as` zu verwenden, um einzelne Elemente eines Moduls umzubenennen.\n",
|
||
"\n",
|
||
"Beispiel: Aus dem Modul dataclasses wird dataclass als dclass importiert:"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 28,
|
||
"id": "b707bf52-546f-4689-8216-c5ad0b9665a7",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-9961359e9d09d79b",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"<function dataclass at 0x7f86d7516340>\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"from dataclasses import dataclass as dclass\n",
|
||
"print(dclass)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "842213e0-a55d-4cfc-863e-f6333e1482e6",
|
||
"metadata": {
|
||
"nbgrader": {
|
||
"grade": false,
|
||
"grade_id": "cell-0ac2347c47ff5774",
|
||
"locked": true,
|
||
"schema_version": 3,
|
||
"solution": false,
|
||
"task": false
|
||
},
|
||
"slideshow": {
|
||
"slide_type": ""
|
||
},
|
||
"tags": []
|
||
},
|
||
"source": [
|
||
"### Aufgabe\n",
|
||
"\n",
|
||
"*2 Punkte*\n",
|
||
"\n",
|
||
"Importiere das Objekt `TextCalendar` aus dem Built-In Module `calendar` als `TC`."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 51,
|
||
"id": "b71c98a6-2e7b-4b6b-bfde-e6b7e2e944a3",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"# BEGIN SOLUTION\n",
|
||
"from calendar import TextCalendar as TC\n",
|
||
"# END SOLUTION"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 56,
|
||
"id": "c3fb8526-3bbd-4440-a366-b671702acfaa",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
" November 2025\n",
|
||
"Mo Tu We Th Fr Sa Su\n",
|
||
" 1 2\n",
|
||
" 3 4 5 6 7 8 9\n",
|
||
"10 11 12 13 14 15 16\n",
|
||
"17 18 19 20 [21] 22 23\n",
|
||
"24 25 26 27 28 29 30\n",
|
||
"\n",
|
||
"21.11.2025 - Nächste Vorlesung\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"# Hier werden die Loesungen getestet...\n",
|
||
"year = 2025\n",
|
||
"month = 11 # November\n",
|
||
"highlight_day = 21\n",
|
||
"event_text = \"Nächste Vorlesung\"\n",
|
||
"\n",
|
||
"# Generate the month as a multi-line string\n",
|
||
"month_str = TC().formatmonth(year, month)\n",
|
||
"\n",
|
||
"# Highlight the day by surrounding it with brackets\n",
|
||
"highlighted_month = month_str.replace(\n",
|
||
" f\"{highlight_day:2}\",\n",
|
||
" f\"[{highlight_day:2}]\"\n",
|
||
")\n",
|
||
"\n",
|
||
"highlighted_month += f\"\\n{highlight_day:2}.11.{year} - {event_text}\"\n",
|
||
"\n",
|
||
"print(highlighted_month)\n",
|
||
"### BEGIN HIDDEN TESTS\n",
|
||
"assert 'TC' in dir()\n",
|
||
"### END HIDDEN TESTS"
|
||
]
|
||
}
|
||
],
|
||
"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.11.6"
|
||
}
|
||
},
|
||
"nbformat": 4,
|
||
"nbformat_minor": 5
|
||
}
|