{
 "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 Sie Fragen oder Verbesserungsvorschläge zum Inhalt oder Struktur der Notebooks haben, dann können sie eine E-Mail an Phil Keier ([p.keier@hbk-bs.de](mailto:p.keier@hbk-bs.de?subject=[SigSys]%20Feedback%20Programmierübung&amp)) oder Martin Le ([martin.le@tu-bs.de](mailto:martin.le@tu-bs.de?subject=[SigSys]%20Feedback%20Programmierübung&amp)) 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 des 'for-loops' dabei handelt es sich sprachlich um den 'for-each loop'.\n",
    "\n",
    "Mittlerweile hat jede nennenswerte Programmiersprache das Konzept des 'for-each loops' auf seine Weise implementiert. Python hingegen nutzt diesen als Standard. Sprachen wie JavaScript, C/C++, etc. verwenden standardmässig eine 'Zählschleife', dabei wird meist von '0' angefangen bis zu einem Grenzwert 'n' gezählt.\n",
    "\n",
    "Ein schönes beispiel bietet hierfür JavaScript:\n",
    "\n",
    "```js\n",
    "for (let i = 0; i < arr.length; i++) {\n",
    "  // do something\n",
    "} \n",
    "```\n",
    "\n",
    "Zu lesen ist dies wie folgt: \"Für ein i mit dem Wert 0 (let i = 0), zähle bis i größer die Länge von Array arr (i < arr.length) und erhöhe nach jedem Schleifendurchlauf den Wert von i um 1 (i++)\"\n",
    "\n",
    "In Python sehe selbiger Code wie folgt aus:\n",
    "\n",
    "```python\n",
    "for i in range(0,len(arr)):\n",
    "    # do something\n",
    "```\n",
    "\n",
    "Zu lesen ist dies wie folgt: \"Für jedes (for each) i in dem Intervall/Menge 0 bis arr.length mach etwas\"\n",
    "\n",
    "Der Unterschied besteht darin das Python jedes Element einer Menge durchläuft, der Catch liegt darin das es absolut unabhängig davon ist wie die Menge aussieht. Widmen wir uns zunächst einer 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": 12,
   "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": 13,
   "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 mit der Built-In Funktion 'range' zählen kann, schauen wir uns folgend ein paar Beispiele an wie in Python eigentlich Iteriert werden soll.\n",
    "\n",
    "#### Beispiel 1 - Iterieren über eine Liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": [],
   "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 immer aus 'key-value' paaren. Mit der Built-In Funktion `.items()` bekommen wir ein Tuple an Werten zurück, welches erst entpackt werden muss. Dazu behilft uns der 'for-loop' indem einfach 2 variabeln gleichzeitig deklariert werden. (Achtung! Mit `.items()` werden die 'key-value' paare als '(key, value)' zurückgegeben)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": [],
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": [],
   "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 der absolut Selbe Output generieren. Das verwenden von `enumerate()` ist jedoch eleganter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": [],
   "source": [
    "alphabet = [\"a\", \"b\", \"c\", \"d\"]\n",
    "for index in range(len(alphabet)):\n",
    "    print(index, \"->\", alphabet[index])"
   ]
  },
  {
   "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",
    "Ihnen ist das Dictionary `dict2` gegeben. Ändern Sie jeden Wert in dem Dictionary nach der Formel $f(x) = x^3-1$ mittels `for-loop`.\n",
    "\n",
    "Tipp: Lassen Sie sich nicht von den Schlüsseln verwirren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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": [
    "dict2 = {\"a\": 56, 5: 12, \"python\": 9, 3.14: 1.141414}\n",
    "### BEGIN SOLUTION\n",
    "dict2 = {key: value**3-1 for key, value in dict2.items()}\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7e0f9ac4-c5d4-44b6-a2fc-db98e2b46356",
   "metadata": {
    "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": "ecc21f6a-2ea0-41a0-9e56-04faae5a0fc6",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-9ffa970f1cdac592",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Mit dem Unterstrich `_` als Zählvariable werden `for`-loops gekennzeichnet die ihre Zählvariable nicht verwenden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": "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/) gibt es in Python die List Comprehension.\n",
    "\n",
    "Für diese Vorlesung ist es nicht nötig das Sie die Syntax anwenden können, Sie sollten zumindest verstehen wie diese funktioniert.\n",
    "\n",
    "Angenommen wir haben 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 ist es möglich genau diese Menge in einer einzigen Zeile Abzubilden. Dazu wird die List Comprehension verwendet deren Syntax im allgemeinen folgende Form hat:\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": null,
   "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": [],
   "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",
    "Erstellen Sie eine List 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": 15,
   "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": 16,
   "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 dem Eingeben von Daten in ein Programm. Dies geschieht entweder 'von Hand', also über den Benutzer, oder über Dateien."
   ]
  },
  {
   "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": [
    "Im Normalfall wollen wir größere Datenmengen einlesen. Dazu nutzen wir die Built-In Funktion `open` ([Python Docs - Open](https://docs.python.org/3/library/functions.html?highlight=open#open)). Auch wenn in der Doku viele Parameter stehen benötigt man im Normalfall nur zwei. Der erste ist der Name der File, der zweite im welchem Modus die Datei geöffnet werden soll (Angegeben als String).\n",
    "\n",
    "Zum bearbeiten der Datei nutzen wir den Python Kontext Manager - das `with`-Statement. Bei externen Daten ist es immer wichtig die Datei auch wieder zu schließen, damit es nicht zu Datenverlust oder Arbeitsspeichermüll kommt. Daher ist der Lebenzyklus einer Datei in einem Programm immer `Datei öffnen` -> `Datei Bearbeiten` -> `Datei schließen`. Kommt es in einer der Drei schritte zu einem Fehler, bleibt die Datei im RAM hängen und der Computer muss neu gestartet werden um diesen Speicher wieder Frei zu geben.\n",
    "\n",
    "Daher gibt es Kontext Manager. Dieser versichert dem Programmierer, dass das schließen der Datei immer (!!) passiert. Die Syntax folgt folgender Strucktur:\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",
    "Erstellen und Öffnen sie eine Datei `testfile.txt` mit der `open` Funktion, nutzen Sie dafür das `with`-Statement.\n",
    "\n",
    "Schreiben Sie in diese Datei 100 mal den String `\"Python\\n\"`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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",
    "Öffnen Sie die zuvor erstellte Datei `testfile.txt` im Lesemodus und weißen Sie den Inhalt der `.readlines()` Funktion der Variabeln `lines` zu. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": 24,
   "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 nutzen wir Bibliotheken von anderen Entwicklern.\n",
    "\n",
    "Dazu nutzt man das Keyword `import` gefolgt von dem Modul welches man Importieren möchte. Nutzen wir als Beispiel `numpy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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>`. Dazu folgendes Numpy Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": [],
   "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 Python 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": 21,
   "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": 22,
   "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 Keyword `as` ist bereits bekannt, dieses kann auch verwendet werden um Module beim import umzubennen. Dies ist dann Hilfreich wenn Module lange Namen haben.\n",
    "\n",
    "Numpy wird im Internet immer mit np abgekürzt. Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": [],
   "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",
    "Importieren Sie die Built-In Library `datetime` als `dt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 28,
   "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": [
      "2024-11-01 19:32:22.691479\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": 29,
   "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"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "pprint({n: 2**n for n in range(20)})"
   ]
  },
  {
   "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",
    "Importieren Sie die Funktion `sqrt` aus dem Built-In Modul `math`.\n",
    "Berechnen Sie $\\sqrt4$. Speichern Sie das Ergebnis in der variablen `s4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": 33,
   "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": [
    "Ein letzter Hinweis: Es gibt auch die Möglichkeit in der `import from` Syntax das Keyword `as` zu verwenden.\n",
    "\n",
    "Beispiel aus dem Modul `dataclasses` importiert `dataclass` als `dclass`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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 0x7f0d58902f20>\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import dataclass as dclass\n",
    "print(dclass)"
   ]
  }
 ],
 "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.12.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
