{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9675ab87",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-b5ef3c2f2dca81de",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# 1. Programmierungübung: Python Tutorial Teil 1\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. Im zweiten Teil werden die Bibliotheken `numpy`, `sympy` und `matplotlib` kurz vorgestellt und Übungsaufgaben dazu gestellt.\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.\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 Paul Nowitzki ([p.nowitzki@tu-bs.de](mailto:p.nowitzki@tu-bs.de?subject=[SigSys]%20Feedback%20Programmierübung&amp;cc=besser@ifn.ing.tu-bs.de,%20le@ifn.ing.tu-bs.de)), Karl Besser ([besser@ifn.ing.tu-bs.de](mailto:besser@ifn.ing.tu-bs.de)) oder Martin Le ([le@ifn.ing.tu-bs.de](mailto:le@ifn.ing.tu-bs.de)) 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_ angepasst.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2de11f87",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-d1b6225195341484",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Aufgabe 1-1: Datentypen und Variablen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ab82d94",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-095d0c8663473ea9",
     "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": "bed3548e",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e703bd590336dbb9",
     "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "12ad52cc",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-38558c816fdeb383",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "a = 1\n",
    "b = -2\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fceefd81",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-9aec33e8d27e8106",
     "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": "473eaf9a",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-b503ba72573ea20e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**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": 3,
   "id": "eef86caa",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-1188bd957b9e1c98",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "text = \"Hi Mom, I am on TV!\"\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3624a893",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-b6c5a77a33bde905",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert isinstance(text, str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e82998a1",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-1763af54eb134b32",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Aufgabe**: Geben Sie die Werte der Variablen auf dem Bildschirm mit Hilfe der [print-Funktion](https://www.w3schools.com/python/ref_func_print.asp) aus. Der Output soll wie folgt aussehen: `\"a = 12 und b = 12\"` (Die Werte sollen dann den Werten aus ihrer Definition entsprechen. 12 ist hier nur ein Beispiel).\n",
    "\n",
    "Hinweis: Für die Ausgabe der Variablen in einem String-Objekt wird die [format-Funktion](https://www.w3schools.com/python/ref_string_format.asp) verwendet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "abf16ea3",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-8149b06e15a5d0a0",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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": "8142c51f",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-97c2cafe4fbb33c1",
     "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": 6,
   "id": "5df47a7f",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-75b4095bcaa5ab4a",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "c = a + b\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d9a5ff84",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-e897c81ec0545569",
     "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": "22192796",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-83d9dfcbd73a6c79",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Aufgabe**: Geben Sie das Ergebnis der Addition im folgenden Format aus: `\"a + b = <c> (datatype = <type>)\"`. (Die Ausdrücke `<...>` sind durch den jeweiligen Inhalt zu ersetzen.)  \n",
    "Der Datentyp einer Variablen kann mit Hilfe der Funktion [type](https://www.w3schools.com/python/ref_func_type.asp) abgerufen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "41ad3920",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-89b0a52e9998c4cb",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a + b = -1 (datatype = <class 'int'>)\n"
     ]
    }
   ],
   "source": [
    "# BEGIN SOLUTION\n",
    "print(\"a + b = {} (datatype = {})\".format(c, type(c)))\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad5aa173",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-6d1a6b863f5c42d1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Speichern Sie auch 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": null,
   "id": "728b83fa",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e4a5884ac413cd47",
     "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": null,
   "id": "2f5ebf9a",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-93235c2c6510fc3b",
     "locked": true,
     "points": 3,
     "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": "93aed1ec",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e8d0da8229c50b55",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Aufgabe 1-2: Sequentielle Datentypen: Listen und Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06f60e75",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e829b042c10534b2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Sequentielle Datentypen sind ein wichtiger Bestandteil in der Programmierung. Dazu gehören Listen, Tupel und auch die in Aufgabe 1-1 genutzten String-Objekte.\n",
    "\n",
    "Wichtige Eigenschaften dieser Datentypen sind:\n",
    "- Die Elemente von Listen, Strings oder Tupeln sind in einer bestimmten Reihenfolge angeordnet.\n",
    "- Der Zugriff (Lesen und Schreiben) dieser Objekte erfolgt über Indizes.\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!\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f8cecd9",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-12a0b9c3b6e5441a",
     "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": null,
   "id": "9d18ab2e",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-a47c28c0674be0de",
     "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": null,
   "id": "f06c66b2",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-2116010bb09add7a",
     "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(l, list)\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert l == [0, 1, 2, 3, 4]\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56058b07",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-b8f643167979c5e1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "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": null,
   "id": "fd5d9064",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-5ba438d830677790",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "l.append(42)\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cf3e111",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-4e49a95d8f8e1bca",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "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": "65bf74ce",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-01ba15275a765efc",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Aufgabe** Geben Sie den Inhalt der Liste mit Hilfe der `print()` Funktion aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3a78a8a",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-5b392a24d0ed100a",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "print(l)\n",
    "# END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b4e7159",
   "metadata": {
    "editable": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-595ed0febab392a3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Aufgabe 1-3: Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d17fb780",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-d21e87c25280c85e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**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": null,
   "id": "2585e308",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-b462428ed9c9617c",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "my_dict = {\"apple\": \"Apfel\", \"banana\": \"Banane\", \"cherry\": \"Kirsche\"}\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed73673b",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-ceecad3d50b9f3ba",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "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": "82eb700a",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-b2e8643ce6771d13",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Aufgabe:** Fügen Sie nun das Key-Value Paar `\"pear\": \"Birne\"` zu `my_dict` hinzu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c76bec2",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e88317079248bf45",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "my_dict[\"pear\"] = \"Birne\"\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1840fbf7",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-5e68ca12bc0c13dc",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "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": "50347f8d",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-94ec5997d98e07ac",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Aufgabe:** Drucken Sie jedes Key-Value-Paar aus `my_dict` in einer eigenen Zeile im Format `Zu <key> gehoert <value>.` aus. Verwenden Sie dazu den `print()` Befehl."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43992f58",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-4c9804ba462612f4",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "for key, value in my_dict.items():\n",
    "    print(\"Zu {} gehoert {}\".format(key, value))\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3af58d44",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c6b2adacb2ca42b8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Aufgabe 1-4: Funktionen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2ba62a",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c9188bbb0560e9a3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Funktionen können wie folgt in Python definiert werden:\n",
    "```python\n",
    "def some_function_name(param1, param2):\n",
    "    a = do_something1(param1)\n",
    "    b = do_something2(a, param2)\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."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1103172b",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-1fe9a24d046f3b13",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Aufgabe**: Schreiben Sie Ihre eigene Funktion `fibonacci(n)`, die die `n`-te Zahl der Fibonacci-Folge berechnet.\n",
    "\n",
    "Die Fibonacci-Folge ist wie folgt definiert:\n",
    "\n",
    "$ \\mathrm{fibonacci}(n)=\n",
    "\\begin{cases}\n",
    "0 & \\text{if}~n = 0\\\\\n",
    "1 & \\text{if}~n = 1\\\\\n",
    "\\mathrm{fibonacci}(n-1) + \\mathrm{fibonacci}(n-2) & \\text{if}~n > 1\\\\\n",
    "\\end{cases} $\n",
    "\n",
    "Es existiert zwar eine Fortsetzung der Fibonacci-Folge für negative $n$, diese soll hier allerdings nicht betrachtet werden.\n",
    "\n",
    "Hinweis: Diese Aufgabe kann auf mehrere Arten gelöst werden, beispielsweise [rekursiv](https://www.w3schools.com/python/gloss_python_function_recursion.asp)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fe64db2",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-273f9551a614d75f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    # BEGIN SOLUTION\n",
    "    if n < 2:\n",
    "        number = n\n",
    "    else:\n",
    "        number = fibonacci(n - 1) + fibonacci(n - 2)\n",
    "    # END SOLUTION\n",
    "    return number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ea4932c",
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-bd84fc94aca517aa",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert fibonacci(0) == 0\n",
    "assert fibonacci(1) == 1\n",
    "assert fibonacci(2) == 1\n",
    "assert fibonacci(3) == 2\n",
    "assert fibonacci(10) == 55\n",
    "### BEGIN HIDDEN TESTS\n",
    "assert list(map(fibonacci, range(26))) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025]\n",
    "### END HIDDEN TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3c4472b",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-1b4c87ec9a37f6ff",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Aufgabe**: Nutzen Sie Ihre selbstdefinierte Funktion `fibonacci()` und geben Sie die Fibonacci-Zahlen der ersten vier Elemente der Liste `l` mit Hilfe der `print()` Funktion aus. Der Output soll für jede Fibonacci-Zahl eine Zeile nach folgendem Format enthalten:\n",
    "`\"Die Fibonacci-Zahl von <Element der Liste l> ist <Fibonacci-Zahl des Listenelements>\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "311b18a3",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c34ee038f199afe2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# BEGIN SOLUTION\n",
    "for n in l[0:4]:\n",
    "    print(\"Die Fibonacci-Zahl von {} ist {}\".format(n, fibonacci(n)))\n",
    "# END SOLUTION"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Create Assignment",
  "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
}
