{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "92fe3a94-61b2-47f9-9485-02aa8b103d5c",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e72aa2f84c4b1cb7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# 1. Programmierübung: Python Tutorial\n",
    "\n",
    "<div style=\"display:flex;\">\n",
    "    <div style=\"text-align: left\">\n",
    "        Willkommen zur ersten 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",
    "Python ist eine universelle Programmiersprache, die aufgrund ihrer Einfachheit sehr leicht zu lernen und zu bedienen ist. Die Funktionalität kann durch den Import von Bibliotheken erweitert werden. Im Folgenden werden wir Ihnen zeigen, wie man hier im Jupyter Notebook Python Code ausführen kann. Die grundlegenden Konzepte und Strukturen in Python werden mit Hilfe von externen Quellen gezeigt. Die Übungsaufgaben dienen zum Testen und der Hands-on-Praxis des gelernten Wissens. \n",
    "\n",
    "In diesem Jupyter Notebook werden die grundlegende Funktionen und Konzepte in Python vorgestellt. Dazu wird es kleine Programmierübungen um das gelernte Wissen in Beispielen anzuwenden. (Objekt Orientierte Programmierung werden wir in diesem Kurs nicht behandeln!)\n",
    "\n",
    "Das Jupyter Notebook ist in Zellen unterteilt, die durch Boxen gekennzeichnet sind, die einzeln ausgeführt werden können (entweder über `Shift + Enter` oder den `Run`-Knopf). Sie können auch alle Zellen im Notebook ausführen über `Kernel > Restart & Run All` oder dem \"Vorspulen\"-Zeichen.\n",
    "\n",
    "Bitte beachten Sie, dass alle Zellen im Notebook ein gemeinsamen Workspace nutzen. Das bedeutet, dass Bibliotheken nur einmal importiert werden müssen und dann innerhalb des Notebooks genutzt werden können. Es können jedoch auch Variablen überschrieben werden, wenn diese nicht richtig gekapselt werden (z.B. über Funktionen).\n",
    "\n",
    "Viel Spaß und Erfolg!\n",
    "\n",
    "Es gibt _sehr_ viele weitere Python-Tutorials online, z.B. auf [Youtube](https://youtu.be/kqtD5dpn9C8), mit denen Sie die benötigten Grundlagen für Python lernen können.\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 ([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 wurden für _Signale und Systeme_, sowie _Einführung in die Programmierung für Nicht Informatiker_ angepasst.\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ac5a9e3-7190-4db6-859b-3cb1511fe29f",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c8293a61ad8fb19c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Printing\n",
    "\n",
    "Für viele Anwendungsfälle ist es wichtig, dass der Computer mit uns als Mensch kommunizieren kann. Zu diesem Zweck lernen wir zuerst wie wir eine Ausgabe erzeugen können. Hierzu verwenden wir die Funktion `print()`.\n",
    "\n",
    "[print()](https://www.w3schools.com/python/ref_func_print.asp) ist eine BuiltIn Funktion, zu diesen später mehr. Es soll aber gesagt sein, dass keinerlei anstrengungen notwendig sind um die Print-Funktion zu verwenden, da Python sie von Haus aus kennt.\n",
    "\n",
    "## Hello World\n",
    "\n",
    "Schauen wir uns nun folgend ein einfaches Programm an:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3733ea3b-12b5-4c1c-9b03-0f1c397babfc",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-5f71f94cf9d603e2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "708d34f1-a479-4277-90e7-14d67a8c688a",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-d49c16a44b1d3984",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Der Teil in den Klammern ist der Wert den wir ausgeben wollen in diesem Fall eine einfache Zeichenkette (auch dazu später mehr).\n",
    "\n",
    "Damit zu ersten **Aufgabe**: Geben Sie den Text `Hallo Python` aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "88b8d4db-6f4c-411c-b8ad-d2d6ca0b427c",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-cd36c0330024bfe5",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m()\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# BEGIN SOLUTION\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHallo Python\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# BEGIN SOLUTION\n",
    "print(\"Hallo Python\")\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad8d06df-5d3d-4203-b17c-227a663c8e7b",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-95b07b67b0ede718",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Datentypen und Variablen\n",
    "\n",
    "Python unterstützt verschiedene Datentypen. Zu diesen Zählen :\n",
    "1. Integer (Ganze Zahlen) $$\\mathbb{Z} = \\{1,-1,2,-2,3,-3,\\dots\\}$$\n",
    "2. Floatings Point Numbers (Fließkommazahlen) $$\\pi = 3.141592653589793$$\n",
    "3. Strings (Zeichenketten)\n",
    "> \"Ich bin eine Zeichenkette\"\n",
    "\n",
    "4. Listen\n",
    "> [Objekt1, Objekt2, 42]\n",
    "\n",
    "5. Dictionaries\n",
    "> {\"Schlüssel1\": \"Wert1\", \"Schlüssel2\": \"Wert2\",}\n",
    "\n",
    "6. Sets\n",
    "> {\"Wert1\", 7, \"Zeichenkette\"}\n",
    "\n",
    "7. Tupel\n",
    "> (42, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "313d37b0-52ad-4de4-9fc5-0f362bfe7284",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-12a63250c85469f1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Zahlentypen (Floats, Integers)\n",
    "\n",
    "### Aufgabe 1-1: Zuweisungen von Variablen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65dae625-2f0b-46d2-803c-c3d6c54000f7",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-782aef1600674714",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Eine Definition und Zuweisung eines Wertes zu einer Variablen erfolgt über den `=` Operator."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fca50dd5-4a56-451a-9a1a-6cbd8d76519a",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-7b71098cec169f0f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Definieren Sie zunächst die zwei Variablen `a` und `b` und initialisieren diese mit einem Integerwert ungleich `0`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d7d24e44-8581-4c5c-a723-83b9f7e418ac",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-7be930fd387f1043",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "a = 1\n",
    "b = -2\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8cfd850c-02c7-4b32-b20c-e37f5eb4fe8b",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-d44ec6114b65557c",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "assert isinstance(a, int)\n",
    "assert isinstance(b, int)\n",
    "\n",
    "assert a != 0\n",
    "assert b != 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "337fbcc5-c960-4206-83d1-605d05a51d5d",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-2f79b7b52775db8b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Definieren Sie zwei Variablen `s` und `t` und initialisieren diese mit einem Floatwert ungleich `0`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "03b7469a-4f59-437f-aa8f-797d200b41a1",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-7d48f9bed0df944d",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "s = 1.5\n",
    "t = -2.7\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "45404bbe-2026-491d-9aef-9d3ee8894adf",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-3b426f39262c1e03",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "assert isinstance(s, float)\n",
    "assert isinstance(t, float)\n",
    "\n",
    "assert s != 0\n",
    "assert t != 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5452589d-5997-4e8f-b8bb-363925c6166a",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-8690aecc1748ad4a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Aufgabe 1-2: Operationen auf Zahlen\n",
    "\n",
    "Aus der Schule sollten die folgenden Grunlegenden Operationen die sich auf Zahlen ausführen lassen bekannt sein:\n",
    "\n",
    "1. Addition $\\Rightarrow a+b=c$\n",
    "2. Subtraktion $\\Rightarrow a-b=c$\n",
    "3. Multiplikation $\\Rightarrow a\\cdot b=c$\n",
    "4. Division $\\Rightarrow\\frac{a}{b} = c$\n",
    "> Teilt man zwei Integer durcheinander werden diese erst in Floats umgewandelt und dann als Float gespeichert: $$10/3=3.3333333333$$\n",
    "> Die Integer Division (Ganzzahl Division $\\lfloor\\frac{a}{b}\\rfloor$) (Notiert mit \"//\") zweier Zahlen schneidet den Rest nach dem Komma ab: $$10//3\\equiv 3$$\n",
    "\n",
    "5. Modulus $\\Rightarrow a\\mod b \\equiv c$\n",
    "> \"Teilen mit Rest\" (in Python notiert mit \"%\" hat nichts mit Prozenten zutun) funktioniert genauso wie man die Uhr lesen würde. Ist es 15 Uhr sagt man im Sprachgebrauch 3 Uhr (Mittags). Der Modulus Operator funktioniert genauso. $$15 \\mod 12 \\equiv 3$$\n",
    "\n",
    "6. Exponentation $\\Rightarrow a^b = c$\n",
    "> In Python notiert mit \"a**b\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e408960-4180-4e92-ba88-ebf39441dfa7",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c4551eabf148e18e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe:** Addieren Sie die Werte der Variablen `a` und `b` und speichern Sie das Ergebnis in der Variable `c`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6aaa0c05-ae16-4c48-b841-79931dae94bd",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-2ff97153b6652687",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# BEGIN SOLUTION\n",
    "c = a + b\n",
    "# END SOLUTION\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2fa4d7f2-235d-411e-956c-4ff335705124",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-3ba3833c7220bbb7",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "assert isinstance(c, int)\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert a + b == c\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fccb90e-1f22-46b9-99a1-14b64274ece5",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f80a3165c27dc297",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Nutzen Sie die Variablen `a` & `b` und Speichern Sie die Ergebnisse für die Multiplikation, Division, Ganzzahldivision, Exponentiation und den Modulo-Operator in den unten angegebenen Variablen:\n",
    "\n",
    "\\begin{align}\n",
    "m &= a\\cdot b\\\\\n",
    "d &= \\frac{a}{b}\\\\\n",
    "i &= \\lfloor\\frac{a}{b}\\rfloor\\\\\n",
    "e &= a^b\\\\\n",
    "r &= a\\; \\textrm{mod}\\; b\n",
    "\\end{align}\n",
    "\n",
    "\n",
    "Die Ausführung der anderen arithmetischen Operationen in Python erfolgt analog. Eine Übersicht können Sie [hier](https://www.python-kurs.eu/operatoren.php) entnehmen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "30ce28b3-b97d-4b3f-bac0-6d01356dcc60",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-3f3640eaf7ee2dd3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "m = a*b\n",
    "d = a/b\n",
    "i = a//b\n",
    "e = a**b\n",
    "r = a%b\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "95108d9d-4cba-489b-bdbc-ed5c71316ac8",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-804a957c4a02e824",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert m == a*b\n",
    "assert d == a/b\n",
    "assert i == a//b\n",
    "assert e == a**b\n",
    "assert r == a%b\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "444c4633-9186-497f-88a7-e2ec0013dff4",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-7ac5c4d8e6463b16",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Sequentielle Datentypen\n",
    "\n",
    "Sequentielle Datentypen sind ein wichtiger Bestandteil in der Programmierung. Dazu gehören Listen, Tupel und Strings.\n",
    "\n",
    "Wichtige Eigenschaften dieser Datentypen sind:\n",
    "- Die Elemente von Listen, Strings oder Tupeln sind in einer bestimmten Reihenfolge angeordnet (Diese entspricht der Ordnung in der die Elemente eingefügt worden).\n",
    "- Der Zugriff (Lesen und Schreiben) dieser Objekte erfolgt über Indizes (Das erste Element eines Sequentiellen Datentypes ist immer `0`).\n",
    "- Zugriff auf Elemente kann auch Rückwärts erfolgen das letzte Element wird dann mit `-1` ausgelesen. \n",
    "\n",
    "Beispiel für eine Liste:\n",
    "`some_list = [\"a\", \"b\", \"c\"]`\n",
    "\n",
    "Beispiel für ein Tupel:\n",
    "`some_tuple = (1, 2, 3)`\n",
    "\n",
    "Beispiel für ein String:\n",
    "`some_string = \"Python ist cool!\"`\n",
    "\n",
    "### Aufgabe 2-1: Strings\n",
    "\n",
    "Zeichenketten, Text oder Strings lassen sich in Python mit `'Text'`, `\"Text\"` oder der Funktion `str()` definieren.\n",
    "\n",
    "**Aufgabe**: Ein String-Objekt (Text) können sie mit Hilfe von `'Some Text'` oder `\"Some Text2\"` definieren. Definieren sie die Variable `text` mit einem beliebigen Text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "f8028cf5-0dc4-4e72-a98e-3e18705c8c98",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-73a9beb04648359b",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "text = \"Hi Mom, I am on TV!\"\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "7a6832ae-e6c7-4230-b3ca-b1f1f90345fb",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-1677fa4f3b4eec12",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "assert isinstance(text, str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e10cd2a-53dc-485f-bbdd-aa2709574660",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-05f0b0cd1211c396",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Python Strings lassen sich mit verschiedenen mitteln formatieren. Dazu zählt die [format-Funktion](https://www.w3schools.com/python/ref_string_format.asp) \n",
    "\n",
    "**Aufgabe**: Geben Sie die Variablen `a` & `b` aus Aufgabe 1 im format `\"a = 12 und b = 12\"` (Die Werte sollen dann den Werten aus ihrer Definition entsprechen. 12 ist hier nur ein Beispiel) aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "d3efbadb-3c33-40eb-9260-8f8b11faaf75",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c94a5b5e9f73479e",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1 und b = -2\n"
     ]
    }
   ],
   "source": [
    "# BEGIN SOLUTION\n",
    "print(\"a = {} und b = {}\".format(a, b))\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d860edba-749c-41c0-827b-0c68ba6fd00a",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e4c5420224d04f6a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Aufgabe 2-2: Listen \n",
    "\n",
    "Listen lassen sich mit der Funktion `list()` oder `[]` definieren und können eine \"unendliche\" Menge an Elementen unterschiedlichen Datentyps speichern. Die Liste `[420, \"Hallo Jupyter\", 0.222]` ist eine Korrekt definierte Liste. Im Allgemeinen ist es Ratsam listen mit gleichem Datentyp zu füllen, da dies bei der Verarbeitung zu Problemen führen kann."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51416edc-4c96-437c-a1ff-c458f06c9e8a",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-36d12824040df91e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Definieren Sie die Variable `l` und weisen Sie dieser Variable eine Liste mit aufsteigenden Integerwerten von `0` bis `4` zu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "b361ee09-cd48-4c16-89ea-714ee8ab541f",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-89d74b5c210fc331",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "l  = list(range(5))\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "65fcfdb4-58ff-47d3-bebd-d3786a971af2",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-589caab43851d55a",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert isinstance(l, list)\n",
    "assert l == [0, 1, 2, 3, 4]\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6dfba7d-4bb5-4530-bb75-689843a718a8",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-5ca56027cd6a5698",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Hängen Sie der Liste `l` noch den Wert `42` an.\n",
    "\n",
    "Hinweis: Nutzen Sie dafür die Methode [.append](https://www.w3schools.com/python/ref_list_append.asp)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "e39e50dc-3d97-4579-aeb4-04ec2de3dbb3",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-853db222010bee68",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "l.append(42)\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "53000a6c-1187-48b0-b038-129d434cc45a",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-c1aca9603460d1de",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert l == [0, 1, 2, 3, 4, 42]\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4510d2f3-3386-4d33-baa5-1d684ab52370",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c58e5530e380c09a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Zugriff auf Elemente eines Sequentiellen Datentypes lassen sich über `[]` realisieren.\n",
    "\n",
    "Beispiel - Zugriff auf das erste Element einer Liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "259d73e8-eca3-4172-8a0a-1efbbe3b527b",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-cb1b7e8055910efc",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf6d1243-9650-4c27-b3dc-86a2d48b3abc",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-1d8edfe975ed19bf",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Geben Sie das dritte Element der Liste `l` aus.\n",
    "\n",
    "Hinweis: Achten Sie darauf das der erste Index immer `0` ist. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "358a0b51-3bfa-4e65-9cd4-ee2e7f8bc9d5",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-a386250119dc89fb",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# BEGIN SOLUTION\n",
    "print(l[2])\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f25fa6d-9a72-464b-ada6-d2630dd03e92",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-0ff369c64d2f8c24",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Geben Sie das vorletzte Element der Liste `l` aus.\n",
    "\n",
    "Hinweis: Achten Sie darauf das der letzte Index mit `-1` ausgegeben wird"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "16ec2e20-e28e-41de-8f85-1091e41bb401",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-2394235b49ebb749",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# BEGIN SOLUTION\n",
    "print(l[-2])\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "291522bc-9c4d-4348-b2cb-99f9653168fa",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c8fe8cb9d2ca1028",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Aufgabe 2-3: Dictionaries\n",
    "\n",
    "Das Dictionary ist ein Datentyp, welcher Schlüssel-Werte-Paare speichert. Dabei wird ein Dictionary mit `dict()` oder `{\"Schlüssel1\": \"Wert1\"}` initalisiert. Wichtig ist hierbei das ein Dictionary nicht mit `{}` initialisiert werden kann da dies die Notation für das **Set** Objekt ist.\n",
    "\n",
    "**Aufgabe**: Initialisieren Sie die Dictionary Variable `my_dict` mit folgendem Mapping:\n",
    "\n",
    "| Key | Value |\n",
    "|:----|:------|\n",
    "| `\"apple\"` | `\"Apfel\"` |\n",
    "| `\"banana\"` | `\"Banane\"` |\n",
    "| `\"cherry\"` | `\"Kirsche\"` |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "c17338bb-c6df-493c-9d88-0e9ea36a755d",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-86ce3695bf3f6780",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "my_dict = {\"apple\": \"Apfel\", \"banana\": \"Banane\", \"cherry\": \"Kirsche\"}\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "a367442e-2c8c-4d32-8acb-5bccf94d64fb",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-969a9415b60857a8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "assert isinstance(my_dict, dict)\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert my_dict == {\"apple\": \"Apfel\", \"banana\": \"Banane\", \"cherry\": \"Kirsche\"}\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ec10cc1-4b8b-4b53-b1d1-991d6287abda",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-0f5df3b99a4774ba",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe:** Fügen Sie nun das Key-Value Paar `\"pear\": \"Birne\"` zu `my_dict` hinzu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "d3aac185-2d6e-4b30-b247-89be8aeeab7d",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-ed3cf3b9d6a8ad58",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "my_dict[\"pear\"] = \"Birne\"\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "c377ec37-b382-4f83-a9cc-829a44b7682e",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-9735fc9ff4416c4c",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert my_dict == {\"apple\": \"Apfel\", \"banana\": \"Banane\", \"cherry\": \"Kirsche\", \"pear\": \"Birne\"}\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b3cfdf2-6864-402c-9ded-9fd0c7c489ee",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-957ca6c50c1cfb70",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Für gewisse Anwendungen reicht es nur die Schlüssel (oder Werte) aus einem Dictionary zu haben. Dazu bietet das Dictionary die Funktionen `.keys()` (für eine Liste der Schlüssel) und `.values()` (für eine Liste der Werte).\n",
    "\n",
    "**Aufgabe**: Geben Sie die nur die Werte des Dictionaries `my_dict` aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "03f2c31a-04b4-4dc7-ab00-476cec6922ad",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f190c63e28ae9e82",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['Apfel', 'Banane', 'Kirsche', 'Birne'])\n"
     ]
    }
   ],
   "source": [
    "### BEGIN SOLUTION\n",
    "print(my_dict.values())\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e774e49-895b-4bb2-9436-cddb75a3d46d",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-5bd0f8a189d6db1c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Wichtiger für die meisten Probleme ist die Dictionary Funktion `.items()` diese gibt eine Liste an Tupeln mit den Schlüssel Werte Paaren aus.\n",
    "\n",
    "**Aufgabe**: Geben Sie die Elemente des Dictionaries `my_dict` mit der Funktion `.items()` aus. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "a399cf66-43eb-4749-8864-18c5e4202f79",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-03afb00cc074d1ef",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('apple', 'Apfel'), ('banana', 'Banane'), ('cherry', 'Kirsche'), ('pear', 'Birne')])\n"
     ]
    }
   ],
   "source": [
    "### BEGIN SOLUTION\n",
    "print(my_dict.items())\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d62b7e-ae53-4bd7-a930-84508c3948f9",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-83b1e45bc901dc68",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Funktionen\n",
    "\n",
    "Mit einigen Funktionen haben wir uns bereits befasst dazu zählen `print()`, `.keys()` und alle weiteren die diesem Schema folgen.\n",
    "\n",
    "In diesem Kapitel wollen wir uns mit dem Aufbau von Funktionen befassen. Dabei folgt jede Funktion folgendem Aufbaue:\n",
    "\n",
    "```python\n",
    "def some_function_name(param1, param2):\n",
    "    a = do_something1(param1)\n",
    "    b = do_something2(a, param2)\n",
    "    do_something3(b)\n",
    "    return b\n",
    "```\n",
    "\n",
    "Das `def`-Schlüsselwort leitet die Definition einer Funktion ein, gefolgt von dem Funktionsnamen, den Eingabeparametern der Funktion in runden Klammern und einem Doppelpunkt. Wichtig ist, dass die Anweisungen innerhalb der Funktion eingerückt sein müssen. Das Ergebnis (oder die Ergebnisse) werden mit Hilfe des `return`-Schlüsselworts gekennzeichnet.\n",
    "\n",
    "**Aufgabe**: Schreibe eine Funktion `successor` die auf jede Eingabe `+1` rechnet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "1a151db2-617c-48f4-969b-3bafb45b1fd1",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c6a731a4a13b2bbc",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "def successor(n):\n",
    "    return n+1\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "615a98b6-139e-485b-874e-d0a70cd22517",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-00693d8d9c92af76",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert successor(1) == 2\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6f47a61-b692-4f46-8ccc-83af10189f93",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-9c358751403a1986",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**_ Schreibe eine Funktion `add` mit den Eingabeparametern `a` & `b`, welche die Werte von `a` & `b` miteinander addiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "3f101d21-aa1a-4bf3-aadf-bb4e41d8fe12",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-2b72cf583fed9b8c",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "def add(a,b):\n",
    "    return a+b\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "1d155c26-0875-4a71-8564-a4a0e0e3bb70",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-7a24b5cfd7fc9990",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert add(1,2) == 3\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d77ab363-9fe0-4504-b43b-6f7894666525",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-0fd1dbfed99faa8a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Kontrollstruckturen\n",
    "\n",
    "## Aufgabe 3-1: Conditionals - If-Else\n",
    "\n",
    "Um Entscheidungen treffen zu können nutzt man in Python das Kommando `if <ausdruck>` ist der Ausdruck wahr wird der darauf folgende Code ausgeführt.\n",
    "\n",
    "Liste von möglichen Ausdrücken:\n",
    "\n",
    "- `a == b` checkt ob die Werte `a` & `b` gleich sind\n",
    "- `a != b` checkt ob die Werte `a` & `b` **nicht** gleich sind\n",
    "- `a > b` checkt ob der Wert `a` größer als `b` ist (Analog dazu \"größer gleich\" `a >= b`)\n",
    "- `a < b` checkt ob der Wert `a` kleiner als `b` ist (Analog dazu \"kleiner gleich\" `a <= b`)\n",
    "- `not <ausdruck1>` invertiert das Ergebnis des Ausdruckes, also aus einem wahren Ausdruck wird ein falscher und andersherum.\n",
    "\n",
    "Zur Verkettung von Ausdrücken:\n",
    "\n",
    "- `<ausdruck1> and <ausdruck2>` checkt ob die Ausdrücke `ausdruck1` & `ausdruck2` wahr also erfüllt sind\n",
    "- `<ausdruck1> or <ausdruck2>` checkt ob einer der Ausdrücke `ausdruck1` & `ausdruck2` wahr also erfüllt sind\n",
    "\n",
    "Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "4363cda5-98c5-4424-8fb3-7c92e1994993",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-020d46673782a358",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're the Number One\n"
     ]
    }
   ],
   "source": [
    "zahl = 1\n",
    "if zahl == 1:\n",
    "    print(\"You're the Number One\")\n",
    "\n",
    "if zahl == 2:\n",
    "    print(\"You Lose\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21a23914-d0b7-492d-bcfe-8ecde9c20c85",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-aa2d59d677afd5a3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Das Kommando `else` funktioniert nur zusammen mit dem `if` Kommando und bietet dem Programm eine Art \"Fall Back\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "3eaf3062-ae81-48c0-802d-88a72db587be",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f4124dd62687158f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're not the Number One\n"
     ]
    }
   ],
   "source": [
    "zahl = 5\n",
    "if zahl == 1:\n",
    "    print(\"You're the Number One\")\n",
    "else:\n",
    "    print(\"You're not the Number One\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e35f339-3f59-4fd6-a162-e6eb0379c778",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-167fb232c7163fe6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Um auf mehrere Ausdrücke zu checken kann das `elif` verwendet werden. Es findet seinen Platz zwischen `if` & `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "e37dd53c-e375-4548-9563-c8c6664dfdd0",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-0c0312666fa7648f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're the Number Two\n"
     ]
    }
   ],
   "source": [
    "zahl = 2\n",
    "if zahl == 1:\n",
    "    print(\"You're the Number One\")\n",
    "elif zahl == 2:\n",
    "    print(\"You're the Number Two\")\n",
    "elif zahl == 2:\n",
    "    print(\"You're the Number Three\")\n",
    "else:\n",
    "    print(\"You're not the Number One\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5248404d-4717-462d-a67f-57431e599945",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-060bd6eb927fa8b1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Aufgabe**: Schreibe eine Funktion `is_odd` mit einem Eingabeparameter `n` die prüft ob die eingegebene Zahl ungerade ist.\n",
    "\n",
    "Wenn die Zahl gerade ist gebe den Text `\"Gerade Zahl\"` und bei ungerade `\"Ungerade Zahl\"` zurück."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d4b1cef3-6222-438d-bbc3-243431fad0cb",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-77afd241bc69d6b1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "def is_odd(n):\n",
    "    if n % 2 == 0:\n",
    "        return \"Gerade Zahl\"\n",
    "    else:\n",
    "        return \"Ungerade Zahl\"\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "141d73da-90e6-401a-a651-ad14635de5b7",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-d8541ba8c61147c3",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert is_odd(2).lower() == \"Gerade Zahl\".lower()\n",
    "assert is_odd(3).lower() == \"Ungerade Zahl\".lower()\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0086b8c-da02-4fdf-8341-9c0518bb6406",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-69409d8dcfe070e1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Aufgabe 3-2: Sequentielles - While Loop\n",
    "\n",
    "Schleifen sind wichtig um eine Aufgabe öfter zu wiederholen. \n",
    "\n",
    "Schauen wir uns dazu zunächst den `while`-loop an. Die Syntax schaut wie folgt aus:\n",
    "\n",
    "```python\n",
    "while <ausdruck>:\n",
    "    do_something()\n",
    "```\n",
    "\n",
    "Solange der Ausdruck nach dem `while` wahr ist wird die Schleife ausgeführt. **!Vorsichtig!** solange der Ausdruck wahr bleibt und nie falsch wird hört die Schleife nie auf zu laufen.\n",
    "\n",
    "**Aufgabe**: Schreibe eine Funktion `faktoriel` mit Eingabeparameter `n`, welche die Fakultät der Zahl `n` berechnet. Dabei ist die Fakultät definiert als\n",
    "\n",
    "$$f(n) = n! = 1 \\cdot 2 \\cdot 3 \\cdot ... \\cdot n-1 \\cdot n$$\n",
    "\n",
    "Ein Beispiel für die Zahl 5:\n",
    "\n",
    "$$5! = 1 \\cdot 2 \\cdot 3 \\cdot 4 \\cdot 5$$\n",
    "$$\\Rightarrow 5! = 2 \\cdot 3 \\cdot 4 \\cdot 5$$\n",
    "$$\\Rightarrow 5! = 6 \\cdot 4 \\cdot 5$$\n",
    "$$\\Rightarrow 5! = 24 \\cdot 5$$\n",
    "$$\\Rightarrow 5! = 120$$\n",
    "\n",
    "Für den Fall `n=0` ist $0!=1$ für negative (-1) und gebrochene Zahlen (3.14) ist die Fakultät nicht definiert, gebe daher für die Spezialfälle `-1` zurück.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d1f074e2-c036-445c-97f6-618f5aa4cedb",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-0796f3b2cbac6f8e",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "def faktoriel(n: int) -> int:\n",
    "    if not isinstance(n, int):\n",
    "        return -1  \n",
    "    if n < 0:\n",
    "        return -1\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    \n",
    "    count = 1\n",
    "    while n > 0:\n",
    "        count *= n\n",
    "        n -= 1\n",
    "    return count\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "22784528-9205-4575-84ef-0060732cd053",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-f7774d4246e958a6",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Hier werden die Loesungen getestet...\n",
    "### BEGIN HIDDEN TEST\n",
    "def fak(n: int) -> int:\n",
    "    if not isinstance(n, int):\n",
    "        return -1  \n",
    "    if n < 0:\n",
    "        return -1\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    \n",
    "    count = 1\n",
    "    while n > 0:\n",
    "        count *= n\n",
    "        n -= 1\n",
    "    return count\n",
    "\n",
    "import random\n",
    "l = list(set([random.randint(0,20) for _ in range(5)]))\n",
    "random.shuffle(l)\n",
    "for el in l:\n",
    "    assert fak(el) == faktoriel(el)\n",
    "\n",
    "assert faktoriel(-3) == -1\n",
    "assert faktoriel(3.19134) == -1\n",
    "### END HIDDEN TEST"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
