seminar03.ipynb

    "- lokale Variable:\n",
    "- Rückgabewert:\n",
    "- `None`:\n",
    "- Modul:\n",
    "- `import`-Anweisung:\n",
    "- Modul-Objekt:\n",
    "- Punkt-Schreibweise:\n",
    "- Verknüpfung:\n",
    "- Kontrollfluss:\n",
    "- Stapel-Diagramm:\n",
    "- Box:\n",
    "- Traceback:\n",
    "\n",
    "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.14 Übung\n",
    "\n",
    "### Aufgabe 1\n",
    "\n",
    "\n",
    "#### Aufgabe 1a\n",
    "Diese Aufgabe ist etwas schwieriger, daher haben Sie zwei Möglichkeiten:\n",
    "\n",
    "1. Lösen Sie die Aufgabe selbständig.\n",
    "2. Scrollen Sie etwas herunter und lösen Sie die Aufgabe mit etwas Hilfe (\"Lückentext\").\n",
    "\n",
    "Schreiben Sie eine Funktion `right_justify` die eine Zeichenkette als Parameter `s` erwartet und diese Zeichenkette rechtsbündig ausgibt. Konkret heißt das, dass so viele Leerzeichen vor der Zeichenkette ausgibt, dass der letzte Buchstabe der Zeichenkette in Spalte 70 angezeigt wird. \n",
    "\n",
    "Beispiel: wenn wir die fertige Funktion mit dem Wert `monty` aufrufen, soll folgendes passieren:\n",
    "```python\n",
    "right_justify('monty')\n",
    "                                                                 monty\n",
    "```\n",
    "\n",
    "*Hinweis: Nutzen Sie die Zeichenkettenverknüpfung und -wiederholung. Python bietet uns auch eine Funktion an, mit der wir die Länge einer Zeichenkette ermitteln können. Diese Funktion heißt `len`. Sie erwartet als Argument eine Zeichenkette und gibt ihre Länge zurück. Der Rückgabewert von `len('monty')` ist also `5`.*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definieren Sie hier die Funktion right_justify:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wenn Sie fertig sind, rufen Sie die Funktion hier auf:\n",
    "right_justify(\"Monty Python's\")\n",
    "right_justify('The Ministry of Silly Walks')\n",
    "# (und testen Sie die Funktion zwischendurch immer mal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Lückentext\n",
    "\n",
    "\n",
    "![Silly Walk](https://media.giphy.com/media/RzKHvdYC3uds4/giphy.gif)\n",
    "\n",
    "Bitte hier nur weiterlesen, wenn Sie Hilfe benötigen. Versuchen Sie es aber vorher unbedingt erst einmal zu zweit. Es lohnt sich die Lösung selber herauszufinden; so lernen Sie am meisten dazu. \n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)\n",
    "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "So sollte der Kopf Ihrer Funktion ausehen (alle notwendigen Informationen dazu stehen im ersten Teil des ersten Satzes der Aufgabe):\n",
    "\n",
    "```python\n",
    "def right_justify(s):\n",
    "```\n",
    "\n",
    ".\n",
    "\n",
    "."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def right_justify(s):\n",
    "    # Anzahl Leerzeichen berechnen\n",
    "    anzahl_leerzeichen = \n",
    "    # Zeichenkette erzeugen\n",
    "    ergebnis =\n",
    "    # und ausgeben\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt ein paar Tipps, wie Sie das Problem angehen könnten. Lesen Sie nicht alles auf einmal durch, sondern nur jeweils einen Tipp und versuchen Sie dann erstmal wieder, das Problem zu zweit zu lösen: \n",
    "1. Wieviele Leerzeichen benötigen Sie, um 'monty' rechtsbündig auszugeben? (Falls Sie die Frage nicht beantworten können, lesen Sie sich die Aufgabe nochmal genau durch.)\n",
    "2. Wie können Sie diese Anzahl berechnen? Welche Werte benötigen Sie dafür?\n",
    "3. Das alles können Sie jetzt schon in Ihre Funktion packen.\n",
    "4. Funktioniert das was Sie geschrieben haben auch für andere Werte als 'monty', insbesondere für den Parameter `s` der Funktion?\n",
    "5. Wenn Sie jetzt ausgerechnet haben, wie viele Leerzeichen Sie benötigen, müssen Sie diese noch erzeugen.\n",
    "6. Dafür können Sie den Operator  `*` für Zeichenkettenwiederholung verwenden. \n",
    "7. `' ' * 10` ergibt z.B. 10 Leerzeichen\n",
    "8. Jetzt haben Sie genug Leerzeichen, aber die müssen ja noch vor die Zeichenkette `s`.\n",
    "9. Sie können Zeichenketten mittels `+` verknüpfen.\n",
    "10. `' ' * 65 + 'monty'` wäre die Zeichenkette, die Sie für 'monty' bräuchten. Wie können Sie das allgemein formulieren, sodass es auch für den Parameter `s` (mit beliebiger Länge) funktioniert?\n",
    "11. Schließlich müssen Sie das Ergebnis noch ausgeben - dafür gibt es die `print`-Funktion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Macht ihre Funktion auch wirklich, was sie soll? Ein paar Ideen zum Testen:\n",
    "- Zählen Sie die Leerzeichen bis zum Wort. Das ist schwierig, da Leerzeichen schwer zu sehen sind. Zum Zählen können Sie das Leerzeichen durch ein anderes Zeichen — zum Beispiel einen Punkt — ersetzen.\n",
    "- Bei kurzen Wörtern sind es recht viele Punkte; als Abhilfe könnten Sie, statt in der 70. Spalte, alles rechtsbündig in der 10. Spalte ausgeben, also 70 Zeichen auf 10 reduzieren. Dann lässt es sich leichter zählen.\n",
    "\n",
    "Wenn Ihre Funktion so richtig funktioniert, sollte sie auch mit Leerzeichen statt Punkten und rechtsbündig in Spalte 70 statt Spalte 10 korrekt funktionieren. Das ist auch Debugging und Testen — es ist wichtig, um Fehler zu finden und hilft Ihnen, mit Ihrem Programm vertrauter zu werden.\n",
    "\n",
    "Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist? Probieren Sie es aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "right_justify('Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 1b\n",
    "Testen Sie folgendermaßen, ob Sie verstanden haben, wie die Funktion `right_justify` funktioniert: Schreiben Sie eine Funktion `center`, die eine als Argument übergebene Zeichenkette zentriert ausgibt (bei einer angenommen maximalen Spaltenbreite von 70, wie gerade eben):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schreiben Sie hier Ihre Funktion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Hinweis: Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Gleitkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).*\n",
    "\n",
    "Ein Aufruf der Funktion mit den folgenden Argumenten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "center('Diese Wörter')\n",
    "center('stehen')\n",
    "center('in')\n",
    "center('der Mitte')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sollte folgendes Ergebnis liefern:\n",
    "\n",
    "```\n",
    "                             Diese Wörter\n",
    "                                stehen\n",
    "                                  in\n",
    "                              der Mitte\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)\n",
    "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
    "\n",
    "1. Diese Aufgabe ist Aufgabe 1a sehr ähnlich, schreiben sie den Kopf auf. Die folgenden Hinweise zeigen den Unterschied zu `right_justify`\n",
    "2. Wie viele Leerzeichen benötigen Sie insgesamt? Wie können Sie das berechnen?\n",
    "3. Diesmal stehen die Leerzeichen auf beiden Seiten des Texts. Wie viele Leerzeichen benötigen Sie vor, wie viele hinter der Zeichenkette?\n",
    "4. Verknüpfen Sie die Leerzeichen und das Argument und geben Sie es mit `print` aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def center(s):\n",
    "    space=(70-len(s))//2\n",
    "    print(' '*space+s+' '*space)\n",
    "    \n",
    "center (\"Das ist der Test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 2\n",
    "\n",
    "Ein Funktionsobjekt ist ein Wert, den wir einer Variablen zuweisen oder auch einer Funktion als Argument übergeben können. Zum Beispiel ist `do_twice` eine Funktion, die ein Funktionsobjekt als Argument erwartet und die Funktion dann zweimal aufruft:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_twice(f):\n",
    "    f()\n",
    "    f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im Folgenden ein Beispiel, in dem die Funktion `do_twice` genutzt wird, um die Funktion `print_spam` zweimal aufzurufen:\n",
    "\n",
    "```python\n",
    "def print_spam():\n",
    "    print('spam')\n",
    "\n",
    "do_twice(print_spam)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***(Hinweis: Mit der Tastenkombination `SHIFT STRG -` können wir einen Block teilen - also `SHIFT` und `STRG` gleichzeitig gedrückt halten und dann die Minustaste drücken. So können Sie Ihren Code direkt hinter jeder der folgenden Teilaufgaben einfügen.)*** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Geben Sie dieses Beispiel in einen Code-Block ein und testen Sie es.\n",
    "2. Ändern Sie `do_twice`, so dass \n",
    "  - es zwei Argumente erwartet: ein Funktionsobjekt und einen Wert und\n",
    "  - die übergebene Funktion zweimal aufruft und ihr den Wert als Argument übergibt.\n",
    "3. Rufen Sie mit der geänderten Funktion `do_twice` die Funktion `print_twice` (die wir weiter vorne definiert hatten) auf und übergeben Sie ein Wort Ihrer Wahl als Argument.\n",
    "4. Definieren Sie eine Funktion `do_four`, die ein Funktionsobjekt und einen Wert erwartet und die übergebene Funktion viermal aufruft und ihr dabei den Wert als Parameter übergibt. Die Funktion `do_four` sollte dabei aus nur zwei Zeilen im Rumpf bestehen, nicht aus vier!\n",
    "\n",
    ".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier finden Sie die Lösung. Versuchen Sie es erst einmal zu zweit und gehen Sie Schritt für Schritt vor!\n",
    "\n",
    "![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)\n",
    "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_spam():\n",
    "    print('spam')\n",
    "\n",
    "do_twice(print_spam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_twice(f,wert):\n",
    "    f(wert)\n",
    "    f(wert)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "do_twice(print_twice,\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_four(f,wert):\n",
    "    do_twice(f,wert)\n",
    "    do_twice(f,wert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 3\n",
    "\n",
    "*Hinweis: Nutzen Sie nur Anweisungen und Funktionen, die wir bereits kennengelernt haben.*\n",
    "\n",
    "##### 1.\n",
    "\n",
    "Schreiben Sie eine Funktion, die das folgende Gitter \"zeichnet\":\n",
    "\n",
    "```\n",
    "+ - - - - + - - - - +\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "+ - - - - + - - - - +\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "+ - - - - + - - - - +\n",
    "```\n",
    "*Hinweis: Um mehr als ein Zeichen pro Zeile zu drucken, können Sie die Zeichen durch Kommata getrennt schreiben. (`print(\"+\",\"-\")`)*\n",
    "\n",
    "##### 2. \n",
    "\n",
    "Schreiben Sie eine ähnliche Funktion die ein Gitter mit je 4 Reihen und Zeilen zeichnet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie gehabt, folgt jetzt die Lösung, lesen Sie erst weiter, wenn Sie die Aufgabe gelöst haben oder Schritt für Schritt wenn Sie überhaupt nicht weiterkommen.\n",
    "\n",
    "![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)\n",
    "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
    "\n",
    "Zuerst ein paar Tipps um die Aufgabe selber zu lösen. Lesen Sie nicht alle Tipps auf einmal durch:\n",
    "\n",
    "1. Welche Zeilen müssen wir überhaupt ausgeben? Schreiben Sie die Zeilen einzel auf.\n",
    "2. Wie sieht das Gitter aus? Können sie es mit einer Reihe von `print`-Statements darstellen?\n",
    "3. Welche Zeilen wiederholen sich? Können sie diese mit Hilfe von Funktionen zusammenfassen?\n",
    "\n",
    "\n",
    "Dies ist nur eine mögliche Lösung, weitere Lösungsmöglichkeiten finden sie [hier](http://greenteapress.com/thinkpython2/code/grid.py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_sides():\n",
    "    print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
    "    print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
    "    print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
    "    print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
    "\n",
    "def print_grid():\n",
    "    print (\"+\", \"- \"*4, \"+\", \"- \"*4, \"+\")\n",
    "    print_sides()\n",
    "    print(\"+\", \"- \"*4, \"+\", \"- \"*4, \"+\")\n",
    "    print_sides()\n",
    "    print(\"+\", \"- \"*4, \"+\", \"- \"*4, \"+\")\n",
    "    \n",
    "print_grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_two(f):\n",
    "    f()\n",
    "    f()\n",
    "    \n",
    "def setup():\n",
    "    print(\"+\",\"-\",\"+\",\"-\",\"+\")\n",
    "    print(\"|\", \" \",\"|\", \" \",\"|\")\n",
    "\n",
    "\n",
    "def minigrid():\n",
    "    do_two(setup)\n",
    "    print(\"+\",\"-\",\"+\",\"-\",\"+\")\n",
    "    \n",
    "minigrid()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonusaufgabe\n",
    "\n",
    " Finden Sie einen Algorithmus zur Lösung des folgenden Problems:\n",
    "   *Gegeben sei eine positive ganze Zahl `n`. Finden Sie eine Liste\n",
    "   von positiven ganzen Zahlen, so dass das Produkt der Zahlen am\n",
    "   größten unter allen positiven ganzen Zahlen ist, deren Summe\n",
    "   gleich `n` ist.*\n",
    "\n",
    "   Zum Beispiel: \n",
    "   - Für `n = 4` ist die gesuchte Liste `(2,2)`, denn `2 * 2` ist größer als `1 * 1 * 1 * 1`, `2 * 1 * 1` und `3 * 1`.\n",
    "   - Für `n = 5` ist die gesuchte Liste `(2,3)`.\n",
    "\n",
    "Erklären Sie, wie Sie \"einen Fuß in die Tür bekommen\" haben.\n",
    "\n",
    "Wie lautet die Liste für `n = 2001`?\n",
    "\n",
    "\n",
    "\n",
    "Versuchen Sie es zunächst ohne Hilfe. Wie kann Ihnen Python dabei helfen? \n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)\n",
    "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "Mein \"Fuß in der Tür\" war, dass ich von Hand eine Tabelle mit den Ergebnissen für die ersten `n` Zahlen gebaut habe:\n",
    "\n",
    "|  n | Liste     | Produkt |\n",
    "|----|-----------|---------|\n",
    "|  2 | 1 1       |       1 | \n",
    "|  3 | 1 2       |       3 | \n",
    "|  4 | 2 2       |       4 |\n",
    "|  5 | 2 3       |       6 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ergänzen Sie diese Tabelle von Hand. Dabei kann Ihnen eine Funktion helfen, die für eine gegebene Liste an Zahlen das Produkt und die Summe berechnet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prodsum(zahlen):\n",
    "    prod = 1\n",
    "    summ = 0\n",
    "    for zahl in zahlen:\n",
    "        prod = prod * zahl\n",
    "        summ = summ + zahl\n",
    "    print(\"Produkt =\", prod, \"Summe =\", summ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine Liste von Zahlen können wir erzeugen, indem wir die Zahlen durch Komma getrennt zwischen zwei Klammern schreiben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir können also `prodsum` so aufrufen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prodsum((2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testen Sie für jedes `n` mehrere Listen, bis Sie sich jeweils sicher sind, die mit dem größten Produkt gefunden zu haben.\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "Ich habe mit Hilfe der Funktion die Tabelle bis `n=15` ergänzt bis ich mir sicher war, dass ich das Prinzip verstanden hatte. \n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "Sehen Sie jetzt ein Muster in der Tabelle? Die Produkte bestehen nur aus 3en und ggf. noch 2en oder 4en. Genauer:\n",
    "\n",
    "Beobachtung: \n",
    "- Ein Produkt aus möglichst vielen 3en ergibt das beste Ergebnis.\n",
    "- Falls es nicht ganz aufgeht, mit 2 oder 4 auffüllen.\n",
    "\n",
    "Erklärung:\n",
    "- Ob wir eine 4 oder zwei 2en nehmen, ist egal, da `2+2 = 4 = 2*2`.\n",
    "- Da `2+3=5` aber `2*3=6`, lohnt es sich nicht, größere Zahlen zu nehmen\n",
    "  (ebenso: `3+3=6` aber `3*3=9`) - das Produkt der kleinen Zahlen ist stets größer als ihre Summe\n",
    "\n",
    "Algorithmus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def produkt_summe(n):\n",
    "    \"\"\"Berechnet für gegebenes n>2 das Produkt derjenigen Liste von\n",
    "    Zahlen, deren Summe n ergibt und gleichzeitig die größte Liste mit\n",
    "    dieser Eigenschaft ist.\n",
    "    \n",
    "    Vorgehen: wiederholt 3 von n abziehen, bis der Rest kleiner oder \n",
    "    gleich 4 ist. (letzter Schritt klappt, weil 2+2=4=2*2)\n",
    "\n",
    "    \"\"\"\n",
    "    rest = n\n",
    "    prod = 1\n",
    "    zahlen = []\n",
    "    while rest > 4:\n",
    "        rest = rest - 3\n",
    "        prod = prod * 3\n",
    "        zahlen.append(3)\n",
    "    prod = prod * rest\n",
    "    zahlen.append(rest)\n",
    "    \n",
    "    print(\"*\".join([str(z) for z in zahlen]), \"=\", prod)\n",
    "    print(\"+\".join([str(z) for z in zahlen]), \"=\", sum(zahlen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testen wir es einmal aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "produkt_summe(14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das sollte auch die Zahl sein, die Sie für `n=14` oben in Ihrer Tabelle stehen haben. \n",
    "\n",
    "Die Funktion verwendet zwar ein paar neue Dinge, um eine schöne Ausgabe zu erzeugen, aber die wesentliche Funktionalität in der `while`-Schleife zur Berechnung des Produkts besteht nur aus Konstrukten, die wir schon kennengelernt haben. \n",
    "\n",
    "\n",
    "![I wrote 20 short programs in Python yesterday.  It was wonderful.  Perl, I'm leaving you.\"](https://imgs.xkcd.com/comics/python.png)\n",
    "\n",
    "([Python](https://xkcd.com/353/), Randall Munroe)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, sodass Ihre Änderungen nicht verloren gehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü \"File\" den Punkt \"Download as\"->\"Notebook\" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Smiley](https://upload.wikimedia.org/wikipedia/commons/thumb/3/33/Smiling_smiley_yellow_simple.svg/240px-Smiling_smiley_yellow_simple.svg.png)\n",
    "\n",
    "Herzlichen Glückwunsch! Sie haben das 3. Kapitel geschafft. Weiter geht es in [3 Extra: Reguläre Ausdrücke](seminar03extra.ipynb)."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}