103 - Funktionen und Module.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Einführungskurs für das Physikalische Anfängerpraktikum der Universität Heidelberg | [Startseite](index.ipynb)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 103 - Funktionen und Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Funktionen sind die Bausteine eines Programms](#Funktionen-sind-die-Bausteine-eines-Programms)\n",
    "- [Aufgabe 1 - Mehr Primzahlen](#Aufgabe-1---Mehr-Primzahlen)\n",
    "- [Aufgabe 2 - Fakultät](#Aufgabe-2---Fakultät)\n",
    "- [Funktionen aus Modulen importieren](#Funktionen-aus-Modulen-importieren)\n",
    "- [Aufgabe 3 - Gaussian](#Aufgabe-3---Gaussian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir können nun bereits Variablen setzen und _control flow_ Anweisungen geben um kleine Programme zu schreiben. Damit können wir schon vieles berechnen! Wenn wir jedoch komplexere Berechnungen ausführen möchten, kann ein Programm schnell sehr lang und unleserlich werden. Eine wichtige Regel in der Programmierung ist es daher, **Wiederholung zu vermeiden**. Dazu definieren wir wiederverwendbare **Funktionen** und verwenden schon vorhandene Funktionalität aus **Modulen**.\n",
    "\n",
    "## Funktionen sind die Bausteine eines Programms\n",
    "\n",
    "Eine Funktion ist ein Codeblock, der eine abgeschlossene Aufgabe erfüllt. Funktionen haben immer einen **Namen**, können **Argumente** annehmen und **Rückgabewerte** zurückgeben. In Python haben Funktionen folgende Syntax:\n",
    "\n",
    "```python\n",
    "def function_name(arguments):\n",
    "    # code here\n",
    "    return values\n",
    "```\n",
    "\n",
    "Beachtet wieder die Abgrenzung des Codeblocks durch Einrückung, wie wir es bereits bei `if`-Abfragen und Schleifen kennengelernt haben.\n",
    "\n",
    "Ist die Funktion definiert, können wir sie mit folgender Syntax aufrufen:\n",
    "\n",
    "```python\n",
    "function_name(arguments)\n",
    "```\n",
    "\n",
    "Mit Funktionen können wir ein komplexes Problem in lösbare Teilprobleme zerlegen, die wir dann zu einem vollständigen Programm zusammensetzen.\n",
    "\n",
    "> **Beispiel:** Haben wir einmal eine Funktion geschrieben, die eine Liste sortiert, können wir immer darauf zurückgreifen, anstatt den Code jedes mal aufs Neue zu schreiben.\n",
    "\n",
    "> **Hinweis:** Nur weil du Code in Funktionen auslagern _kannst_ solltest du das nicht immer tun. Schreibe dann eine Funktion, wenn du dadurch Wiederholungen vermeidest oder das Programm klarer strukturierst. **Häufig ist eine Funktion dann sinnvoll, wenn du ihr einen deskriptiven Namen geben kannst.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argumente und Rückgabewerte\n",
    "\n",
    "Eine Funktion kann mehrere Argumente annehmen..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(add(1,3))\n",
    "print(add(1.,3.2))\n",
    "print(add(4,3.))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... und kann mehrere Werte zurückgeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def double_and_halve(value):\n",
    "    return value * 2, value / 2\n",
    "\n",
    "print(double_and_halve(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Rückgabewerte können wir einer oder mehreren Variablen zuweisen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "d, h = double_and_halve(5.)\n",
    "print(d)\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funktionen können **andere Funktionen aufrufen**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def do_a():\n",
    "    print(\"doing A\")\n",
    "    \n",
    "def do_b():\n",
    "    print(\"doing B\")\n",
    "    \n",
    "def do_a_and_b():\n",
    "    do_a()\n",
    "    do_b()\n",
    "    \n",
    "do_a_and_b()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Argumente können auch einen **_default_-Wert** besitzen und damit **optional** sein:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def say_hello(to_name=\"World\"):\n",
    "    print(\"Hello {}!\".format(to_name))\n",
    "say_hello()\n",
    "say_hello(\"Alice\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Argumente können in der **Reihenfolge** gegeben werden, in der die Funktion sie definiert, oder mit Angabe des Argumentnamens in beliebiger Reihenfolge:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def say_hello(to_name=\"World\", my_name=None):\n",
    "    if my_name is None:\n",
    "        print(\"Hello {}!\".format(name))\n",
    "    else:\n",
    "        print(\"Hello {}! My name is {}.\".format(to_name, my_name))\n",
    "say_hello(\"Alice\", \"Bob\")\n",
    "say_hello(my_name=\"Bob\", to_name=\"Alice\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 1 - Mehr Primzahlen\n",
    "\n",
    "Definiere eine Funktion mit dem Namen `is_prime`, die eine Zahl annimmt und `True` zurückgibt wenn die Zahl eine Primzahl ist, bzw. `False` wenn nicht.\n",
    "\n",
    "Kopiere dazu deinen Code um Primzahlen zu finden von zuvor und verändere ihn entsprechend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "nbgrader": {
     "grade": false,
     "grade_id": "103-1-sol",
     "locked": false,
     "solution": true
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def is_prime(n):\n",
    "    for m in range(2, n):\n",
    "        if n % m == 0:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "103-1-test",
     "locked": true,
     "points": 1,
     "solution": false
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_true, assert_false\n",
    "try:\n",
    "    is_prime\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Funktion mit dem Namen 'is_prime'. Stelle sicher, dass deine Funktion so benannt ist.\")\n",
    "assert_true(is_prime(47), \"Die Zahl 47 sollte eine Primzahl sein. Prüfe den Code deiner Funktion.\")\n",
    "assert_false(is_prime(48), \"Die Zahl 48 sollte _keine_ Primzahl sein. Prüfe den Code deiner Funktion.\")\n",
    "print(\"Klappt.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 2 - Fakultät\n",
    "\n",
    "Schreibe eine Funktion mit dem Namen `factorial`, die eine Zahl annimmt und die Fakultät `n! = n*(n-1)*...*3*2*1` dieser Zahl zurückgibt.\n",
    "\n",
    "**Hinweis:** Du kannst zunächst versuchen, die Aufgabe mit einer Schleife zu lösen. Funktionen können sich jedoch auch selbst aufrufen (sog. _rekursive_ Funktionen). Versuche eine Funktion zu schreiben, die _keine Schleife_ verwendet!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "nbgrader": {
     "grade": false,
     "grade_id": "103-2-sol",
     "locked": false,
     "solution": true
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n==1:\n",
    "        return n\n",
    "    return n * factorial(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "103-2-test",
     "locked": true,
     "points": 1,
     "solution": false
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_equal\n",
    "try:\n",
    "    factorial\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Funktion mit dem Namen 'factorial'. Stelle sicher, dass deine Funktion so benannt ist.\")\n",
    "assert_equal(factorial(1), 1, \"1! sollte 1 ergeben. Prüfe den Code deiner Funktion.\")\n",
    "assert_equal(factorial(2), 2, \"2! sollte 2 ergeben. Prüfe den Code deiner Funktion.\")\n",
    "assert_equal(factorial(5), 120, \"5! sollte 120 ergeben. Prüfe den Code deiner Funktion.\")\n",
    "print(\"🙌 Funktioniert!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Einzeilige `lambda`-Funktionen sind praktisch für Mathematik\n",
    "\n",
    "Mit der `lambda`-Funktionssyntax können wir Funktionen in nur einer Zeile definieren:\n",
    "\n",
    "```python\n",
    "function_name = lambda arguments: return_value\n",
    "```\n",
    "\n",
    "Das ist für mathematische Funktionen häufig sehr praktisch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "linear = lambda x, a, b: a * x + b\n",
    "linear(0, a=1, b=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variablen sind dort verfügbar, wo sie definiert wurden\n",
    "\n",
    "Argumente von Funktionen und Variablen, die im Codeblock der Funktion definiert wurden, sind nur innerhalb der Funktion verfügbar (**_local scope_**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def do_something():\n",
    "    local_var = 1 # Diese Variable ist innerhalb der Funktion definiert...\n",
    "# ... und ist außerhalb nicht verfügbar:\n",
    "print(local_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variablen, die zum Zeitpunkt des Funktionsaufrufs außerhalb der Funktion definiert sind, sind ebenfalls in der Funktion verfügbar (**_global scope_**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "PI = 3.14 # Diese Variable ist global definiert...\n",
    "# ...und kann innerhalb von Funktionen verwendet werden:\n",
    "degrees_to_radians = lambda degrees: degrees / 180 * PI\n",
    "degrees_to_radians(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Verwende in Funktionen nur solche Variablen aus dem _global scope_, die während der Ausführung des Programms konstant bleiben.** Wenn die Funktion Input-Parameter benötigt solltest du sie der Funktion immer als Argumente übergeben.\n",
    "\n",
    "> Per Konvention schreiben wir Konstanten in Python in Großbuchstaben wie `PI`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lokale Variablen werden bevorzugt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn eine Variable sowohl global als auch lokal definiert ist, wird die lokale Variable bevorzugt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "def show_var():\n",
    "    a = 2\n",
    "    print(a)\n",
    "show_var() # Hier wird die lokale Variable verwendet...\n",
    "print(a) # ... und hier die Globale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen aus Modulen importieren"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die beruhigende Nachricht ist: viele Probleme wurden schon gelöst. Für häufige Aufgaben, wie bspw. das Sortieren von Listen, existieren sogar hochoptimierte und getestete Lösungen, die wir tunlichst verwenden sollten, anstatt unsere eigene zu schreiben!\n",
    "\n",
    "Abgesehen von einigen grundlegenden Datentypen und Funktionen wie `print` oder `len` sind diese Funktionen nicht in der Python Standard Library enthalten sondern in **Modulen** ausgelagert. Mit der folgenden Syntax können wir ein Modul **importieren**, um auf die enthaltenen Funktionen zugreifen zu können:\n",
    "\n",
    "```python\n",
    "import module\n",
    "module.function_name()\n",
    "```\n",
    "\n",
    "Häufig verwendeten Modulen können wir einen abgekürzten Namen geben:\n",
    "\n",
    "```python\n",
    "import module as m\n",
    "m.function_name()\n",
    "```\n",
    "\n",
    "Wir können auch nur einzelne Funktionen eines Moduls importieren:\n",
    "\n",
    "```python\n",
    "from module import function_name\n",
    "function_name()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anstatt die Funktion `factorial` aus der obigen Aufgabe selbst zu schreiben, können wir nun einfach die gleichnamige Funktion aus dem Modul `math` verwenden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.factorial(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Hinweis: Um herauszufinden welche Funktionen ein Modul zur Verfügung stellt, kannst du wieder die `<TAB>`-Vervollständigung im Jupyter Notebook verwenden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import math # Importiere das Modul, indem du diese Zelle ausführst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#math.<TAB> # Entferne das '#'-Symbol und drücke die <TAB>-Taste nach dem Punkt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die `from`-`import`-Syntax ist insbesondere für mathematische Ausdrücke hilfreich, sodass wir das Modul nicht immer schreiben müssen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from math import cos, sin\n",
    "from math import pi as PI\n",
    "x = lambda r, phi, theta: r * cos(phi) * sin(theta)\n",
    "x(1, 0, PI/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module bieten vielseitige Funktionalität"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neben eingebauten Modulen wie `math` haben Python-Entwickler eine Vielzahl von Modulen für jeden Anwendungsbereich geschrieben. So können wir mit wenigen Zeilen Code äußerst komplexe Programme schreiben.\n",
    "\n",
    "> Beispielsweise lesen wir mit `numpy` unseren Datensatz ein, berechnen mit `scipy` einen Fit und plotten beides mit `matplotlib`. Den Umgang mit diesen Modulen lernen wir im nächsten Kapitel.\n",
    "\n",
    "Funktionen zur Berechnung von Mittelwert und Standardabweichung stellt bspw. `numpy` zur Verfügung:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "li = [1,2,7,3,1,3]\n",
    "np.mean(li), np.std(li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Es gibt natürlich nicht nur Module für die wissenschaftliche Anwendung. Python wird höchst vielseitig eingesetzt, sodass du bspw. auch\n",
    "> - eine [Webseite erstellen](http://getpelican.com),\n",
    "> - einen [Webserver programmieren](http://www.djangoproject.com) oder\n",
    "> - ein [Spiel entwickeln](http://www.pygame.org) kannst!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 3 - Gaussian\n",
    "\n",
    "Importiere die Funktionen `exp` aus `numpy` oder `math`.\n",
    "\n",
    "Definiere eine **einzeilige** (`lambda`-) Funktion mit dem Namen `gaussian`, welche die Argumente `x`, `mu`, `sigma` und `A` annimmt und den Wert $$A\\,\\mathrm{exp}\\!\\left(\\frac{(x-\\mu)^2}{2\\sigma^2}\\right)$$ zurückgibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "nbgrader": {
     "grade": false,
     "grade_id": "103-3-sol",
     "locked": false,
     "solution": true
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from numpy import exp, sqrt\n",
    "gaussian = lambda x, mu, sigma, A: A * exp((x-mu)**2/2/sigma**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "103-3-test",
     "locked": true,
     "points": 1,
     "solution": false
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_equal, assert_almost_equal\n",
    "try:\n",
    "    exp\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Funktion mit dem Namen 'exp'. Hast du die Funktion mit der `from module import function_name` Syntax importiert?\")\n",
    "try:\n",
    "    gaussian\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Funktion mit dem Namen 'gaussian'. Stelle sicher, dass deine Funktion so benannt ist.\")\n",
    "assert_equal(gaussian(x=0, mu=0, sigma=1, A=1), 1, \"gaussian(x=0, mu=0, sigma=1, A=1) sollte 1 ergeben. Prüfe den Code deiner Funktion.\")\n",
    "assert_almost_equal(gaussian(x=0, mu=1, sigma=2, A=3), 3.4, 1, \"gaussian(x=0, mu=0, sigma=1, A=1) sollte 1 ergeben. Prüfe den Code deiner Funktion.\")\n",
    "print(\"👍 Stimmt so.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Nun kannst du vollständige Programme schreiben und Funktionen aus Modulen verwenden. Erinnere dich daran - du musst nicht alles selbst schreiben! Baue lieber auf der Vorarbeit von schlauen Entwicklern auf der ganzen Welt auf, die schon hochoptimierte und getestete Lösungen für viele Probleme geschrieben haben. [giyf](http://www.google.de).\n",
    "\n",
    "In den nächsten drei Lektionen lernen wir die Grundlagen jeweils eines Moduls, das in der wissenschaftlichen Programmierung mit Python allgegenwärtig ist und beginnen mit dem Numerik-Modul _Numpy_.\n",
    "\n",
    "[Startseite](index.ipynb) | [**>> 201 - Numerik mit Numpy**](201 - Numerik mit Numpy.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}