08_json.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# JSON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neben CSV-Dateien gibt es noch viele andere Strukturen, in denen Daten vorliegen und kommuniziert werden können. Ein verbreitetes Format nennt sich JSON. JSON steht für **JavaScript Object Notation**, ist jedoch von vielen Programmiersprachen und Tools adoptiert worden; So auch von Python.\n",
    "\n",
    "Während im Fall von CSV jeder Dateneintrag die selbe Form hat (jede Zeile hat genau einen Wert für jede Spalte), erlaubt JSON eine sehr freie Form. Dies wird erreicht, indem jeder **Wert** einen bestimmten Namen zugeordnet hat, ein sogenannter **Schlüssel**. Programmierer:innen nennen so eine Kombination von Schlüssel und Wert **key/value pair**.\n",
    "\n",
    "Schauen wir uns ein Beispiel an:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```json\n",
    "{\n",
    "    \"name\": \"Jannes\",\n",
    "    \"age\": 25,\n",
    "    \"height\": 1.86,\n",
    "    \"working_remote\": true,\n",
    "    \"car\": null\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unser einfaches Beispiel beschreibt eine Person und demonstriert die Datentypen, die ein JSON-Datensatz enthalten kann. Er ähnelt in der Erscheinung und Funktion einem `dict` in Python.\n",
    "\n",
    "Zeile für Zeile:\n",
    "\n",
    "- `{`\n",
    "  - Geschweifte Klammern signalisieren den Anfang und Ende eines **Objektes**. Objekte sind Sammlungen von key/value-Paaren. In Python werden diese als `dict` repräsentiert.\n",
    "- `\"name\": \"Jannes\",`\n",
    "  - Das erste key/value-Paar. `name` ist hier der Schlüssel (key) und `\"Jannes\"` ist der Wert (value). In diesem Fall ist der Wert eine Zeichenfolge (`str` in Python), erkennbar an den umschließenden Anführungszeichen.\n",
    "- `\"age\": 25,`\n",
    "  - Der Schlüssel `age` enthält eine Ganzzahl (`int` in Python)\n",
    "- `\"height\": 1.86,`\n",
    "  - `height` ist eine Kommazahl (`float` in Python)\n",
    "- `\"working_remote\": true,`\n",
    "  - Auch Boolean-Werte (`bool` in Python) sind möglich, werden allerdings anders als in Python klein geschrieben\n",
    "- `\"car\": null`\n",
    "  - `null` ist das JSON-Equivalent zu `None` und steht für \"kein Wert\"\n",
    "- `}`\n",
    "  - Signalisiert das Ende des Objektes\n",
    "\n",
    "Alle Schlüssel müssen von Anführungszeichen umschlossen sein. Außerdem ist jedes key/value-Paar in einem Objekt mit einem Komma voneinander getrennt. Das letzte Paar hat kein Komma. Aufgrund dieser Regel benötigt JSON keine Zeilenumbrüche.\n",
    "\n",
    "Nicht jeder JSON-Datensatz beginnt mit einem Objekt, oder muss überhaupt eines beinhalten. Ein einzelner Wert, sowie eine Liste (siehe nächstes Beispiel), sind auch valides JSON.\n",
    "\n",
    "Bis hierhin ist der Unterschied oder gar Vorteil zu einem CSV-Datensatz vielleicht noch nicht sehr offensichtlich. Allerdings können JSON-Datensätze Datenstrukturen abbilden, die in CSV nur schwer abzubilden sind.\n",
    "\n",
    "Betrachten wir ein weiteres, etwas komplexeres Beispiel. Angenommen, die Person aus unserem vorherigen Beispiel hätte sich ein Auto zugelegt, und wir möchten auch dieses beschreiben. Außerdem wollen wir seine Hobbies auflisten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```json\n",
    "{\n",
    "    \"name\": \"Jannes\",\n",
    "    \"age\": 25,\n",
    "    \"height\": 1.86,\n",
    "    \"working_remote\": true,\n",
    "    \"car\": {\n",
    "        \"make\": \"Toyota\",\n",
    "        \"model\": \"Auris\"\n",
    "    },\n",
    "    \"hobbies\": [\n",
    "        \"Programmieren\",\n",
    "        \"Musik machen\",\n",
    "        \"Zocken\"\n",
    "    ]\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schauen wir uns die Änderungen an unserem Datensatz an. Er besteht weiterhin aus einem Objekt, das eine Person beschreibt. Allerdings ist dem `car`-Schlüssel nun ein weiteres Objekt mit eigenen Schlüsseln und Werten zugeordnet. Außerdem ist ein neues key/value-Paar hinzugekommen. Zu dem neuen Schlüssel `hobbies` ist ein neuer Wertetyp zugeordnet: Eine Liste. Listen sind mit eckigen Klammern umschlossen und können beliebig viele Elemente enthalten, die wieder mit Kommata voneinander getrennt sind. Die Elemente einer Liste können, wie in Python auch, verschiedene Typen haben - Sie können sogar Objekte oder weitere Listen sein.\n",
    "\n",
    "Objekte und Listen können kombiniert werden, um beliebig komplexe Strukturen anzunehmen. \n",
    "\n",
    "Wie wir sehen, können wir mit JSON deutlich komplexere Strukturen abbilden, als mit CSV."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um JSON-Daten mit Python einzulesen, können wir das `json`-Modul aus der Standardbibliothek benutzen. `json.loads` erlaubt es uns, einen String direkt zu laden, während `json.load` genutzt wird, um Dateien einzulesen.\n",
    "\n",
    "Betrachten wir ein paar einfache Beispiele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "True\n",
      "[1, 2, 3, '4', 5.0, {'6': None}]\n",
      "{'key': 'value'}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "print(json.loads('42'))\n",
    "print(json.loads('true'))\n",
    "print(json.loads('[1, 2, 3, \"4\", 5.0, {\"6\": null}]'))\n",
    "print(json.loads('{\"key\": \"value\"}'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kommen wir zurück zu dem Beispiel von unserer Person und präsentieren die Daten ein wenig:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hobbies von Jannes: Programmieren, Musik machen, Zocken\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "with open('data/jannes.json') as json_file:\n",
    "    person = json.load(json_file)\n",
    "\n",
    "name = person['name']\n",
    "hobbies = ', '.join(person['hobbies'])\n",
    "print(f'Hobbies von {name}: {hobbies}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Übung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Versuch doch mal, das neue Auto von Jannes auf ähnliche Weise zu beschreiben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JSON und Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie wir gesehen haben, lassen sich mit JSON Datenstrukturen abbilden, die weitaus komplexer sind, als eine klassische Tabellenform, wie sie Pandas Dataframes enhalten. Aber nicht alle JSON-Daten sind so komplex, und nicht immer sind wir an allen Daten interessiert. \n",
    "\n",
    "Betrachten wir folgendes Beispiel einer Liste von fiktiven Personen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('data/fictional_persons.json') as json_file:\n",
    "    persons = json.load(json_file)\n",
    "\n",
    "persons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Art von Struktur kann Pandas relativ gut verstehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "persons = pd.read_json('data/fictional_persons.json')\n",
    "persons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie wir sehen, hat Pandas die Struktur der Daten korrekt interpretiert. Falls das mal nicht der Fall ist, können wir mit dem `orient`-Parameter Pandas einen Hinweis geben, in welcher Form die Daten vorliegen. Die Funktion ist [hier](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_json.html) dokumentiert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weiter geht es damit, zwei verschiedene Datenquellen miteinander zu verbinden:\n",
    "    \n",
    "**[>> Merge and Group Notebook](06_merge_and_group.ipynb)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}