202_Plots_mit_Matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kurs 5.3 \"Vom Gehirn Lernen\" -- Python-Tutorial | [Startseite](index.ipynb)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 202 - Wissenschaftliche Grafiken mit Matplotlib\n",
    "\n",
    "**\"Wissenschaftliche Grafiken\" ist ein umständlicher und viel zu langer Begriff, deswegen hat sich das englische \"Plot\" dafür eingebürgert. Und in guter denglisch Manier hat man auch gleich noch das passende Verb \"plotten\" für das Erstellen der Grafiken gebastelt.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Einfaches Plotten](#Einfaches-Plotten)\n",
    "- [Plots gestalten](#Plots-gestalten)\n",
    "- [Aufgabe 1 - Plot Design](#Aufgabe-1---Plot-Design)\n",
    "- [Plots speichern](#Plots-speichern)\n",
    "- [Aufgabe 2 - Temperaturen in Heidelberg visualisieren](#Aufgabe-2---Temperaturen-in-Heidelberg-visualisieren)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir können mit Numpy nun numerisch Daten auswerten, und um diese zu visualisieren können wir mit dem **Matplotlib** Modul Plots von wissenschaftlicher Qualität erstellen.\n",
    "\n",
    "Per Konvention importieren wir das PyPlot Submodul von Matplotlib unter dem Namen `plt`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "% matplotlib inline  # das ist einer sogenannter \"cell magic command\",\n",
    "# also ein -- naja -- \"magischer\" Jupyter-Befehl, der dem Jupyter-Notebook mitteilt,\n",
    "# dass die Plots direkt unter den Zellen angezeigt werden sollen.\n",
    "# kleiner Hinweis: eigentlich ist dieser Befehl heutzutage obsolet, aber auf\n",
    "# EBRAINS wird er scheinbar doch noch benötigt...\n",
    "\n",
    "import matplotlib.pyplot as plt  # Die Abkürzung `plt` ist Konvention\n",
    "\n",
    "# Numpy brauchen wir immer.\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Einfaches Plotten\n",
    "\n",
    "PyPlot stellt einige grundlegende Funktionen zur Verfügung, mit denen wir Daten schnell plotten können:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`plot`** nimmt x- und y-Daten sowie eine Vielzahl von optionalen Argumenten zur Konfiguration an. Fehlen die x-Daten, werden die Indizes der y-Daten verwendet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(-10, 10, 0.1)\n",
    "y = np.arange(-10, 10, 0.1) ** 2\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(y)  # Beachte die x-Achse die du hier bekommst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entfernt das '`#`'-Zeichen und schaut euch die Argumente in der Dokumentation an, mit denen wir den Plot konfigurieren können:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.plot?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib bietet unzählige Möglichkeiten, das Aussehen von Plots anzupassen! Ihr könnt oben einige ausprobieren, wie bspw. `color`, `linestyle` und `linewidth`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`scatter`** plottet Datenpunkte statt einer Linie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(10)\n",
    "y = np.arange(10) ** 2\n",
    "plt.scatter(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.scatter?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`errorbar`** nimmt zusätzlich Fehler in x- und y-Richtung an und zeichnet Fehlerbalken:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(10)\n",
    "y = np.arange(10) ** 2\n",
    "err = np.arange(1, 6, 0.5)\n",
    "\n",
    "plt.errorbar(x, y, yerr=err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.errorbar?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`hist`** plottet schnell ein Histogramm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = plt.hist(np.random.normal(size=100), bins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.hist?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Alternativ könnt ihr Histogramme mit `numpy.histogram` und `matplotlib.pyplot.bar` plotten. Diese Methode bietet etwas mehr Kontrolle über die Berechnung der Histogrammdaten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`imshow`** visualisiert zweidimensionale Daten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_values = np.random.random((64, 64))\n",
    "plt.imshow(random_values, interpolation=\"none\")\n",
    "plt.colorbar()  # die Farbe codiert den Wert der Einträge des zweidimensionalen arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.imshow?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plots gestalten\n",
    "\n",
    "Mit Matplotlib könnt ihr jegliche Plots erstellen, die ihr euch vorstellen könnt. Überlegt euch zuerst, wie der Plot aussehen soll. Die [Gallerie](http://matplotlib.org/gallery.html) kann dabei helfen. Mit einer beherzten Websuche, die meist direkt zur [Dokumentation](http://matplotlib.org/api/pyplot_api.html) führt, findet ihr dann die Funktionen, die ihr braucht.\n",
    "\n",
    "> **Hinweis:** Plotten ist eine Kunst.\n",
    "\n",
    "> **Weiterer Hinweis:** Versucht's mal mit `plt.xkcd()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Titel, und Achsen und Legende\n",
    "\n",
    "Wir können Strings benutzen um die Plots mit Titel und Achsenbeschriftungen zu versehen.\n",
    "\n",
    "Üblicherweise beschriftet man eine Achse mit dem Namen der Variablen und (falls möglich) mit der physikalischen Einheit der Größe in eckigen Klammern (z.B. `[cm]`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2 * np.pi, 100)\n",
    "y1 = np.sin(x)\n",
    "y2 = np.cos(x)\n",
    "\n",
    "# Plot mit Label für Legende\n",
    "plt.plot(x, y1, label=\"sin(x)\")\n",
    "plt.plot(x, y2, label=\"cos(x)\")\n",
    "\n",
    "# Titel\n",
    "plt.title(\"Oszillation\")\n",
    "\n",
    "# Achsenlimits\n",
    "plt.xlim(0, 2 * np.pi)\n",
    "plt.ylim(-1, 1)\n",
    "\n",
    "# Achsenbeschriftungen\n",
    "plt.xlabel(\"Winkel x [rad]\")\n",
    "plt.ylabel(\"Auslenkung y [cm]\")\n",
    "\n",
    "# Legende\n",
    "plt.legend(loc=\"lower left\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 1 - Plot Design\n",
    "\n",
    "a) Erstelle einen Plot für y und z\n",
    "\n",
    "b) Beschrifte die y-Kurve mit \"y = f(x)\" und die z-Kurve mit \"z = g(x)\" in einer Legende\n",
    "\n",
    "c) Ändere die Farbe von y auf grün und von z auf rot.\n",
    "\n",
    "d) Verschiebe die Legende nach oben und in die Mitte des Plots\n",
    "\n",
    "e) Beschrifte die Achsen mit \"x\" und \"y/z\"\n",
    "\n",
    "f) Ändere den Bereich der y-Achse des Plots zu Werten zwischen -30 und 110\n",
    "\n",
    "g) Markiere jeden geplotteten Datenpunkt in den plots (Stichwort \"marker\") mit einem Punkt für y und einem Stern für z\n",
    "\n",
    "h) Ändere den linestyle für y zu gestrichelt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-10, 10, 16)\n",
    "y = 3 * x + 10\n",
    "z = x**2\n",
    "\n",
    "# DEIN CODE HIER"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plots speichern\n",
    "\n",
    "Mit `matplotlib.pyplot.savefig` könnt ihr einen Plot als Bilddatei speichern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-10, 10, 16)\n",
    "y = 3 * x + 10\n",
    "plt.plot(x, y)\n",
    "plt.savefig(\"plots/my_plot.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Du kannst die Größe (in inches) und Auflösung (in dots-per-inch dpi) des gespeicherten Plots anpassen:\n",
    ">\n",
    "> ```python\n",
    "> plt.savefig(filename, dpi=150, filesize=(10, 5))\n",
    "> ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 2 - Temperaturen in Heidelberg visualisieren\n",
    "\n",
    "Wir visualisieren nun die Temperaturdaten mit denen wir schon numerisch gearbeitet haben. Lest die Daten zunächst erneut ein:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zelle ausführen, um Daten einzulesen\n",
    "data = np.loadtxt(\"data/temperatures.txt\")\n",
    "date, T = data[np.abs(data[:, 1]) != 99, :].transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) Plottet den Temperaturverlauf über den gesamten Zeitraum. Vergesst nicht Titel, Achsenbeschriftungen und Legende."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "202-1a-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# DEIN CODE HIER"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sieht dein Plot etwa so aus?\n",
    "\n",
    "![Temperaturverlauf in Heidelberg](plots/202-1a.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setze die Variable auf `True` wenn du mit deinem Plot zufrieden bist:\n",
    "plot_1a_fertig = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "202-1a-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert (\n",
    "    plot_1a_fertig\n",
    "), \"Versuche dich an Aufgabe 1a, bis du mit deinem Plot zufrieden bist.\"\n",
    "print(\"Sieht gut aus.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Plottet den kombinierten Jahres-Temperaturverlauf, also die Temperaturdaten aufgetragen über dem Zeitpunkt innerhalb des Jahres.\n",
    "\n",
    "Plottet nur die Datenpunkte und keine verbindende Linie. Vergesst nicht Titel, Achsenbeschriftungen und Legende.\n",
    "\n",
    "**Hinweis:** Den Zeitpunkt innerhalb eines Jahres erhaltet ihr wieder mit dem Modulo Operator: `date % 1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "202-1b-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# DEIN CODE HIER"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sieht dein Plot etwa so aus?\n",
    "\n",
    "![Jahres-Temperaturverlauf in Heidelberg](plots/202-1b.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setze die Variable auf `True` wenn du mit deinem Plot zufrieden bist:\n",
    "plot_1b_fertig = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "202-1b-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert (\n",
    "    plot_1b_fertig\n",
    "), \"Versuche dich an Aufgabe 1b, bis du mit deinem Plot zufrieden bist.\"\n",
    "print(\"🖼 Wunderschön.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Nun kannst du Daten mit Numpy analysieren und mit Matplotlib plotten. \n",
    "\n",
    "[Startseite](index.ipynb) | [**>> 301 - Abschlussaufgabe**](301_Gelateria.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}