jupyter_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Einführung in Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Was Sie hier gerade verwenden, ist ein sogenanntes *Jupyter Notebook*. [`Jupyter`](https://jupyter.org/) steht für [`Julia`](https://julialang.org/), [`Python`](https://www.python.org/), [`R`](https://www.r-project.org/), welche die drei populärsten Programmiersprachen im Bereich Data Science sind. *Jupyter Notebooks* sind eine Umsetzung des Konzepts des sogenannten [Literate Programming](https://de.wikipedia.org/wiki/Literate_programming), da sie Text, Code, sowie den Output des Codes in einem Dokument darstellen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zellen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Jupyter Notebooks gibt es zwei Arten sogenannter Zellen (cells): \n",
    "* Code-Zellen (code cells)\n",
    "* Text-Zellen (text cells)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text-Zellen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Text-Zellen sind das, was Sie hier gerade lesen. Für Sie wird [`Markdown`](https://de.wikipedia.org/wiki/Markdown) verwendet. `Markdown` ist eine sogenannte Markup Language, welche die einfache Formatierung von Texte ermöglicht. So lassen sich beispielsweise Links in Texte einfügen (wie bei den Begriffen `Jupyter`, `Julia`, `Python`, `R` sowie Literate Programming im ersten Absatz). Eine gute Einführung in `Markdown` bietet der [`Markdown` Guide](https://www.markdownguide.org/) (eine Kurzübersicht liefert z.B. das [`Markdown` Cheatsheet von Adam Pritchard](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)). Genau genommen, verwenden Jupyter Notebooks das sogenannte *GitHub-Flavored Markdown* (welches für die Code-Sharing Plattform [*GitHub*](https://github.com/) entwickelt wurde; daher der Name), das einige eigene bzw. zusätzliche [Formatierungsoptionen](https://docs.github.com/en/free-pro-team@latest/github/writing-on-github/basic-writing-and-formatting-syntax) bietet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code-Zellen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code-Zellen beinhalten ausführbaren Code. In welcher Programmiersprache der Code geschrieben werden kann, hängt vom sogenannten [Kernel](https://jupyter.readthedocs.io/en/latest/projects/kernels.html) ab, den das Notebook verwendet. Welcher das ist, sehen Sie in der oberen rechten Ecke des Dokuments (neben dem Kreis-Symbol). Dieses Notebook nutzt den `R`-Kernel, da wir für die Beispiele hier sowie in den weiteren Notebooks für die Exploration eigener digitaler Verhaltensdaten `R` verwenden werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interaktion & Bearbeitung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zellen ausführen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sie können den Code in Code-Zellen ausführen, indem Sie in die Code-Zelle klicken und dann das Play-Symbol im Menü links oben im Notebook klicken. Alternativ können Sie auch *Strg + Enter* drücken (oder *Shift + Enter*, um direkt nach dem Ausführen zur nächsten Zelle zu springen). Es gibt zahlreiche weitere Keyboard Shortcuts für Jupyter Notebooks. Viele davon werden in einem [Post auf *Medium* von Ventsislav Yordanov](https://towardsdatascience.com/jypyter-notebook-shortcuts-bf0101a98330) in der Reihe [*Towards Data Science*](https://towardsdatascience.com/) erklärt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die nachfolgende Code-Zelle können Sie ausführen, um die `R`-Pakete zu laden, die wir für das Beispiel in diesem Notebook benötigen. Dass es sich bei der folgenden Zelle um eine Code-Zelle handelt, sehen Sie an der eckigen Klammer. Wenn der Code läuft, wird in der eckigen Klammer das Sternchen-Symbol \\* angezeigt. Wenn der Code ausgeführt wurde, wird in der eckigen Klammer eine Zahl angezeigt. Diese Zahl gibt an, in welcher Reihenfolge die Code-Zellen ausgeführt wurden. Dies ist besonders auch für Code-Zellen hilfreich, die keinen Output erzeugen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "library(readr)\n",
    "library(magrittr)\n",
    "library(tidyr)\n",
    "library(dplyr)\n",
    "library(ggplot2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auch Text-Zellen können ausgeführt werden. Dann wird statt des Inputs (Markdown-Code) der Output (formatierter Text) angezeigt. In diesem Notebook wurden alle Text-Zellen bereits ausgeführt, so dass der formatierte Text angezeigt wird. Sie können sowohl Text- als auch Code-Zellen bearbeiten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zellen bearbeiten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es gibt zwei Modi in Jupyter Notebooks:\n",
    "* Command Mode\n",
    "* Edit Mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im Command Mode können Sie Code-Zellen ausführen, neue Zellen einfügen oder vorhandene Zellen löschen. Im Edit Mode können Sie Zellen bzw. deren Inhalt bearbeiten. In welchem Modus Sie sich gerade befinden, wird Ihnen unten rechts am Rand des Notebooks angezeigt (Mode: Edit oder Mode: Command). Um in den Edit Mode zu wechseln, müssen Sie eine Zelle auswählen und Return/Enter klicken. Alternativ können Sie diese auch einfach (Code-Zelle) oder doppelt (Text-Zelle) anklicken. Um wieder in den Command Mode zu wechseln, können Sie die Zelle ausführen oder *Escape* drücken."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im Command Mode können Sie auch neue Zellen einfügen. Um über der aktuell angewählten Zelle eine weitere einzufügen, drücken sie die a-Taste (für above). Um unter der ausgewählten Zelle eine neue einzufügen, drücken Sie *b* (für below)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für jede Zelle können Sie zwischen dem Typ Code oder Text (Markdown) wählen bzw. wechseln (der Default für neue Zellen ist Code). Dies können Sie entweder über das Menü des Notebooks machen (über den kleinen Pfeil neben der Angabe des aktuellen Zellen-Typs; in der Nähe des Play-Symbols) oder Sie verwenden die Tastaturkürzel *m* für Text (Markdown) und *y* für Code (hierfür müssen Sie im Command Mode sein). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um eine Zelle zu löschen, wählen Sie diese aus und drücken 2x die Taste *d*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jupyter-Lab-Menü"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir nutzen zur Interaktion mit und Bearbeitung von Jupyter Notebooks [*Jupyter Lab*](https://jupyterlab.readthedocs.io/en/stable/). Das Jupyter-Lab-Menü befindet sich auf der linken Seite. Dort sehen Sie einen File Explorer (ähnlich wie bei Betriebssystemen wie *Windows* oder *MacOS*), über den Sie Dateien auswählen und öffnen können. Jupyter Notebooks haben die Dateiendung `.ipynb`. Neben Ihnen lassen Sie im Jupyter Lab auch einige andere Dateitypen öffnen (z.B. .csv-Dateien), jedoch deutlich weniger als in Ihrem lokalen Betriebssystem. Sie können über den File Explorer auch den Ordner wechseln. Zudem können Sie neue Ordner erstellen und Dateien hinzufügen/hochladen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Über den Menüreiter *File* können Sie bspw. Notebooks speichern oder in einem anderen Dateiformat exportieren. Sie können auch ein Notebook als solches (`.ipynb`-Datei) herunterladen, indem Sie einen Rechtsklick auf die entsprechende Datei im File Explorer auf der linken Seite machen und *Download* auswählen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Über das Menüband ganz links können Sie sich beispielsweise alle Befehle anzeigen lassen (hier werden auch die entsprechenden Keyboard Shortcuts aufgeführt), nach Befehlen suchen und diese ausführen. Diese Funktionen finden Sie über den Menüpunkt, der aussieht wie ein Dokument mit einer kleinen Lupe oben rechts (dieser Menüpunkt lässt sich auch mit dem Keyboard Shortcut *Strg + Shift + C* aufrufen)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sofern die entsprechende Jupyter-Lab-Erweiterung aktiviert ist (was für dieses Projekt der Fall ist), lässt sich über das Icon mit den drei Strichen im linken Menüband (das aussieht, wie eine stilisierte Stichpunktliste) ein Inhaltsverzeichnis für das aktive Notebook aufrufen, welches die Navigation im Dokument erleichtert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Weitere Informationen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für ausführliche Informationen und Hilfestellungen schauen Sie am besten in die offizielle Dokumentation von [Jupyter Notebooks](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html) und [Jupyter Lab](https://jupyterlab.readthedocs.io/en/latest/user/interface.html). Zudem gibt es im Netz auch zahlreiche Tutorials zu Jupyter Notebooks. Ein sehr einsteigerfreundliches ist das von [Dataquest](https://www.dataquest.io/blog/jupyter-notebook-tutorial/) (bei dem der Fokus allerdings auf `Python` liegt)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Troubleshooting 101"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sollte bei der Ausführung von Code im Jupyter Notebook etwas nicht funktionieren, gibt es ein paar einfache Dinge, die Sie probieren können:\n",
    "1. Führen Sie die Code-Zelle nochmals aus.\n",
    "1. Sollte die Ausführung der Zelle ungewöhnlich lange dauern (das \\*-Symbol wird dauerhaft neben der Zelle angezeigt), können Sie den Kernel stoppen. Dies ist über das Stoptasten-Symbol oben links im Notebook-Menü möglich.\n",
    "1. Sollte auch dies nicht helfen, können Sie den Kernel neu starten. Dies geht über das Jupyter-Lab-Menü auf der linken Seite unter *Kernel*: *Restart Kernel...*\n",
    "1. Eine weitere Variante von \"Have you tried turning it off and on again?\" für Jupyter Notebooks ist es, das Notebook zu schließen und erneut zu öffnen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispiel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im Nachfolgenden erstellen wir als Beispiel eine Visualisierung mit `R`. Sie müssen den Code nicht verstehen, sind aber herzlich eingeladen, den Code oder auch das Jupyter Notebook zu verändern (z.B. indem Sie Text-Zellen bearbeiten oder neue Zellen einfügen)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir nutzen für das Beispiel Daten von [Gapminder](https://www.gapminder.org/). Wir verwenden für die Visualisierung Daten zu Population, Lebenserwartung und Bruttoinlandsprodukt. Zudem fügen wir noch Daten zur Fertilitätsrate hinzu. Das Ziel unseres Beispiels ist es, eins der sogenannten Bubble Charts aus dem berühmten [TED-Talk von Hans Rosling](https://www.ted.com/talks/hans_rosling_the_best_stats_you_ve_ever_seen) nachzubauen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die benötigten `R`-Pakete sollten Sie schon durch das Ausführen der Beispiel-Code-Zelle weiter oben geladen haben (falls Sie dies noch nicht gemacht haben, sollten Sie diese Zelle nun ausführen). Alle Pakete sind Teil des sogenannten [`tidyverse`](https://www.tidyverse.org/), welches eine Sammlung von `R`-Paketen ist, die speziell für den Bereich Data Science entwickelt wurden, aber generell das Arbeiten mit Daten in `R` (einlesen, aufbereiten, explorieren, visualisieren, etc.) erleichten können."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der nächste Schritt nach dem Laden der benötigten `R`-Pakete ist das Einlesen der Daten. Diese sind als `.csv`-Dateien im Ordner `data` gespeichert. *Hinweis*: Es gibt auch ein eigenes `R`-Paket namens [`gapminder`](https://github.com/jennybc/gapminder), welches einen Teil der Daten enthält. Diese sind jedoch nicht so umfangreich wie die Daten, die über die Gapminder-Webseite verfügbar sind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gap_cont <- read_csv(\"./data/countries_continent.csv\")\n",
    "gap_life <- read_csv(\"./data/life_expectancy_years.csv\")\n",
    "gap_pop <- read_csv(\"./data/population_total.csv\")\n",
    "gap_gdp <- read_csv(\"./data/gdppercapita_us_inflation_adjusted.csv\")\n",
    "gap_fert <- read_csv(\"./data/children_per_woman_total_fertility.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nach dem Einlesen der Daten müssen wir diese nun so aufbereiten, dass wir sie für unsere Visualisierung nutzen können. Hierfür ändern wir ein paar der Variablentypen und überführen alle bis auf einen der Datensätze vom sogenannten [Wide Format ins Long Format](https://de.wikipedia.org/wiki/Wide-Format_und_Long-Format). Anschließend kombinieren wir die einzelnen Datensätze zu einem großen Datensatz (über sogenannte [*joins*](https://r4ds.had.co.nz/relational-data.html)). Da die unterschiedlichen Daten für verschiedene Zeiträume vorliegen und um eine übersichtliche Visualisierung zu ermöglichen, reduzieren wir den kombinierten Datensatz zuletzt auf die Daten aus dem Jahr 2018 und beschränken uns auf Länder, für die alle Daten für 2018 vorliegen (d.h. Länder, die keine fehlenden Werte bei einer oder mehreren der Variablen im haben)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ein kurzer Hinweis für diejenigen, die bereits mit `R`, jedoch noch nicht mit dem `tidyverse` gearbeitet haben. Die Symbolkette `%>%` ist die sogenannte [Pipe](https://r4ds.had.co.nz/pipes.html). Was diese macht, ist, den Output der vorherigen Funktion (dies ist i.d.R. ein Dataframe) als Input für das erste Argument in der nachfolgenden Funktion zu übergeben. D.h. `function(data = x, value = y)` ist äquivalent zu `x %>% function(y)`. Durch den üblichen Assignment Operator `<-` in `R` ordnen wir das Ergebnis der Pipe bzw. Pipe Chain (Verkettung von Funktionen durch Pipes) einem Objekt zu, auf das wir dann in weiteren Befehlen zugreifen können."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gap_cont <- gap_cont %>% \n",
    "  mutate(continent = as.factor(continent))\n",
    "\n",
    "gap_life <- gap_life %>% \n",
    "  pivot_longer(-country,\n",
    "               names_to = \"year\",\n",
    "               values_to = \"life_exp\") %>% \n",
    "  mutate(year = as.numeric(year))\n",
    "\n",
    "gap_pop <- gap_pop %>% \n",
    "  pivot_longer(-country,\n",
    "               names_to = \"year\",\n",
    "               values_to = \"pop\") %>% \n",
    "  mutate(year = as.numeric(year))\n",
    "\n",
    "gap_gdp <- gap_gdp %>% \n",
    "  pivot_longer(-country,\n",
    "               names_to = \"year\",\n",
    "               values_to = \"gdp_percap\") %>% \n",
    "  mutate(year = as.numeric(year))\n",
    "\n",
    "gap_fert <- gap_fert %>% \n",
    "  pivot_longer(-country,\n",
    "               names_to = \"year\",\n",
    "               values_to = \"fert\") %>% \n",
    "  mutate(year = as.numeric(year))\n",
    "\n",
    "gap_full <- gap_pop %>% \n",
    "  full_join(gap_life, by = c(\"country\", \"year\")) %>% \n",
    "  full_join(gap_fert, by = c(\"country\", \"year\")) %>% \n",
    "  full_join(gap_gdp, by = c(\"country\", \"year\")) %>%\n",
    "  left_join(gap_cont, by = \"country\") \n",
    "\n",
    "gap_2018 <- gap_full %>% \n",
    "  filter(year == 2018) %>% \n",
    "  select(-year)\n",
    "\n",
    "gap_2018_complete <- gap_2018 %>% \n",
    "  drop_na()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um zu schauen, wie der finale Datensatz aussieht, können wir uns die ersten zehn Zeilen (in diesem Fall Länder) anzeigen lassen. Über den Befehl `options(scipen = 15)` stellen wir die [wissenschaftliche Notation](https://de.wikipedia.org/wiki/Wissenschaftliche_Notation) für die Darstellung besonders großer (oder kleiner) Zahlen aus (bzw. setzen das Limit für die Anzeige von Ziffern sehr hoch)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "options(scipen = 15)\n",
    "\n",
    "head(gap_2018_complete, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um die Daten weiter zu explorieren, können wir die Länder in in auf- oder absteigender Reihenfolge nach verschiedenen Variablen sortieren. Hierdurch ist es möglich, einen ersten Eindruck davon zu bekommen, ob bestimmte Variablen evtl. zusammenhängen (z.B. das Bruttoinlandsprodukt und die durchschnittliche Lebenserwartung in einem Land)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gap_2018_complete %>% \n",
    "  arrange(desc(gdp_percap)) %>% \n",
    "  head(10)\n",
    "\n",
    "gap_2018_complete %>% \n",
    "  arrange(desc(life_exp)) %>% \n",
    "  head(10)\n",
    "\n",
    "gap_2018_complete %>% \n",
    "  arrange(gdp_percap) %>% \n",
    "  head(10)\n",
    "\n",
    "gap_2018_complete %>% \n",
    "  arrange(life_exp) %>% \n",
    "  head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nachdem wir nun die Daten ins richtige Format gebracht haben, erstellen wir unseren Plot. Auch hier müssen Sie den Code nicht verstehen. Dennoch ein paar Hinweise: Wir nutzen für die Visualisierung das `R`-Paket [`ggplot2`](https://ggplot2.tidyverse.org/), welches auch Teil des `tidyverse` ist. Auf der X-Achse ist das Bruttoinlandsprodukt des jeweiligen Landes dargestellt. Da dieses sehr schief verteilt ist, werden die Werte auf dieser Achse logarithmiert. Auf der Y-Achse ist die durchschnittliche Lebenserwartung abgetragen. Die Größe der Kreise repräsentiert die Bevölkerungsgröße der Länder und die Farben geben an, auf welchem Kontinent sie liegen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gap_2018_complete %>% \n",
    "  ggplot(aes(x = gdp_percap, y = life_exp)) +\n",
    "  geom_point(aes(size = pop, color = continent), alpha = .5) +\n",
    "  scale_x_log10() +\n",
    "  labs(title = \"GDP per capita, life expectancy, and population in 2018\",\n",
    "       x = \"GDP per capita\",\n",
    "       y = \"Life expectancy\",\n",
    "       size = \"Population\",\n",
    "       color = \"Continent\",\n",
    "       caption = \"Source: gapminder.org\") +\n",
    "  theme_bw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie weiter oben erwähnt, können Sie gerne den Code bearbeiten, um die Visualisierung zu verändern. Eine einfache Option ist z.B. die Änderung der Labels (Titel, Achsenbeschriftung, Legende). Sie können auch die Variablen ändern, die hier visualisiert werden, wenn Sie dies versuchen mögen (Hinweis: Der Name der Fertilitätsratenvariable im Datensatz lautet `fert`)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}