04_Module_nutzen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module nutzen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bislang haben wir einige Grundlagen in Python kennengelernt. Wie wissen, was Listen sind, wie eigene Funktionen geschrieben werden etc. \n",
    "\n",
    "Grundsätzlich könnten wir also mit der Datenanalyse anfangen. Jedoch müssten wir jegliche Funktionalität (z.B. CSV-Dateien einlesen, Graphen plotten etc.) selber von Grund auf programmieren. \n",
    "\n",
    "Dies ist aber natürlich nicht notwendig, da Python sich eine großen Community erfreut und viele der **benötigten Funktionalitäten bereits von anderen programmiert** wurden. Um diese Funktionalitäten nutzen zu können (Hinweis: Python ist Open Source, d.h. der Source Code ist grundsätzlich frei zugänglich) müssen wir spezifische Module importieren. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module importieren"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dies ist in Python ziemlich einfach und wird durch den `import` Befehl erreicht.\n",
    "\n",
    "**Ein anschauliches Beispiel:** wir möchten den Sinus der Zahl 0.5 berechnen, jedoch ist diese Funktion bei den 70 buildin Funktionen nicht enthalten. Wir können also ganz einfach das Modul `math` importieren und aus diesem Modul die Funktion `sin` nutzen. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importieren des gesamten Moduls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.5\n",
    "math.sin(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importieren einzelner Funktionen oder Klassen eines Moduls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sin(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importieren und umbenennen des Moduls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m.sin(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anmerkung: für viele Module hat sich ein de facto Standard für die Umbenennung herausgebilded. \n",
    "\n",
    "So werden die für uns so wichtigen Module `pandas`, `numpy` und `matplotlib` von den meisten Python-Programmieren wiefolgt importiert:\n",
    "\n",
    "```\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wichtige Module für die Datenanalyse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python hat tausende von Modulen. Für nahezu jedes Problem gibt es bereits eine Lösung. Dies gilt natürlich auch für die Datenanalyse. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Numpy](http://www.numpy.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy ist eines der wichtigsten Module in Python. Es ermöglicht schnelle (weil meist vektorisierte) Berechnungen mit Vektoren und Matrizen. Dies ist sehr hilfreich, selbst wenn man sich nicht mit Linearer Algebra beschäftigen muss oder möchte. Jede Tabelle mit Daten kann als Matrix angesehen werden (man stelle sich bspw. eine Exceltabelle vor). \n",
    "\n",
    "Es gibt unzählige Tutorials und Supportseiten für die Bibliothek numpy. Zwei sehr gute Tutorials finden Sie hier:\n",
    "\n",
    "- kurze Einführung auf deutsch: [Link](https://www.grund-wissen.de/informatik/python/scipy/numpy.html)\n",
    "\n",
    "- ausführliches Tutorial auf englisch: [Link](https://stackabuse.com/numpy-tutorial-a-simple-example-based-guide/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im folgenden seien die Vorteiel von `numpy` und einer vektorisierten Form der Berechnung gegenüber einer Berechnung mit For-Schleifen dargestellt. \n",
    "\n",
    "**Aufgabe:** addiere die Elemente zweier (gleich großer) Vektoren. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector1 = [1,2,3,4]\n",
    "vector2 = [5,6,7,8]\n",
    "\n",
    "vector1 + vector2 # das ist nicht was wir wollen. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Elementweise Addition mit For-Schleife**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "neuer_vector = []\n",
    "for x,y in zip(vector1,vector2):\n",
    "    neuer_vector.append(x+y)\n",
    "neuer_vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Besser: mit List Comprehension**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x+y for x,y in zip(vector1,vector2)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Noch besser: mit Numpy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array(vector1)\n",
    "arr2 = np.array(vector2)\n",
    "\n",
    "arr1 + arr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Variante via Numpy ist nicht nur syntaktisch bedeutend einfacher, sondern bei großen Datenmengen auch um ein Vielfaches schneller. Mit Numpy können so ohne Probleme Millionen von Werten errechnet, transformiert etc. werden. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Pandas](https://pandas.pydata.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas baut auf numpy auf, d.h. nutzt die Funktionalität von numpy und dient insbesondere der Datenanalyse. Mithilfe von Pandas können z.B. Exceldateien sehr einfach eingelesen, angezeigt und manipuliert werden.\n",
    "\n",
    "Sehr gute Tutorials zu Pandas finden Sie z.B hier:\n",
    "\n",
    "- ein einführendes deutsches Tutorial: [Link](https://www.statworx.com/de/blog/data-science-in-python-pandas-teil-3/)\n",
    "\n",
    "- ein sehr ausführliches englisches Tutorial: [Link](https://bitbucket.org/hrojas/learn-pandas)\n",
    "\n",
    "Hier ein kurzes Beispiel: Einlesen einer Excel-Datei und Berechnung des durchschnittlichen Umsatzes je Region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nutzen Sie diese Zelle in GoogleColab\n",
    "#!wget -O \"MyData.xlsx\" \"https://www.dropbox.com/s/csjk3w6hraitb86/MyData.xlsx?dl=0\"\n",
    "#fpath = \"MyData.xlsx\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nutzen Sie diese Zelle in MyBinder \n",
    "fpath = \"data/MyData.xlsx\"    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_excel(fpath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head() # Ersten 5 Zeilen des Datensatzes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.tail() # Letzten 5 Zeilen des Datensatzes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.shape # Datensatz hat 260 Zeilen und 3 Spalten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Durchschnittlicher Umsatz je Region\n",
    "mean_per_region = df.groupby(\"Region\").agg({\"Umsatz\":[np.mean]})\n",
    "mean_per_region"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der große Vorteil von Jupyter Notebooks und einer der Hauptgründe für den großen Erfolg ist die Möglichkeit neben Text und ausführbarem Code auch Graphiken darzustellen. Um dies zu tun benötigen Sie natürlich ein Modul zum Erstellen von Charts (es sei denn, Sie wollen diese Funktionalität von Grund auf selber implementieren). \n",
    "\n",
    "Es gibt unzählige Visualisierungs-Module. Das wohl beliebteste und in Summe vielseitigste ist `matplotlib`.   \n",
    "\n",
    "Für eine gute Einführung in Matplotlib ist die offizielle Dokumentation recht hilfreich ([hier](https://matplotlib.org/users/index.html)). \n",
    "\n",
    "Andere gute Bibliotheken, auf die an dieser Stelle nicht weiter eingegangen werden soll, sind z.B.:\n",
    "\n",
    "- die deklarative Visualisierungsbibliothek [Altair](https://altair-viz.github.io/)\n",
    "\n",
    "- die webfähige Bibliothek [Plotly](https://plot.ly/python/) bzw. die darauf aufbauende Bibliothek zur Erstellung von Dashboards [Dash](https://dash.plot.ly/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib ermöglicht es nahezu jedes Detail eines Charts selber zu definieren. Das wirkt zu Anfang etwas umständlich, hat aber große Vorteile, weil man nicht - wie z.B. in Excel - beschränkt ist in dem, was man darstellen möchte. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt # Importieren der Bibliothek\n",
    "# Ermöglicht die Darstellung im Jupyter Notebook direkt \n",
    "%matplotlib inline  \n",
    "plt.style.use(\"seaborn\") # unter plt.style.available können sie sich eine Liste der verfügbaren Styles ausgeben lassen. Es ist aber auch möglich eigene Styles zu definieren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "x = np.arange(len(mean_per_region))\n",
    "y = np.array(mean_per_region[\"Umsatz\"]).flatten()\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(mean_per_region.index)\n",
    "ax.bar(x,y, align=\"center\", alpha=0.4);\n",
    "ax.set_title(\"Umsatz per Region\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da `Pandas` und `Matplotlib` zusammenarbeiten kann man in diesem Fall jedoch den Plot auch sehr viel einfacher erstellen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_per_region.plot(kind=\"bar\", legend=False,title=\"Umsatz per Region\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fazit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Summe sollte diese Zusammenstellung zwei Dinge zeigen:\n",
    "\n",
    "1. Durch den Import von Modulen kann Python um speziell benötigte Funktionalitäten erweitert werden\n",
    "\n",
    "2. Die Bibliotheken Numpy, Pandas und Matplotlib sind drei der grundlegenden Bibliotheken zur Datenanalyse in Python\n",
    "\n",
    "Natürlich gibt es noch unzählige weitere Bibliothken, die für die Datenanalyse wichtig sind. Mit den o.g. Bibliotheken kann man jedoch schon sehr viel erreichen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[<center><< zurück zu Einführung Python</center>](03_Einführung_Python.ipynb)[<center>weiter zur Datenanalyse >></center>](05_Beispiel_Datenanalyse.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python [conda env:anaconda3]",
   "language": "python",
   "name": "conda-env-anaconda3-py"
  },
  "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.6.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}