seminar03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 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",
    "\n",
    "\n",
    "\n",
    "**Bevor Sie mit diesem Notebook starten, sollten Sie wiederholen, was Sie im letzten Notebook gelernt haben. Gehen Sie zurück und schauen Sie sich mindestens das Glossar an und wiederholen Sie die dort genannten Begriffe.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Inhalt<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Ihre-Lernziele\" data-toc-modified-id=\"Ihre-Lernziele-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Ihre Lernziele</a></span></li><li><span><a href=\"#Exkurs:-Was-mir-an-Python-gefällt\" data-toc-modified-id=\"Exkurs:-Was-mir-an-Python-gefällt-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Exkurs: Was mir an Python gefällt</a></span></li><li><span><a href=\"#Warum?\" data-toc-modified-id=\"Warum?-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Warum?</a></span></li><li><span><a href=\"#Funktionsaufrufe\" data-toc-modified-id=\"Funktionsaufrufe-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Funktionsaufrufe</a></span></li><li><span><a href=\"#Mathematische-Funktionen\" data-toc-modified-id=\"Mathematische-Funktionen-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Mathematische Funktionen</a></span></li><li><span><a href=\"#Verknüpfung\" data-toc-modified-id=\"Verknüpfung-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Verknüpfung</a></span></li><li><span><a href=\"#Neue-Funktionen-hinzufügen\" data-toc-modified-id=\"Neue-Funktionen-hinzufügen-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Neue Funktionen hinzufügen</a></span></li><li><span><a href=\"#Definition-von-Funktionen-und-deren-Aufruf\" data-toc-modified-id=\"Definition-von-Funktionen-und-deren-Aufruf-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Definition von Funktionen und deren Aufruf</a></span></li><li><span><a href=\"#Kontrollfluss\" data-toc-modified-id=\"Kontrollfluss-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>Kontrollfluss</a></span></li><li><span><a href=\"#Parameter-und-Argumente\" data-toc-modified-id=\"Parameter-und-Argumente-10\"><span class=\"toc-item-num\">10&nbsp;&nbsp;</span>Parameter und Argumente</a></span></li><li><span><a href=\"#Variablen-und-Parameter-sind-lokal\" data-toc-modified-id=\"Variablen-und-Parameter-sind-lokal-11\"><span class=\"toc-item-num\">11&nbsp;&nbsp;</span>Variablen und Parameter sind lokal</a></span></li><li><span><a href=\"#Stapel-Diagramme\" data-toc-modified-id=\"Stapel-Diagramme-12\"><span class=\"toc-item-num\">12&nbsp;&nbsp;</span>Stapel-Diagramme</a></span></li><li><span><a href=\"#Funktionen-mit-Rückgabewert\" data-toc-modified-id=\"Funktionen-mit-Rückgabewert-13\"><span class=\"toc-item-num\">13&nbsp;&nbsp;</span>Funktionen mit Rückgabewert</a></span></li><li><span><a href=\"#Exkurs:-Eigene-Funktionen-mit-Rückgabewert\" data-toc-modified-id=\"Exkurs:-Eigene-Funktionen-mit-Rückgabewert-14\"><span class=\"toc-item-num\">14&nbsp;&nbsp;</span>Exkurs: Eigene Funktionen mit Rückgabewert</a></span></li><li><span><a href=\"#Debugging\" data-toc-modified-id=\"Debugging-15\"><span class=\"toc-item-num\">15&nbsp;&nbsp;</span>Debugging</a></span></li><li><span><a href=\"#Glossar\" data-toc-modified-id=\"Glossar-16\"><span class=\"toc-item-num\">16&nbsp;&nbsp;</span>Glossar</a></span></li><li><span><a href=\"#Übung\" data-toc-modified-id=\"Übung-17\"><span class=\"toc-item-num\">17&nbsp;&nbsp;</span>Übung</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-17.1\"><span class=\"toc-item-num\">17.1&nbsp;&nbsp;</span>Aufgabe 1</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1a\" data-toc-modified-id=\"Aufgabe-1a-17.1.1\"><span class=\"toc-item-num\">17.1.1&nbsp;&nbsp;</span>Aufgabe 1a</a></span><ul class=\"toc-item\"><li><span><a href=\"#Lückentext\" data-toc-modified-id=\"Lückentext-17.1.1.1\"><span class=\"toc-item-num\">17.1.1.1&nbsp;&nbsp;</span>Lückentext</a></span></li></ul></li><li><span><a href=\"#Aufgabe-1b\" data-toc-modified-id=\"Aufgabe-1b-17.1.2\"><span class=\"toc-item-num\">17.1.2&nbsp;&nbsp;</span>Aufgabe 1b</a></span></li></ul></li><li><span><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-17.2\"><span class=\"toc-item-num\">17.2&nbsp;&nbsp;</span>Aufgabe 2</a></span></li><li><span><a href=\"#Aufgabe-3\" data-toc-modified-id=\"Aufgabe-3-17.3\"><span class=\"toc-item-num\">17.3&nbsp;&nbsp;</span>Aufgabe 3</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-3.1\" data-toc-modified-id=\"Aufgabe-3.1-17.3.1\"><span class=\"toc-item-num\">17.3.1&nbsp;&nbsp;</span>Aufgabe 3.1</a></span></li><li><span><a href=\"#Aufgabe-3.2\" data-toc-modified-id=\"Aufgabe-3.2-17.3.2\"><span class=\"toc-item-num\">17.3.2&nbsp;&nbsp;</span>Aufgabe 3.2</a></span></li></ul></li><li><span><a href=\"#Bonusaufgabe\" data-toc-modified-id=\"Bonusaufgabe-17.4\"><span class=\"toc-item-num\">17.4&nbsp;&nbsp;</span>Bonusaufgabe</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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",
    "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": [
    " \n",
    "## Warum?\n",
    "\n",
    "Warum ist es sinnvoll, ein Programm in Funktionen aufzuteilen?\n",
    "Hier einige Beispiele: \n",
    "\n",
    "- **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 setzen.\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",
    "\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 — \n",
    "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 Gleitkommazahlen in ganze Zahlen umwandeln. Allerdings wird dabei der Teil hinter dem Dezimalpunkt abgeschnitten und nicht gerundet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(32.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analog dazu können wir mit der `float`-Funktion ganze Zahlen und Zeichenketten in Gleitkommazahlen 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": [
    "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 den 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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tipp**: Nutzen Sie [Pythontutor](http://pythontutor.com), um Ihren Code nachvollziehen zu können und Fehler zu finden!"
   ]
  },
  {
   "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",
    "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 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 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": [
    "import math \n",
    "\n",
    "# ohne Verknüpfung\n",
    "degrees = 120\n",
    "radiant = degrees / 360.0 * 2 * math.pi\n",
    "x = math.sin(radiant)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "# mit Verknüpfung\n",
    "degrees = 120\n",
    "x = math.sin(degrees / 360.0 * 2 * math.pi)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "und sogar Funktionsaufrufe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "# ohne Verknüpfung\n",
    "x_1 = 2 + math.pi\n",
    "x_2 = math.log(x_1)\n",
    "x = math.exp(x_2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "# ohne Verknüpfung\n",
    "x = math.exp(math.log(2 + math.pi))\n",
    "print(x)"
   ]
  },
  {
   "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 mehr.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neue Funktionen hinzufügen\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.lib.display import YouTubeVideo\n",
    "YouTubeVideo('https://www.youtube.com/watch?v=LQCfN5HS9xI&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=18')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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:"
   ]
  },
  {
   "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, 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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_lyrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "Ü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 Sie 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",
    "\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": [
    "***Achtung:** 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?"
   ]
  },
  {
   "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 und der Reihe nach ausgeführt; von oben nach unten.\n",
    "\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 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",
    "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",
    "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",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.lib.display import YouTubeVideo\n",
    "YouTubeVideo('https://www.youtube.com/watch?v=af9ORp1Pty0&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=19')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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; anstelle eines Wertes können wir 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!*** \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`."
   ]
  },
  {
   "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; das heißt 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, 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 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 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:"
   ]
  },
  {
   "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 — 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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_twice(\"Hallo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen mit Rückgabewert\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.lib.display import YouTubeVideo\n",
    "YouTubeVideo('https://www.youtube.com/watch?v=ehSP-sYoKCY&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=20')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "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": [
    "import math\n",
    "\n",
    "math.sqrt(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aber wenn wir sonst nichts damit machen, geht der Wert verloren. Wir berechnen also etwas und 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",
    "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": [
    "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`:"
   ]
  },
  {
   "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 keine Zeichenkette, sondern ein spezieller Wert mit eigenem Typ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Exkurs: Eigene Funktionen mit Rückgabewert\n",
    "\n",
    "Dieser Abschnitt taucht nicht im englischen Python-Kurs auf und gibt einen Ausblick auf ein späteres Kapitel. Wir können selbst eine Funktion mit Rückgabewert schreiben, indem wir das Schlüsselwort `return` verwenden:\n"
   ]
  },