seminar03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seminar Problemorientierte Programmierung\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",
    "- \n",
    "- \n",
    "- \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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import random, math\n",
    "import matplotlib.pyplot as pyplot\n",
    "\n",
    "random.random()\n",
    "\n",
    "pyplot.plot(range(1,4), range(2,5))"
   ]
  },
  {
   "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",
    "### Warum?\n",
    "\n",
    "- Lesbarkeit\n",
    "- Fehlersuche\n",
    "- kürzerer Programmkode\n",
    "- Wartbarkeit\n",
    "- Testbarkeit\n",
    "- Wiederverwendbarkeit\n",
    "\n",
    "It may not be clear why it is worth the trouble to divide a program into functions. There are several reasons:\n",
    "\n",
    "    Creating a new function gives you an opportunity to name a group of statements, which makes your program easier to read and debug.\n",
    "    Functions can make a program smaller by eliminating repetitive code. Later, if you make a change, you only have to make it in one place.\n",
    "    Dividing a long program into functions allows you to debug the parts one at a time and then assemble them into a working whole.\n",
    "    Well-designed functions are often useful for many programs. Once you write and debug one, you can reuse it.\n",
    "\n",
    "### Funktionsaufrufe\n",
    "\n",
    "Wir haben schon einige Funktionsaufrufe gesehen:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der Name der Funktion ist `type`, der Ausdruck innerhalb der Klammern ist das **Argument** der Funktion. Das Ergebnis dieser Funktion ist der Typ des Arguments.\n",
    "\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 wandelt 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):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('wassolldas?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit Hilfe der `int`-Funktion können wir zum Beispiel Fließkommazahlen in ganze Zahlen umwandeln:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": {},
   "source": [
    "Analog dazu können wir mit der `float`-Funktion ganze Zahlen und Zeichenketten in Fließkommazahlen umwandeln:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float('32.2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und schließlich wandelt die `str`-Funktion Zahlen in Zeichenketten um: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(3.1415923)"
   ]
  },
  {
   "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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",
    "\n",
    "Wir können ein Modul mit Hilfe der **import-Anweisung** einbinden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ab jetzt stehen uns die Funktionen des `math`-Moduls zur Verfügung und zwar als sogenanntes **Modulobjekt**. Wir können uns das Modulobjekt \"anschauen\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Darin sind Funktionen und Variablen enthalten, die in der Moduldatei definiert wurden. Um auf eine der Funktionen oder Variablen zuzugreifen, müssen wir den Namen des Moduls angeben und den Namen der Funktion (oder Variable), getrennt durch einen Punkt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sin(3)"
   ]
  },
  {
   "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",
    "\n",
    "Ein weiteres Beispiel ist der Wert von π, der im `math`-Modul definiert ist: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der Wert ist in der Variable `pi` im `math`-Modul definiert, auf die wir mit Hilfe der Punkt-Schreibweise zugreifen können."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "degrees = 120\n",
    "x = math.sin(degrees / 360.0 * 2 * math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "und sogar Funktionsaufrufe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = math.exp(math.log(2 + math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Versuchen Sie es selber einmal: Verketten Sie die Zeichenkette `\"Der Typ des Ausdrucks 27 + 3 ist: \"` mit dem Aufruf der Funktionsverknüpfung `str(type(27+3))` und geben Sie das Ergebnis mit der `print`-Funktion aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Fast überall, wo wir einen Wert verwenden können, können wir auch einen beliebigen Ausdruck einsetzen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gesamt = degrees * 20    # richtig\n",
    "20 * degrees = gesamt    # falsch!\n"
   ]
  },
  {
   "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.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def 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": [
    "- Dabei ist `def` ein Schlüsselwort, welches dem Python-Interpreter verrät, dass jetzt eine Funktionsdefinition folgt,\n",
    "- `print_lyrics` ist der Name der Funktion (es gelten die gleichen Regeln wie für Variablennamen: nur Buchstaben, Zahlen und Unterstrich und keine Zahlen am Anfang des Namens),\n",
    "- 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",
    "\n",
    "Wenn wir das alles beachtet und richtig gemacht haben (was am Anfang wohl kompliziert aussieht), dann können wir die Funktion aufrufen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_lyrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dazu müssen wir nur den Namen der Funktion schreiben, gefolgt von den beiden Klammern. \n",
    "\n",
    "Exkurs: Übrigens wird durch die Definition einer Funktion ein sogenanntes **Funktionsobjekt** erzeugt, dessen Typ wir uns anschauen können:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(print_lyrics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das Objekt trägt den Namen der Funktion und ist vom Typ `function`. \n",
    "\n",
    "Sobald wir eine Funktion definiert haben, können wir diese in anderen Funktionen verwenden. Wir könnten zum Beispiel eine Funktion schreiben, die unsere `print_lyrics`-Funktion zweimal aufruft. Implementieren Sie diese Funktion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def repeat_lyrics():\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und rufen Sie die neu definierte Funktion jetzt auf:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definition von Funktionen und deren Aufruf\n",
    "\n",
    "Schauen wir uns noch einmal an, was wir gerade programmiert haben:\n",
    "\n",
    "```python\n",
    "def print_lyrics():\n",
    "    print(\"Jetzt fahr'n wir über'n See, über'n See,\")\n",
    "    print(\"            jetzt fahr'n wir über'n See\")\n",
    "\n",
    "def repeat_lyrics():\n",
    "    print_lyrics()\n",
    "    print_lyrics()\n",
    "\n",
    "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",
    "\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",
    "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_lyrics():\n",
    "    print(\"Jetzt fahr'n wir über'n See, über'n See,\")\n",
    "    print(\"            jetzt fahr'n wir über'n See\")\n",
    "\n",
    "def repeat_lyrics():\n",
    "    print_lyrics()\n",
    "    print_lyrics()\n",
    "\n",
    "repeat_lyrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verschieben Sie den Aufruf jetzt wieder ans Ende und vertauschen Sie die Reihenfolge der beiden Funktionsdefinitionen. Was passiert dabei?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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",
    "\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",
    "\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",
    "\n",
    "![Kontrollfluss](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/control_flow_function.png)\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 wo zurückgesprungen werden muss. \n",
    "\n",
    "Wenn wir also ein Programm zu verstehen versuchen, ist es manchmal hilfreich, 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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",
    "Innerhalb einer Funktion werden die Argumente Variablen zugewiesen. Diese speziellen Variablen werden **Parameter** genannt. Schauen wir uns eine Funktion an, die ein Argument erwartet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_twice(wert):\n",
    "    print(wert)\n",
    "    print(wert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktion weist das übergebene Argument dem Parameter `wert` zu. Wenn die Funktion aufgerufen wird, gibt Sie den Wert von `wert` zweimal mit Hilfe der `print`-Funktion aus.\n",
    "\n",
    "Diese Funktion können wir jetzt mit beliebigen Werten aufrufen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_twice('Film')\n",
    "print_twice(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Regeln zur Verknüpfung gelten auch hier: statt eines Wertes können wir auch einen Ausdruck übergeben:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_twice('Film' * 2)\n",
    "print_twice(math.cos(math.pi))"
   ]
  },
  {
   "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",
    "\n",
    "Wir können auch eine Variable als Argument übergeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'Gähn'\n",
    "print_twice(text)"
   ]
  },
  {
   "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",
    "- innerhalb dieser Funktion heißt der Wert `wert`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cat_twice(part1, part2):\n",
    "    cat = part1 + part2\n",
    "    print_twice(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktion erwartet zwei Argumente, verkettet sie und gibt das Ergebnis zweimal aus. Testen wir das mal:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teil1 = 'Holleri du dödel di '\n",
    "teil2 = 'diri diri dudel dö'\n",
    "cat_twice(teil1, teil2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nachdem `cat_twice` ausgeführt wurde, wird die lokale Variable `cat` zerstört. Wenn wir versuchen darauf zuzugreifen, erhalten wir eine Fehlermeldung:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameter sind auch lokal. Außerhalb von `print_twice` können wir nicht auf `wert` zugreifen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(wert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stapel-Diagramme\n",
    "\n",
    "Um den Überblick zu behalten, wo welche Variable genutzt werden kann, ist es manchmal hilfreich, ein sogenanntes **Stapel-Diagramm** (Englisch: *stack diagram*) zu zeichnen:\n",
    "\n",
    "![Stapel-Diagramm](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/stack_diagram.png)\n",
    "\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 eine **Box** (Englisch: *frame*) repräsentiert: links neben der Box erscheint der Name der Funktion und innerhalb der Box die Parameter und Variablen und die Werte, die ihnen zugewiesen wurden.\n",
    "\n",
    "Die Boxen 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 die oberste Box 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",
    "\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",
    "\n",
    "Wenn wir z.B. versuchen, `cat` innerhalb von `print_twice` aufzurufen, bekommen wir einen `NameError`. Probieren Sie es aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_twice(wert):\n",
    "    print(cat)\n",
    "    print(wert)\n",
    "    print(wert)\n",
    "\n",
    "cat_twice(\"eins\", \"zwei\")"
   ]
  },
  {
   "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. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reparieren wir das lieber mal wieder, damit wir die Funktion `print_twice` später noch verwenden können:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_twice(wert):\n",
    "    print(wert)\n",
    "    print(wert)"
   ]
  },
  {
   "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_twice(\"Hallo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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",
    "\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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = math.cos(4)\n",
    "goldener_schnitt = (math.sqrt(5) + 1)/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn wir eine Funktion mit Rückgabewert hier aufrufen, gibt uns Jupyter den Rückgabewert aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sqrt(5)"
   ]
  },
  {
   "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",
    "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`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = print_twice('Bing')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der wert `None` ist nicht das selbe wie die Zeichenkette `'None'`, sondern ein spezieller Wert mit eigenem Typ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(radius):\n",
    "    a = math.pi * radius**2\n",
    "    return a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktion erhält als Argument einen Wert, der dem Parameter `radius` zugewiesen wird. Innerhalb wird dieser Wert verwendet, um eine Berechnung durchzuführen. Das Ergebnis der Berechnung wird der lokalen Variablen `a` zugewiesen, die schließlich in der letzten Zeile mittels `return a` zurückgegeben wird. Wenn wir jetzt die Funktion aufrufen, erhalten wir einen Wert zurück:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flaeche = area(3)\n",
    "print(flaeche)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir werden uns Funktionen mit Rückgabewert später noch genauer anschauen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exkurs: 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",
    "\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",
    "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 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",
    "\n",
    "Zum Beispiel ist Linux ein Betriebssystem, was auf Millionen von Rechnern verwendet wird und Millionen von Codezeilen enthält, aber es begann als ein einfaches Programm welches der finnische Student Linus Torvalds geschrieben hat, um den Intel 386 Prozessor besser zu verstehen. Laut Larry Greenfield war einer der ersten Versuche von Linus ein Programm, welches abwechselnd \"AAAA\" und \"BBBB\" ausgab. Daraus wurde später Linux. (*The Linux Users’ Guide Beta Version 1*). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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",
    "- Rumpf:\n",
    "- Parameter:\n",
    "- Funktionsaufruf:\n",
    "- Argument:\n",
    "- 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": [
    "### Übung\n",
    "\n",
    "### Aufgabe 1\n",
    "Diese Aufgabe kennen Sie schon vom Seminar letzte Woche. Sie haben drei Möglichkeiten:\n",
    "1. Übersprinen 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",
    "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",
    "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"
   ]
  },
  {
   "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')\n",
    "right_justify('python')\n",
    "right_justify('life of Brian')\n",
    "# (und testen Sie die Funktion zwischendurch immer mal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "spoiler\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",
    ".\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. Jetzt wo Sie (hoffentlich) 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",