04_uebung_funktionen_bilder_text_loesung.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Lizenz: Das folgende Lehrmaterial kann unter einer [CC-BY-SA 4.0](https://creativecommons.org/licenses/by/4.0/legalcode) Lizenz frei verwendet, verbreitet und modifiziert werden._   \n",
    " _Authoren: Jana Lasser (jana.lasser@ds.mpg.de)_  \n",
    " _Das Lehrmaterial wurde im Zuge des Projektes \"Daten Lesen Lernen\", gefördert vom Stifterverband und der Heinz Nixdorf Stiftung erstellt._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lösungen zu Übung 4: Funktionen, Bilder und Text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"top\"></a>Inhalt\n",
    "---\n",
    "* [Funktionen](#funktionen)\n",
    "* [Bilder](#bilder)\n",
    "* [Text](#text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"funktionen\"></a> Funktionen\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.A\n",
    "# Erstelle die Funktion mit dem Namen \n",
    "# \"meine rechenfunktion\". Die Funktion\n",
    "# bekommt zwei Argumente, \"zahl1\" und \"zahl2\".\n",
    "# Sie berechnet in ihrem Inneren Summe,\n",
    "# Differenz, Produkt und Quotient der beiden\n",
    "# Argumente und gibt sie jeweils aus.\n",
    "def meine_rechenfunktion(zahl1, zahl2):\n",
    "    summe = zahl1 + zahl2\n",
    "    print('{} + {} = {}'.format(zahl1, zahl2, summe))\n",
    "    \n",
    "    differenz = zahl1 - zahl2\n",
    "    print('{} - {} = {}'.format(zahl1, zahl2, differenz))\n",
    "    \n",
    "    produkt = zahl1 * zahl2\n",
    "    print('{} * {} = {}'.format(zahl1, zahl2, produkt))\n",
    "    \n",
    "    quotient = zahl1 / zahl2\n",
    "    print('{} / {} = {}'.format(zahl1, zahl2, quotient))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.A Fortsetzung\n",
    "# WICHTIG: die bloße Definition der Funktion\n",
    "# in der obenstehenden Code-Zelle hat noch zu\n",
    "# keiner Ausgabe geführt. Aber unser Script \"kennt\"\n",
    "# die Funktion \"meine_rechenfunktion\" jetzt, und wir\n",
    "# können sie nachfolgend benutzen. Wir testen also\n",
    "# die Funktion mit verschiedenen Argumenten:\n",
    "meine_rechenfunktion(6, 10)\n",
    "print()\n",
    "meine_rechenfunktion(100956, 79348)\n",
    "print()\n",
    "meine_rechenfunktion(10,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.B\n",
    "# Definiere eine neue Funktion mit dem Namen\n",
    "# \"quadratsumme\". Diese Funktion bekommt nur\n",
    "# ein Argument und zwar eine Liste. Sie berechnet\n",
    "# das Quadrat jedes Elementes in der Liste und\n",
    "# summiert die Zwischenergebnisse auf (sie werden\n",
    "# in der nur innerhalb der Funktion bekannten \n",
    "# Variablen \"summe\" gespeichert).\n",
    "# Statt das Rechenergebnis direkt\n",
    "# auszugeben, gibt sie es diesmal \"zurück\" (siehe\n",
    "# das \"return\"-Keyword). Wir können also das Ergebnis\n",
    "# der Funktion einer neuen Variable zuweisen\n",
    "def quadratsumme(liste):\n",
    "    summe = 0\n",
    "    \n",
    "    for zahl in liste:\n",
    "        summe = summe + zahl * zahl\n",
    "        \n",
    "    return summe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.B Fortsetzung\n",
    "# teste die Funktion mit einer kurzen Liste\n",
    "ergebnis = quadratsumme([1,2,3,4,5])\n",
    "print(ergebnis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.C \n",
    "# Implementierung des Sortier-Algorithmus\n",
    "# \"Bubblesort\" \n",
    "# (siehe https://de.wikipedia.org/wiki/Bubblesort)\n",
    "def bubbleSort(liste):\n",
    "    \n",
    "    # erzeuge eine Liste der Durchlaeufe durch\n",
    "    # die Liste. Bei einer Liste mit 5 Elementen\n",
    "    # ist z.B. durchlaeufe = [5,4,3,2,1]\n",
    "    durchlaeufe = range(len(liste) - 1, 0, -1)\n",
    "    \n",
    "    # iteriere über alle \"durchlaeufe\"\n",
    "    for durchlauf in durchlaeufe:\n",
    "        \n",
    "        # iteriere über jeden Durchlauf\n",
    "        # im 3. Durchlauf wird hier z.B: über\n",
    "        # die Liste [0,1,2] iteriert\n",
    "        for i in range(durchlauf):\n",
    "            \n",
    "            # wenn das Element auf Listenindex\n",
    "            # i größer als das Element auf Index\n",
    "            # i + 1 ist, vertausche die Beiden\n",
    "            # Elemente. Vertauschen wird realisiert,\n",
    "            # indem das Element auf Index i in der \n",
    "            # Variable \"temp\" zwischengespeichert wird\n",
    "            if liste[i] > liste[i + 1]:\n",
    "                temp = liste[i]\n",
    "                liste[i] = liste[i + 1]\n",
    "                liste[i + 1] = temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.C Fortsetzung\n",
    "# lange Liste: dauert sehr lange. \n",
    "# Genauer: dieser Sortieralgorithmus\n",
    "# skaliert mit n^2, wobei n die Anzahl der\n",
    "# Elemente in der Liste ist. Besser wäre\n",
    "# z.B. \"Quicksort\" oder \"Mergesort\", die\n",
    "# mit n * log(n) skalieren.\n",
    "bubbleSort(range(10000,0,-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Anfang](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"funktionen\"></a> Bilder\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.A\n",
    "# importiere die benötigten Bibliotheken\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# lade das Bild mit der Funktion open()\n",
    "# und speichere es in der Variable \"bild\"\n",
    "bild = Image.open('daten/cat_image.JPG')\n",
    "\n",
    "# konvertiere das Bild in ein NumPy array\n",
    "bild = np.asarray(bild)\n",
    "\n",
    "# zeige das Bild an\n",
    "plt.imshow(bild)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.B ausschneiden\n",
    "# Das Katzengesicht beginnt in vertikaler Richtung\n",
    "# bei etwa 1000 Pixeln und hört be 2050 Pixeln auf:\n",
    "# 1000:2050. In horizontaler Richtung beginnt es bei \n",
    "# 1500 Pixeln und hört bei 2550 auf: 1500:2550.\n",
    "# In der dritten Dimension (den Farbwerten), nehmen \n",
    "# wir alle drei Werte (rot, grün und blau) mit, \n",
    "# indem wir das offene Intervall 0: angeben.\n",
    "gesicht = bild[1000:2050,1500:2550,0:]\n",
    "plt.imshow(gesicht)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.C\n",
    "from os.path import join\n",
    "ordner = \"daten\"\n",
    "bildname = \"katzengesicht.png\"\n",
    "\n",
    "# zum Speichern im Unterordner \"daten\" geben wir \n",
    "# den Pfad dorthin an. Den korrekten Pfad erzeugen\n",
    "# wir betriebssystem-unabhängig indem wir die \n",
    "# Funktion \"join()\" aus dem Modul \"os.path\"\n",
    "# benutzen. Alternativ können wir auch \"daten/katzengesicht.png\"\n",
    "# unter Linus oder \"daten\\katzengesicht.png\" unter\n",
    "# Windows als Pfad angeben.\n",
    "plt.savefig(join(ordner, bildname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.D (optional) Graustufen\n",
    "\n",
    "# erzeuge das Graustufenbild indem wir alle drei\n",
    "# Farbwerte je Pixel mitteln (aufsummiereun und\n",
    "# dann durch 3 teilen). Das machen wir mit der \n",
    "# Funktion \"sum()\" des arrays in dem das Bild\n",
    "# gespeichert ist. Um klar zu machen, über welche\n",
    "# Dimension (Achse) summiert werden soll, geben wir \n",
    "# der Funktion die Achse explizit als sog. \n",
    "# \"keyword argument\" mit. Die nullte Achse wäre hier\n",
    "# die vertikale Richtung, die erste Achse die \n",
    "# horizontale Richtung und die zweite Achse steht\n",
    "# für die Farbwerte. Mit \"axis=2\" wird also über\n",
    "# die zweite Achse summiert\n",
    "grayscale = bild.sum(axis = 2) / 3.\n",
    "\n",
    "# um das Bild auch in Graustuften anzuzeigen, müssen\n",
    "# wir der Funktion \"imshow()\" noch explizit mitteilen,\n",
    "# welche Farbtabelle (colormap) sie verwenden soll.\n",
    "# Tun wir das nicht, verwendet sie die default-colormap\n",
    "# die das Bild in Falschfarben anzeigt. Mit dem\n",
    "# keyword-argument cmap='gray' teilen wir also mit, dass\n",
    "# eine Farbtabelle mit graustufen verwendet werden soll.\n",
    "plt.imshow(grayscale, cmap = 'gray')\n",
    "\n",
    "# wie im Aufgabenteil oben speichern wir das Bild im\n",
    "# ordner \"daten\", indem wir den ganzen Pfad dorthin\n",
    "# angeben.\n",
    "bildname = 'katze_graustufen.png'\n",
    "plt.savefig(join(ordner, bildname))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Anfang](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"funktionen\"></a> Text\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.A\n",
    "# als erstes laden wir das Grundgesetz wieder als Text\n",
    "text_file = open('daten/GG.txt')\n",
    "text = text_file.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.B Worte zählen\n",
    "\n",
    "# speichere das Wort, nach dem gesucht werden soll in\n",
    "# der Variable \"wort\"\n",
    "wort = 'Freiheit'\n",
    "\n",
    "# zähle die Vorkommnisse des Wortes für jede Zeile,\n",
    "# indem über alle Zeilen des Textes iteriert wird.\n",
    "# Die Vorkommnisse werden in einer eigenen Liste\n",
    "# mit dem Namen anzahl_wort gespeichert.\n",
    "anzahl_wort = [zeile.count(wort) for zeile in text]\n",
    "\n",
    "# gib das Ergebnis aus\n",
    "print('Das Wort {} kommt {} mal im Grundgesetz vor.' \\\n",
    "     .format(wort, sum(anzahl_wort)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.C entferne alle Zeilenumbrüche\n",
    "\n",
    "# iteriere über alle Zeilen. Die Funktion \"enumerate()\"\n",
    "# liefert sowohl den Index der Zeile (\"i\") als auch die \n",
    "# Zeile selbst (\"zeile\"). Um Werte in der Liste der Zeilen\n",
    "# zu verändern, müssen wir auf sie über ihren Index zugreifen:\n",
    "for i,zeile in enumerate(text):\n",
    "    text[i] = zeile.replace('\\n','')\n",
    "    \n",
    "# wir zählen wieder die Anzahl der Zeichen je Zeile\n",
    "zeichen = [len(zeile) for zeile in text]\n",
    "\n",
    "# und rechnen die Gesamtanzahl aus \n",
    "# (vorher: 184855 Zeichen)\n",
    "anzahl_zeichen = sum(zeichen)\n",
    "print('Das Grundgesetz ohne Zeilenumbrüche hat {} Zeichen.'\\\n",
    "      .format(anzahl_zeichen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.D durchschnittliche Wortlänge\n",
    "# erstelle eine Liste mit der Anzahl der Leerzeichen\n",
    "# je Zeile\n",
    "leerzeichen = [zeile.count(' ') for zeile in text]\n",
    "\n",
    "# summiere über die Liste, um die Gesamtanzahl der \n",
    "# Leerzeichen im Text zu errechnen\n",
    "anzahl_leerzeichen = sum(leerzeichen)\n",
    "print('Das Grundgesetz hat {} Leerzeichen.'\\\n",
    "      .format(anzahl_leerzeichen))\n",
    "\n",
    "# erreichne die durchschnittliche Wortlänge als die Anzahl\n",
    "# aller Zeichen minus die Anzahl der Leerzeichen, dividiert\n",
    "# durch die Anzahl der Leerzeichen. Dabei machen wir uns das\n",
    "# Wissen zunutze, dass zwischen zwei Worten immer ein \n",
    "# Leerzeichen steht.\n",
    "wortlaenge = (anzahl_zeichen - anzahl_leerzeichen) / anzahl_leerzeichen\n",
    "print('Die durchschnittliche Wortlänge ist {:1.2f} Zeichen.'\\\n",
    "      .format(wortlaenge))\n",
    "\n",
    "# Hinweis: das Kürze \":1.2f\" beschränkt die Ausgabe einer\n",
    "# Zahl auf zwe Dezimalstellen nach dem Komma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.E (optional) Wortlänge je Zeile\n",
    "\n",
    "# importiere pandas\n",
    "import pandas as pd\n",
    "\n",
    "# errechne die Anzahl der zeichen je Zeile\n",
    "zeichen = [len(zeile) for zeile in text]\n",
    "\n",
    "# erstelle eine Tabelle (DataFrame) mit je einer Spalte \n",
    "# für die Textzeilen und die Anzahl der Zeichen je Textzeile\n",
    "tabelle = pd.DataFrame({'zeilen':text, 'zeichen':zeichen})\n",
    "\n",
    "# erstelle eine leere Liste, um die Wortlänge zu speichern\n",
    "wortlaenge = []\n",
    "\n",
    "# iteriere über alle Zeilen\n",
    "for zeile in text:\n",
    "    \n",
    "    # zähle die Anzahl der Leerzeichen je Zeile\n",
    "    # addiere 1, um später Division durch 0 zu\n",
    "    # vermeiden\n",
    "    leerzeichen = 1 + zeile.count(' ')\n",
    "    \n",
    "    # zähle die Anzahl der Zeichen je Zeile\n",
    "    # addiere 1, um später negaitve Ergebnisse\n",
    "    # zu vermeiden.\n",
    "    zeichen = 1 + len(zeile)\n",
    "    \n",
    "    # errechne die Wortlänge je Zeile wie oben\n",
    "    laenge = (zeichen - leerzeichen) / leerzeichen\n",
    "    \n",
    "    # füge das Ergebnis für die aktuelle Zeile\n",
    "    # der Liste hinzu\n",
    "    wortlaenge.append(laenge)\n",
    "\n",
    "# füge die errechnete wortlänge je Zeile zu der\n",
    "# Tabelle hinzu\n",
    "tabelle['wortlaenge'] = wortlaenge\n",
    "\n",
    "# zeige die ersten paar Zeilen der Tabelle an\n",
    "tabelle.head()\n",
    "\n",
    "ordner = 'daten'\n",
    "tabellenname = 'grundgesetz_wortlaenge.csv'\n",
    "tabelle.to_csv(join(ordner, tabellenname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.D (optional) Vergleich der Wortlänge mit einem andere Text\n",
    "\n",
    "# lade den Huckleberry-Finn Text wie in der Vorlesung \n",
    "# beschrieben aus dem Internet herunter. Dafür werden\n",
    "# die Bibliothek \"urllib\" für das Herunterladen sowie\n",
    "# die Bibliothek \"re\" für Zeichenersetzung im Text\n",
    "# verwendet. Wie schon im Grundgesetz, entfernen wir\n",
    "# alle Zeilenumbrüche und carriage-returns aus dem Text\n",
    "from urllib.request import urlopen \n",
    "import re\n",
    "\n",
    "# Hier definieren wir uns eine kleine Funktion, die \n",
    "# das Herunterladen und die Zeichenersetzung erledigt\n",
    "# und den fertigen Text zurückliefert.\n",
    "def read_url(url): \n",
    "    return re.sub('\\\\s+', ' ', urlopen(url).read().decode())\n",
    "\n",
    "# lies den Text von der vorgegebenen URL\n",
    "# HINWEIS: dieses Kommando funktioniert nur, \n",
    "# wenn dein Rechner eine Internetverbindung hat. Da\n",
    "# du aber wahrscheinlich ohnehin auf dem Jupyter-Hub\n",
    "# arbeitest, sollte das gegeben sein\n",
    "huck_finn_url = 'https://www.inferentialthinking.com/data/huck_finn.txt'\n",
    "huck_finn_text = read_url(huck_finn_url)\n",
    "\n",
    "# zähle die Zeichen je Zeile und summiere über die Zeilen\n",
    "zeichen = [len(zeile) for zeile in huck_finn_text]\n",
    "zeichen = sum(zeichen)\n",
    "\n",
    "# zähle die Leerzeichen je Zeile und summiere über die Zeilen\n",
    "leerzeichen = [zeile.count(' ') for zeile in huck_finn_text]\n",
    "leerzeichen = sum(leerzeichen)\n",
    "\n",
    "# errechne die Wortlänge\n",
    "wortlaenge = (zeichen - leerzeichen) / leerzeichen\n",
    "print('Die durchschnittliche Wortlänge ist {:1.2f} Zeichen'\\\n",
    "     .format(wortlaenge))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie Wortlänge ist mit 4.15 deutlich kleiner als im deutschen Grundgesetz (7.13). Das kann zum einen daran liegen, dass die Sprache eine andere ist (Englisch vs. Deutsch). Zum anderen kann es auch daran liegen, dass es sich bei dem Grundgesetz um einen juristischen Text handelt, der vielleicht etwas kompliziertere und längere Wörter beinhaltet als eine Kindergeschichte. Ein guter weiterer Vergleich, um diese Hypothese zu überprüfen wäre z.B. ein Vergleich mit der Amerikanischen Verfassung oder einem Deutschen Märchen.\n",
    "\n",
    "Natürlich könnte der Unterschied auch daran liegen, dass die Texte unterschiedlich strukturiert/formatiert sind: Wenn z.B. ein Text an irgendeiner Stelle große Mengen an Leerzeichen enthält, würde das unser Ergebnis hier stark verfälschen, ohne dass wir es bemerken würden. Ein Test, um dieses Problem auszuschließen wäre, nach Zeichenkombinationen wie ```\"   \"``` (drei Leerzeichen hintereinander) zu suchen und diese zu entfernen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Anfang](#top)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}