Lecture2_Graphics (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 2: Graphik"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn as sl\n",
    "%matplotlib inline\n",
    "import scipy as sc\n",
    "import math as ma\n",
    "from scipy import linalg, optimize, constants, interpolate, special, stats\n",
    "from math import exp, pow, sqrt, log\n",
    "\n",
    "import seaborn as sns #spezielle Graphikdarstellungen\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.stats.api as sms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Graphik mit Python - Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1) Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das Paket matplotlib ist das am häufigsten benutzte Python Paket um 2D Graphiken zu generieren.  \n",
    "Aus der Notebookumgebung heraus muß zuerst das Paket selbst eingebunden werden.  \n",
    "Günstig ist es, wenn die erzeugten Graphiken gleich direkt ins Notebook eingebunden sind.  \n",
    "Das stellt der \"inline\"-Befehl sicher."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pyplot ist die zugeordnete Plot-Library. Die Befehle orientieren sich sehr nah an den Befehlen, die in MatLab benutzt werden.  \n",
    "Zuerst muß man das Paket ins Notebook einbinden: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt # standard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...hat man das so eingebunden ohne interaktive Graphiken in der Notebook-Umgebung zu aktivieren braucht man zusätzlich noch den show Befehl   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y) # line plot\n",
    "plt.show() # <-- zeigt den plot (nicht nötig, wenn interaktive Plots aktiviert sind)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ansonsten (also mit dem inline-Befehl sh. ln2) reicht"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das verknüpfte Bild kann nicht angezeigt werden.  \n",
    "-> Fehlermeldung kommt in beiden Fällen natürlich daher, daß wir x und y nirgends definiert haben :-)\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) 1D Graphiken"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1) Graphische Darstellung von Punktmengen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 3, 20) #20 Punkte mit gleichem Abstand zwischen [0,3) - x-Werte\n",
    "y = np.linspace(0, 9, 20) #20 Punkte mit gleichem Abstand zwischen [0,9) - y-Werte \n",
    "plt.plot(x, y) # durchgezogene Linie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...jetzt noch die einzelnen Punkte (x,y) die gegeben sind auf die Linie einzeichnen..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y) # Linie\n",
    "plt.plot(x, y, 'o') # Punkte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt ein etwas ausführlicheres Beispiel.  \n",
    "Dazu tabellieren wir zunächst 256 X-Werte von -Pi bis Pi (eingeschlossen) sowie die zugehörigen Werte sin(x) und cos(x) (Y-Werte). Wir legen dazu ein NumPy array an.                   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.linspace(-np.pi, np.pi, 256, endpoint=True)\n",
    "#np.pi -> Wert für Pi aus NumPy, endpoint=True -> Endpunkt eingeschlossen\n",
    "\n",
    "C, S = np.cos(X), np.sin(X) #erster Eintrag cos(x) zweiter sin(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "die Graphik zeigt die default settings für einen entsprechenden plot der tabellierten Funktionen sin(x) und cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(X, C) #plotte cos(x) zu den X-Werten\n",
    "plt.plot(X, S) #plotte sin(x) \n",
    "\n",
    "# -> zwei oder mehrere in einer Zelle ausgeführten Plots werden überlagert wenn möglich                        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ein \";\" hinter dem plot-Befehl verhindert die Kommentarausgabe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(X, C); #plotte cos(x) zu den X-Werten\n",
    "plt.plot(X, S); #plotte sin(x) -> zwei oder mehrere in einer Zelle ausgeführten Plots werden überlagert wenn möglich"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Graphik kann natürlich den Bedürfnissen angepaßt werden.  \n",
    "Das Beispiel zeigt einige der Optionen.  \n",
    "\n",
    "Grundsätzlich gilt:\n",
    "\n",
    "- Zunächst kann eine (leere) Figure angelegt werden.  \n",
    "- Im ersten Schritt werden allgemeine features wie Größe oder Auflösung festgelegt.\n",
    "- Alle Bestandteile des Bildes werden in einer code-Zelle nacheinander definiert.  \n",
    "- Das finale Bild entsteht dann durch Überlagerung aller Optionen/Komponenten.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot der Größe 8x6 inches, 80 dots per inch \n",
    "plt.figure(figsize=(8, 6), dpi=80)\n",
    "\n",
    "X = np.linspace(-np.pi, np.pi, 256, endpoint=True)\n",
    "C, S = np.cos(X), np.sin(X)\n",
    "\n",
    "# Plotte Cosinus mit einer durchgezogenen blauen Linie der Stärke 1 (pixels)\n",
    "plt.plot(X, C, color=\"blue\", linewidth=1.0, linestyle=\"-\")\n",
    "\n",
    "# Plotte Sinus mit einer grünen durchgezogenen Linie der Stärke 1 (pixels)\n",
    "plt.plot(X, S, color=\"green\", linewidth=1.0, linestyle=\"-\")\n",
    "\n",
    "# Setze Wertebereich für x (limits)\n",
    "plt.xlim(-4.0, 4.0)\n",
    "\n",
    "# Setze Marker auf der x-Achse (x ticks)\n",
    "plt.xticks(np.linspace(-4, 4, 9, endpoint=True))\n",
    "\n",
    "# Setze Wertebereich für y (limits)\n",
    "plt.ylim(-1.0, 1.0)\n",
    "\n",
    "# Setze Marker auf der y-Achse (y ticks)\n",
    "plt.yticks(np.linspace(-1, 1, 5, endpoint=True))\n",
    "\n",
    "# Graphik speichern (72 dots per inch)\n",
    "plt.savefig(\"exercice_2.png\", dpi=72)\n",
    "# Wichtig: der Pfad zum Zielordner muß angegeben werden\n",
    "# default: Graphik wird da abgespeichert, wo auch das notebook liegt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sinnvoll ist es auch aussagekräftige Achsenbeschriftungen zu haben - hier sind das natürlich Einheiten von Pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 6), dpi=80); #Größe der Graphik\n",
    "plt.plot(X, C, color=\"blue\", linewidth=2.5, linestyle=\"-\"); #Farbe und Dicke der Linie\n",
    "plt.plot(X, S, color=\"red\", linewidth=2.5, linestyle=\"-\");\n",
    "plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi]); #Label der x-Achse in Einheiten von Pi\n",
    "plt.yticks([-1, 0, +1]); #explizit gegeben Ticks für die y-Achse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...schon besser aber es wäre noch besser wenn \"Pi\" tatsächlich sichtbar wäre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 6), dpi=80);\n",
    "plt.plot(X, C, color=\"blue\", linewidth=2.5, linestyle=\"-\");\n",
    "plt.plot(X, S, color=\"red\", linewidth=2.5, linestyle=\"-\");\n",
    "plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi], #Definition der Punkte\n",
    "         [r'$-\\pi$', r'$-\\pi/2$', r'$0$', r'$+\\pi/2$', r'$+\\pi$']); #zugehörige Label in Latex Notation\n",
    "plt.yticks([-1, 0, +1],[r'$-1$', r'$0$', r'$+1$']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Achsenbeschriftungen und Plot-Labels sind in jedem Fall wichtig. Wenn man z.B. echte Daten darstellt sind sie unerläßlich!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 6), dpi=80);\n",
    "plt.plot(X, C, color=\"blue\", linewidth=2.5, linestyle=\"-\");\n",
    "plt.plot(X, S, color=\"red\", linewidth=2.5, linestyle=\"-\");\n",
    "plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi], #Definition der Punkte\n",
    "[r'$-\\pi$', r'$-\\pi/2$', r'$0$', r'$+\\pi/2$', r'$+\\pi$']); #zugehörige Label in Latex Notation \n",
    "    \n",
    "plt.yticks([-1, 0, +1], [r'$-1$', r'$0$', r'$+1$']);\n",
    "plt.xlabel('x-Values'); #Beschriftung x-Achse\n",
    "plt.ylabel('y-Values'); #Beschriftung y-Achse \n",
    "plt.title('Sinus und Cosinus'); #Titel der Graphik"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...jetzt noch eine Legende"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 6), dpi=80);\n",
    "\n",
    "plt.plot(X, C, color=\"blue\", linewidth=2.5, linestyle=\"-\", label=\"Cosinus\"); #<- das Label muß HIER angegeben werden\n",
    "plt.plot(X, S, color=\"red\", linewidth=2.5, linestyle=\"-\", label=\"Sinus\"); #<- das Label muß HIER angegeben werden\n",
    "\n",
    "plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi], #Definition der Punkte\n",
    "[r'$-\\pi$', r'$-\\pi/2$', r'$0$', r'$+\\pi/2$', r'$+\\pi$']); #zugehörige Label in Latex Notation\n",
    "\n",
    "plt.yticks([-1, 0, +1], [r'$-1$', r'$0$', r'$+1$']);\n",
    "plt.xlabel('x-Values');\n",
    "plt.ylabel('y-Values'); \n",
    "plt.title('Sinus and Cosinus');\n",
    "plt.legend(loc='upper left'); #Befehl zum Anzeigen der Legende mit Angabe der Position\n",
    "\n",
    "plt.savefig(\"plots\\Lecture2\\exercice_2.png\", dpi=72)\n",
    "# Wichtig: der Pfad zum Zielordner muß angegeben werden\n",
    "# default: Graphik wird da abgespeichert, wo auch das notebook liegt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Praktisch auch: man kann mehrere Punktmengen gleichzeitig in enem Plot-Befehl einfügen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sample von Daten von 0 bis 5 in 0.2er Schritten \n",
    "t = np.arange(0., 5., 0.2)\n",
    "\n",
    "# rote Striche, blaue Quadrate und grüne Dreiecke \n",
    "\n",
    "plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2) Graphische Darstellung von Funktionen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiere eine Funktion wie bereits gesehen und lege die x-Werte fest, an denen die Funktion ausgewertet werden soll:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(t):\n",
    "    return np.exp(-t) * np.cos(2*np.pi*t) #Definiere die Funktion e^(-t) + cos(2*Pi*t) <- gedämpfte Schwingung\n",
    "\n",
    "t1 = np.arange(0.0, 5.0, 0.02) #x-Werte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "der eigentliche Plot funktioniert denkbar einfach :-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t1,f(t1), 'b');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zeige nun die gedämpfte Schwingung zusammen mit ungedämpften Cosinus..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t1,f(t1), 'b', label=\"gedämpfter Cosinus\");\n",
    "plt.plot(t1,np.cos(2*np.pi*t1),'g', label=\"ungedämpfter Cosinus\");\n",
    "plt.plot(t1,0*t1,'r', label=\"Nullinie\");\n",
    "plt.title('default: overlay');\n",
    "plt.legend(loc='upper right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Will man separate Graphiken erzeugen und keinen Overlay kann man den Befehl subplot verwenden.  \n",
    "subplot(3,2,1) heißt: 3 Zeilen, 2 Spalten und die letzte Spalte gibt an, wo das Bild in diesem Grid auftauchen soll. \n",
    "\n",
    "Hier ein Beispiel mit Funktionen ausgewertet an den x-Werten t1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplot(211);\n",
    "plt.plot(t1, f(t1), 'b', label=\"gedämpfter Cosinus\");\n",
    "plt.legend(loc='upper right');\n",
    "plt.title('verschiedene Subplots');\n",
    "\n",
    "plt.subplot(212);\n",
    "plt.plot(t1, np.cos(2*np.pi*t1), 'g--', label=\"ungedämpfter Cosinus\"); \n",
    "plt.legend(loc='upper right');\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(t,a):\n",
    "    return a*t\n",
    "plt.subplot(321); \n",
    "plt.plot(t1, f(t1,1), 'b');\n",
    "plt.title('subplot(3,2,1)');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#definiere Funktion\n",
    "def f(t,a):\n",
    "    return np.cos(a*t**3)\n",
    "\n",
    "#Größe und Auflösung der zusammengesetzten Gesamtgraphik\n",
    "plt.figure(figsize=(10, 8), dpi=90)\n",
    "\n",
    "#einzelne subplots - Nummerierung von links nach rechts und von oben nach unten\n",
    "\n",
    "plt.subplot(321);                          \n",
    "plt.plot(t1, f(t1,1), 'r');\n",
    "plt.title('subplot(3,2,1)');\n",
    "\n",
    "plt.subplot(322);\n",
    "plt.plot(t1, f(t1,2), 'b'); \n",
    "plt.title('subplot(3,2,2)');\n",
    "\n",
    "plt.subplot(323);\n",
    "plt.plot(t1, f(t1,3), 'g');\n",
    "plt.title('subplot(3,2,3)');\n",
    "\n",
    "plt.subplot(324); \n",
    "plt.plot(t1, f(t1,4), 'r--'); \n",
    "plt.title('subplot(3,2,4)');\n",
    "\n",
    "plt.subplot(325); \n",
    "plt.plot(t1, f(t1,5), 'b--'); \n",
    "plt.title('subplot(3,2,5)');\n",
    "\n",
    "plt.subplot(326); \n",
    "plt.plot(t1, f(t1,6), 'g--'); \n",
    "plt.title('subplot(3,2,6)');\n",
    "\n",
    "#sorgt dafür, daß das Spacing zwischen den Bildern gut ist, so daß sich die Beschriftungen nicht überschneiden\n",
    "plt.tight_layout();\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 1: \n",
    "\n",
    "- Definieren Sie die Funktionen  \n",
    "$f_1(x)= 4+x$, $f_2(x)= 4+x+0.5x^2$ und $f_3(x) = 4+x+0.5x^2+0.2x^3$.\n",
    "- Stellen Sie die drei Funktionen in einem sinnvollen Wertebereich in einer Graphik gemeinsam dar.  \n",
    "- Fügen Sie Achsenbeschriftungen, PlotLabel und sinnvolle Ticks ein.  \n",
    "- Berechnen Sie die Funktion  \n",
    "$f_4(x) = 1/3\\cdot(f_1(x)+f_2(x)+f_3(x))$  \n",
    "und stellen Sie alle 4 Funktionen als Subplots in einer gemeinsamen Abbildung dar.\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) 2D Graphik und besondere Darstellungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1) Scatter Plots mit $\\textit{scatter()}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zuerst erzeugen wir zwei Punktmengen.\n",
    "Jeweils ein Random Sample aus einer Normalverteilung $N(0,1)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 1024\n",
    "X = np.random.normal(0,1,n)\n",
    "Y = np.random.normal(0,1,n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ein scatter Plot stellt die geordneten Tupel $(x_i,y_i)$ aus den beiden Mengen $X$ und $Y$ als Punkte im $\\mathbb{R}^2$ dar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(X,Y); #Scatter Plot 2D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 2:\n",
    "\n",
    "- Nehmen Sie die Funktionen $f_1$ - $f_4$ aus Aufgabe 1) und erzeugen Sie sich die Punktmengen $(X,f_i(X))$ für eine sinnvolle Wahl von $X$. \n",
    "- Stellen Sie die 4 Punktmengen mit unterschiedlichen Farben in einem Scatterplot zusammen dar. \n",
    "- beschriften Sie die Graphik sinnvoll.\n",
    "                          "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2) Contour-Plots mit $\\textit{plt.contour()}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contour-Plots sind ein gutes Werkzeug um Funktionen $f(x,y)=z$ als 2-D Graphik darzustellen.  \n",
    "Zu jedem Tupel $(x,y)$ wird der Funktionswert $f(x,y)=z$ als Höhenkontur in der Graphik angezeigt.  \n",
    "Es entsteht also eine Art $\\textit{Landkarte}$ der Funktionswerte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x, y):\n",
    "    return (1 - x/2+x**5+y**3)*np.exp(-x**2-y**2) # definiere eine Funktion f(x,y)=z\n",
    "\n",
    "n = 256 #Anzahl der \n",
    "x = np.linspace(-3,3,n) # x-Werte \n",
    "y = np.linspace(-3,3,n) # y-Werte\n",
    "\n",
    "\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "plt.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap='jet')\n",
    "C = plt.contour(X, Y, f(X, Y), 8, colors='black')\n",
    "\n",
    "plt.clabel(C, inline=1, fontsize=10) \n",
    "plt.title('Default Einstellung mit Labels');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 3) \n",
    "- Definieren Sie die Funktionen $f_1(x,y) = sin(x) + cos(y)$ und $f_2(x,y) = sin(x) \\cdot cos(y)$.\n",
    "- Erzeugen Sie zwei Contour-Plots für $f_1(x)$ und $f_2(x)$ für x und y aus $I=[-Pi,Pi]$. \n",
    "- Schauen Sie in der Doku (z.B. http://matplotlib.org/examples/index.html) nach wie man die Graphiken noch anders gestalten könnte (Farbe der Flächen, Farbe und Dicke der Konturen, Labels, Größe, Schriftform etc.) und experimentieren Sie mit dem Design.\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3) Plots von Arrays mit $\\textit{plt.imshow()}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x, y):\n",
    "     return (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2) #definiere Funktion f(x,y)\n",
    "                 \n",
    "n = 40\n",
    "x = np.linspace(-3, 3, n) #x-Werte \n",
    "y = np.linspace(-3, 3, n) #y-werte\n",
    "\n",
    "X, Y = np.meshgrid(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(X,Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = plt.imshow(f(X, Y));\n",
    "plt.colorbar(C, shrink=0.9, extend='both'); #Fügt eine Colorbar ein, damit man weiß welche Werte wie eigefärbt sind"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 3) \n",
    "- Nehmen Sie die Darstellung von oben (plt.imshow()) und experimentieren Sie mit den Einstellungen für die Colorbar. \n",
    "- Schauen Sie in die Hilfe (http://matplotlib.org/examples/index.html), welche Optionen man für den imshow-Befehl noch verwenden kann und testen Sie diese Optionen.\n",
    "             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4) 3D Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um 3D Graphiken zu erzeugen benötigt man eine spezielle Toolbox."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lade 3D Toolbox\n",
    "from mpl_toolkits.mplot3d import Axes3D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure() # leere Graphik erzeugen\n",
    "\n",
    "ax = Axes3D(fig) # Achsensystem als 3D festlegen\n",
    "\n",
    "X = np.arange(-4, 4, 0.25) # x-Werte\n",
    "Y = np.arange(-4, 4, 0.25) # y-Werte\n",
    "X, Y = np.meshgrid(X, Y) # (x,y)-Tupel in einem Grid erzeugen\n",
    "Z = np.sin(X*Y) # sin(x*y) für jedes Tupel auswerten\n",
    "\n",
    "ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='jet');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure() \n",
    "\n",
    "ax = Axes3D(fig)\n",
    "X = np.arange(-4, 4, 0.25)\n",
    "Y = np.arange(-4, 4, 0.25) \n",
    "X, Y = np.meshgrid(X, Y)\n",
    "R = np.sqrt(X**2 + np.cos(Y)**2)\n",
    "\n",
    "ax.plot_surface(X, Y, R, rstride=1, cstride=1, cmap='jet');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 4) \n",
    "\n",
    "- Definieren Sie die Funktion $f_1(x,y) = sin(x) + cos(y)$ und stellen Sie sie in einer echten 3D Graphik dar. \n",
    "- Was gibt es hier für Optionen?\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5) Graphik-Tools für statistische Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use package seaborn:  \n",
    "https://seaborn.pydata.org\n",
    "\n",
    "-> \"import seaborn as sns\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...für die Beispiele importieren wir zunächst mit Hilfe von Pandas einen Testdatensatz.  \n",
    "Mehr zum Umgang mit Daten später :-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cornprice = pd.read_csv('../Daten/Test/corn2013-2017.txt') #Datenimport mit pd.read_csv\n",
    "cornprice.head() # head() gibt die ersten 5 Zeilen aus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1) Univariate Verteilungen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Histogramm der Daten mit geschätzter Verteilungsfunktion (PDF)\n",
    "cprice = cornprice['price'] # betrachte nur die Spalte mit den Preisen\n",
    "\n",
    "sns.distplot(cprice); #Histogramm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.distplot(cprice, bins=20, kde=False); #Optionen: Anzahl der Bins, nur Histogramm etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 5)\n",
    "\n",
    "- Experimentieren Sie mit der Anzahl der Bins im Histogramm für den Getriedepreis.\n",
    "- Welche Anzahl von Bins macht noch Sinn?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2) Bi- und multivariate Verteilungen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CryptoMarkets = pd.read_csv('../Daten/Test/crypto-markets.csv') # Daten importieren\n",
    "CryptoMarkets.head() # erste Einträge anzeigen lassen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CryptoHigh=CryptoMarkets[\"high\"].values[0:1000] # erste 1000 Werte high - nur BTC (Bitcoin)\n",
    "CryptoLow=CryptoMarkets[\"low\"].values[0:1000]  #erste 1000 Werte low - nur BTC (Bitcoin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(CryptoHigh, label='BTC high');\n",
    "plt.plot(CryptoLow, label='BTC low');\n",
    "plt.title('BitCoin')\n",
    "plt.legend(loc='upper right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotte die gemeinsame empirische Verteilungsfunktion mit der geschätzten PDF.  \n",
    "\n",
    "Die geschätzten Marginal- oder Randverteilungen werden am Rand der Graphik mit ausgegeben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.jointplot(x=\"high\", y=\"low\", data=CryptoMarkets.iloc[:1000],kind='kde'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sucht man nach zusammenhängen von Variablen in einem Datensatz, dann ist ein paarweiser Scatter-Plot genau das Richtige!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.pairplot(CryptoMarkets.iloc[:1000]);\n",
    "#plt.savefig(\"PairPlot.pdf\", dpi=72) # saves figure to current folder!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Bemerkung:}$  \n",
    "der Pairplot such in den Daten automatisch nach float und integer Größen für die diese Darstellun g dann auch Sinn macht.  \n",
    "Die Achsenbeschriftungen werden automatisch (Benutzung der Header im File) erzeugt!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CryptoMarkets.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.3) Spezielle Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nicht numerische Daten sind gerade bei Klassifikationsaufgaben relevant..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TipsData = pd.read_csv(\"../Daten/Test/tips.csv\")\n",
    "TipsData.dtypes\n",
    "TipsData.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ein Boxplot visualisiert die Eigenschaften der unterschiedlichen Kategorien im Datensatz!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.boxplot(x=\"day\", y=\"total_bill\", hue=\"sex\", data=TipsData, palette=\"PRGn\")\n",
    "sns.despine(offset=10, trim=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...sieht so aus, als wären die Männer i.A. etwas spendabler :-)  \n",
    "    \n",
    "Mehr Infos unter\n",
    "\n",
    "https://seaborn.pydata.org/api.html\n",
    "    \n",
    "Styling (colour, Layout, labeling, etc.) unter\n",
    "\n",
    "https://seaborn.pydata.org/tutorial/aesthetics.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pie-Charts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = 'Backwaren', 'Milchprodukte', 'Drogerie', 'Schreibwaren'\n",
    "sizes = [10, 35, 45, 10]\n",
    "explode = (0, 0.1, 0, 0)  # only \"explode\" the 2nd slice (i.e. 'Milchprodukte')\n",
    "\n",
    "fig1, ax1 = plt.subplots()\n",
    "ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "ax1.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Viele schöne Beispiele und eine gute Doku zu allen Graphikroutinen und zusätzlichen Tools findet man in der Doku von matplotlib:\n",
    "http://matplotlib.org/examples/index.html\n",
    "http://matplotlib.org/contents.html\n",
    "http://matplotlib.org/gallery.html\n",
    "\n",
    "und\n",
    "\n",
    "https://seaborn.pydata.org\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 6)\n",
    "\n",
    "Analysieren Sie die Getreidepreise aus dem Datensatz \"corn2013-2017.txt\".\n",
    "\n",
    "- Stellen Sie die Zeitverläufe der unterschiedlichen Jahre in einer geeigneten Graphik dar.\n",
    "- Vergleichen Sie die statistischen Eigenschaften der unterschiedlichen Jahre indem Sie jeweils die Histogramme der Daten graphisch darstellen.\n",
    "- Kann man mit Hilfe von scatter-Plots auch etwas über die Zusammenhänge lernen?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 7)\n",
    "\n",
    "- Nehmen Sie den Datensatz \"tips.csv\" und stellen Sie die Zusammenhänge mit einem Pairplot dar.\n",
    "- Was fällt auf?\n",
    "- Lesen Sie die Dokumentation zum Boxplot und experimentieren Sie mit den verschiedenen Darstellungsmöglichkeiten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.9.6 (default, Oct 18 2022, 12:41:40) \n[Clang 14.0.0 (clang-1400.0.29.202)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}