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.\n",
    "\n",
    "Es ist sehr leicht, Ergebnisse mit Hilfe eines Plots darzustellen und auch mathematische Funktionen können professionell geplottet werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import math\n",
    "import matplotlib.pyplot as pyplot\n",
    "\n",
    "# sin(x) und cos(x) zwischen 0 und 2pi\n",
    "x = [xx/10 for xx in range(0,int(2*math.pi*10))]\n",
    "sinx = [math.sin(xx) for xx in x]\n",
    "cosx = [math.cos(xx) for xx in x]\n",
    "pyplot.plot(x, sinx, label='sin(x)')\n",
    "pyplot.plot(x, cosx, label='cos(x)')\n",
    "pyplot.grid(linestyle=\"dashed\")\n",
    "pyplot.legend()"
   ]
  },
  {
   "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",
    "Warum ist es sinnvoll, ein Programm in Funktionen aufzuteilen?\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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionsaufrufe\n",
    "\n",
    "Wir haben schon einige Funktionsaufrufe gesehen:"
   ]
  },
  {
   "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 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": [
    "Hilfreicher ist es allerdings, das Modulobjekt der Funktion `help` zu übergeben: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im Modulobjekt 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 Variablen `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": "markdown",
   "metadata": {},
   "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!"
   ]
  },
  {
   "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, 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 `repeat_lyrics` 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",
    "\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": [
    "*(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",
    "\n",
    "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.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",
    "\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."
   ]
  },
  {
   "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 `cat_twice` können wir auf `part1` nicht zugreifen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(part1)"
   ]
  },
  {
   "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.svg)\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 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",
    "\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",
    "\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",
    "Schreiben Sie einen Ausdruck auf, der die Funktion `math.sqrt` verwendet und weisen Sie das Ergebnis einer Variablen zu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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`:"
   ]
  },
  {
   "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 der Funktion 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": [
    "Schreiben Sie die Funktion `area_triangle` die den Flächeninhalt eines Dreieckes berechnet und zurückgibt. Das Dreieck sei durch die Längen `a, b` und `c` seiner drei Seiten gegeben. Verwenden Sie dazu den [Satz des Heron](https://de.wikipedia.org/wiki/Satz_des_Heron), wonach der Flächeninhalt gleich \n",
    "\n",
    "\\begin{equation}\n",
    "\\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area_triangle(a, b, c):\n",
    "    # Formulieren Sie hier den Rumpf der Funktion\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testen Sie Ihr Ergebnis mit einem Dreieck mit den Seitenlängen 3, 4 und 5. Der Flächeninhalt sollte 6 ergeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(area_triangle(3, 4, 5))"
   ]
  },
  {
   "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",
    "![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",
    "\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",
    "![Tux](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3c/TuxFlat.svg/199px-TuxFlat.svg.png)\n",
    "\n",
    "Ein Beispiel ist **Linux**: ein Betriebssystem, welches auf Millionen von Rechnern verwendet wird und Millionen von Codezeilen enthält. Linux 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",