python_8.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "8. Sitzung: Datenstrukturen"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Hausaufgaben</h3>\n",
      "<ul><li>Schreiben Sie eine Funktion, die s\u00e4mtliches Markup in einer XML-Datei entfernt. Verwenden Sie eine XML-Datei von TextgridRep als Beispiel.</li>\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import glob\n",
      "import os\n",
      "import re\n",
      "\n",
      "def remove_xml(content):\n",
      "    return re.sub(\"<.+?>\", \"\", content)\n",
      "\n",
      "for file in glob.glob(\"xml\" + os.sep + \"*.xml\"):\n",
      "    print (file)\n",
      "    with open (file, \"r\", encoding=\"utf-8\") as fin:\n",
      "        with open (file[:-3]+\"txt\", \"w\", encoding=\"utf-8\") as fout:\n",
      "            content = fin.read(None)\n",
      "            fout.write(remove_xml(content))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "xml\\Aston,-Louise__Aus dem Leben einer Frau.xml\n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<li>Schreiben Sie einen Tokenisierer, der S\u00e4tze in eine Liste der W\u00f6rter zerlegt (ohne Satzzeichen wie .#() usw.). Wenden Sie ihn auf die Datei an, die sie gerade vom Markup befreit haben. BONUS-Aufgabe: Erstellen Sie eine H\u00e4ufigkeitswortliste.</li>\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import glob\n",
      "import os\n",
      "import re\n",
      "\n",
      "def tokenizer (line):\n",
      "    \"\"\"\n",
      "    splits a line into tokens\n",
      "    \"\"\"\n",
      "    return re.findall(\"\\w+\", line)\n",
      "\n",
      "def count_words(wordlist, line_list):\n",
      "    \"\"\"\n",
      "    counts the words in line_list and adds the result to dict wordlist\n",
      "    \"\"\"\n",
      "    for word in line_list:\n",
      "        if word in wordlist:\n",
      "            wordlist[word] += 1\n",
      "        else:\n",
      "            wordlist[word] = 1\n",
      "    return wordlist\n",
      "\n",
      "def write_freq_list(filename, wordlist):\n",
      "    with open (filename, \"w\", encoding=\"utf-8\") as fout:\n",
      "        fout.write (\"words\" + \"\\t\" + \"frequency\" + \"\\n\")\n",
      "        for w in sorted(wordlist, key=wordlist.get, reverse=True):\n",
      "            fout.write (w + \"\\t\" + str(wordlist[w])+\"\\n\")     \n",
      "        \n",
      "for file in glob.glob(\"xml\" + os.sep + \"*.txt\"):\n",
      "    with open (file, \"r\", encoding=\"utf-8\") as fin:\n",
      "        wordlist = {}\n",
      "        for line in fin:\n",
      "            wordlist.update(count_words(wordlist, tokenizer(line)))\n",
      "    write_freq_list(file[:-3]+\"wlist\", wordlist)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<li>Schreiben Sie eine Funktion, die die L\u00e4nge aller W\u00f6rter eines Textes z\u00e4hlt. Aufruf und Ausgabe sollten so aussehen (Zahlen anstelle von n,m usw.):<br/>\n",
      "<code>wordlengths(\"faust.txt\")\n",
      "the text has: <br/>\n",
      "words with 2 chars: n<br/>\n",
      "words with 3 chars: m<br/>\n",
      "...</code>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Datenstrukturen im \u00dcberblick</h3>\n",
      "<ul>\n",
      "<li>Sequence  (geordnete Folge)</li>\n",
      "<ul>\n",
      "<li>String (enth\u00e4lt Folge von Unicode-Zeichen) <b>nicht</b> ver\u00e4nderbar</li>\n",
      "<li>List (enth\u00e4lt Elemente des gleichen Datentyps; beliebige L\u00e4nge) ver\u00e4nderbar</li>\n",
      "<li>Tuple (enth\u00e4lt Elemente unterschiedlichen Datentyps; gleiche L\u00e4nge) <b>nicht</b> ver\u00e4nderbar</li>\n",
      "<li>namedtuple (Tuple, dessen Felder Namen haben) <b>nicht</b> ver\u00e4nderbar</li>\n",
      "<li>Range (Folge von Zahlen) <b>nicht</b> ver\u00e4nderbar</li>\n",
      "<li>deque (double-ended queue) ver\u00e4nderbar</li>\n",
      "</ul>\n",
      "<li>Maps (ungeordnete Zuordnungen)</li>\n",
      "<ul>\n",
      "<li>Dictionary (enth\u00e4lt key-value Paare)</li>\n",
      "<li>Counter</li>\n",
      "<li>OrderedDict</li>\n",
      "</ul>\n",
      "<li>Set (Gruppe von Elementen ohne Duplikate)</li>\n",
      "<ul>\n",
      "<li>Set (enth\u00e4lt ungeordnet Elemente ohne Duplikate; ver\u00e4nderbar)</li>\n",
      "<li>Frozenset (wie Set, nur unver\u00e4nderlich)</li>\n",
      "</ul>\n",
      "</ul>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Wiederholung: String, List, Range</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#String\n",
      "a = \"hallo welt\"\n",
      "b = str(2)\n",
      "b"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 13,
       "text": [
        "'2'"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#List\n",
      "a = [1, 5, 2, 84, 23]\n",
      "b = list(\"hallo\")\n",
      "b"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "['h', 'a', 'l', 'l', 'o']"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Range\n",
      "a = range(1,5)\n",
      "print (a)\n",
      "print (type(a))\n",
      "print (list(a))\n",
      "for x in a:\n",
      "    print (x, end=\"-\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "range(1, 5)\n",
        "<class 'range'>\n",
        "[1, 2, 3, 4]\n",
        "1-2-3-4-"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Tuple: unver\u00e4nderliche Listen</h3>\n",
      "<p>Tuple sind unver\u00e4nderliche Listen. Sie k\u00f6nnen auch verschiedene Datentypen enthalten.</p>\n",
      "<p>Sie werden so erzeugt / gecastet: tuple (iterable)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = tuple ([2, 4, 6])\n",
      "a[0]"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 26,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#tuples sind unver\u00e4nderbar\n",
      "try:\n",
      "    a[0] = 1    \n",
      "except TypeError:\n",
      "    print (\"TypeError: 'tuple' object does not support item assignment\")"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "TypeError: 'tuple' object does not support item assignment\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#sie werden auch oft verwendet, um unterschiedliche \n",
      "#Datentypen in einer Struktur aufzubewahren (wie in einer Tabellenreihe)\n",
      "a = (\"hallo\", 5, 2)\n",
      "a"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "('hallo', 5, 2)"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Achtung: Nicht die Klammer definiert das Tuple. Def. eines Tuples mit einem Feld:\n",
      "a = (2,)\n",
      "a = 2,\n",
      "a"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 34,
       "text": [
        "(2,)"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>namedtuple f\u00fcr Datenbank-\u00e4hnliche Reihen</h3>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Instanziierung von namedtuples: namedtuple(\"Name\", \"Feldnamen\")<br/>\n",
      "Die Feldnamen sind ein String, wobei die einzelnen Namen durch Leerzeichen oder Kommata getrennt sind. \n",
      "<p>Wird besonders zum Einlesen von Datenbank-Dateien, z.B. im csv-Format, verwendet oder um Ergebnisse von Datenbankabfragen zu managen."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from  collections import namedtuple\n",
      "Name = namedtuple('Name', \"first surname \")   #erzeugt eine Datenstruktur, die immer \n",
      "                                              #aus zwei Felder mit festgelegten Namen besteht\n",
      "n = Name(\"Friedrich\", \"Schiller\")   #kann man nun ohne Namen verwenden\n",
      "m = Name(first=\"Thomas\", surname=\"Mann\")   #oder mit\n",
      "print (n)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Name(first='Friedrich', surname='Schiller')\n"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Nun kann man die Felder mit den Namen verwenden:"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(m.first)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Thomas\n"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "m[0]  #aber es funktionieren auch die typischen Sequence-Funktionedn"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 58,
       "text": [
        "'Thomas'"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Aufgabe</h3>\n",
      "<ul>\n",
      "<li>Definieren Sie ein namedtuple zum Speichern von 2-dimensionalen Punktkoordinaten mit den Feldnamen x und y. Speichern Sie unter Verwendung der Namen 2 Koordinaten ab und drucken Sie dann aus.</li>\n",
      "</ul>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>deque</h3>\n",
      "<p>Ein deque (kurz f\u00fcr: double-ended queue) ist eine Datenstruktur, die zwei typische Datenstrukturen in einem Format vereint: \n",
      "Stacks (Stapel) und queues (Reihe).<br/>\n",
      "Einen Stapel kann man sich vorstellen wie einen Stapel von Karten. Ich lege eine Karte nach der anderen auf den Stapel. Wenn ich nun Karten herunternehme, dann nehme ich zuerst die Karte in die Hand, die ich als letzte abgelegt habe. Ganz zum Schlu\u00df erhalte ich die Karte, die ich als erstes abgelegt habe. Verallgemeinert kann man sagen: diese Datenstruktur funktioniert nach dem Prinzip: FILO (first in - last out). Wenn Sie etwa die Tags in einem XML-Baum parsen, w\u00fcrden Sie einen Stack verwenden, um die Tags abzulegen.</p>\n",
      "<p>Eine queue funktioniert dagegen nach dem Prinzip FIFO: First in first out. Man kann sich das wie eine Warteschlange an einer Bushaltestelle vorstellen. Wer sich zuerst angestellt hat, darf zuerst einsteigen (In England - in Deutschland beginnt der Kampf um den Platz, wenn der Bus kommt...) Wenn Sie zb Daten aus dem Netz laden und sie zwischenspeichern, bevor sie sie weiterverarbeiten, da die Verarbeitung l\u00e4nger dauert, dann w\u00e4re eine queue geeignet.</p>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import deque\n",
      "#deque als stack verwenden\n",
      "stack = deque()\n",
      "#auf den stapel ablegen\n",
      "stack.append(\"TEI\")\n",
      "stack.append(\"teiHeader\")\n",
      "stack.append(\"p\")\n",
      "print (stack)\n",
      "#vom stapel nehmen\n",
      "stack.pop()\n",
      "print(stack)\n"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "deque(['TEI', 'teiHeader', 'p'])\n",
        "deque(['TEI', 'teiHeader'])\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#deque als queue verwenden\n",
      "queue = deque()\n",
      "queue.append(\"todo 1\")\n",
      "queue.append(\"todo 2\")\n",
      "print(queue)\n",
      "queue.popleft()\n",
      "print(queue)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "deque(['todo 1', 'todo 2'])\n",
        "deque(['todo 2'])\n"
       ]
      }
     ],
     "prompt_number": 43
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#auch hier funktioniert das typische Arbeiten, das wir von Listen kennen\n",
      "for i in stack:\n",
      "    print(i)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "TEI\n",
        "teiHeader\n"
       ]
      }
     ],
     "prompt_number": 44
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "queue.appendleft(\"todo 1\")\n",
      "for i in queue:\n",
      "    print(i)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "todo 1\n",
        "todo 2\n"
       ]
      }
     ],
     "prompt_number": 45
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Aufgabe</h3>\n",
      "<ul>\n",
      "<li>Zerlegen Sie einen Text in S\u00e4tze (Verwenden Sie die txt-Datei aus Ihrer Hausaufgabe). Speichern Sie den Satz in einem deque. Geben Sie jeweils das erste und das letzte Wort des Satzes aus.\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Funktionen f\u00fcr Sequences (str, list, tuple, namedtuple, range, deque)</h3>\n",
      "<p>x in s, x not in s"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"welt\" in \"hallo welt\""
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<p>slicing: s[start:end]"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"woman\"[2:5]          "
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 5,
       "text": [
        "'man'"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>L\u00e4nge: len (s)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "len ([3,12,4,67])"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "4"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<p>Minimum und Maximum: min(s), max(s)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = [23, 1, 56, 154, 99, 1]\n",
      "print (\"Minimum: \", min(a), \" und Maximum: \", max(a))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Minimum:  1  und Maximum:  154\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Anzahl der Token des Typs x: sequence.count(x)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = [23, 1, 56, 154, 99, 1]\n",
      "a.count(1)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Verkettung von zwei Sequences (a,b): a + b"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = [1, 2]\n",
      "b = [3, 4]\n",
      "a + b"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 21,
       "text": [
        "[1, 2, 3, 4]"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Aufgabe</h3>\n",
      "<ul>\n",
      "<li>F\u00fcllen Sie das deque a mit \"todo 2\", \"todo 1\". F\u00fcllen Sie das deque b mit \"todo 7\", \"todo 4\". ERezugen Sie ein deque, das alle Eintr\u00e4ge in sortierter Reihenfolge enth\u00e4lt.\n",
      "</li>\n",
      "</ul>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Dictionaries</h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#3 constructors for dict\n",
      "wordlist = {\"und\" : 23, \"der\" : 21, \"die\" : 19}\n",
      "print (wordlist)\n",
      "wordlist = dict ( und = 23, der = 21, die = 19 )\n",
      "print (wordlist)\n",
      "wordlist = dict (zip( [\"und\", \"der\", \"die\"], [23, 21, 19] ))\n",
      "print (wordlist)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'der': 21, 'die': 19, 'und': 23}\n",
        "{'der': 21, 'die': 19, 'und': 23}\n",
        "{'der': 21, 'die': 19, 'und': 23}\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Counter</h3>\n",
      "<p>Counter ist ein dictionary, das sich besonders zum Z\u00e4hlen eignet, da es bei Elementen, die nicht enthalten sind, den Wert 0 zur\u00fcckgibt. Wir haben oben die Funktion zum Z\u00e4hlen von Worten gesehen, die den Fall, dass das Wort noch nichtin der Liste  enthalten ist, gesondert behandeln musste: </p>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def count_words(wordlist, line_list):\n",
      "    \"\"\"\n",
      "    counts the words in line_list and adds the result to dict wordlist\n",
      "    \"\"\"\n",
      "    for word in line_list:\n",
      "        if word in wordlist:\n",
      "            wordlist[word] += 1\n",
      "        else:\n",
      "            wordlist[word] = 1\n",
      "    return wordlist"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "source": [
      "<p>Das kann man nun mit Counter einfacher machen:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import Counter\n",
      "import re\n",
      "wordlist = Counter()\n",
      "text = \"dies ist eine Zeile. dies ist keine Zeile. dies ist.\"\n",
      "for word in re.findall(\"\\w+\", text):\n",
      "    wordlist[word] += 1\n",
      "    \n",
      "for key, value in wordlist.items():\n",
      "    print (key + \"\\t\" + str(value))"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "ist\t3\n",
        "keine\t1\n",
        "dies\t3\n",
        "Zeile\t2\n",
        "eine\t1\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#das gleiche kann man mit der Methode update von Counter erreichen\n",
      "from collections import Counter\n",
      "import re\n",
      "wordlist = Counter()\n",
      "text = \"dies ist eine Zeile. dies ist keine Zeile. dies ist.\"\n",
      "for word in re.findall(\"\\w+\", text):\n",
      "    wordlist.update([word])\n",
      "    \n",
      "for key, value in wordlist.items():\n",
      "    print (key + \"\\t\" + str(value))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "ist\t3\n",
        "keine\t1\n",
        "dies\t3\n",
        "Zeile\t2\n",
        "eine\t1\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Set</h3>\n",
      "<p>Def.: \"A set object is an unordered collection of distinct hashable objects.\""
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "l = [1,1,1,2,2,3,3]\n",
      "set (l)"
     ],
     "language": "python",
     "metadata": {
      "slideshow": {
       "slide_type": "fragment"
      }
     },
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 26,
       "text": [
        "{1, 2, 3}"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h3>Aufgabe</h3>\n",
      "<p>Schreiben Sie die Funktion zum Z\u00e4hlen von Worten unter Verwendung von Counter um</p> "
     ]
    }
   ],
   "metadata": {}
  }
 ]
}