02_Jupyter_Notebooks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Einführung in Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sie befinden Sie in einem Jupyter Notebook. Das hier spezifische Notebook ist mit einem `iPython` Kernel verbunden, welcher in der Lage ist, `Python` Kommandos auszuführen. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Was sind Jupyter Notebooks and warum nutzen wir diese?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter Notebooks (JN) sind eine **interaktive Umgebung** innerhalb derer Sie \n",
    "\n",
    "- Programmcode ausführen können, \n",
    "- Ergebnisse visualisieren können, \n",
    "- Markdown, HTML oder Latex nutzen können\n",
    "\n",
    "Es handelt sich deshalb um eine Form des `Literate Computing` in der komplexe Analysen durchgeführt UND erläutert werden \n",
    "können.  \n",
    "\n",
    "JN bieten sich deshalb für komplexe Datenanalyse sehr gut an und haben sich hier als \"state of the art\" Werkzeug durchgesetzt.\n",
    "\n",
    "Siehe hierzu auch einen Artikel aus [**Nature**](https://www.nature.com/articles/d41586-018-07196-1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wie funktionieren Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alle JN bestehen aus Zellen. Jeglicher Inhalt - inklusive dieses Textes - befindet sich in einer Zelle. \n",
    "\n",
    "Es muss dabei zwischen `zwei Arten` von Zellen unterschieden werden:\n",
    "\n",
    "1. Markdown Zellen und \n",
    "2. Code Zellen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Markdown und Code Zellen\n",
    "Die bisherigen Zellen waren alle **Markdown-Zellen** und beinhalten deshalb nur Text. Markdown ist eine vereinfachte Auszeichnungssprache, die zum Ziel hat ohne große Formatierung und Konvertierung gut und leicht lesbaren Text zu produzieren. Sie wird vor allem auf Plattformen wie GitHub oder Stackoverflow oder von Webbloggern genutzt. \n",
    "\n",
    "Markdown ermöglicht es **Bilder**:\n",
    "\n",
    "![FH Bielefeld](./assets/FH_Bielefeld.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "oder **Formeln**\n",
    "\n",
    "$$f(x) = \\sum_{t=1}^{T} \\frac{CF_t}{(1+i)^t} + \\sqrt{a^2 + b^2}$$\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "einzubetten\n",
    "\n",
    "Weiterführende Links zu **Markdown**: \n",
    "\n",
    "- [Was ist Markdown](https://de.wikipedia.org/wiki/Markdown)\n",
    "- [Wie funktioniert Markdown](https://cmsstash.de/website-praxis/markdown-fur-webseiten)\n",
    "\n",
    "Neben den o.g. Markdown-Zellen gibt es desweiteren **Code Zellen**. In diesen wird der Programmcode geschrieben und ausgeführt. Da wir in unserem Fall einen IPython Kernel nutzen, handelt es sich dabei um Python Code.\n",
    "\n",
    "So ist die nachfolgende Zelle bspw eine Code-Zelle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie man sehen kann wird in der Zelle die Berechnung `3 + 3` durchgeführt. Das Ergebnis `=6` wird dann direkt darunter ausgegeben. \n",
    "\n",
    "Hierzu später noch mehr...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wechseln von Zellen-Typ \n",
    "\n",
    "Zwischen Markdown und Code Zellen kann ganz einfach gewechselt werden durch `ESC + M` für Markdown und `ESC + Y` für Code. Alternativ kann auch das `Menü` genutzt werden \n",
    "\n",
    "\n",
    "**Menü: Jupyter Notebooks**\n",
    "![Menü_Jupyter](./assets/Menü.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "**Menü: Google Colab**\n",
    "\n",
    "![Menü Colab](./assets/Menü_Colab.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "**Hinweis**: die Tastenkombinationen sowie die Menüleiste (siehe oben) sind in `Google Colab` teilweise etwas abweichend. Jedoch können die Tastenkombinationen selber festgelegt werden. Außerdem ist das Menü relativ intuitiv und selbsterklärend, so dass die Erläuterungen in diesem Notebook ausreichend sein sollten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Einfügen von Zellen\n",
    "\n",
    "Der große Vorteil von Jupyter Notebooks ist - neben der Integration von Textverarbeitung und Progammcode - die ermöglichte explorative Vorgehensweise bei der Durchführung von Analysen. Der Code eines Jupyter Notebooks muss nicht sequentiell ausgeführt werden, sondern man kann in jede beliebige Zelle springen und diese ausführen.\n",
    "\n",
    "Darüber hinaus können Zellen an vor oder nach jeder belieben Zelle eingefügt werden. Dies erfolgt wieder enweder über das Menü oder über die Tastenkürzel `ESC + A` (Zelle oberhalb der selektierten Zelle einfügen) oder `ESC + B` (Zelle unterhalb der selektierten Zelle einfügen. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ausführen von Zellen\n",
    "\n",
    "Jede Zelle - unabhängig davon, ob Markdown oder Code Zelle, kann u.a. durch die Tastenkombination `shift + ENTER` ausgeführt werden. Alle `Code Zellen` liefern immer eine **`Out`** Zelle mit, in welcher das Ergebnis dargestellt wird."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 + 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ein Ergebnis wird jedoch immer nur dann ausgegeben, wenn die letzte Zeile der Code-Zelle einen Output hat. Dies ist nicht der Fall, wenn z.B. das Ergebnis einer Rechnung in einer Variable festgehalten wird. \n",
    "\n",
    "**Beispiel:** Hier wird kein Ergebnis ausgegeben, sondern in der Variable \"ergebnis\" gespeichert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "ergebnis = 9 + 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es kann dann aber die Varialbe \"ergebnis\" ausgegeben werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ergebnis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Beispiel:** hier ein weiteres Beispiel. Es wird nur die letzte Zeile ausgegeben, da diese einen Output hat. Die beiden vorangegangenen Berechnungen gehen \"verloren\", weil diese weder ausgegeben noch gespeichert werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 7 \n",
    "3 + 12\n",
    "4 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5 + 7\n",
    "b = 3 + 12\n",
    "c = 4 - 2\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Beispiel:** das Print-Statement sorgt dafür, dass auch andere Zeilen ausgegeben werden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "15\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nutzung von Zellergebnissen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ergebnisse von Zellen können überall im Notebook weiterverwendet werden. So wurde z.B. einige Zellen vorab \n",
    "\n",
    "b = 3 + 12 definiert (= 15). Die Variable b kann dann einfach in einer anderen Zelle weitergenutzt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tab Completion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Teil 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit Hilfe von `tab completion` werden die bereits definierten bzw. verwendeten Variablen angezeigt. Hat man bspw. zwei Variablen im Notebook definiert\n",
    "\n",
    "- kleine_Zahl_1 = 12\n",
    "- kleine_Zahl_2 = 15\n",
    "\n",
    "So kann man durch eingabe von `kl` + `tab` eine Vorschlagsliste erhalten, in dem die bereits definierten Variablen aufgeführt sind. \n",
    "\n",
    "![Tab Completion](./assets/Tab_Completion.png)\n",
    "\n",
    "Probieren Sie es aus...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "kleine_Zahl_1 = 12\n",
    "kleine_Zahl_2 = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Teil 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neben der Anzeige von bereits definierten Variablen kann `tab completion` jedoch auf genutzt werden, um verfügbare Operationen einer Variable anzeigen zu lassen. \n",
    "\n",
    "So verfügt in Python eine Variable vom Type `list` über verschiedene Operationen, z.B. \n",
    "\n",
    "- sortieren\n",
    "- einfügen\n",
    "- löschen \n",
    "\n",
    "etc. \n",
    "\n",
    "Diese Operationen werden einem via `tab completion` angezeigt, so dass man diese nicht alle auswendig im Kopf haben muss. \n",
    "\n",
    "`liste = [1, 2, 3, 4, 5, 6]`\n",
    "\n",
    "Durch die Eingabe der Variable (hier \"liste\") sowie `.` und `tab` werden einem die verfügbaren Operationen angezeigt. \n",
    "\n",
    "![Tab Completion 2](./assets/Tab_Completion_2.png)\n",
    "\n",
    "\n",
    "Probieren Sie es aus....\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste = [1,2,3,4, 5, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kommentare in Code-Zellen\n",
    "\n",
    "Es ist möglich Kommentare in Code-Zellen einzufügen - auch wenn das in Jupyter Notebooks oft nicht nötig ist, da die Kommentierung auch über die Markdown Zellen erfolgen kann. Die Kommentarfunktion ist abhängig von der Programmiersprache und damit vom Kernel, der genutzt wird. In unserem Fall kann deshalb das \"#\" aus Python genutzt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# hier wird eine wichtige Berechnung durchgeführt\n",
    "3 / 2.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kurze Übungsaufgabe\n",
    "\n",
    "Wieviele Sekunden hat das Semester?\n",
    "\n",
    "Annahme: ein Semester dauert 12 Wochen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ihr Code hier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[<center><< zurück zur Einführung</center>](01_Einführung.ipynb)[<center>weiter zur Einführung Python >></center>](03_Einführung_Python.ipynb)"
   ]
  }
 ],
 "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
}