201 - Numerik mit Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Einführungskurs für das Physikalische Anfängerpraktikum der Universität Heidelberg | [Startseite](index.ipynb)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 201 - Numerik mit Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Numpy Arrays erstellen](#Numpy-Arrays-erstellen)\n",
    "- [Aufgabe 1 - Numpy Arrays](#Aufgabe-1---Numpy-Arrays)\n",
    "- [Aufgabe 2 - Slicing](#Aufgabe-2---Slicing)\n",
    "- [Funktionen auf Arrays anwenden](#Funktionen-auf-Arrays-anwenden)\n",
    "- [Daten einlesen und speichern](#Daten-einlesen-und-speichern)\n",
    "- [Aufgabe 3 - Temperaturen in Heidelberg](#Aufgabe-3---Temperaturen-in-Heidelberg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Listen sind sehr flexibel, da sie Werte unterschiedlicher Datentypen beinhalten können und einfach verändert werden können (bspw. mit `append`). Diese Flexibilität geht jedoch auf Kosten der Performance, sodass Listen für numerische Berechnungen nicht ideal sind.\n",
    "\n",
    "Das **Numpy** Modul definiert daher den n-dimensionalen **Array** Datentyp `numpy.ndarray`, der für numerische Berechnungen auf höchst performanten C und Fortran Code zurückgreift.\n",
    "\n",
    "Arrays können nur Werte eines einzelnen numerischen Datentyps (bspw. floating point Werte) enthalten und sind sehr viel starrer als Listen. Dies ist jedoch für viele wissenschaftliche Anwendung, wie die Arbeit mit Datensätzen, genau was wir brauchen!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir importieren das Numpy Modul per Konvention unter der Abkürzung `np`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # Das Numpy Modul wird per Konvention als `np` abgekürzt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Arrays erstellen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Am einfachsten erstellen wir Numpy Arrays aus Python Listen, indem wir die `numpy.array` Funktion verwenden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([ 1, 2, 3, 5, 8, 13 ])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([ [ 1.5, 2.2, 3.1 ], [ 4.0, 5.2, 6.7 ] ])\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy Arrays haben einige **Attribute**, die hilfreiche Informationen über das Array geben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.ndim, b.ndim # Die Zahl der Dimensionen des Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape, b.shape # Die Länge des Arrays in jeder Dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.dtype, b.dtype # Der Datentyp des Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Erinnerung:** Verwendet die `<TAB>`-Autovervollständigung und die `?`-Dokumentation im Jupyter Notebook wenn ihr nicht wisst, welche Funktionen es gibt oder was diese bewirken!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Es gibt viele Möglichkeiten, Arrays zu erstellen\n",
    "\n",
    "- Die `numpy.arange` Funktion arbeitet ähnlich wie Python's `range` Funktion, kann jedoch auch floating-point Argumente annehmen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(1.5, 2, 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Außerdem sehr hilfreich sind `numpy.linspace` und `numpy.logspace`, welche eine Anzahl von Werten in linearem oder logarithmischem Abstand zwischen zwei Zahlen generiert:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linspace(10, 20, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.logspace(1, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Wir können mit `numpy.zeros` und `numpy.ones` Arrays erstellen, die mit Nullen oder Einsen gefüllt sind. Indem wir dem Argument `shape` dieser Funktionen statt einem Integer einen Tupel übergeben, können wir auch mehrdimensionale Arrays erzeugen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones((5, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mit Arrays rechnen\n",
    "\n",
    "Arrays können mit den Standardoperatoren `+-*/**` **elementweise** kombiniert werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1,2,3])\n",
    "y = np.array([4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x + 2 * y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x ** y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Achtung:** Für Python-Listen sind diese Operatoren völlig anders definiert!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen auf Arrays anwenden\n",
    "\n",
    "Während Funktionen aus dem `math` Modul wie `sin` oder `exp` auf Zahlen anwendbar sind, sind die gleichnamigen Funktionen aus dem `numpy` Modul auf Arrays anwendbar. **Die Funktion wird auf alle Element des Arrays** angewendet und ist typischerweise um einiges schneller als jedes Element einzeln zu berechnen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi = np.linspace(0, 2*np.pi, 10) # 10 Werte zwischen 0 und 2π\n",
    "np.sin(phi) # Der Sinus jedes dieser Werte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Außerdem gibt es viele Funktionen, die Eigenschaften eines Arrays berechnen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "np.sum(x), np.mean(x), np.std(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktionen generalisieren auf mehrere Dimensionen, indem die Achse angegeben wird, auf der die Berechnung durchgeführt werden soll:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([ [ 1, 2 ], [ 3, 4 ] ])\n",
    "np.sum(x), np.sum(x, axis=0), np.sum(x, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 1 - Numpy Arrays\n",
    "\n",
    "a) Erstelle ein Array `a`, das 11 Werte zwischen $10^{-20}$ und $10^{-10}$ in logarithmischem Abstand enthält."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-1a-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "a = np.logspace(-20, -10, 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-1a-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "try:\n",
    "    a\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'a'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_equal(a, [1.00000000e-20, 1.00000000e-19, 1.00000000e-18, 1.00000000e-17, 1.00000000e-16, 1.00000000e-15, 1.00000000e-14, 1.00000000e-13, 1.00000000e-12, 1.00000000e-11, 1.00000000e-10])\n",
    "print(\"Jup.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Erstelle ein Array `b`, das 2x10 Nullen enthält.\n",
    "\n",
    "**Hinweis:** Verwende die passende Funktion, die `numpy` bereitstellt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-1b-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "b = np.zeros((2, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-1b-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "try:\n",
    "    b\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'b'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_equal(b, [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])\n",
    "print(\"Gut.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Erstelle ein Array `c`, das der Einheitsmatrix in 3 Dimensionen entspricht.\n",
    "\n",
    "**Hinweis:** Auch hier stellt `numpy` bereits eine passende Funktion bereit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-1c-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "c = np.identity(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-1c-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "try:\n",
    "    c\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'c'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_equal(c, [[1,0,0],[0,1,0],[0,0,1]])\n",
    "print(\"Richtig.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Erstelle ein Array `d`, das $100$ Werte zwischen $-5$ und $5$ in linearem Abstand enthält. Dies wird eine Raumachse darstellen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-1d-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "d = np.linspace(-5, 5, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-1d-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_almost_equal\n",
    "try:\n",
    "    d\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'd'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_almost_equal(d[:5], [-5., -4.8989899, -4.7979798, -4.6969697, -4.5959596], 4)\n",
    "print(\"Stimmt.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e) Erstelle zwei zweidimensionale Arrays `x` und `y`, die jeweils in einer Richtung konstant sind und in der anderen die Raumachse `d` enthalten. So können wir gleich mit Koordinaten arbeiten.\n",
    "\n",
    "**Hinweis:** Versuche, die Funktion `numpy.meshgrid` zu verstehen. Schreib dann `x, y = np.meshgrid(d, d)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-1e-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "#np.meshgrid?\n",
    "### BEGIN SOLUTION\n",
    "x, y = np.meshgrid(d, d)\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-1e-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_almost_equal\n",
    "try:\n",
    "    x, y\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'x' oder 'y'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_almost_equal(x[:5,0], [-5, -5, -5, -5, -5], 4)\n",
    "assert_array_almost_equal(x[0,:5], [-5., -4.8989899, -4.7979798, -4.6969697, -4.5959596], 4)\n",
    "assert_array_almost_equal(y[0,:5], [-5, -5, -5, -5, -5], 4)\n",
    "assert_array_almost_equal(y[:5,0], [-5., -4.8989899, -4.7979798, -4.6969697, -4.5959596], 4)\n",
    "print(\"Alles klar? 😉\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f) Berechne aus `x` und `y` ein zweidimensionales Array `r`, dessen Werte den Abstand zum Ursprung $r=\\sqrt{x^2+y^2}$ darstellen.\n",
    "\n",
    "**Erinnerung:** Mathematische Operationen und Funktionen werden elementweise auf Numpy Arrays angewendet, du kannst also einfach mit ihnen rechnen. Denk' daran, die Funktionen aus dem `numpy` Modul zu verwenden, wie bspw. `np.sqrt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-1f-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "r = np.sqrt(x**2 + y**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-1f-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_almost_equal\n",
    "try:\n",
    "    r\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'r'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_almost_equal(r[0,:3], [ 7.07106781, 7.00000729, 6.92969048], 4)\n",
    "print(\"👍\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "g) Berechne schließlich für jeden Punkt des zweidimensionalen Raums den Wert $E = \\frac{x}{r}\\sin{\\!(\\pi r)}$. Kommt's dir bekannt vor?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-1g-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "E = x/r*np.sin(r*np.pi)\n",
    "### END SOLUTION\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.contour(x, y, E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-1g-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_almost_equal\n",
    "try:\n",
    "    E\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'E'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_almost_equal(E[0,:3], [ 1.56564647e-01, 1.60235697e-05, -1.51695015e-01 ], 4)\n",
    "print(\"Sehr gut! 👏\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Arrays sind Reihen\n",
    "\n",
    "Wir können alle Funktionen auf Numpy Arrays anwenden die für Reihen definiert sind:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(3)\n",
    "len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in a:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing wählt Teile eines Arrays aus\n",
    "\n",
    "Die **[Slicing](101%20-%20Grundlagen%20der%20Programmierung%20in%20Python.ipynb#Slicing)** Syntax von Reihen haben wir schon kennengelernt. Sie erlaubt uns, auf einzelne Elemente oder Teile einer Reihe zuzugreifen:\n",
    "\n",
    "```python\n",
    "a[start:stop:step]\n",
    "```\n",
    "\n",
    "Numpy erweitert diese Syntax auf mehrdimensionale Arrays:\n",
    "\n",
    "```python\n",
    "b[start:stop:step, start:stop:step]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativ können wir statt einem Index auch eine **Liste von Indizes** in das Subskript schreiben und erhalten die zugehörigen Elemente aus dem Array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([ 1, 6, 4, 7, 9 ])\n",
    "indices = [ 1, 0, 2, 1 ]\n",
    "x[indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Masking filtert ein Array\n",
    "\n",
    "Außerdem erweitert Numpy diese Syntax um die **Masking** Funktionalität. Dabei geben wir im Subskript ein **Array von Booleans** an, welches die gleiche Länge hat, und erhalten nur die Elemente, für die wir `True` angegeben haben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([ 1, 6, 4, 7, 9 ])\n",
    "mask = np.array([ True, True, False, False, True ])\n",
    "x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Masking ist deshalb äußerst praktisch, weil die **Vergleichsoperatoren** in Kombination mit Numpy Arrays wiederum Boolean Arrays zurückgeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x > 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Somit können wir Teile eines Arrays herausfiltern, die einer **Bedingung** entsprechen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[x > 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bedingungen werden mit dem `&` Operator kombiniert:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[(x > 4) & (x < 8)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slices oder Masken eines Arrays kann auch zugewiesen werden\n",
    "\n",
    "Wenn ein Slice oder eine Maske eines Arrays auf der linken Seite einer Zuweisung steht, wird diesem Teil des Original-Arrays zugewiesen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([ 1, 6, 4, 7, 9 ])\n",
    "x[x > 4] = 0\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 2 - Masken & Slicing\n",
    "\n",
    "a) Gegeben ein Array `x` der Länge `n`, berechne das Array `dx` der Länge `n-1` mit den Werten `dx[i] = x[i+1] - x[i]`. Verwende keine Schleifen sondern Slicing!\n",
    "\n",
    "**Hinweis:** Du musst zwei Arrays subtrahieren, von denen das eine der um 1 versetzte hintere und das andere der vordere Teil von `x` ist.\n",
    "\n",
    "**Erinnerung:** Mit negativen Zahlen im Subskript wählst du Indizes vom Ende einer Reihe aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-2a-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "x = np.array([ 1, 1, 2, 3, 5, 8 ])\n",
    "### BEGIN SOLUTION\n",
    "dx = x[1:] - x[:-1]\n",
    "### END SOLUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-2a-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "try:\n",
    "    dx\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'dx'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_equal(dx, [0, 1, 1, 2, 3])\n",
    "print(\"EZ 😉\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Erstelle eine Maske `binary_donut`, die nur für Werte von `r` zwischen $5$ und $2$ `True` ist, und sonst `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-2b-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "x, y = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6))\n",
    "r = np.sqrt(x**2 + y**2)\n",
    "### BEGIN SOLUTION\n",
    "binary_donut = (r > 2) & (r < 5)\n",
    "### END SOLUTION\n",
    "print(binary_donut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-2b-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "try:\n",
    "    binary_donut\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'binary_donut'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_equal(binary_donut[1,:], [False, False, False, True, True, True, True, True, False, False, False])\n",
    "print(\"mhm 🍩!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Wähle aus `z` solche Werte, die der Maske `binary_donut` entsprechen, und weise sie der Variable `n` zu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-2c-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "z = x + y\n",
    "print(z)\n",
    "### BEGIN SOLUTION\n",
    "n = z[binary_donut]\n",
    "### END SOLUTION\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-2c-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "try:\n",
    "    n\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'n'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "assert_array_equal(n[:10], [-6, -5, -4, -3, -2, -6, -5, -4, -3, -2])\n",
    "print(\"👌\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Daten einlesen und speichern"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit der `numpy.loadtxt` Funktion können wir Daten aus einer Datei als Numpy Array einlesen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.loadtxt('data/temperatures.txt')\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion gibt ein zweidimensionales Array mit den _Zeilen_ der eingelesenen Datei zurück. Alle Werte einer _Spalte_ können wir durch Slicing erhalten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date = data[:,0] # Alle Zeilen, jeweils erste Spalte\n",
    "T = data[:,1] # Alle Zeilen, jeweils zweite Spalte\n",
    "date, T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Die `numpy.loadtxt` Funktion kann auch direkt ein Array für jede Spalte zurückgeben, wenn das Argument `unpack=True` übergeben wird:\n",
    ">\n",
    "> ```python\n",
    "> date, T = np.loadtxt('data/temperatures.txt', unpack=True)\n",
    "> ```\n",
    ">\n",
    "> Weitere praktische Optionen, wie die ersten Zeilen zu überspringen u.ä., findet ihr in der Dokumentation. Entfernt das '`#`'-Zeichen in der folgenden Zelle und schaut euch die Optionen mal an:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.loadtxt?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit der verwandten `np.savetxt` Funktion können wir Daten als Textdatei abspeichern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.savetxt?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Im Jupyter Notebook erhalten wir eine praktische Vorschau auf den Anfang einer Datei mit dem `!head path/to/file` Aufruf. Dies ist sehr hilfreich um die enthaltenen Daten zu prüfen, oder ob es Titelzeilen zu Überspringen gibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!head data/temperatures.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Berechnungen zwischenspeichern mit `numpy.save`\n",
    "\n",
    "Die `numpy.loadtxt` und `numpy.savetxt` Funktionen arbeiten mit Textdateien. Wenn ihr ein Numpy Array jedoch nur zwischenspeichern möchtet, bspw. das Ergebnis einer langen numerischen Berechnung, könnt ihr es auch mit `numpy.save` in einer `.npy` Binärdatei speichern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lange numerischen Berechnung hier\n",
    "result = np.random.random(10)\n",
    "print(result)\n",
    "# Ergebnis zwischenspeichern\n",
    "np.save('data/result.npy', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anstatt die Berechnung jedes mal erneut durchführen zu müssen, könnt ihr nun einfach mit `numpy.load` das zwischengespeicherte Ergebnis laden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = np.load('data/result.npy')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Diese Vorgehensweise kann viel Zeit sparen während ihr an einem Teil eures Programms arbeitet, das die numerische Berechnung nicht betrifft, bspw. die graphische Ausgabe als Plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 3 - Temperaturen in Heidelberg\n",
    "\n",
    "Die Datei `data/temperatures.txt` enthält Temperaturdaten aus Heidelberg von 1995 bis einschließlich 2012. Schaue dir die Struktur der Daten zunächst an:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!head data/temperatures.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) Lies die Daten mithilfe der `numpy.loadtxt` Funktion ein und weise die beiden Spalten zwei Variablen `date` und `T` zu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-3a-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "date, T = np.loadtxt('data/temperatures.txt', unpack=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-3a-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_almost_equal\n",
    "try:\n",
    "    date\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'date'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "try:\n",
    "    T\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'T'. Weise das Array einer Variablen mit diesem Namen zu.\")\n",
    "\n",
    "assert_array_almost_equal(date[:3], [ 1995.00274, 1995.00548, 1995.00821], 4, \"Das Array 'date' enthält nicht die richtigen Daten. Verwende die 'unpack=True' Funktion von 'numpy.loadtxt' wie im Hinweis oben.\")\n",
    "assert_array_almost_equal(T[:3], [ 0.944444, -1.61111, -3.55556], 4, \"Das Array 'T' enthält nicht die richtigen Daten. Verwende die 'unpack=True' Funktion von 'numpy.loadtxt' wie im Hinweis oben.\")\n",
    "print(\"Daten eingelesen!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Berechne für jedes Jahr von 1995 bis einschließlich 2012 die Durchschnittstemperatur, die minimale und die maximale Temperatur. Füge dabei der Liste `yearly_temperatures` für jedes Jahr eine Zeile mit dem Jahr und diesen drei Werten hinzu.\n",
    "\n",
    "Die Datei enthält fehlerhafte Daten, die durch den Wert `+/-99` gekennzeichnet sind und nicht in die Berechnung mit einbezogen werden dürfen.\n",
    "\n",
    "**Hinweis:** Gehe die Jahre in einer for-Schleife durch und verwende eine Maske für das Array `T`, sodass du nur die Temperaturdaten des entsprechenden Jahres als Slice erhälst. Darauf kannst du dann die Numpy Funktionen für den Mittelwert, das Minimum und das Maximum anwenden.\n",
    "\n",
    "**Erinnerung:** Mehrere Masken kannst du mit dem `&`-Operator kombinieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-3b-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "yearly_temperatures = []\n",
    "### BEGIN SOLUTION\n",
    "for year in range(1995, 2013):\n",
    "    temperatures = T[(date >= year) & (date < year + 1) & (np.abs(T) != 99)]\n",
    "    yearly_temperatures.append([year, np.mean(temperatures), np.min(temperatures), np.max(temperatures)])\n",
    "### END SOLUTION\n",
    "from tabulate import tabulate\n",
    "print(tabulate(yearly_temperatures, headers=[\"Jahr\", \"Durchschnitt [°C]\", \"Minimal [°C]\", \"Maximal [°C]\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-3b-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_almost_equal\n",
    "assert_array_almost_equal(yearly_temperatures[0], [ 1995, 8.7656, -13.2778, 25.9444 ], 4, \"Die Daten sind nicht richtig. Überprüfe, ob jedes Element der Liste 'yearly_temperatures' wiederum eine Liste mit den Werten Jahr, Durchschnittstemperatur, Minimum und Maximum ist und du die fehlerhaften Werte +/-99 herausgefiltert hast.\")\n",
    "print(\"Ganz schön warm, oder? ☀️🌴😅\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Berechne diese Daten analog aufgeteilt in Monate statt Jahre, also bspw. die Durschnittstemperatur im Januar im ganzen gemessenen Zeitraum.\n",
    "\n",
    "**Hinweis:** Den Zeitpunkt innerhalb eines Jahres, wobei `0` dem Jahresanfang und `1` dem Jahresende entspricht, erhälst du mit dem Modulo Operator: `date % 1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "201-3c-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "monthly_temperatures = []\n",
    "### BEGIN SOLUTION\n",
    "for month in range(0, 12):\n",
    "    temperatures = T[(date % 1 >= month / 12) & (date % 1 < (month + 1) / 12) & (np.abs(T) != 99)]\n",
    "    monthly_temperatures.append([month + 1, np.mean(temperatures), np.min(temperatures), np.max(temperatures)])\n",
    "### END SOLUTION\n",
    "from tabulate import tabulate\n",
    "print(tabulate(monthly_temperatures, headers=[\"Monat\", \"Durchschnitt [°C]\", \"Minimal [°C]\", \"Maximal [°C]\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "201-3c-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_almost_equal\n",
    "assert_array_almost_equal(monthly_temperatures[0][1:], [ -0.8494, -16.7778, 12.2222 ], 4, \"Die Daten sind nicht richtig. Überprüfe, ob jedes Element der Liste 'monthly_temperatures' wiederum eine Liste mit den Werten Monat, Durchschnittstemperatur, Minimum und Maximum ist und du die fehlerhaften Werte +/-99 herausgefiltert hast.\")\n",
    "print(\"👍 Sieht richtig aus.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Du kannst jetzt Daten einlesen und mit Numpy analysieren. Lerne in der nächsten Lektion, wie du mit _Matplotlib_ wissenschaftlich plotten kannst.\n",
    "\n",
    "[Startseite](index.ipynb) | [**>> 202 - Plots mit Matplotlib**](202%20-%20Plots%20mit%20Matplotlib.ipynb)"
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}