seminar09.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seminar Problemorientierte Programmierung\n",
    "\n",
    "## 9 Fallstudie: Wortspiele\n",
    "[Chapter 9: Case study: Word play](http://greenteapress.com/thinkpython2/html/thinkpython2010.html)\n",
    "\n",
    "In diesem Abschnitt gibt es die zweite Fallstudie. In dieser werden Wort-Rätsel gelöst, in denen Wörter mit bestimmten Eigenschaften gesucht werden. Beispielsweise finden wir die längsten Palindrome und suchen nach Wörtern, deren Buchstaben in alphabetischer Reihenfolge erscheinen. Und wir lernen eine weitere Entwicklungsmethode kennen: Rückführung auf ein bereits gelöstes Problem.\n",
    "\n",
    "### Ihre Lernziele:\n",
    "\n",
    "Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:\n",
    "\n",
    "- \n",
    "- \n",
    "- \n",
    "\n",
    "## Exkurs: Was mir an Python gefällt\n",
    "\n",
    "Dieser Code enthält das Grundgerüst, um eine auf TCP basierende Serveranwendung zu programmieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quellen: https://docs.python.org/3/howto/sockets.html und \n",
    "# http://www.binarytides.com/python-socket-server-code-example/\n",
    "\n",
    "import socket\n",
    "\n",
    "# function for handling connections. This will be used to create threads\n",
    "def client_thread(conn):\n",
    "    # sending message to connected client\n",
    "    conn.send(bytearray('Welcome to the server. Type something and hit enter\\n', \"utf-8\")) #send only takes string\n",
    "     \n",
    "    # infinite loop so that function do not terminate and thread do not end.\n",
    "    while True:\n",
    "         \n",
    "        # receiving from client\n",
    "        data = conn.recv(1024)\n",
    "        if not data: \n",
    "            break\n",
    "        # print on server side\n",
    "        print(data.decode(\"utf-8\"))\n",
    "        # echo to client side\n",
    "        reply = bytearray('OK ... ', \"utf-8\") + data\n",
    "        conn.sendall(reply)\n",
    "     \n",
    "    # came out of loop\n",
    "    conn.close()\n",
    "    \n",
    "# create an INET, STREAMing socket\n",
    "serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "# bind the socket to a public host, and a port\n",
    "# serversocket.bind((socket.gethostname(), 8080))\n",
    "# use localhost instead \n",
    "serversocket.bind((\"localhost\", 8080))\n",
    "# become a server socket\n",
    "serversocket.listen(5)\n",
    "\n",
    "\n",
    "while True:\n",
    "    # accept connections from outside\n",
    "    (clientsocket, address) = serversocket.accept()\n",
    "    # now do something with the clientsocket\n",
    "    # in this case, we'll pretend this is a threaded server\n",
    "    ct = client_thread(clientsocket)\n",
    "    ct.run()\n",
    "\n",
    "serversocket.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn Sie den Code starten und sich dann mit Hilfe von Telnet mit der Anwendung verbinden (telnet localhost 8080), werden alle Eingaben an Sie zurückgespiegelt (\"echo\") und hier in Jupyter ausgegeben. Das ist eine sehr einfache Testanwendung, die aus Sicherheitsgründen nur von Ihrem Rechner aus erreichbar ist.\n",
    "\n",
    "Falls Ihr Rechner keinen Paketfilter (\"Firewall\") laufen hat und Sie die Zeile mit localhost auskommentieren und stattdessen die mit socket.gethostbyname() aktivieren, dann ist die Anwendung ggf. auch von anderen Rechnern erreichbar und stellt ziemlich sicher eine Sicherheitslücke dar. Gehen Sie also vorsichtig mit dieser Option um."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### 9.1 Wortlisten einlesen\n",
    "\n",
    "Die Übungen in diesem Abschnitt weichen vom [Original](http://greenteapress.com/thinkpython2/html/thinkpython2010.html) insofern ab, als dass Wortlisten mit deutschen Wörtern verwendet werden. Alle Übungen können jedoch auch mit englischen Wortlisten durchgeführt werden.\n",
    "\n",
    "Für die Übungen in diesem Abschnitt benötigen wir eine Liste deutscher Wörter. Es gibt sehr viele Wortlisten im Web, wir verwenden hier eine Liste des [Wortschatz-Projektes](http://wortschatz.uni-leipzig.de/) der Universität Leipzig. Laden Sie [diese Liste mit 10000 häufigen deutschen Wörtern](http://pcai056.informatik.uni-leipzig.de/downloads/etc/legacy/Papers/top10000de.txt) herunter und speichern Sie sie unter dem Dateinamen `top10000de.txt`.\n",
    "\n",
    "Die Datei ist eine reine Textdatei, daher können wir sie mit einem Texteditor anschauen. Wir können sie aber auch leicht mit Python einlesen. Die eingebaute Funktion `open` erwartet einen Dateiname als Parameter und gibt uns ein **Dateiobjekt** (*file object*) zurück, mit dessen Hilfe wir die Datei lesen können:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin = open('top10000de.txt', encoding=\"latin1\")\n",
    "# Hinweis: der Parameter encoding gibt an, in welcher Zeichenkodierung\n",
    "# die Datei verfasst ist. Im Allgemeinen sollten Dateien heute in Unicode codiert\n",
    "# sein, bei diesen ist in Python3 diese Angabe nicht notwendig.\n",
    "# Leider ist die Datei vom Wortschatz-Projekt aber noch in der\n",
    "# Latin1-Kodierung, so dass wir dies Python mitteilen müssen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`fin` ist ein üblicher Name für ein Dateiobjekt zum lesenden Zugriff auf die Datei (`fin` steht für **f**ile **in**put). Das Dateiobjekt bietet uns mehrere Methoden zum Lesen der Datei, unter anderem die Methode `readline`, die Zeichen aus einer Datei einliest, bis ein Zeichen für den Zeilenumbruch erreicht wird, und das Ergebnis als Zeichenkette zurückgibt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin.readline()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das erste \"Wort\" in dieser Liste ist \"der\". Die Zeichenfolge \"\\n\" repräsentiert das Zeichen für den Zeilenumbruch, durch das die Wörter (zeilenweise) getrennt sind. \n",
    "\n",
    "Das Dateiobjekt merkt sich, an welcher Stelle innerhalb der Datei wir gerade sind. Wenn wir also `readline` nochmal aufrufen, erhalten wir die nächste Zeile zurück:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin.readline()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das nächste Wort ist also \"die\". Wenn uns das Zeichen für den Zeilenumbruch stört, können wir es mit der Methode `strip` entfernen: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "line = fin.readline()\n",
    "word = line.strip()\n",
    "word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir können das Dateiobjekt auch innerhalb einer `for`-Schleife verwenden. Das folgende Programm liest die Datei ein und gibt jedes Wort aus – eines pro Zeile:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin = open('top10000de.txt', encoding=\"latin1\")\n",
    "for line in fin:\n",
    "    word = line.strip()\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Schleife können Sie leicht nutzen, um nach Wörtern mit bestimmten Eigenschaften zu suchen. Gibt es im Deutschen Wörter, die auf \"gry\" enden? Oder zumindest auf \"ry\"?\n",
    "\n",
    "<details>\n",
    "    <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
    "  <div class=\"alert alert-info\" role=\"alert\">\n",
    "\n",
    "Mit der Zeichenkettenfunktion [endswith](https://docs.python.org/3/library/stdtypes.html#str.endswith) können Sie prüfen, ob eine Zeichenkette auf eine andere Zeichenkette endet. Zusammen mit einer Verzweigung (`if`) können Sie damit nur die entsprechenden Wörter ausgeben.\n",
    "      \n",