Python_2_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": "true"
   },
   "source": [
    "# Table of Contents\n",
    " <p><div class=\"lev1 toc-item\"><a href=\"#Python-für-Fortgeschrittene-2\" data-toc-modified-id=\"Python-für-Fortgeschrittene-2-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Python für Fortgeschrittene 2</a></div><div class=\"lev2 toc-item\"><a href=\"#Funktionales-Programmieren-I\" data-toc-modified-id=\"Funktionales-Programmieren-I-11\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Funktionales Programmieren I</a></div><div class=\"lev3 toc-item\"><a href=\"#Typen-von-Programmiersprachen:\" data-toc-modified-id=\"Typen-von-Programmiersprachen:-111\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>Typen von Programmiersprachen:</a></div><div class=\"lev3 toc-item\"><a href=\"#Weitere-Merkmale-des-funktionalen-Programmierens:\" data-toc-modified-id=\"Weitere-Merkmale-des-funktionalen-Programmierens:-112\"><span class=\"toc-item-num\">1.1.2&nbsp;&nbsp;</span>Weitere Merkmale des funktionalen Programmierens:</a></div><div class=\"lev3 toc-item\"><a href=\"#Vorteile-des-funktionalen-Programmierens:\" data-toc-modified-id=\"Vorteile-des-funktionalen-Programmierens:-113\"><span class=\"toc-item-num\">1.1.3&nbsp;&nbsp;</span>Vorteile des funktionalen Programmierens:</a></div><div class=\"lev2 toc-item\"><a href=\"#Iteratoren\" data-toc-modified-id=\"Iteratoren-12\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Iteratoren</a></div><div class=\"lev2 toc-item\"><a href=\"#List-Comprehension\" data-toc-modified-id=\"List-Comprehension-13\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>List Comprehension</a></div><div class=\"lev2 toc-item\"><a href=\"#Geschachtelte-Schleifen\" data-toc-modified-id=\"Geschachtelte-Schleifen-14\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Geschachtelte Schleifen</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-141\"><span class=\"toc-item-num\">1.4.1&nbsp;&nbsp;</span>Aufgabe 1</a></div><div class=\"lev2 toc-item\"><a href=\"#Die-Funktionen-map(),-filter()\" data-toc-modified-id=\"Die-Funktionen-map(),-filter()-15\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Die Funktionen map(), filter()</a></div><div class=\"lev3 toc-item\"><a href=\"#map()\" data-toc-modified-id=\"map()-151\"><span class=\"toc-item-num\">1.5.1&nbsp;&nbsp;</span>map()</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-152\"><span class=\"toc-item-num\">1.5.2&nbsp;&nbsp;</span>Aufgabe 2</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-3-(optional)\" data-toc-modified-id=\"Aufgabe-3-(optional)-153\"><span class=\"toc-item-num\">1.5.3&nbsp;&nbsp;</span>Aufgabe 3 (optional)</a></div><div class=\"lev3 toc-item\"><a href=\"#filter()\" data-toc-modified-id=\"filter()-154\"><span class=\"toc-item-num\">1.5.4&nbsp;&nbsp;</span>filter()</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-4\" data-toc-modified-id=\"Aufgabe-4-155\"><span class=\"toc-item-num\">1.5.5&nbsp;&nbsp;</span>Aufgabe 4</a></div><div class=\"lev2 toc-item\"><a href=\"#Das-itertools-Modul\" data-toc-modified-id=\"Das-itertools-Modul-16\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>Das itertools-Modul</a></div><div class=\"lev3 toc-item\"><a href=\"#Neuen-Iterator-erzeugen\" data-toc-modified-id=\"Neuen-Iterator-erzeugen-161\"><span class=\"toc-item-num\">1.6.1&nbsp;&nbsp;</span>Neuen Iterator erzeugen</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-5\" data-toc-modified-id=\"Aufgabe-5-162\"><span class=\"toc-item-num\">1.6.2&nbsp;&nbsp;</span>Aufgabe 5</a></div><div class=\"lev3 toc-item\"><a href=\"#Teile-der-Ausgabe-eines-Iterators-auswählen.\" data-toc-modified-id=\"Teile-der-Ausgabe-eines-Iterators-auswählen.-163\"><span class=\"toc-item-num\">1.6.3&nbsp;&nbsp;</span>Teile der Ausgabe eines Iterators auswählen.</a></div><div class=\"lev3 toc-item\"><a href=\"#Iteratoren-kombinieren\" data-toc-modified-id=\"Iteratoren-kombinieren-164\"><span class=\"toc-item-num\">1.6.4&nbsp;&nbsp;</span>Iteratoren kombinieren</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-7\" data-toc-modified-id=\"Aufgabe-7-165\"><span class=\"toc-item-num\">1.6.5&nbsp;&nbsp;</span>Aufgabe 7</a></div><div class=\"lev3 toc-item\"><a href=\"#The-operator-module\" data-toc-modified-id=\"The-operator-module-166\"><span class=\"toc-item-num\">1.6.6&nbsp;&nbsp;</span>The operator module</a></div><div class=\"lev2 toc-item\"><a href=\"#Lambda-Funktionen\" data-toc-modified-id=\"Lambda-Funktionen-17\"><span class=\"toc-item-num\">1.7&nbsp;&nbsp;</span>Lambda-Funktionen</a></div><div class=\"lev2 toc-item\"><a href=\"#Hausaufgabe\" data-toc-modified-id=\"Hausaufgabe-18\"><span class=\"toc-item-num\">1.8&nbsp;&nbsp;</span>Hausaufgabe</a></div><div class=\"lev2 toc-item\"><a href=\"#Lösungen\" data-toc-modified-id=\"Lösungen-19\"><span class=\"toc-item-num\">1.9&nbsp;&nbsp;</span>Lösungen</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-191\"><span class=\"toc-item-num\">1.9.1&nbsp;&nbsp;</span>Aufgabe 1</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-192\"><span class=\"toc-item-num\">1.9.2&nbsp;&nbsp;</span>Aufgabe 2</a></div><div class=\"lev3 toc-item\"><a href=\"#Aufgabe-4\" data-toc-modified-id=\"Aufgabe-4-193\"><span class=\"toc-item-num\">1.9.3&nbsp;&nbsp;</span>Aufgabe 4</a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python für Fortgeschrittene 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionales Programmieren I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Typen von Programmiersprachen:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "<li>Prozedural<br/>\n",
    "Programm besteht aus einer Liste von Anweisungen, die sequentiell abgearbeitet werden. Die meisten Programmiersprachen sind prozedural, z.B. C.</li>\n",
    "<li>Deklarativ<br/>\n",
    "Im Programm wird nur spezifiziert, welches Problem gelöst werden soll, der Interpreter setzt dies dann in Anweisungen um, z.B. SQL</li>\n",
    "<li>Objekt-orientiert<br/>\n",
    "Programme erzeugen und verwenden Objekte und manipulieren diese Objekte. Objekte haben interne Zustände, die durch Methoden gesetzt werden, z.B. Java, C++. </li>\n",
    "<li>Funktional<br/>\n",
    "Zerlegen ein Problem in eine Reihe von Funktionen (vergleichbar mit mathematischen Funktionen, z.B.  f(x) = y. Die Funktionen haben einen definierten Input und Output, aber keine internen Zustand, der die Ausgabe eines bestimmten Input beeinflusst, z.B. Lisp oder Haskell.</li>\n",
    "\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Weitere Merkmale des funktionalen Programmierens:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "<li>Funktionen können wie Daten behandelt werden, d.h. man kann einer Funktion als Parameter eine Funktion geben bzw. die Ausgabe einer Funktion kann eine Funktion sein.</li>\n",
    "<li>Rekursion ist die primäre Form der Ablaufkontrolle, etwa um Schleifen zu erzeugen.</li>\n",
    "<li>Im Zentrum steht die Manipulation von Listen. </li>\n",
    "<li>'Reine' funktionale Programmiersprachen vermeiden Nebeneffekte, z.B. einer Variablen erst einen Wert und dann einen anderen zuzuweisen, um so den internen Zustand des Programms zu verfolgen. Einige Funktionen werden aber nur wegen ihrer 'Nebeneffekte' aufgerufen, z.B. print() oder time.sleep() und nicht für die Rückgabewerte der Funktion. </li>\n",
    "<li>Funktionale Programmiersprachen vermeiden Zuweisungen und arbeiten stattdessen mit Ausdrücken, also mit Funktionen, die Parameter haben und eine Ausgabe. Im Idealfall besteht das ganze Programm aus einer Folge von Funktionen, wobei die Ausgabe der einen Funktion zum Parameter der nächsten wird usw., z.B.:<br/>\n",
    "a = 3<br/>\n",
    "func3(func2(func1(a)))<br/>\n",
    "<li>Funktionale Programmiersprachen verwenden vor allem Funktionen, die auf anderen Funktionen arbeiten, die auf anderen Funktionen arbeiten.\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vorteile des funktionalen Programmierens:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "<li>Formale Beweisbarkeit (eher von akademischem Interesse</li>\n",
    "<li>Modularität<br/>\n",
    "Funktionales Programmieren erzwingt das Schreiben von sehr kleinen Funktionen, die leichter wiederzuverwenden und modular einzusetzen sind.</li>\n",
    "<li>Einfachheit der Fehlersuche und des Testens<br/>\n",
    "Da Ein- und Ausgabe stets klar definiert sind, sind Fehlersuche und das Erstellen von Unittests einfacher</li>\n",
    "\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie immer gilt in Python auch hier: Python ermöglicht die Verwendung des funktionalen Paradigmas, erzwingt es aber nicht durch Einschränkungen, wie es reine funktionale Programmiersprachen tun. Typischerweise verwendet man in Python prozedurale, objekt-orientierte und funktionale Verfahren, z.B. kann man objekt-orientiertes und funktionales Programmieren verwenden, indem man Funktionen definiert, die als Ein- und Ausgabe Objekte verwenden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python wird das funktionale Programmieren u.a. durch folgende Komponenten realisiert:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "<li>Iteratoren</li>\n",
    "<li>List Comprehension, Generator Expressions</li>\n",
    "<li>Die Funktionen map(), filter()</li>\n",
    "<li>Das itertools Modul </li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteratoren"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "An iterator is an object representing a stream of data; this object returns the data one element at a time. A Python iterator must support a method called __next__() that takes no arguments and always returns the next element of the stream. If there are no more elements in the stream, _ _next_ _() must raise the StopIteration exception. Iterators don’t have to be finite, though; it’s perfectly reasonable to write an iterator that produces an infinite stream of data. (Python Documentation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Methode iter() versucht für ein beliebiges Objekt einen Iterator zurückzugeben. Der Iterator gibt bei jedem Aufruf ein Objekt der Liste zurück und setzt den Pointer der Liste um eines höher. Objekte sind iterierbar (iterable) wenn sie die Methode iter() unterstützen, z.B. Listen, Dictionaries, Dateihandles usw."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#beispiel\n",
    "a = [1, 2, 3,]\n",
    "my_iterator = iter(a)\n",
    "my_iterator.__next__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_iterator.__next__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python erwartet in bestimmten Kontexten ein iterierbares Objekt, z.B. in der for-Schleife:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(str(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das ist äquivalent zu "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in iter(a):\n",
    "    print(str(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man kann sich die vollständige Ausgabe eines Iterators ausgeben lassen, wenn man ihn als Parameter der list()- oder tuple() Funktion übergibt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#beispiel\n",
    "a = [1, 2, 3,]\n",
    "my_iterator = iter(a)\n",
    "list(my_iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_iterator = iter(a)\n",
    "tuple(my_iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Frage: Warum habe ich im letzten Beispiel den Iterator neu erzeugt? Kann man das weglassen?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>List Comprehension</h3>\n",
    "<p>List Comprehension sind ein Element (von vielen) des funktionalen Programmierens in Python. Der wichtigste Vorteil ist das Vermeiden von Nebeneffekten. Was heißt das? Anstelle des Verändern des Zustands einer Datenstruktur (z.B. eines Objekts), sind funktionale Ausdrücke wie mathematische Funktionen aufgebaut, die nur aus einem klaren Input und einen ebenso eindeutig definierten Output bestehen.</p>\n",
    "<p>Prinzipielle Schreibweise: <br/>\n",
    "<code>[&lt;expression> for &lt;variable> in &lt;iterable> &lt;&lt;if &lt;condition> >>]</code>\n",
    "<p>Im folgenden Beispiel ist es das Ziel, die Zahlen von 0 bis 9 ins Quadrat zu setzen. Zuerst die traditionelle Lösung mit einer for-Schleife, in deren Körper eine neue Datenstruktur aufgebaut wird.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#eine traditionelle for-Schleife:\n",
    "squared = []\n",
    "for x in range(10):\n",
    "    squared.append(x**2)\n",
    "squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und hier die Version mit List Comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x**2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4.5, 5.0, 5.5, 6.0, 6.5, 7.0]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#a + bx\n",
    "#2 + 0.5x\n",
    "#x = 5 bis x = 10\n",
    "[x*0.5 + 2 for x in range(5, 11)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Natürlich kann man den Rückgabewert von List Comprehensions auch in einer Variablen abspeichern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squared = [x**2 for x in range(10)]\n",
    "squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Geschachtelte Schleifen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Man kann in list comprehensions auch mehrere geschachtelte for-Schleifen aufrufen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Aufgabe: vergleiche zwei Zahlenlisten und gebe alle Zahlenkombinationen aus, die ungleich sind\n",
    "#Erst einmal die traditionelle Lösung mit geschachtelten Schleifen:\n",
    "combs = [] \n",
    "for x in [1,2,3 ]: \n",
    "    for y in [3,1,4]: \n",
    "        if x != y: \n",
    "            combs.append((x, y))\n",
    "combs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und nun als List Comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4>Aufgabe 1</h4>\n",
    "<p>Ersetzen Sie eine Reihe von Worten durch eine Reihe von Zahlen, die die Anzahl der Vokale anzeigen. Z.B.: \"Dies ist ein Satz\" -> \"2 1 2 1\". </p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Die Funktionen map(), filter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### map()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "map(FunktionX, Liste)<br/> \n",
    "Die Funktion FunktionX wird auf jedes Element der Liste angewandt. Ausgabe ist ein Iterator über eine neue Liste mit den Ergebnissen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 10, 8]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [\"ein Haus\", \"eine Tasse\", \"ein Kind\"]\n",
    "list(map(len, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "prozedurale Schreibweise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "10\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(len(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verwenden Sie map() um in einer Liste von Worten jedes Wort in Großbuchstaben auszugeben. Diskutieren Sie evtl. Probleme mit einem Nachbarn. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 3 (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lösen Sie Aufgabe 1 mit map()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### filter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "filter(FunktionX, Liste)<br/>\n",
    "Die Funktion FunktionX wird auf jedes Element der Liste angewandt. Konstruiert einen neuen Iterator, in den die Elemente der Liste aufgenommen werden, für die die FunktionX den Ausgabewert True hat. \n",
    "<br/>Bsp.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#returns True if x is an even number\n",
    "def is_even(x): \n",
    "    return (x % 2) == 0 \n",
    "\n",
    "b = [2,3,4,5,6]\n",
    "list(filter(is_even, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verwenden Sie filter, um aus dem folgenden Text eine Wortliste zu erstellen, in der alle Pronomina, Artikel und die Worte \"dass\", \"ist\", \"nicht\", \"auch\", \"und\" nicht enthalten sind: <br/>\n",
    "\"Ich denke auch, dass ist nicht schlimm. Er hat es nicht gemerkt und das ist gut. Und überhaupt: es ist auch seine Schuld. Ehrlich, das ist wahr.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Das itertools-Modul"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktionen des itertools-Moduls lassen sich einteilen in Funktionen, die: \n",
    "<ul>\n",
    "<li>die einen neuen Iterator auf der Basis eines existierenden Iterators erzeugen. </li>\n",
    "<li>die Teile der Ausgabe eines Iterators auswählen. </li>\n",
    "<li>die die Ausgabe eines Iterators gruppieren.</li>\n",
    "<li>die Iteratoren kombinieren</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Neuen Iterator erzeugen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktionen erzeugen einen neuen Iterator auf der Basis eines existierenden: <br/>\n",
    "itertools.count(),itertools.cycle(), itertools.repeat(), itertools.chain(), itertools.isslice(), itertools.tee() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.cycle(iterator) Gibt die Liste der Elemente in iterator in einer unendlichen Schleife zurück"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "#don't try this at home:\n",
    "#list(itertools.cycle([1,2,3,4,5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.repeat(iterator, [n]) wiederholt die Elemente in iterator n mal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools\n",
    "list(itertools.repeat([1,2,3,4], 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.chain(iterator_1, iterator_2, ...)  Erzeugt einen neuen Iterator, in dem die Elemente von iterator_1, _2 usw. aneinander gehängt sind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "c = [7, 8, 9]\n",
    "list(itertools.chain(a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verknüpfen Sie den Inhalt dreier Dateien zu einem Iterator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Teile der Ausgabe eines Iterators auswählen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.filterfalse(Prädikat, iterator) ist das Gegenstück zu filter(). Ausgabe enthält alle Elemente, für die das Prädikat falsch ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.takewhile(Prädikat, iterator) - gibt solange Elemente aus, wie das Prädikat wahr ist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.dropwhile(Prädikat, iter)entfernt alle Elemente, solange das Prädikat wahr ist. Gibt dann den Rest aus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.compress(Daten, Selektoren) Nimmt zweei Iteratoren un dgibt nur die Elemente des ersten (Daten) zurück, für die das entsprechende Element im zweiten (Selektoren) wahr ist. Stoppt, wenn einer der Iteratoren erschöpft ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteratoren kombinieren"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.combinations(Iterator, r)  gibt alle r-Tuple Kombinationen der Elemente des Iterators wieder. Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(itertools.combinations([1, 2, 3, 4], 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itertools.permutations(iterator, r) gibt alle Permutationen aller Elemente unabhängig von der Reihenfolge in Iterator wieder: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1, 2),\n",
       " (1, 3),\n",
       " (1, 4),\n",
       " (2, 1),\n",
       " (2, 3),\n",
       " (2, 4),\n",
       " (3, 1),\n",
       " (3, 2),\n",
       " (3, 4),\n",
       " (4, 1),\n",
       " (4, 2),\n",
       " (4, 3))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(itertools.permutations([1, 2, 3, 4], 2)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wieviele Zweier-Permutationen sind mit den graden Zahlen zwischen 1 und 101 möglich? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The operator module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mathematische Operationen: add(), sub(), mul(), floordiv(), abs(), ... <br/>\n",
    "Logische Operationen: not_(), truth()<br/>\n",
    "Bit Operationen: and_(), or_(), invert()<br/>\n",
    "Vergleiche: eq(), ne(), lt(), le(), gt(), and ge()<br/> \n",
    "Objektidentität: is_(), is_not()<br/> \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 8, 12, 22, 1]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [2, -3, 8, 12, -22, -1]\n",
    "list(map(abs, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda-Funktionen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lambda erlaubt es, kleine Funktionen anonym zu definieren. Nehmen wir an, wir wollen in einer List von Zahlen alle Zahlen durch 100 teilen und mit 13 multiplizieren. Dann könnten wir das so machen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.13, 0.26, 0.65, 0.91]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def calc(n):\n",
    "    return (n * 13) / 100\n",
    "\n",
    "a = [1, 2, 5, 7]\n",
    "list(map(calc, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktion können wir mit Lambda nun direkt einsetzen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.13, 0.26, 0.65, 0.91]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: (x *  13)/100, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allerdings gibt es sehr unterschiedliche Meinungen darüber, ob auf diese Weise guter Code entsteht. Ich finde diesen Ratschlag anz gut: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "<li>Write a lambda function.</li> \n",
    "<li>Write a comment explaining what the heck that lambda does. </li>\n",
    "<li>Study the comment for a while, and think of a name that captures the essence of the comment. </li>\n",
    "<li>Convert the lambda to a def statement, using that name. </li>\n",
    "<li>Remove the comment. </li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hausaufgabe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Geben Sie alle Unicode-Zeichen zwischen 34 und 250 aus und geben Sie alle aus, die keine Buchstaben oder Zahlen sind"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Wie könnte man alle Dateien mit der Endung *.txt in einem Unterverzeichnis hintereinander ausgeben? \n",
    "\n",
    "3) Schauen Sie sich in der Python-Dokumentation die Funktionen sort und itemgetter an. Wie kann man diese so kombinieren, dass man damit ein Dictionary nach dem value sortieren kann. (no stackoverflow :-)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/><br/><br/><br/><br/><br/><br/><br/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lösungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 3, 2, 2, 1]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#zählt die Vokale eines strings\n",
    "def cv(word):\n",
    "    return sum([1 for a in word if a in \"aeiouAEIOUÄÖÜäöü\"])\n",
    "\n",
    "a = \"Dies ist eine Lüge, oder nicht?\"\n",
    "[cv(w) for w in a.split()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "<br/><br/><br/><br/><br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DIES', 'IST', 'EIN', 'SATZ']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#uppeditys the string word \n",
    "def upper(word):\n",
    "    return word.upper()\n",
    "\n",
    "a = [\"dies\", \"ist\", \"Ein\", \"satz\"]\n",
    "list(map(upper, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/><br/><br/><br/><br/><br/><br/><br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aufgabe 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 3, 2, 2, 1]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def cv(word):\n",
    "    return sum([1 for a in word if a in \"aeiouAEIOUÄÖÜäöü\"])\n",
    "\n",
    "a = \"Dies ist eine Lüge, oder nicht?\"\n",
    "\n",
    "list(map(cv, a.split()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/><br/><br/><br/><br/><br/><br/><br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['denke',\n",
       " 'schlimm',\n",
       " 'gemerkt',\n",
       " 'gut',\n",
       " 'überhaupt',\n",
       " 'seine',\n",
       " 'Schuld',\n",
       " 'Ehrlich',\n",
       " 'wahr']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "#returns True if word is a function word\n",
    "def is_no_function_word(word):\n",
    "    f_words = [\"der\", \"die\", \"das\", \"ich\", \"du\", \"er\", \"sie\", \"es\", \"wir\", \"ihr\", \"dass\", \"ist\", \"hat\", \"auch\", \"und\", \"nicht\"]\n",
    "    if word.lower() in f_words:\n",
    "        return False\n",
    "    else: \n",
    "        return True\n",
    "   \n",
    "    \n",
    "text = \"\"\"Ich denke auch, dass ist nicht schlimm. Er hat es nicht gemerkt und das ist gut. \n",
    "          Und überhaupt: es ist auch seine Schuld. Ehrlich, das ist wahr.\"\"\"\n",
    "\n",
    "list(filter(is_no_function_word, re.findall(\"\\w+\", text)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.1"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "512px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": true,
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}