diff --git a/notebooks/seminar03.ipynb b/notebooks/seminar03.ipynb
index 64e603558825e69971cdaea4c2d056d680ee218f..4f3330f5ada741c6d1dc748b4c1e4d68cbf6d067 100644
--- a/notebooks/seminar03.ipynb
+++ b/notebooks/seminar03.ipynb
@@ -6,7 +6,12 @@
    "source": [
     "# Seminar Problemorientierte Programmierung\n",
     "\n",
-    "## Ihre Lernziele\n",
+    "## Kapitel 3: Funktionen\n",
+    "[Chapter 3: Functions](http://greenteapress.com/thinkpython2/html/thinkpython2004.html)\n",
+    "\n",
+    "**Funktionen** bezeichnen eine benannte Folge von Anweisungen. Wenn wir eine Funktion definieren, dann geben wir der Funktion einen Namen und fügen die Folge von Anweisungen, die die Funktion ausführen sollen, hinzu. Später können wir die Funktion mit ihrem Namen **aufrufen**. \n",
+    "\n",
+    "### Ihre Lernziele\n",
     "\n",
     "Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:\n",
     "\n",
@@ -15,9 +20,7 @@
     "- \n",
     "\n",
     "\n",
-    "## Exkurs: Was mir an Python gefällt\n",
-    "\n",
-    "In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\n",
+    "### Exkurs: Was mir an Python gefällt\n",
     "\n",
     "Es ist sehr leicht, Ergebnisse mit Hilfe eines Plots darzustellen und auch mathematische Funktionen können professionell geplottet werden:"
    ]
@@ -46,27 +49,25 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 3: Funktionen\n",
-    "\n",
-    "**Funktionen** bezeichnen eine benannte Folge von Anweisungen. Wenn wir eine Funktion definieren, dann geben wir den Namen der Funktion an und die Folge von Anweisungen. Später können wir die Funktion dann mit ihrem Namen **aufrufen**. \n",
-    "\n",
+    " \n",
     "### Warum?\n",
     "\n",
     "Warum ist es sinnvoll, ein Programm in Funktionen aufzuteilen?\n",
+    "Hier einige Beispiele: \n",
     "\n",
-    "- **Lesbarkeit** - z.B. weil eine Folge von Anweisungen dann einen Namen trägt der beschreibt, was sie tun\n",
-    "- **Fehlersuche** - z.B. weil Fehler innerhalb einer Funktion den Suchbereich einschränken \n",
-    "- **kürzerer Programmkode** - z.B. weil sich Quellcode nicht wiederholt\n",
-    "- **Wartbarkeit** - z.B. weil wir Änderungen nur an einer Stelle durchführen müssen\n",
-    "- **Testbarkeit** - z.B. weil wir jede Funktion einzeln testen können\n",
-    "- **Wiederverwendbarkeit** - z.B. weil eine gut funktionierende Funktion in vielen Programmen verwendet werden kann."
+    "- **Lesbarkeit** - Mit einer Funktion können wir eine Gruppe von Anweisungen benennen und so beschreiben was die Gruppe macht.\n",
+    "- **Fehlersuche** - Lange Programme in Funktionen aufzuteilen ermöglicht es, das Programm funktionsweise zu debuggen und später zusammen zu setzten.\n",
+    "- **Testbarkeit** - Analog zur Fehlersuche kann jede Funktion einzeln getestet werden\n",
+    "- **kürzerer Programmcode** - Durch Funktionen können Wiederholungen im Quellcode reduziert oder eliminiert werden.\n",
+    "- **Wartbarkeit** - Dadurch, dass sich Quellcode nicht (bzw. kaum) wiederholt, können Änderungen an nur einer Stelle vorgenommen werden und die Effekte sind im gesamten Programm zu sehen.\n",
+    "- **Wiederverwendbarkeit** - Eine gut funktionierende Funktion kann in vielen Programmen sinnvoll verwendet werden."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Funktionsaufrufe\n",
+    "### 3.1 Funktionsaufrufe\n",
     "\n",
     "Wir haben schon einige Funktionsaufrufe gesehen:"
    ]
@@ -88,7 +89,8 @@
     "\n",
     "Üblicherweise sagen wir, dass eine Funktion ein Argument \"erwartet\" und ein Ergebnis \"zurückgibt\". Dieses Ergebnis wird auch **Rückgabewert** genannt. \n",
     "\n",
-    "Python stellt einige Funktionen bereit, um Werte von einem Datentyp zu einem anderen umzuwandeln. Beispielsweise erwartet die `int`-Funktion einen Wert als Argument, den sie dann in eine ganze Zahl umwandelt - falls möglich (andernfalls beschwert sie sich und gibt einen Fehler aus):"
+    "Python stellt einige Funktionen bereit, um Werte von einem Datentyp zu einem anderen umzuwandeln. Beispielsweise erwartet die `int`-Funktion einen Wert als Argument, den sie dann in eine ganze Zahl umwandelt — \n",
+    "falls möglich (andernfalls beschwert sie sich und gibt einen Fehler aus):"
    ]
   },
   {
@@ -113,7 +115,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Mit Hilfe der `int`-Funktion können wir zum Beispiel Gleitkommazahlen in ganze Zahlen umwandeln:"
+    "Mit Hilfe der `int`-Funktion können wir auch zum Beispiel Gleitkommazahlen in ganze Zahlen umwandeln. Allerdings wird dabei der Teil hinter dem Dezimalpunkt abgeschnitten und nicht gerundet:"
    ]
   },
   {
@@ -125,22 +127,6 @@
     "int(32.7)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Allerdings wird dabei der Teil hinter dem Dezimalpunkt abgeschnitten und nicht gerundet:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "int(-2.2)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -195,7 +181,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Hinweis: Anfangs hatten wir die Gänsefüßchen als \"Markierung\" für Zeichenketten kennengelernt. Es ist auch möglich, Zeichenketten mit einfachen Hochkommata (') einzuschließen - so wie das Python hier gemacht hat. Das ermöglicht uns z.B., Sätze mit indirekter Rede ('Da sagte er \"heute wird es regnen\" und ging ab.') als Zeichenkette auszudrücken. Umgekehrt können wir mit Hilfe der Gänsefüßchen Sätze wie \"Das wär's gewesen.\" einschließen. Probieren Sie beides aus, indem Sie die beiden Sätze jeweils einer Variablen zuweisen und dann mit der `print`-Anweisung ausgeben:"
+    "Anfangs hatten Sie Gänsefüßchen als \"Markierung\" für Zeichenketten kennengelernt. In Python ist es auch möglich Zeichenketten mit 'einfachen Hochkommata' einzuschließen. Das ermöglicht uns z.B. Sätze mit wörtlicher Rede darzustellen, so zum Beispiel der Satz: 'Da sagte er: \"Heute wird es regnen\" und ging ab.'; umgekehrt können wir mit Gänsefüßchen Sätze wie \"Das wär's gewesen.\" einschließen. \n",
+    "Probieren Sie beides aus, indem Sie die beiden Sätze jeweils einer Variablen zuweisen und dann mit der `print`-Anweisung ausgeben:"
    ]
   },
   {
@@ -209,11 +196,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Mathematische Funktionen\n",
+    "### 3.2 Mathematische Funktionen\n",
     "\n",
     "Mit Python wird ein Mathematik-Modul mitgeliefert, das die üblichen mathematischen Funktionen enthält. Ein **Modul** ist eine Datei, die eine Sammlung von verwandten Funktionen enthält. \n",
     "\n",
-    "Exkurs: Oft sagt man statt Modul auch *Bibliothek*. Einen Überblick über die mitgelieferten \"Standardbibliotheken\" finden Sie hier: https://docs.python.org/3.5/library/. Es gibt z.B. Module zur [Datumsberechnung](https://docs.python.org/3.5/library/datetime.html), für [Datenbankzugriffe](https://docs.python.org/3.5/library/sqlite3.html), für [Datenkomprimierung](https://docs.python.org/3.5/library/gzip.html), [Verschlüsselung](https://docs.python.org/3.5/library/ssl.html) und [Netzwerkzugriffe](https://docs.python.org/3.5/library/socket.html). Einige dieser Module werden wir vielleicht noch kennenlernen. Zusätzlich gibt es tausende Module im Web, die wir uns herunterladen und installieren können.\n",
+    "Oft sagt man statt Modul auch *Bibliothek*. Einen Überblick über die mitgelieferten \"Standardbibliotheken\" finden Sie [hier](https://docs.python.org/3.5/library/). Es gibt z.B. Module zur [Datumsberechnung](https://docs.python.org/3.5/library/datetime.html), für [Datenbankzugriffe](https://docs.python.org/3.5/library/sqlite3.html), für [Datenkomprimierung](https://docs.python.org/3.5/library/gzip.html), [Verschlüsselung](https://docs.python.org/3.5/library/ssl.html) und [Netzwerkzugriffe](https://docs.python.org/3.5/library/socket.html). Einige dieser Module werden wir vielleicht noch kennenlernen. Zusätzlich gibt es tausende Module im Web, die wir uns herunterladen und installieren können.\n",
     "\n",
     "Wir können ein Modul mit Hilfe der **import-Anweisung** einbinden:"
    ]
@@ -279,7 +266,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Dies gibt beispielsweise den Wert der Sinus-Funktion an der Stelle 3 aus. Dieses Format heißt **Punkt-Schreibweise** (Englisch: *dot notation*) und wird uns öfter begegnen.\n",
+    "Dies gibt den Wert der Sinus-Funktion an der Stelle 3 aus. Dieses Format heißt **Punkt-Schreibweise** (Englisch: *dot notation*) und wird uns öfter begegnen.\n",
     "\n",
     "Ein weiteres Beispiel ist der Wert von π, der im `math`-Modul definiert ist: "
    ]
@@ -304,9 +291,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Verknüpfung\n",
+    "### 3.3 Verknüpfung\n",
     "\n",
-    "Bisher haben wir uns die Elemente von Programmen - Variablen, Ausdrücke, Anweisungen - einzeln angeschaut aber nicht groß darüber gesprochen, wie wir sie kombinieren können. \n",
+    "Bisher haben wir uns die Elemente von Programmen - Variablen, Ausdrücke, Anweisungen - einzeln angeschaut aber nicht darüber gesprochen, wie wir sie kombinieren können. \n",
     "\n",
     "Eine der nützlichsten Eigenschaften von Programmiersprachen ist, dass wir kleinere Bausteine miteinander **verknüpfen** (Englisch: *compose*/*composition*) können. Beispielsweise kann das Argument einer Funktion jeglicher Ausdruck sein, einschließlich arithmetischer Operatoren"
    ]
@@ -372,16 +359,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Die linke Seite einer Zuweisung muss *immer* ein Variablenname sein! Jeglicher anderer Ausdruck auf der linken Seite ergibt einen Syntaxfehler. (Ausnahmen bestätigen die Regel ... aber dazu später.)"
+    "Die linke Seite einer Zuweisung muss *immer* ein Variablenname sein! Jeglicher anderer Ausdruck auf der linken Seite ergibt einen Syntaxfehler. (Ausnahmen bestätigen die Regel ... aber dazu später mehr.)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Neue Funktionen hinzufügen\n",
+    "### 3.4 Neue Funktionen hinzufügen\n",
     "\n",
-    "Bisher haben wir nur Funktionen genutzt, die bei Python schon \"mitgeliefert\" werden. Es ist aber auch möglich, eigene Funktionen hinzuzufügen. Eine **Funktionsdefinition** gibt den Namen der Funktion an und eine Folge von Anweisungen, die ausgeführt werden, wenn die Funktion ausgeführt wird:"
+    "Bisher haben wir nur Funktionen genutzt, die bei Python schon \"mitgeliefert\" werden. Es ist aber auch möglich, eigene Funktionen hinzuzufügen. Eine **Funktionsdefinition** gibt den Namen der Funktion an und beschreibt die Folge von Anweisungen, die ausgeführt werden, wenn die Funktion aufgerufen wird:"
    ]
   },
   {
@@ -404,7 +391,7 @@
     "- Die leeren Klammern am Ende zeigen an, dass diese Funktion keine Argumente erwartet.\n",
     "- Die erste Zeile einer Funktion ist der **Kopf** (Englisch: *header*), welcher mit einem Doppelpunkt abgeschlossen wird.\n",
     "- Danach kommt der **Rumpf** (Englisch: *body*), der um vier Leerzeichen eingerückt werden muss.\n",
-    "- Im Rumpf können beliebig viele Anweisungen stehen ... die erste Anweisung, die nicht mehr eingerückt ist, gehört nicht mehr zur Funktion.\n",
+    "- Im Rumpf können beliebig viele Anweisungen stehen; die erste, nicht mehr eingerückte, Anweisung gehört nicht mehr zur Funktion.\n",
     "\n",
     "Wenn wir das alles beachtet und richtig gemacht haben, dann können wir die Funktion aufrufen:"
    ]
@@ -422,9 +409,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Dazu müssen wir nur den Namen der Funktion schreiben, gefolgt von den beiden Klammern. \n",
+    "Dazu müssen wir - analog zum Aufruf von vordefinierten Funktionen - den Namen der Funktion gefolgt von den Klammern schreiben. Die Klammern sind leer, da die Funktion keine Argumente erwartet. \n",
     "\n",
-    "Exkurs: Übrigens wird durch die Definition einer Funktion ein sogenanntes **Funktionsobjekt** erzeugt, dessen Typ wir uns anschauen können:"
+    "Übrigens wird durch die Definition einer Funktion ein sogenanntes **Funktionsobjekt** erzeugt, dessen Typ wir uns anschauen können:"
    ]
   },
   {
@@ -473,9 +460,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Definition von Funktionen und deren Aufruf\n",
+    "### 3.5 Definition von Funktionen und deren Aufruf\n",
     "\n",
-    "Schauen wir uns noch einmal an, was wir gerade programmiert haben:\n",
+    "Schauen wir uns noch einmal an, was Sie gerade programmiert haben:\n",
     "\n",
     "```python\n",
     "def print_lyrics():\n",
@@ -489,11 +476,12 @@
     "repeat_lyrics()\n",
     "```\n",
     "\n",
-    "Dieses Programm enthält zwei Funktionsdefinitionen: `print_lyrics` und `repeat_lyrics`. Funktionsdefinitionen werden wie jede andere Anweisung auch ausgeführt, aber das Ergebnis ist, dass Funktionsobjekte erzeugt werden. Die Anweisungen innerhalb der Funktion werden dabei noch nicht ausgeführt - erst, wenn die Funktion aufgerufen wird. Die Definition einer Funktion erzeugt daher keine Ausgabe.\n",
+    "Dieses Programm enthält zwei Funktionsdefinitionen: `print_lyrics` und `repeat_lyrics`. Funktionsdefinitionen werden wie jede andere Anweisung auch ausgeführt, aber das Ergebnis ist, dass Funktionsobjekte erzeugt werden. Die Anweisungen innerhalb der Funktion werden dabei noch nicht ausgeführt — erst, wenn die Funktion aufgerufen wird. Die Definition einer Funktion erzeugt daher keine Ausgabe.\n",
     "\n",
     "Vielleicht haben Sie es sich schon gedacht: Bevor wir eine Funktion nutzen können, müssen wir sie definieren. Die Funktionsdefinition muss also *vor* dem Funktionsaufruf ausgeführt werden.\n",
     "\n",
     "\n",
+    "\n",
     "Daher als Ãœbung: verschieben Sie den Funktionsaufruf in der letzten Zeile ganz an den Anfang, so dass der Funktionsaufuruf vor den Funktionsdefinitionen erscheint und beobachten Sie, welche Fehlermeldung das ergibt:"
    ]
   },
@@ -518,7 +506,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "*(Falls Sie keine Fehlermeldung erhalten, müssen Sie evtl. den Jupyter-Kernel neustarten. Wählen Sie dafür \"Restart & Clear Output\" im \"Kernel\"-Menü.)*\n",
+    "*(Falls Sie keine Fehlermeldung erhalten, müssen Sie den Jupyter-Kernel neustarten, da sich Jupyter die ursprüngliche Funktionsdefinition gemerkt hat. Wählen Sie dafür \"Restart & Clear Output\" im \"Kernel\"-Menü.)*\n",
     "\n",
     "Verschieben Sie den Aufruf jetzt wieder ans Ende und vertauschen Sie die Reihenfolge der beiden Funktionsdefinitionen. Was passiert dabei?"
    ]
@@ -527,30 +515,52 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Kontrollfluss\n",
+    "### 3.6 Kontrollfluss\n",
     "\n",
     "Damit wir sicherstellen können, dass eine Funktion definiert ist, bevor wir sie aufrufen, müssen wir die Reihenfolge kennen, in der Anweisungen ausgeführt werden - den sogenannten **Kontrollfluss**.\n",
     "\n",
-    "Die Ausführung eines Programms beginnt immer mit der ersten Anweisung. Anweisungen werden einzeln ausgeführt, von oben nach unten.\n",
+    "Die Ausführung eines Programms beginnt immer mit der ersten Anweisung. Anweisungen werden einzeln und der Reihe nach ausgeführt; von oben nach unten.\n",
     "\n",
-    "Funktionsdefinitionen verändern den Kontrollfluss eines Programms nicht (und wir erinnern uns, dass die Anweisungen innerhalb der Funktion erst ausgeführt werden, wenn die Funktion aufgerufen wird).\n",
+    "Funktionsdefinitionen verändern den Kontrollfluss eines Programms nicht — Anweisungen innerhalb der Funktion werden zunächst übersprungen und erst ausgeführt, wenn die Funktion aufgerufen wird. \n",
     "\n",
-    "Ein Funktionsaufruf ist wie eine Umleitung im Kontrollfluss: Anstatt zur nächsten Anweisung zu springen, springt Python zum Rumpf der Funktion, führt die Anweisungen dort aus und springt dann zurück zum Ausgangspunkt:\n",
+    "Ein Funktionsaufruf ist wie eine Umleitung im Kontrollfluss: Anstatt zur nächsten Anweisung zu gehen, springt Python zum Rumpf der Funktion, führt die Anweisungen dort aus und springt dann zurück zum Ausgangspunkt:\n",
     "\n",
     "![Kontrollfluss](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/control_flow_function.svg)\n",
     "\n",
     "(Quelle: Brookshear & Brylow, 2015: Computer Science: An Introduction)\n",
     "\n",
-    "Das klingt noch recht einfach ... aber wir erinnern uns: eine Funktion kann eine weitere aufrufen und diese noch eine weitere, usw. Glücklicherweise merkt sich Python immer genau, wo es ist und wohin zurückgesprungen werden muss. \n",
+    "Es ist also so, als ob bei dem Aufruf von `repeat_lyrics` eigentlich folgender Code gelesen wird:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "repeat_lyrics()\n",
+    "print_lyrics()\n",
+    "print(\"Jetzt fahr'n wir über'n See, über'n See,\")\n",
+    "print(\"            jetzt fahr'n wir über'n See\")\n",
+    "print_lyrics()\n",
+    "print(\"Jetzt fahr'n wir über'n See, über'n See,\")\n",
+    "print(\"            jetzt fahr'n wir über'n See\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Das klingt noch recht einfach aber erinnern Sie sich? Jede Funktion kann eine weitere aufrufen, sodass diese Abweichung im Kontrollfluss mehrere Funktionen tief gehen kann. Glücklicherweise merkt sich Python immer genau, wo es ist und wohin zurückgesprungen werden muss. \n",
     "\n",
-    "Wenn wir also ein Programm zu verstehen versuchen, ist es manchmal hilfreich, das Programm nicht einfach nur von oben nach unten durchzulesen, sondern dem Kontrollfluss zu folgen, also beim Aufruf einer Funktion zu dieser Funktion zu springen und sie durchzulesen."
+    "Zusammengefasst heißt das: Um ein Programm zu verstehen, ist es hilfreich das Programm nicht einfach von oben nach unten durchzulesen. Stattdessen sollte man dem Kontrollfluss folgen, also immer zu der aufgerufenen Funktion springen und diese durchlesen."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Parameter und Argumente\n",
+    "### 3.7 Parameter und Argumente\n",
     "\n",
     "Einige der Funktionen, die wir schon gesehen haben, benötigen **Argumente** (z.B. `print` oder `type`). Wenn wir `math.sin` aufrufen, müssen wir eine Zahl als Argument übergeben. Einige Funktionen benötigen auch mehrere Argumente (z.B. benötigt `math.pow` zwei Argumente: die Basis und den Exponenten).\n",
     "\n",
@@ -591,7 +601,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Die Regeln zur Verknüpfung gelten auch hier: statt eines Wertes können wir auch einen Ausdruck übergeben:\n"
+    "Die Regeln zur Verknüpfung gelten auch hier; Anstelle eines Wertes können wir einen Ausdruck übergeben:\n"
    ]
   },
   {
@@ -608,7 +618,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Das Argument wird ausgewertet (also berechnet) bevor die Funktion aufgerufen wird. Daher werden die Ausdrücke `'Film' * 2` und `math.cos(math.pi))` nur einmal ausgewertet!\n",
+    "Das Argument wird ausgewertet (also berechnet) bevor die Funktion aufgerufen wird. Daher werden die Ausdrücke `'Film' * 2` und `math.cos(math.pi))` nur einfach ausgewertet. \n",
     "\n",
     "Wir können auch eine Variable als Argument übergeben:"
    ]
@@ -627,7 +637,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Wichtig**: der Name der Variablen, die wir als Argument übergeben (hier: `text`) hat nichts mit dem Namen des Parameters (hier `wert`) zu tun! Egal, wie der Wert der da reinkommt ausserhalb der Funktion bezeichnet wurde -\n",
+    "***Wichtig!*** \n",
+    "Der Name der Variablen, die wir als Argument übergeben (hier: `text`) hat nichts mit dem Namen des Parameters (hier: `wert`) zu tun! Egal, wie der Wert, den wir übergeben, außerhalb der Funktion benannt wurde —\n",
     " innerhalb dieser Funktion heißt der Wert `wert`."
    ]
   },
@@ -635,9 +646,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Variablen und Parameter sind lokal\n",
+    "### 3.8 Variablen und Parameter sind lokal\n",
     "\n",
-    "Wenn wir eine Variable innerhalb einer Funktion erzeugen, ist dies eine **lokale** Variable. D.h., diese Variable existiert nur innerhalb der Funktion. Zum Beispiel:"
+    "Wenn wir eine Variable innerhalb einer Funktion erzeugen, ist dies eine **lokale** Variable; das heißt diese Variable existiert nur innerhalb der Funktion. Zum Beispiel:"
    ]
   },
   {
@@ -713,13 +724,13 @@
     "\n",
     "Das Diagramm zeigt uns den Wert jeder Variablen und auch die Funktion zu der jede Variable gehört.\n",
     "\n",
-    "Jede Funktion wird durch einen **Block** (Englisch: *frame*) repräsentiert: links neben dem Block erscheint der Name der Funktion und innerhalb des Blocks die Parameter und Variablen und die Werte, die ihnen zugewiesen wurden.\n",
+    "Jede Funktion wird durch einen **Block** (Englisch: *frame*) repräsentiert: links neben dem Block erscheint der Name der Funktion und innerhalb des Blocks die Parameter, Variablen und die Werte, die ihnen zugewiesen wurden.\n",
     "\n",
     "Die Blöcke sind in einem Stapel (*stack*) angeordnet, der uns zeigt, welche Funktion welche andere Funktion aufgerufen hat. In unserem Beispiel wurde `print_twice` durch `cat_twice` aufgerufen und `cat_twice` wurde durch `__main__` aufgerufen, was ein spezieller Name für den obersten Block ist. Wenn wir eine Variable ausserhalb einer Funktion erzeugen, gehört diese zu `__main__`.\n",
     "\n",
-    "Jeder Parameter verweist auf den selben Wert wie das zugehörige Argument. In unserem Fall hat also `part1` den selben Wert wie `teil1`, `part2` den selben Wert wie `teil2` und `wert` den selben Wert wie `cat`.\n",
+    "Jeder Parameter und zugehöriges Argument verweisen auf den selben Wert. In unserem Fall hat also `part1` den selben Wert wie `teil1`, `part2` den selben Wert wie `teil2` und `wert` den selben Wert wie `cat`.\n",
     "\n",
-    "Wenn uns ein Fehler während eines Funktionsaufrufes unterläuft, gibt uns Python den Namen der Funktion aus, die den Fehler verursacht hat, den Namen der Funktion, die diese Funktion aufgeführt hat, usw. bis hinauf zu `__main__`. \n",
+    "Wenn uns während eines Funktionsaufrufes ein Fehler unterläuft, gibt uns Python den Namen der Funktion aus, die den Fehler verursacht hat, den Namen der Funktion, die diese Funktion ausgeführt hat usw. bis hinauf zu `__main__`. \n",
     "\n",
     "Wenn wir z.B. versuchen, `cat` innerhalb von `print_twice` aufzurufen, bekommen wir einen `NameError`. Probieren Sie es aus:"
    ]
@@ -742,7 +753,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Diese Liste von Funktionen wird **Traceback** genannt und zeigt uns, wo der Fehler aufgetreten ist und welche Zeilen in welchen Funktionen gerade aufgerufen wurden. Die Reihenfolge ist die gleiche wie im Stapeldiagramm: die Funktion die gerade die Kontrolle hatte und ausgeführt wurde, ist ganz unten. "
+    "Diese Liste von Funktionen wird **Traceback** genannt und zeigt uns, wo der Fehler aufgetreten ist und welche Zeilen in welchen Funktionen gerade aufgerufen wurden. Die Reihenfolge ist die gleiche wie im Stapeldiagramm: die Funktion, die gerade die Kontrolle hatte und ausgeführt wurde, ist ganz unten. "
    ]
   },
   {
@@ -767,7 +778,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Damit lernen wir auch, dass wir eine Funktion mit dem gleichen Namen mehrmals definieren können: Jede neue Definition überschreibt einfach die vorherige und beim Aufrufen der Funktion wird die zuletzt definierte Variante ausgeführt:"
+    "Damit lernen wir auch, dass wir — wie bei Variablen — eine Funktion mit dem gleichen Namen mehrmals definieren können: Jede neue Definition überschreibt einfach die vorherige und beim Aufrufen der Funktion wird die zuletzt definierte Variante ausgeführt:"
    ]
   },
   {
@@ -783,11 +794,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Funktionen mit Rückgabewert\n",
+    "### 3.10 Funktionen mit Rückgabewert\n",
     "\n",
-    "Einige der Funktionen, die wir bisher verwendet haben (z.B. die mathematischen Funktionen) geben einen Wert zurück. Andere führen eine Aktion aus, aber geben keinen Wert zurück (z.B. `print_twice`). \n",
+    "Einige der Funktionen, die wir bisher verwendet haben (z.B. die mathematischen Funktionen) geben einen Wert zurück. Andere führen eine Aktion aus, geben aber keinen Wert zurück (z.B. `print_twice`). Diese werden auch **void functions** — also leere Funktionen genannt.\n",
     "\n",
-    "Wenn wir eine Funktion mit Rückgabewert aufrufen, wollen wir meistens etwas mit dem Rückgabewert anfangen, ihn z.B. einer Variable zuweisen oder innerhalb eines Ausdrucks verwenden:"
+    "Wenn wir eine Funktion mit Rückgabewert aufrufen, wollen wir meistens etwas mit dem Rückgabewert anfangen; ihn z.B. einer Variable zuweisen oder innerhalb eines Ausdrucks verwenden:"
    ]
   },
   {
@@ -820,8 +831,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Aber wenn wir sonst nichts damit machen, dann geht der Wert verloren. Wir berechnen also etwas, aber fangen damit nichts weiter an. Daher weisen wir den Rückgabewert einer Funktion meist einer Variablen zu oder verwenden ihn in einem Ausdruck, wie oben gesehen.\n",
-    "\n",
+    "Aber wenn wir sonst nichts damit machen, geht der Wert verloren. Wir berechnen also etwas und fangen damit nichts weiter an. \n",
     "Schreiben Sie einen Ausdruck auf, der die Funktion `math.sqrt` verwendet und weisen Sie das Ergebnis einer Variablen zu:"
    ]
   },
@@ -836,7 +846,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Funktionen ohne Rückgabewert zeigen vielleicht etwas auf dem Bildschirm an oder haben einen anderen Effekt, aber sie geben uns keinen Wert zurück. Wenn wir das Ergebnis einer solchen Funktion einer Variablen zuweisen, erhält diese den speziellen Wert `None`:"
+    "Leere Funktionen zeigen vielleicht etwas auf dem Bildschirm an, oder haben einen anderen Effekt, aber sie geben uns keinen Wert zurück. Wenn wir das Ergebnis einer solchen Funktion einer Variablen zuweisen, erhält diese den speziellen Wert `None`:"
    ]
   },
   {
@@ -853,7 +863,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Der wert `None` ist nicht das selbe wie die Zeichenkette `'None'`, sondern ein spezieller Wert mit eigenem Typ:"
+    "Der Wert `None` ist keine Zeichenkette, sondern ein spezieller Wert mit eigenem Typ:"
    ]
   },
   {
@@ -869,9 +879,10 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Eigene Funktionen mit Rückgabewert\n",
     "\n",
-    "Wir können selbst eine Funktion mit Rückgabewert schreiben, indem wir das Schlüsselwort `return` verwenden:\n"
+    "### 3.11 Exkurs: Eigene Funktionen mit Rückgabewert\n",
+    "\n",
+    "Dieser Abschnitt taucht nicht im englischen Python-Kurs auf und gibt einen Ausbilck auf ein späteres Kapitel. Wir können selbst eine Funktion mit Rückgabewert schreiben, indem wir das Schlüsselwort `return` verwenden:\n"
    ]
   },
   {
@@ -912,7 +923,9 @@
     "\\sqrt{s(s-a)(s-b)(s-c)}\n",
     "\\end{equation}\n",
     "\n",
-    "ist (mit $s = (a+b+c)/2$). Hinweis: Sie können die Quadratwurzel einer Zahl mit der Funktion `math.sqrt` berechnen."
+    "mit $s = (a+b+c)/2$ ist. \n",
+    "\n",
+    "*(Hinweis: Sie können die Quadratwurzel einer Zahl mit der Funktion `math.sqrt` berechnen.)*"
    ]
   },
   {
@@ -953,17 +966,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Exkurs: Debugging\n",
+    "### 3.12 Debugging\n",
     "\n",
-    "Eine der wichtigsten Fähigkeiten, die wir gerne lernen wollen ist **Debugging**. Obwohl es manchmal frustrierend ist, ist es eine der intellektuell anspruchsvollsten, herausforderndsten und interessantesten Aspekte des Programmierens.\n",
+    "Eine der wichtigsten Fähigkeiten des Programmierens ist **Debugging**. Obwohl es manchmal frustrierend ist, ist es einer der intellektuell anspruchsvollsten, herausforderndsten und interessantesten Aspekte des Programmierens.\n",
     "\n",
     "Debugging ist wie **Detektiv spielen**: Wir haben ein paar Hinweise und wir müssen die Vorgänge und Ereignisse herausfinden, die zu den Ergebnissen geführt haben, die wir sehen.\n",
     "\n",
     "![Lupe](https://media.giphy.com/media/JUh0yTz4h931K/giphy.gif)\n",
     "\n",
-    "Debugging ist aber auch wie **experimentelle Wissenschaft**: Wenn wir erstmal eine Idee haben, was schiefgelaufen sein könnte, können wir unser Programm verändern und es noch einmal versuchen. Wenn unsere Annahme richtig war, können wir das Ergebnis unserer Veränderung vorhersagen und mit dem realen Ergebnis vergleichen. Damit kommen wir hoffentlich einem richtig funktionierendem Programm näher. Wenn unsere Annahme falsch war, müssen wir uns eine neue ausdenken. Wie schon Sherlock Holmes sagte: *\"Wenn man das Unmögliche ausgeschlossen hat, muss das, was übrig bleibt - wie unwahrscheinlich auch immer - die Wahrheit sein\"* (A. Conan Doyle, *The Sign of Four*).\n",
+    "Debugging ist aber auch wie eine **experimentelle Wissenschaft**: Wenn wir erstmal eine Idee haben, was schiefgelaufen sein könnte, können wir unser Programm verändern und es noch einmal versuchen. Wenn unsere Annahme richtig war, können wir das Ergebnis unserer Veränderung vorhersagen. Damit kommen wir hoffentlich einem richtig funktionierendem Programm näher. Wenn unsere Annahme falsch war, müssen wir uns eine neue überlegen. Wie schon Sherlock Holmes sagte: *\"Wenn man das Unmögliche ausgeschlossen hat, muss das, was übrig bleibt — wie unwahrscheinlich auch immer —, die Wahrheit sein\"* (A. Conan Doyle, *The Sign of Four*).\n",
     "\n",
-    "Für viele Menschen ist Programmieren und Debugging das gleiche. D.h., Programmieren bedeutet, dass man ein Programm solange debuggt, bis es das tut, was man möchte. Die Idee ist, dass man mit einem kleinen, einfachen Programm beginnt und solange kleine Änderungen vornimmt und debuggt, bis es tut was es soll.\n",
+    "Für einige Menschen ist Programmieren und Debugging das gleiche. Das heißt, Programmieren bedeutet, dass man ein Programm solange debuggt bis es das tut, was man möchte. Die Idee ist, dass man mit einem kleinen, einfachen - und vor allem funktionierenden- Programm beginnt und solange kleine Änderungen vornimmt bis es tut was es soll. Währenddessen muss man natürlich konstant debuggen.\n",
     "\n",
     "![Tux](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3c/TuxFlat.svg/199px-TuxFlat.svg.png)\n",
     "\n",
@@ -974,13 +987,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Glossar\n",
+    "### 3.13 Glossar\n",
     "\n",
     "Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 3 gelernt haben:\n",
     "- Funktion:\n",
     "- Funktionsdefinition:\n",
     "- Funktionsobjekt:\n",
-    "- Kopf:\n",
+    "- Kopf: Der Kopf einer Funktionsdefinition gibt den Namen der Funktion sowie alle geforderten Argumente in Klammern an und wird von einem Doppelpunkt abgeschlossen.\n",
     "- Rumpf:\n",
     "- Parameter:\n",
     "- Funktionsaufruf:\n",
@@ -1005,15 +1018,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Ãœbung\n",
+    "## 3.14 Ãœbung\n",
     "\n",
     "### Aufgabe 1\n",
-    "Diese Aufgabe kennen Sie schon vom Seminar letzte Woche. Sie haben drei Möglichkeiten:\n",
-    "1. Ãœberspringen Sie die Aufgabe, weil Sie verstanden haben, wie alles funktioniert.\n",
-    "2. Lösen Sie die Aufgabe selbständig.\n",
-    "3. 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, d.h., die Zeichenkette und so viele Leerzeichen davor ausgibt, dass der letzte Buchstabe der Zeichenkette in Spalte 70 angezeigt wird. \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",
@@ -1021,7 +1037,7 @@
     "                                                                 monty\n",
     "```\n",
     "\n",
-    "Tipp: 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"
+    "*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"
    ]
   },
   {
@@ -1049,9 +1065,12 @@
    "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. Das Erfolgserlebnis, die Lösung selber gefunden zu haben, lohnt die Mühe. Und nur so lernen Sie etwas dazu.\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",
@@ -1076,21 +1095,7 @@
     "\n",
     ".\n",
     "\n",
-    ".\n",
-    "\n",
-    "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 ... aber wie können Sie das allgemein formulieren, so dass es auch für den Parameter `s` (mit beliebiger Länge!) funktioniert?\n",
-    "11. Schließlich müssen Sie das Ergebnis noch ausgeben ... nungut, dafür gibt's die `print`-Funktion.\n",
-    "12. Alles geschafft? Geben Sie hier ihre fertige Funktion ein:"
+    "."
    ]
   },
   {
@@ -1108,15 +1113,33 @@
     "    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. Also tauschen Sie doch das Leerzeichen durch ein anderes Zeichen, z.B. einen Punkt aus.\n",
-    "- Jetzt sind es bei kurzen Wörtern recht viele Punkte ... als Abhilfe könnten Sie statt in der 70. Spalte alles rechtsbündig in der 10. Spalte ausgeben, also 70 zu 10 ändern. Dann lässt es sich leichter zählen.\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, dann sollte sie auch mit Leerzeichen und Spalte 70 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",
+    "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:"
    ]
@@ -1134,7 +1157,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Aufgabe 1+\n",
+    "#### 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):"
    ]
   },
@@ -1143,13 +1166,15 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Schreiben Sie hier Ihre Funktion"
+   ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Tipp zur Lösung: 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",
+    "*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:"
    ]
@@ -1180,13 +1205,39 @@
     "```"
    ]
   },
+  {
+   "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. Die 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 kommen vor, wie viele hinter den String?\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 können 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:"
+    "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:"
    ]
   },
   {
@@ -1218,7 +1269,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "(Tipp: 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.) "
+    "***(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.)*** "
    ]
   },
   {
@@ -1232,22 +1283,155 @@
     "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",
+    ".\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",
-    ".\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",
-    "Die Lösung finden Sie hier: http://thinkpython2.com/code/do_four.py"
+    "Schreiben Sie eine ähnliche Funktion die ein Gitter mit je 4 Reihen und Zeilen zeichnet."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Aufgabe 3\n",
+    "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",
-    "Lösen Sie die folgende Aufgabe: http://greenteapress.com/thinkpython2/html/thinkpython2004.html#hevea_default261"
+    "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"
    ]
   },
   {
@@ -1256,9 +1440,7 @@
    "source": [
     "#### Bonusaufgabe\n",
     "\n",
-    "Erinnern Sie sich noch an die folgende Aufgabe?\n",
-    "\n",
-    "1. Finden Sie einen Algorithmus zur Lösung des folgenden Problems:\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",
@@ -1268,8 +1450,11 @@
     "   - 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",
-    "2. Wie lautet die Liste für `n = 2001`?\n",
-    "3. Erklären Sie, wie Sie \"einen Fuß in die Tür bekommen\" haben.\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",
@@ -1372,9 +1557,6 @@
     "\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",
@@ -1383,11 +1565,11 @@
     "\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 (\"Fuß in der Tür\"): \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 (warum 3en?):\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",
@@ -1459,7 +1641,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (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/).  "
+    "![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/).  "
    ]
   },
   {