python_4.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Programmieren mit Python 3: Funktionen und Module"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Wiederholung</h3>\n",
      "<ul>\n",
      "<li>Bedingungen geben entweder den Wert True oder False zur\u00fcck, z.B. 5 < 8  oder \"nie\" in \"Knie\"\n",
      "<li>Modulo berechnet den Rest einer Division, z.B. ergibt  22 % 5 gleich 2\n",
      "<li>Bedingungen k\u00f6nnen mit or und and zu komplexen Ausdr\u00fccken verkn\u00fcpft werden\n",
      "<li>Bedingte Verzweigungen werden so formuliert:<br/>\n",
      "<code>if &lt;bedingung>:\n",
      "    code\n",
      "[elif &lt;bedingung>: \n",
      "    code]\n",
      "...\n",
      "[else:\n",
      "    code]\n",
      "</code>\n",
      "<p>Der Teil in [ ] - Klammern ist optional</p>\n",
      "<li>Mit input(str) kann man auf der Kommandozeile Benutzereingaben abfragen."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Wiederholung II</h3>\n",
      "<ul>\n",
      "<li>while - Schleifen werden so formuliert:<br/>\n",
      "<code>while &lt;bedingung>:\n",
      "    code</code><br/>\n",
      "Sie werden solange ausgef\u00fchrt, wie die Bedingung wahr ist. Achtung vor Endlosschleifen\n",
      "<li>F\u00fcr alles Listenartige verwendet man aber besser for - Schleifen:<br/>\n",
      "<code>\n",
      "for x in <List>:\n",
      "    code</code>\n",
      "<li>Mit der Funktion range(n) kann man eine Liste von Zahlen von 0 bis n erzeugen. Mit range(n,m) erzeugt man eine Liste, die bei n anf\u00e4ngt und bis m reicht. Sie wird h\u00e4ufig in for-Schleifen verwendet:   <br/>\n",
      "<code>\n",
      "for i in range (3):\n",
      "    print (i)</code>\n",
      "<li>Schleifen und bedingte Verzweigungen k\u00f6nnen beliebig verschachtelt werden.    \n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "    "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Musterl\u00f6sung f\u00fcr die Hausaufgaben</h3>\n",
      "<p> Sie haben eine Liste mit 5 Elementen: sa = [1,2,3,4]\n",
      "<p> 1) Schreiben Sie ein Skript, das jedes Element mit jedem anderen vergleicht (1 -> 3 und 3 -> 1), aber nicht mit sich selbst.<br/> \n",
      "Der Output soll so aussehen: <br/> \n",
      "<code>comparing 1 -> 2\n",
      "comparing 1 -> 3 \n",
      "comparing 1 -> 4 \n",
      "comparing 2 -> 1 \n",
      "usw.</code>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sa = [1,2,3,4]\n",
      "c = 0\n",
      "d = 0\n",
      "while c < len(sa):\n",
      "    while d < len(sa):\n",
      "        if c != d:\n",
      "            print (\"comparing \", sa[c], \" -> \", sa[d])\n",
      "        d += 1\n",
      "    d = 0\n",
      "    c += 1\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "comparing  1  ->  2\n",
        "comparing  1  ->  3\n",
        "comparing  1  ->  4\n",
        "comparing  2  ->  1\n",
        "comparing  2  ->  3\n",
        "comparing  2  ->  4\n",
        "comparing  3  ->  1\n",
        "comparing  3  ->  2\n",
        "comparing  3  ->  4\n",
        "comparing  4  ->  1\n",
        "comparing  4  ->  2\n",
        "comparing  4  ->  3\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sa = [1,2,3,4]\n",
      "for c in range(len(sa)):\n",
      "    for d in range(len(sa)):\n",
      "        if c != d:\n",
      "            print (\"comparing \", sa[c], \" -> \", sa[d])"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "comparing  1  ->  2\n",
        "comparing  1  ->  3\n",
        "comparing  1  ->  4\n",
        "comparing  2  ->  1\n",
        "comparing  2  ->  3\n",
        "comparing  2  ->  4\n",
        "comparing  3  ->  1\n",
        "comparing  3  ->  2\n",
        "comparing  3  ->  4\n",
        "comparing  4  ->  1\n",
        "comparing  4  ->  2\n",
        "comparing  4  ->  3\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<p>2) Schreiben Sie das Programm so um, dass jedes Element nur einmal mit jedem anderen verglichen wird (aber nicht mit sich selbst), also statt  1 -> 2 und 2 -> 1  gibt es nun nur noch eine Zeile: 1 <-> 2"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(len(sa)):\n",
      "    for j in range (i,len(sa)):        #only change: add i as a start parameter for the range object \n",
      "        if sa[i] != sa[j]:\n",
      "            print (\"comparing \", sa[i], \" <-> \", sa[j])"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "comparing  1  <->  2\n",
        "comparing  1  <->  3\n",
        "comparing  1  <->  4\n",
        "comparing  1  <->  5\n",
        "comparing  2  <->  3\n",
        "comparing  2  <->  4\n",
        "comparing  2  <->  5\n",
        "comparing  3  <->  4\n",
        "comparing  3  <->  5\n",
        "comparing  4  <->  5\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Funktionen und Module</h3>\n",
      "<p>Management von Komplexit\u00e4t. Durch\n",
      "<ul>\n",
      "<li>Modularisierung. Funktionalit\u00e4t wird in einzelnen Modulen gekapselt.\n",
      "<li>Abstraktion, so dass Wiederverwendung m\u00f6glich ist\n",
      "<li>Klare Schnittstellen zum Rest des Programms.\n",
      "</ul>\n",
      "<p>Praxis: So klein wie m\u00f6glich"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Definition einer Funktion</h3>\n",
      "<p>Eine Funktionsdefinition muss folgende Aspekte der Funktion festlegen:\n",
      "<ul>\n",
      "<li>das Befehlswort, mit dem die Funktion aufgerufen wird\n",
      "<li>die Parameter, die beim Aufruf der Funktion an die Funktion \u00fcbergeben werden (optional)\n",
      "<li>den R\u00fcckgabewert der Funktion (optional)\n",
      "</ul>\n",
      "<p>Beispiel:</p>\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Funktionsdefinitionen beginnen mit 'def'  \n",
      "#der String nach def ist das Befehlswort\n",
      "#in den Klammern stehen die Parameter der Funktion\n",
      "def add (nr1,nr2):\n",
      "    #nach der Definitionszeile folgt der Code der Funktion\n",
      "\tresult = nr1 + nr2\n",
      "    #return bestimmt den R\u00fcckgabewert der Funktion\n",
      "\treturn result\n",
      "\n",
      "#jetzt kann man die Funktion aufrufen:\n",
      "add(211,889)\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "subslide"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "1100"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Funktionen - Schritt f\u00fcr Schritt</h3>\n",
      "<code>def add (nr1,nr2):\n",
      "\tresult = nr1 + nr2\n",
      "\treturn result\n",
      "</code>\n",
      "\n",
      "<p>Was passiert nun genau beim Aufruf der Funktion?</p>\n",
      "\n",
      "<code>add(3,7)</code>\n",
      "<p>Implizit wird am Anfang der Funktion durch die Angabe der Parameter eine Zuweisung vorgenommen:</p>\n",
      "<code>nr1 = 3\n",
      "nr2 = 7</code>\n",
      "<p>D.h. die Werte 3 und 7 werden beim Aufruf der Funktion an die Variablen nr1 und nr2 gebunden.</p>\n",
      "\n",
      "<p>Dann kann das Ergebnis berechnet werden:</p>\n",
      "<code>result = nr1 + nr2 </code>\n",
      "\n",
      "<p>Und als R\u00fcckgabewert ausgegeben werden:</p>\n",
      "<code>return result</code>\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3 style=\"color:green\">Aufgaben</h3>\n",
      "<p>1) Schreiben Sie eine Funktion, der beim Aufruf ein String \u00fcbergeben wird und die als R\u00fcckgabe einen String der Form \"Dieser String hat x Zeichen\" ausgibt, wobei x die Anzahl der Zeichen im String sind.</p>\n",
      "<p>2) Mit der Methode split() kann man Zeichenketten in Listen zerlegen. Wenn s = \"Dies ist ein Satz\" ist, dann gibt s.split() als R\u00fcckgabewert die Liste [\"Dies\",\"ist\",\"ein\",\"Satz\"] aus. <br/>\n",
      "Schreiben Sie eine Funktion, die die durchschnittliche Wortl\u00e4nge einer Zeichenkette berechnet (wir ignorieren die Satzzeichen erst einmal). \n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Musterl\u00f6sung</h3>\n",
      "1) Schreiben Sie eine Funktion, der beim Aufruf ein String \u00fcbergeben wird und die als R\u00fcckgabe einen String der Form \"Dieser String hat x Zeichen\" ausgibt, wobei x die Anzahl der Zeichen im String sind."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def print_len(s):\n",
      "    return \"Dieser String hat \" + str(len(s)) + \" Zeichen.\"\n",
      "\n",
      "#test\n",
      "print_len(\"Dies ist ein kleiner Test\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 2,
       "text": [
        "'Dieser String hat 25 Zeichen.'"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>2) Schreiben Sie eine Funktion, die die durchschnittliche Wortl\u00e4nge einer Zeichenkette berechnet (wir ignorieren die Satzzeichen erst einmal). \n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def avg_word_length(s):\n",
      "    words = s.split()\n",
      "    total_len = 0\n",
      "    for w in words:\n",
      "        total_len += len(w)\n",
      "    return total_len / len(words)\n",
      "\n",
      "#test\n",
      "sent = \"Dies ist ein kleiner, aber erheblich interessanterer Test als der letzte oder so.\"\n",
      "print (\"Durchschnittliche Wortl\u00e4nge: \", avg_word_length(sent))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Durchschnittliche Wortl\u00e4nge:  5.3076923076923075\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Signatur der Funktion</h3>\n",
      "<p>Eine Funktion ist auch definiert durch die 'Signatur', d.h. die Anzahl und den Datentyp der Variablen, die ihr beim Aufruf \u00fcbergeben werden. Entsprechend dem Python-Motto m\u00fcssen Sie daf\u00fcr sorgen, dass Sie das richtig machen (es gibt kein \u00dcberpr\u00fcfung). Eine Funktion kann eine ganze Reihe von Variablen empfangen:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def calculate (add1, add2, divisor, factor):\n",
      "    return ((add1 + add2) / divisor) * factor\n",
      "\n",
      "calculate (3,6,3,12)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "36.0"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Funktionen kommentieren</h3>\n",
      "<p>Funktionen sind im Idealfall kleine, selbst\u00e4ndige Einheiten, die ein Problem l\u00f6sen. Dokumentieren Sie Ihre Funktionen!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def add (nr1, nr2):\n",
      "    \"\"\"\n",
      "    adds two numbers\n",
      "    :param: nr1: number to be added\n",
      "    :param: nr2: number to be added\n",
      "    :rtype: int\n",
      "    \"\"\"\n",
      "    return nr1 + nr2"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Scope von Variablen</h3>\n",
      "<p>Der 'Scope' einer Variablen ist ihr G\u00fcltigkeitsbereich. Wir unterscheiden zwischen globalen und lokalen Variablen. Globale Variablen sind f\u00fcr alle Funktionen zug\u00e4nglich, w\u00e4hrend lokale Variablen nur f\u00fcr die Funktionen zug\u00e4nglich sind, in  denen sie definiert wurden. Globale Variablen werden in der globalen Symboltabelle abgelegt. Lokale Variablen sind nur in einem bestimmten Kontext g\u00fcltig (z.B.dem einer Funktion oder einer Schleife)</p> \n",
      "<p>Globale Variablen sind schwierig zu kontrollieren und ihre unvorhergesehenen Ver\u00e4nderungen k\u00f6nnen sehr undurchsichtige Bugs verursachen. Vermeiden Sie sie daher, soweit es geht.<br/>\n",
      "<img src=\"files/images/scope.png\" width=\"50%\" height=\"50%\" border=\"0\"/> "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Globale Variable</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = \"hallo\"\n",
      "def foo():\n",
      "\t   print (x)\n",
      "foo()\n",
      "x = \"hi\"\n",
      "foo()\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hallo\n",
        "hi\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Lokale Variablen</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def bar():\n",
      "    y = \"Welt\"\n",
      "    print (y)\n",
      "    \n",
      "bar()\n",
      "#print(y)\n",
      "#erzeugt einen NameError: name 'y' is not defined"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Welt\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Globale und lokale Variablen</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Don't do this at home!!\n",
      "y = \"Ich\"\n",
      "def bar():\n",
      "    y = \"Welt\"\n",
      "    print (\"lokaler Wert von y: \", y)\n",
      "\n",
      "print(\"globaler Wert von y: \", y)    \n",
      "bar()\n",
      "y = \"NEU\"\n",
      "print (\"neuer globaler Wert von y: \", y)\n",
      "bar()"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "globaler Wert von y:  Ich\n",
        "lokaler Wert von y:  Welt\n",
        "neuer globaler Wert von y:  NEU\n",
        "lokaler Wert von y:  Welt\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Exkurs: by reference vs. by value</h3>\n",
      "<p>Python-Variablen enthalten Referenzen auf die Daten, nicht die Daten. Wenn Daten also \u00fcbergeben werden (etwa bei einer Zuweisung oder als Parameter beim Aufruf einer Funktion/Methode, dann werden die Verweise \u00fcbergeben und nicht Kopien der Daten angelegt!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [1, 4, 5]  ## Erzeugt eine Liste und weist sie der Variablen x zu\n",
      "y = x          ## Weist die Liste auch der Variablen y zu \n",
      "y[1] = 99      ## Ver\u00e4ndert y und x! \n",
      "print (x)\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 99, 5]\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>reference / value in einer Funktion</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def subst(x):      # definiert Funktion mit Parameter x\n",
      "\tx[0] = 99      #setzt ersten Wert der Liste auf 99\n",
      "\tprint (\"Wert von x in der Funktion: \", x)\n",
      "a = [1,2,3,4]      #definiert globale Variable a \n",
      "subst (a)          #Verwendet und ver\u00e4ndert a in der Funktion   \n",
      "print (\"Wert von a als globale Variable: \", a)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Wert von x in der Funktion:  [99, 2, 3, 4]\n",
        "Wert von a als globale Variable:  [99, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Listen kopieren</h3>\n",
      "<p>Wenn man wirklich eine unabh\u00e4ngige Kopie einer Liste braucht, dann sollte man die list Funktion verwenden:</p>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [20, 33, 15] # Erzeugt eine Liste\n",
      "y = list(x) # Erzeugt eine Kopie der Liste; Zuschreibung zu y\n",
      "y[0] = 1000 #Schreibt dem ersten Element von y einen neuen Wert zu, OHNE x zu ver\u00e4ndern\n",
      "print (x)\n",
      "print (y)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[20, 33, 15]\n",
        "[1000, 33, 15]\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Default Argumente f\u00fcr Funktionen</h3>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Man kann auch f\u00fcr Argumente Werte vorgeben, dann muss der Nutzer keine angeben, kann sie aber durch eigene \u00fcberschreiben: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def formula2 (nr1, divisor, nr2 = 3):\n",
      "\treturn (nr1 + nr2) / divisor\n",
      "\n",
      "print (formula2 (7,2))\n",
      "print (formula2 (10,4,2))\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5.0\n",
        "3.0\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Benamste Argumente beim Aufruf einer Funktion</h3>\n",
      "<p>Wenn man Funktionen verwendet, die eine Reihe von Argumenten haben, die alle Standardwerte vorgegeben haben, dann kann man beim Aufruf den Namen des Parameters angeben, um anzugeben, welche man \u00fcberschreiben will. So kann man auch die Reihenfolge der Parameter \u00e4ndern.</p>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def foo (par1=\"hello\", par2=\"all\"):\n",
      "    print (par1, par2)\n",
      "    \n",
      "foo(par2=\"world\")\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hello world\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3> &#42;args und **kwargs</h3>\n",
      "<p>Mit &#42;args in der Parameterliste einer Funktion kann man Parameter festlegen, deren Anzahl und Art man nicht kennt. Das gleiche kann man mit **kwargs f\u00fcr default parameter machen (kwargs = keyword arguments). Das ist u.a. dann n\u00fctzlich, wenn man mit dieser Funktion wiederum Funktionen aufruft, deren Parameter man nicht genau festlegen m\u00f6chte. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def formula3 (nr1,nr2,*args):\n",
      "        print (type(args))\n",
      "        if args == None:\n",
      "            return nr1+nr2\n",
      "        else:\n",
      "            result = 0\n",
      "            for i in args:\n",
      "                result += i\n",
      "        return nr1 + nr2 + result\n",
      "formula3 (2,3,4,5)\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<class 'tuple'>\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "14"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3 style=\"color:green\">Code in Funktionen zerlegen</h3>\n",
      "<p>Es ist gute Praxis, l\u00e4ngere Code-Abschnitte in die kleineren Einheiten von Funktionen zu zerlegen. Dabei spielt es auch eine Rolle, in welcher Weise sie die Funktionen wieder verwenden k\u00f6nnen und wollen. Schreiben Sie den folgenden Code so um, dass er aus Funktionen und einem Hauptteil besteht. \u00dcberlegen Sie, wie Sie ihn m\u00f6glichst weit modularisieren k\u00f6nnen:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s = \"Herr Mustermann kommt ins Haus und trifft dort Frau Musterfrau\"\n",
      "sum_wordlength = 0\n",
      "for w in s.split():\n",
      "    sum_wordlength += len(w)\n",
      "avg_wordlength = sum_wordlength / len(s.split())\n",
      "print(\"Durchschnittliche Wortl\u00e4nge: \", avg_wordlength )\n",
      "list_vowels = []\n",
      "for w in s.lower().split():\n",
      "    word_vowels = 0\n",
      "    for c in w:\n",
      "        if c in \"aeiou\":\n",
      "            word_vowels += 1\n",
      "    list_vowels.append(word_vowels)\n",
      "print(\"Durchschnittliche Vokalanzahl: \", sum(list_vowels) / len(list_vowels))\n",
      "list_consonants = []\n",
      "for w in s.lower().split():\n",
      "    word_cons = 0\n",
      "    for c in w:\n",
      "        if c in \"bcdfghjklmnpqrstvwxyz\":\n",
      "            word_cons += 1\n",
      "    list_consonants.append(word_cons)\n",
      "print(\"Durchschnittliche Konsonantenanzahl: \", sum(list_consonants) / len(list_consonants))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Durchschnittliche Wortl\u00e4nge:  5.3\n",
        "Durchschnittliche Vokalanzahl:  1.7\n",
        "Durchschnittliche Konsonantenanzahl:  3.6\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Musterl\u00f6sung</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def avg_wordlength(s):\n",
      "    sum_wordlength = 0\n",
      "    for w in s.split():\n",
      "        sum_wordlength += len(w)\n",
      "    return sum_wordlength / len(s.split())\n",
      "\n",
      "def avg_vowel(s):\n",
      "    list_vowels = []\n",
      "    for w in s.lower().split():\n",
      "        word_vowels = 0\n",
      "        for c in w:\n",
      "            if c in \"aeiou\":\n",
      "                word_vowels += 1\n",
      "        list_vowels.append(word_vowels)\n",
      "    return sum(list_vowels) / len(list_vowels)\n",
      "\n",
      "def avg_consonant (s):\n",
      "    list_consonants = []\n",
      "    for w in s.lower().split():\n",
      "        word_cons = 0\n",
      "        for c in w:\n",
      "            if c in \"bcdfghjklmnpqrstvwxyz\":\n",
      "                word_cons += 1\n",
      "        list_consonants.append(word_cons)\n",
      "    return sum(list_consonants) / len(list_consonants)\n",
      "\n",
      "s = \"Herr Mustermann kommt ins Haus und trifft dort Frau Musterfrau\"\n",
      "print(\"Durchschnittliche Wortl\u00e4nge: \", avg_wordlength(s) )\n",
      "print(\"Durchschnittliche Vokalanzahl: \", avg_vowel(s))\n",
      "print(\"Durchschnittliche Konsonantenanzahl: \", avg_consonant(s) )"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Durchschnittliche Wortl\u00e4nge:  5.3\n",
        "Durchschnittliche Vokalanzahl:  1.7\n",
        "Durchschnittliche Konsonantenanzahl:  3.6\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def count_chars(s, chars):\n",
      "    \"\"\"\n",
      "    creates a list, which represents the number of c in chars in each word of s\n",
      "    \"\"\"\n",
      "    list_chars = []\n",
      "    for w in s.lower().split():\n",
      "        word_chars = 0\n",
      "        for c in w:\n",
      "            if c in chars:\n",
      "                word_chars += 1\n",
      "        list_chars.append(word_chars)\n",
      "    return list_chars\n",
      "\n",
      "\n",
      "def avg_chars(chars):\n",
      "    \"\"\"\n",
      "    calculates average count list chars\n",
      "    \"\"\"\n",
      "    return sum(chars) / len(chars)\n",
      "\n",
      "\n",
      "def avg_wordlength(s):\n",
      "    all_chars = \"abcdefghijklmnopqrstuvwxyz\"\n",
      "    return avg_chars(count_chars(s, all_chars))\n",
      "\n",
      "\n",
      "def avg_vowel(s):\n",
      "    vowels = \"aeiou\"\n",
      "    return avg_chars(count_chars(s, vowels))\n",
      "\n",
      "\n",
      "def avg_consonant(s):\n",
      "    consonants = \"bcdfghjklmnpqrstvwxyz\"\n",
      "    return avg_chars(count_chars(s, consonants))\n",
      "\n",
      "\n",
      "a = \"Herr Mustermann kommt ins Haus und trifft dort Frau Musterfrau\"\n",
      "print(\"Durchschnittliche Wortl\u00e4nge: \", avg_wordlength(a))\n",
      "print(\"Durchschnittliche Vokalanzahl: \", avg_vowel(a))\n",
      "print(\"Durchschnittliche Konsonantenanzahl: \", avg_consonant(a))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Durchschnittliche Wortl\u00e4nge:  5.3\n",
        "Durchschnittliche Vokalanzahl:  1.7\n",
        "Durchschnittliche Konsonantenanzahl:  3.6\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Rekursion</h3>\n",
      "<p>Als Rekursion bezeichnet man den Aufruf einer Funktion durch sich selbst. Eine rekursive Funktion besteht typischerweise aus zwei Bausteinen, einem Verarbeitungsteil, der auch den Selbstaufruf enth\u00e4lt und einer Pr\u00fcfung, die feststellt, ob ein bestimmte Bedingung erreicht ist, so dass die Rekursion endet. </p>\n",
      "<p>Rekursionen funktionieren also \u00e4hnlich wie Schleifen. Wann soll man Rekursionen verwenden? Wenn man bei der Analyse des Problems feststellt, dass jede komplexere Form des Problems sich auf eine einfache L\u00f6sung des Problems zur\u00fcckf\u00fchren l\u00e4sst. Eine ausf\u00fchrlichere Behandlung von Rekursion finden Sie <a href=\"http://cs.stanford.edu/people/eroberts/courses/cs106b/chapters/05-intro-to-recursion.pdf\">hier</a>.<br/></p>\n",
      "<p>Die prinzipielle Struktur einer rekursiven Funktion sieht also so aus:</p>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if (test for simple case) == True: \n",
      "    Bereche eine einfache L\u00f6sung ohne Rekursion\n",
      "else:\n",
      "    Zerlege das Problem in Teilprobleme, die die gleiche Form haben.\n",
      "    L\u00f6se jedes Teilproblem durch rekursiven Aufruf der Funktion.\n",
      "    Setze die L\u00f6sungen f\u00fcr die Teilprobleme zusammen, um eine L\u00f6sung for das ganze Problem zu erhalten."
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Nehmen wir als Beispiel das Berechnen der Fakult\u00e4t einer Zahl:<br/>\n",
      "n! (sprich: n Fakult\u00e4t) = n &#42; n-1 &#42; n-2 ... &#42; 1\n",
      "\n",
      "z.B. 3! = 3 &#42; 2 &#42; 1  = 6\n",
      "\n",
      "Au\u00dferdem muss man wissen, dass 1! = 1. \n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def factorial(n):\n",
      "    \"\"\"\"\n",
      "    calculates factorial of n\n",
      "    \"\"\"\n",
      "    if n == 1:      #einfacher fall ohne rekursion\n",
      "        return 1\n",
      "    else:\n",
      "        result = n * factorial(n-1)   #Zerlegung: n! = n * (n-1)!   L\u00f6sung von (n-1)! durch rekursiven Aufruf der F.\n",
      "                                      #Zusammensetzung durch die Multiplikation der Einzelzahlen\n",
      "        return result\n",
      "\n",
      "    \n",
      "print(\"Fakult\u00e4t 3! ist \", factorial (3))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "6"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#um zu sehen, was hier genau passiert, f\u00fcgen wir einige print-statements ein\n",
      "def factorial(n):\n",
      "    if n == 1:\n",
      "        print (1, \"(simple)\")\n",
      "        return 1\n",
      "    else:\n",
      "        result = n * factorial(n-1)\n",
      "        print (result)\n",
      "        return result\n",
      "\n",
      "print(\"Fakult\u00e4t 3! ist \", factorial (3))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 (simple)\n",
        "2\n",
        "6\n",
        "Fakult\u00e4t 3! ist  6\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Was passiert hier? Im ersten Durchlauf ist n==3, d.h. das Programm springt von Z.3 zu Z. 6 und beginnt mit der Bearbeitung von Z.7. Es berechnet 3 *, aber um den zweiten Faktor zu berechnen, muss es wiederum die Funktion aufrufen. Der urspr\u00fcngliche Aufruf der Funktion (nennen wir ihn Funktionsaufruf[0]) wir also angehalten und auf einen Stapel gelegt.</p>\n",
      "<p>Die Berechnung des zweiten Faktors hat einen neuen Aufruf gestartet, Funktionsaufruf[1]. n ist hier == 2. Wiederum springt das Programm von Zeile 3 zu Zeile 6 und beginnt dann mit der Arbeit an Zeile 7: Es rechnet 2 * -- und auch hier muss der Programmaufruf angehalten werden, da die Funktion nun zum 3. Mal aufgerufen wird (Funktionsaufruf[2]), w\u00e4hrend Funktionsaufruf[1] ebenfalls auf den Stapel kommt.</p>\n",
      "<p>Bei Funktionsaufruf[2] ist n == 1. Deshalb verzweigt das Programm nun von Z. 3 zu Z. 4 und gibt die Zeile 1 (simple) aus - und das ist die erste Ausgabe, die wir sehen. Dann wird Funktionsaufruf[2] mit dem R\u00fcckgabewert 1 beendet.</p>\n",
      "<p>Der R\u00fcckgabewert wird an den letzten Funktionsaufruf gegeben, der auf den Stapel gewandert ist, also Funktionsaufruf[1]. Hier kann nun die Multiplikation vollzogen werden 2 * 1. Das Ergebnis wird ausgegeben und dann wird die Funktion mit dem R\u00fcckgabewert 2 beendet. </p>\n",
      "<p>Der R\u00fcckgabewert wird an den Funktionsaufruf[0], der noch auf dem Stapel liegt, gegeben. Hier kann nun wiederum weiter gerechnet werden: 3 * 2. Das Ergebnis, 6, wird ausgegeben und dann als R\u00fcckgabewert zur\u00fcckgegeben. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3 style=\"colors:green\">Aufgaben</h3> \n",
      "<p>Gegeben ist eine Liste mit Zahlen, z.B. [2,5,1,7,4].\n",
      "<p>1) Schreiben Sie eine Funktion, die die Summe einer Liste von Zahlen berechnet. Testen Sie Ihre Funktion mit der obenstehenden Liste.\n",
      "<p>2) Schreiben Sie eine Funktion, die die Summe der Zahlen berechnet und dabei Rekursion verwendet. Testen Sie Ihre Funktion mit der obenstehenden Liste."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Musterl\u00f6sung</h3>\n",
      "<p>1) Schreiben Sie eine Funktion, die die Summe einer Liste von Zahlen berechnet."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def lsum1(numbers):\n",
      "    return sum(numbers)\n",
      "\n",
      "def lsum2(numbers):\n",
      "    result = 0\n",
      "    for i in numbers:\n",
      "        result += i\n",
      "    return result\n",
      "\n",
      "s = [2,5,1,7,4]\n",
      "print (\"1. Funktion: \", lsum1(s), \"\\n2. Funktion: \", lsum2(s))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1. Funktion:  19 \n",
        "2. Funktion:  19\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<p>Schreiben Sie eine Funktion, die die Summe der Zahlen berechnet und dabei Rekursion verwendet. Testen Sie Ihre Funktion mit der obenstehenden Liste."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def lsum3(numbers):\n",
      "    if len(numbers) == 1:\n",
      "        return numbers[0]\n",
      "    else:\n",
      "        return numbers[0] + lsum3(numbers[1:])\n",
      "\n",
      "s = [2,5,1,7,4]\n",
      "print (\"Rekursive Funktion: \", lsum3(s))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Rekursive Funktion:  19\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Module</h3>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Module bieten eine weitere M\u00f6glichkeit, Programmcode in abgeschlossene Einheiten zu kapseln. Typischerweise werden zusammengeh\u00f6rige Funktionen in einem Modul versammelt. Module sind die wichtigste Organisationseinheit in Python, da alle Python-eigenen Funktionalit\u00e4ten, aber auch alle zus\u00e4tzlich herunterladbare Erweiterungen immer in Form von Modulen kommen.</p>\n",
      "<p>Module sind Python-Dateien, die Funktionen und Variablen-Definitionen enthalten.<br/>\n",
      "Name des Moduls = Name der Datei (ohne die Endung .py)<br/>\n",
      "Beispiel: <br/>\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def get_chars(instring):\n",
      "    chars = []\n",
      "    for i in instring:\n",
      "        chars.append(i)\n",
      "    return chars"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Speichern Sie diese Funktion in der Datei 'chars.py'\n",
      "<p>Nun k\u00f6nnen Sie in jedem neuen Programm diese Funktion zug\u00e4nglich machen, indem Sie einfach import Dateiname (ohne Endung!) eingeben:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import chars\n",
      "chars.get_chars(\"hallo\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "['h', 'a', 'l', 'l', 'o']"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Formate der import Anweisung<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Standardform. Hier muss der Modulname beim jeden Aufruf einer Funktion genannt werden.\n",
      "import chars\n",
      "chars.get_chars(\"hallo\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "['h', 'a', 'l', 'l', 'o']"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#import eine Funktion in den lokalen Namensraum, d.h. man kann sie nun ohne Modulnamen verwenden\n",
      "#man k\u00f6nnte auch mehrere importieren: from chars import get_chars, other_function\n",
      "from chars import get_chars\n",
      "get_chars(\"hi\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "['h', 'i']"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Man kann auch ein kurzes Alias f\u00fcr einen l\u00e4ngeren Modulnamen setzen:\n",
      "import chars as c\n",
      "c.get_chars(\"hi\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 19,
       "text": [
        "['h', 'i']"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3 style=\"color:green\">Aufgaben</h3>\n",
      "<p>1) Schreiben Sie (oder kopieren Sie von oben) Funktionen, die die Vokale und die Konsonanten eines Wortes z\u00e4hlen. Speichern Sie diese in die Datei stringtools.py\n",
      "<p>2) Verwenden Sie Ihre Funktionen in einem neuen Skript. \n",
      "<p>3) Verwenden Sie die Funktionen mit dem Alias st."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Musterl\u00f6sung</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import stringtools\n",
      "a = \"Herr Mustermann kommt ins Haus und trifft dort Frau Musterfrau\"\n",
      "print(\"Durchschnittliche Wortl\u00e4nge: \", stringtools.avg_wordlength(a))\n",
      "print(\"Durchschnittliche Vokalanzahl: \", stringtools.avg_vowel(a))\n",
      "print(\"Durchschnittliche Konsonantenanzahl: \", stringtools.avg_consonant(a))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Durchschnittliche Wortl\u00e4nge:  5.3\n",
        "Durchschnittliche Vokalanzahl:  1.7\n",
        "Durchschnittliche Konsonantenanzahl:  3.6\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import stringtools as st\n",
      "a = \"Herr Mustermann kommt ins Haus und trifft dort Frau Musterfrau\"\n",
      "print(\"Durchschnittliche Wortl\u00e4nge: \", st.avg_wordlength(a))\n",
      "print(\"Durchschnittliche Vokalanzahl: \", st.avg_vowel(a))\n",
      "print(\"Durchschnittliche Konsonantenanzahl: \", st.avg_consonant(a))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Durchschnittliche Wortl\u00e4nge:  5.3\n",
        "Durchschnittliche Vokalanzahl:  1.7\n",
        "Durchschnittliche Konsonantenanzahl:  3.6\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Docstring-Tests f\u00fcr Funktionen</h3>\n",
      "<p>Idealerweise schreiben Sie f\u00fcr jede neue Funktion gleich einen Test, dann stellen Sie sicher, dass Ihr Code auch in Zukunft gut l\u00e4uft. Es ist ganz einfach: Sie schreiben im Kommentar der Funktion den Aufruf mit Testdaten (achten Sie auf die drei >>> und das Leerzeichen danach. In die n\u00e4chste Zeile kommt der R\u00fcckgabewert, also das Ergebnis. Am Ende des Programms kommt die Anweisung, wenn diese Datei aufgerufen wird, das Modul doctest zu importieren und die Funktion testmod() auszuf\u00fchren.). Schreiben Sie das folgende ab. Rufen Sie das Skript auf. Testen Sie, was passiert, wenn Sie statt 3 eine 4 schreiben."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def count_stops(s):\n",
      "    \"\"\"\n",
      "    counts full stops in a text s.\n",
      "    >>> count_stops(\"Kurze S\u00e4tze. Immer. Nur kurze S\u00e4tze.\")\n",
      "    3\n",
      "    \"\"\"\n",
      "    fs = 0\n",
      "    for c in s:\n",
      "        if c == \".\":\n",
      "            fs += 1\n",
      "    return fs\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    import doctest\n",
      "    doctest.testmod()"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3 style=\"color:green\">Aufgabe</h3>\n",
      "1) Erstellen Sie ein Modul, das Sie mathutils nennen. Es enth\u00e4lt als einzige Funktion factorial(n), mit der man die Fakult\u00e4t einer zahl berechnen kann. Schreiben Sie einen Test f\u00fcr factorial(5). "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Pythons Standard-Module</h3>\n",
      "<p>Python kommt mit einer umfangreichen Bibliothek von Modulen, die f\u00fcr viele Probleme schon ausreichend sind (batteries included).<br/>\n",
      "<img src=\"files/images/reference.png\" height=\"50%\" width=\"50%\"/>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Pythons Standard-Module </h3>\n",
      "<p>sind nichts anderes als normale Module in einem Verzeichnis im Modulsuchpfad\n",
      "\n",
      "<img src=\"files/images/modules.png\" height=\"40%\" width=\"40%\" />\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3 style=\"color:green\">Aufgabe</h3>\n",
      "<p>Schlagen Sie in der Dokumentation nach, wie der Befehl copy aus dem Modul shutil verwendet werden kann, um Dateien zu kopieren. Testen Sie den Befehl."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Musterl\u00f6sung</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import shutil\n",
      "shutil.copy(\"stringtools.py\",\"..\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "'..\\\\stringtools.py'"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Scope von Variablen in Modulen</h3>\n",
      "<p>Module haben eine eigene globale Symboltabelle (global symbol table), d.h. man kann in einem Modul globale Variablen verwenden, ohne dass es beim Import zu Problemen kommt. \n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Modulimportsuchpfad </h3>\n",
      "<ul>\n",
      "<li>ein 'eingebautes' Modul \n",
      "<li>Datei namens Modulname.py im gleichen Verzeichnis wie das Skript\n",
      "<li>In PYTHONPATH definierte Verzeichnisse \n",
      "</ul>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Aufgaben</h3>\n",
      "<p>In dem Modul datetime gibt es das Objekt datetime. Man kann es so verwenden:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from datetime import datetime\n",
      "now = datetime.now()\n",
      "print (now)\n",
      "print (\"______\")\n",
      "print (now.year)\n",
      "print (now.month)\n",
      "print (now.day)\n",
      "print (now.hour)\n",
      "print (now.minute)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2014-05-11 19:34:15.212623\n",
        "______\n",
        "2014\n",
        "5\n",
        "11\n",
        "19\n",
        "34\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "Schreiben Sie nun ein Skript, das dem Benutzer erlaubt, sich entweder das Datum (1) oder die Uhrzeit (2) anzeigen zu lassen. Und das au\u00dferdem mit x beendet wird, ansonsten aber immer weiterl\u00e4uft."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Musterl\u00f6sung</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from datetime import datetime\n",
      "now = datetime.now()\n",
      "\n",
      "def formatted_time():\n",
      "    return str(now.hour) + \":\" + str(now.minute)    \n",
      "\n",
      "def formatted_date():\n",
      "    return str(now.day) + \".\" + str(now.month) + \".\" + str(now.year)\n",
      "\n",
      "while 1:\n",
      "    res = input(\"Bitte w\u00e4hlen Sie: [1] Datum  [2] Uhrzeit [x] Beenden  \")\n",
      "    if res == \"1\":\n",
      "        print (\"Datum: \" + formatted_date())\n",
      "    elif res == \"2\":\n",
      "        print (\"Zeit: \" + formatted_time())\n",
      "    elif res == \"x\":\n",
      "        print (\"Tsch\u00fcss\")\n",
      "        break\n",
      "    else:\n",
      "        print (\"Falsche Eingabe\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Bitte w\u00e4hlen Sie: [1] Datum  [2] Uhrzeit [x] Beenden  2\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Zeit: 19:55\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Bitte w\u00e4hlen Sie: [1] Datum  [2] Uhrzeit [x] Beenden  1\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Datum: 11.5.2014\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Bitte w\u00e4hlen Sie: [1] Datum  [2] Uhrzeit [x] Beenden  x\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Tsch\u00fcss\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3 style=\"color:green\">Hausaufgabe</h3>\n",
      "<ol>\n",
      "<li>Ein besonders bekanntes Beispiel f\u00fcr rekursive Programmierung ist die L\u00f6sung f\u00fcr die T\u00fcrme von Hanoi, das manche sicher auch als Spiel kennen. Schauen Sie sich <a href=\"https://www.cs.cmu.edu/~cburch/survey/recurse/hanoiimpl.html\">hier</a> die Aufgabenstellung und die L\u00f6sung im Pseudocode an. Setzen Sie dann den Pseudocode als Pythonskript um. (Bonus: Machen Sie eine Ascii-Ausgabe des Stands der T\u00fcrme nach jedem Zug.)\n"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}