data2day_2023_Polars_Teil_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tvvEvKzsWboV"
   },
   "source": [
    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/bettercodepaul/data2day_2023_polars/blob/main/data2day_2023_Polars_Teil_2.ipynb\">\n",
    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
    "</a>\n",
    "\n",
    "# Polars: Der Turbo Boost für Dataframes - Teil 2\n",
    "\n",
    "Wichtige Links zur Erinnerung:\n",
    "\n",
    "- Homepage von Polars: https://www.pola.rs/\n",
    "- User-Guide: https://pola-rs.github.io/polars/user-guide/\n",
    "- API-Referenz: https://pola-rs.github.io/polars/py-polars/html/reference/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2EJKvLC6Z8ve"
   },
   "source": [
    "## Installation + Vorbereitung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MJ39jUfNjscb"
   },
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "import os.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IL4ogwh-eFM5",
    "outputId": "e4b623c6-7ffc-4785-d222-7c7559e5febf"
   },
   "outputs": [],
   "source": [
    "REQUIREMENTS_URL = \"https://github.com/bettercodepaul/data2day_2023_polars/raw/main/requirements.txt\"\n",
    "urllib.request.urlretrieve(REQUIREMENTS_URL, os.path.basename(REQUIREMENTS_URL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WH4yZSDm1rKj",
    "outputId": "8b2245ec-f31d-490a-fd19-a44c85969576"
   },
   "outputs": [],
   "source": [
    "# nicht vergessen, dass die Laufzeitumgebung ggf. neu gestartet werden muss\n",
    "!pip install -qr requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aeCD6DDzkGYC"
   },
   "outputs": [],
   "source": [
    "import polars as pl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NU9yjICo90O6",
    "outputId": "982b23fd-e81c-494e-9bfc-19f1b3a776f8"
   },
   "outputs": [],
   "source": [
    "# bis zu 60 Zeichen pro Spalte ausgeben und Fließkommazahlen nicht abkürzen\n",
    "pl.Config(fmt_str_lengths=60, fmt_float=\"full\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jV_0ZZgM16tU",
    "outputId": "4f150400-db52-4826-c1c3-44435bd8f2c9"
   },
   "outputs": [],
   "source": [
    "# Daten herunterladen\n",
    "DATA_URL = \"https://github.com/bettercodepaul/data2day_2023_polars/raw/main/spotify-charts-2017-2021-global-top200.csv.gz\"\n",
    "LOCAL_DATA_FILE_NAME = os.path.basename(DATA_URL)\n",
    "urllib.request.urlretrieve(DATA_URL, LOCAL_DATA_FILE_NAME)\n",
    "GENRES_DATA_URL = \"https://github.com/bettercodepaul/data2day_2023_polars/raw/main/track-genres.parquet\"\n",
    "LOCAL_GENRES_DATA_FILE_NAME = os.path.basename(GENRES_DATA_URL)\n",
    "urllib.request.urlretrieve(GENRES_DATA_URL, LOCAL_GENRES_DATA_FILE_NAME)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Übungen und Hilfsfunktionen herunterladen\n",
    "EXERCISES_URL = \"https://github.com/bettercodepaul/data2day_2023_polars/raw/main/data2day_exercises.py\"\n",
    "urllib.request.urlretrieve(EXERCISES_URL, os.path.basename(EXERCISES_URL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from data2day_exercises import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Daten aus CSV-Datei einlesen und Datums-Spalten parsen\n",
    "df = pl.read_csv(\"spotify-charts-2017-2021-global-top200.csv.gz\", try_parse_dates=True)\n",
    "df.head(2) # die ersten 2 Zeilen ausgeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M6SrEeCgd3D0"
   },
   "source": [
    "## Aggregationen auf Gruppen\n",
    "\n",
    "Du hast im ersten Teil schon erste Aggregat-Funktionen wie `max`, `min`, `mean` und `sum` kennengelernt. Wirklich mächtig werden diese Funktionen, wenn du sie auf Gruppen anwendest, die du aus fast beliebigen Ausdrücken bilden kannst.\n",
    "\n",
    "Die Gruppe wird mit der Methode `group_by` gebildet.\n",
    "\n",
    "Die anschließende Aggregation mit der Methode `agg`. Diese Methode funktioniert ähnlich wie ein `select`, aber für Aggregationen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# die fünf am meisten gestreamten Künstler\n",
    "(df\n",
    "    .group_by(\"artist\")\n",
    "    .agg(pl.col(\"streams\").sum())\n",
    "    .top_k(5, by=\"streams\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In einer Aggregation lassen sich auch mehrere Ausdrücke angeben..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# die fünf am meisten gestreamten Künstler und ihre durchschnittliche Platzierung in den Charts\n",
    "(df\n",
    "    .group_by(\"artist\")\n",
    "    .agg(pl.col(\"streams\").sum(), pl.col(\"rank\").mean())\n",
    "    .top_k(5, by=\"streams\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Gruppierung ist auch mit mehreren Ausdrücken möglich..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# die 5 in einem Jahr am meisten gestreamten Künstler\n",
    "(df\n",
    "    .group_by(\"artist\", pl.col(\"date\").dt.year().alias(\"year\"))\n",
    "    .agg(pl.col(\"streams\").sum())\n",
    "    .top_k(5, by=\"streams\")\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt fehlt uns aber das Jahr 2020! Zum Glück funktioniert die Funktion `head` auch auf einem gruppierten Dataframe und liefert dann die ersten *n* Zeilen je Gruppe. Nachteil gegenüber `top_k`: wir müssen dafür den Datensatz vollständig sortieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Künstler mit den meisten Streams je Jahr\n",
    "(df\n",
    "    .group_by(\"artist\", pl.col(\"date\").dt.year().alias(\"year\"))\n",
    "    .agg(pl.col(\"streams\").sum())\n",
    "    .sort(\"streams\", descending=True)\n",
    "    .group_by(\"year\")\n",
    "    .head(1)\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Du kannst auch schauen, welche Künstler die meisten verschiedenen Songs in den Top-200 hatten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Künstler mit den meisten verschiedenen Songs in den Top 200 je Jahr\n",
    "(df\n",
    "    .group_by(\"artist\", pl.col(\"date\").dt.year().alias(\"year\"))\n",
    "    .agg(pl.col(\"title\").n_unique().alias(\"distinctSongsInTop200\"))\n",
    "    .sort(\"distinctSongsInTop200\", descending=True)\n",
    "    .group_by(\"year\")\n",
    "    .head(1)\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie würde die Rangliste aussehen, wenn du die Tage auf Nummer 1 als Maßstab nimmst?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Künstler mit den meisten Tagen an Nummer 1 je Jahr\n",
    "(df\n",
    "    .filter(pl.col(\"rank\").eq(1))\n",
    "    .group_by(\"artist\", pl.col(\"date\").dt.year().alias(\"year\"))\n",
    "    .agg(pl.len().alias(\"daysOnNumberOne\"))\n",
    "    .sort(\"daysOnNumberOne\", descending=True)\n",
    "    .group_by(\"year\")\n",
    "    .head(1)\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Anstatt den gesamten Datensatz zu filtern, können wir sogar Daten in der Aggregation filtern\n",
    "(df\n",
    "    .group_by(\"artist\", pl.col(\"date\").dt.year().alias(\"year\"))\n",
    "    .agg(\n",
    "        pl.col(\"streams\").sum(),\n",
    "        pl.col(\"date\").filter(pl.col(\"rank\").eq(1)).len().alias(\"daysOnNumberOne\")\n",
    "    )\n",
    "    .sort([\"daysOnNumberOne\", \"streams\"], descending=True)\n",
    "    .group_by(\"year\")\n",
    "    .head(1)\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir haben mehr als einen Künstler pro Zeile, weil wir jede Kollaboration als einen eigenen Künstler bewerten. Es gibt viele bekannte Lieder aus solchen Kollaborationen..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_5_colabs = (df\n",
    "    .filter(pl.col(\"artist\").str.contains(\", \"))\n",
    "    .group_by(\"artist\", \"title\", \"url\")\n",
    "    .agg(pl.col(\"streams\").sum())\n",
    "    .top_k(5, by=\"streams\")\n",
    ")\n",
    "top_5_colabs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "play_song(top_5_colabs, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listen als spezieller Datentyp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Polars kann auch sehr gut mit Listen als speziellem Datentyp umgehen. Eine solche Liste ensteht, wenn wir z.B. eine Zeichenkette mit der Methode `str.split` aufteilen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"artist\" als Zeichenkette\n",
    "df.filter(pl.col(\"artist\").eq(\"Shawn Mendes, Camila Cabello\")).head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"artist\" als Liste von Zeichenketten\n",
    "(df\n",
    "    .filter(pl.col(\"artist\").eq(\"Shawn Mendes, Camila Cabello\"))\n",
    "    .head(1)\n",
    "    .with_columns(pl.col(\"artist\").str.split(\", \"))\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es ist manchmal sehr nützlich solche Listen mit der Methode `explode` auszurollen. Dadurch wird der Datensatz dann entsprechend häufig dupliziert und kann wie jede andere Spalte auch behandelt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(df\n",
    "    .filter(pl.col(\"artist\").eq(\"Shawn Mendes, Camila Cabello\"))\n",
    "    .head(1)\n",
    "    .with_columns(pl.col(\"artist\").str.split(\", \"))\n",
    "    .explode(\"artist\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir können jetzt die Künstler mit den meisten Tagen auf Nummer 1 berechnen ohne jede Kollaboration als eigenen Künstler zu interpretieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# artists with most days on number 1 per year\n",
    "(df\n",
    "    .with_columns(pl.col(\"artist\").str.split(\", \"))\n",
    "    .explode(\"artist\")\n",
    "    .group_by(\"artist\", pl.col(\"date\").dt.year().alias(\"year\"))\n",
    "    .agg(\n",
    "        pl.col(\"streams\").sum(),\n",
    "        pl.col(\"date\").filter(pl.col(\"rank\").eq(1)).len().alias(\"daysOnNumberOne\")\n",
    "    )\n",
    "    .sort([\"daysOnNumberOne\", \"streams\"], descending=True)\n",
    "    .group_by(\"year\")\n",
    "    .head(1)\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anstatt die Listen auszurollen, können wir auch direkt auf Listen-Spalten arbeiten. Passende Methode sind im Kontext `list`, z.B. `list.len()` für die Länge einer Liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wie viele Künstler sind je Top-200 Eintrag vorhanden?\n",
    "(df\n",
    "    .select(pl.col(\"artist\"))\n",
    "    .with_columns(pl.col(\"artist\").str.split(\", \"))\n",
    "    .with_columns(pl.col(\"artist\").list.len().alias(\"artistCount\"))\n",
    "    .group_by(\"artistCount\")\n",
    "    .len()\n",
    "    .sort(\"artistCount\")\n",
    "    .with_columns((pl.col(\"len\")/pl.col(\"len\").sum()).round(2).alias(\"percentage\"))\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Die Chart-Platzierung mit 10 Künstlern ist \"Pa' La Cultura\" auf Platz 151 am 7.8.2020\n",
    "play_song(df\n",
    "    .with_columns(pl.col(\"artist\").str.split(\", \").list.len().alias(\"artistCount\"))\n",
    "    .filter(pl.col(\"artistCount\").eq(10))\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Übungen zu Gruppierungen und Aggregationen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q13.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q13_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q13.check(q13_df)\n",
    "#q13.hint()\n",
    "#q13.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q14.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q14_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q14.check(q14_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q15.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q15_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q15.check(q15_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Joins & Co. - Dataframes verbinden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verketten mit `pl.concat`\n",
    "Eine flexible und einfache Art zwei Dataframes zu verbinden ist die Methode `pl.concat`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how=\"vertical\" stapelt zwei Dataframes übereinander, Namen und Typen der Spalten müssen übereinstimmen\n",
    "pl.concat([\n",
    "    df.sample(1),\n",
    "    df.sample(1)\n",
    "], how=\"vertical\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how=\"vertical_relaxed\" versucht die Datentypen anzupassen, wenn notwendig\n",
    "pl.concat([\n",
    "    df.sample(1),\n",
    "    df.sample(1).with_columns(pl.col(\"artist\").cast(pl.Categorical))\n",
    "], how=\"vertical_relaxed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how=\"diagonal\" kommt auch mit anderen Spalten-Namen klar\n",
    "pl.concat([\n",
    "    df.sample(1).select(\"title\", \"artist\", pl.col(\"rank\").alias(\"position\")),\n",
    "    df.sample(1).select(\"title\", pl.col(\"artist\").alias(\"performer\"), \"rank\")\n",
    "], how=\"diagonal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how=\"horizontal\" stapelt Dataframes nebeneinander, die Anzahl der Datensätze muss übereinstimmen\n",
    "some_df = df.sample(4)\n",
    "pl.concat([\n",
    "    some_df.select(\"title\", \"artist\"),\n",
    "    some_df.select(\"streams\", \"rank\")\n",
    "], how=\"horizontal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how=\"align\" stapelt Dataframes nebeneinander und versucht sie an den gemeinsamen Schlüssel-Spalten auszurichten\n",
    "pl.concat([\n",
    "    some_df.sample(fraction=1.0, shuffle=True).select(\"url\", \"date\", \"title\"),\n",
    "    some_df.sample(fraction=1.0, shuffle=True).select(\"url\", \"date\", \"artist\"),\n",
    "    some_df.sample(fraction=0.5, shuffle=True).select(\"url\", \"date\", \"streams\")\n",
    "], how=\"align\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit `how=align` wird eigentlich schon ein Join durchgeführt, wobei nicht wirklich klar ist auf welchen Spalten.\n",
    "\n",
    "In den meisten Fällen wird es deshalb besser sein, einen expliziten Join durchzuführen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verbinden mit `join`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit Joins können wir zwei Dataframes verbinden. Polars unterstützt folgende Join-Typen:\n",
    "\n",
    "`left.join(right, on=..., how=...)`\n",
    "\n",
    "- `full`: alle Zeilen aus `left` und `right`, auch wenn diese keinen Join-Partner im anderen Dataframe haben\n",
    "- `left`: alle Zeilen aus `left`, auch wenn diese keinen Join-Partner in `right` haben\n",
    "- `inner`: Zeilen aus `left` und `right` mit passendem Join-Partner im anderen Dataframe\n",
    "- `semi`: Zeilen aus `left` mit passendem Join-Partner in `right` (wie `inner`, aber keine neuen Spalten von `right`)\n",
    "- `anti`: Zeilen aus `left` ohne passendem Join-Partner in `right` (Gegenteil von `semi`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "left = pl.DataFrame({\n",
    "    \"key\": [0, 1, 2],\n",
    "    \"value\": [\"a\", \"b\", \"c\"]\n",
    "})\n",
    "right = pl.DataFrame({\n",
    "    \"key\": [1, 2, 3],\n",
    "    \"value\": [\"x\", \"y\", \"z\"]\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# full outer join\n",
    "left.join(right, on=\"key\", how=\"full\").sort(\"key\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# left join\n",
    "left.join(right, on=\"key\", how=\"left\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inner join\n",
    "left.join(right, on=\"key\", how=\"inner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# semi join\n",
    "left.join(right, on=\"key\", how=\"semi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# anti join\n",
    "left.join(right, on=\"key\", how=\"anti\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Übungen zu Joins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q16.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q16_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q16.check(q16_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q17.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q17_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q17.check(q17_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q18.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q18_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q18.check(q18_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gruppieren und Joinen mit Ausdrücken: `over`-Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für viele Berechnungen kann es hilfreich sein, einen Ausdruck über eine Gruppe auszuwerten.\n",
    "\n",
    "Wir könnten z.B. versuchen den Newcomer des Jahres zu bestimmen. Dafür benötigen wir eine Information, wann ein Künstler das erste mal in den Charts auftauchte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_appearance = df.group_by(\"artist\").agg(pl.col(\"date\").min().alias(\"firstChartAppearance\"))\n",
    "first_appearance.filter(pl.col(\"artist\").is_in([\"Billie Eilish\", \"Lewis Capaldi\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese neue Information können wir jetzt an den Gesamtdatensatz joinen und so den Newcomer des Jahres ermitteln."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(df\n",
    "    .join(first_appearance, on=\"artist\")\n",
    "    .filter(pl.col(\"date\").dt.year().eq(pl.col(\"firstChartAppearance\").dt.year()))\n",
    "    .group_by(pl.col(\"date\").dt.year().alias(\"year\"), \"artist\")\n",
    "    .agg(pl.col(\"streams\").sum())\n",
    "    .sort(\"streams\", descending=True)\n",
    "    .group_by(\"year\")\n",
    "    .head(1)\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ed Sheeran war zwar kein Newcomer mehr im Jahr 2017, aber uns fehlt die Informtionen aus den Vorjahren, um das besser zu machen...\n",
    "\n",
    "Wir können das gleiche aber auch ohne den Zwischendatensatz erreichen, in dem wir eine `over`-Expression nutzen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(df\n",
    "    # Ausdruck mit over statt temporärer Dataframe mit group_by, agg und join\n",
    "    .with_columns(pl.col(\"date\").min().over(\"artist\").alias(\"firstChartAppearance\"))\n",
    "    .filter(pl.col(\"date\").dt.year().eq(pl.col(\"firstChartAppearance\").dt.year()))\n",
    "    .group_by(pl.col(\"date\").dt.year().alias(\"year\"), \"artist\")\n",
    "    .agg(pl.col(\"streams\").sum())\n",
    "    .sort(\"streams\", descending=True)\n",
    "    .group_by(\"year\")\n",
    "    .head(1)\n",
    "    .sort(\"year\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für manche Berechnungen und besonders auch Plots ist es hilfreich zwischen verschiedenen Varianten eines Dataframes zu wechseln.\n",
    "\n",
    "Das Wide-Format hat mehr Spalten (Wide) und dafür weniger Zeilen.\n",
    "Das Long-Format hat mehr Zeilen (Long) und dafür weniger Spalten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_df = pl.DataFrame({\n",
    "    \"month\": [\"2023-01\", \"2023-01\", \"2023-01\", \"2023-02\"],\n",
    "    \"genre\": [\"pop\", \"rock\", \"hip-hop\", \"pop\"],\n",
    "    \"streams\": [100, 200, 300, 150] \n",
    "})\n",
    "some_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit der Methode `pivot` können wir einen Datensatz *breiter* machen, also Informationen aus Zeilen in neue Spalten transportieren. Folgende Parameter sind wichtig:\n",
    "\n",
    "- `index`: Spalten, die erhalten bleiben\n",
    "- `on`: Spalte mit Werten, aus denen neuen Spaltennamen gebildet werden\n",
    "- `values`: Spalte mit Werten, die in die neuen Spalten geschrieben werden\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_df.pivot(index=\"month\", values=\"streams\", on=\"genre\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die enstandenen `null` Werte könnten wir mit `fill_null` ersetzen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_df.pivot(index=\"month\", values=\"streams\", on=\"genre\").fill_null(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit dem Gegenstück `unpivot` können wir einen Datensatz wieder länger machen, also Informationen aus Spalten in Zeilen transportieren. Folgende Parameter sind wichtig:\n",
    "\n",
    "- `index`: Spalten, die erhalten bleiben\n",
    "- `value_name`: Name der Spalte, die die Werte aus den bestehenden Zeilen erhalten soll\n",
    "- `on`: Spalten, die die Werte für die `value_name` Spalte enthalten\n",
    "- `variable_name`: Name der Spalte, die die Spaltennamen aus `on` erhalten soll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(some_df\n",
    "    .pivot(values=\"streams\", on=\"genre\", index=\"month\")\n",
    "    .unpivot(index=\"month\", value_name=\"streams\", on=[\"pop\", \"rock\", \"hip-hop\"], variable_name=\"genre\")\n",
    "    .sort(\"month\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die `null` Werte könnten wir mit `drop_nulls` entfernen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(some_df\n",
    "    .pivot(values=\"streams\", on=\"genre\", index=\"month\")\n",
    "    .unpivot(index=\"month\", value_name=\"streams\", on=[\"pop\", \"rock\", \"hip-hop\"], variable_name=\"genre\")\n",
    "    .sort(\"month\")\n",
    "    .drop_nulls()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selektoren + horizontale Ausdrücke"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besonders für Daten im \"wide\" Format ist es oft hilfreich Operationen auf mehreren Spalten auszuführen, ohne die Spaltennamen konkret angeben zu müssen. Es kann sogar sein, dass die Spaltennamen manchmal bei der Erstellung einer Abfrage noch gar nicht bekannt sind, weil sie erst aus den konkreten Daten entstehen.\n",
    "\n",
    "Bisher haben wir immer einen einzigen Spaltennamen an `pl.col` übergeben, es gibt aber noch mehr Möglichkeiten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mehrere Spalten mit einem Namen selektieren\n",
    "df.select(pl.col(\"rank\", \"streams\").log()).head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mehrere Spalten mit einem Datentyp selektieren\n",
    "df.select(pl.col(pl.Utf8).str.to_lowercase()).head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mehrere Spalten mit einem regulären Ausdruck selektieren\n",
    "df.select(pl.col(\"^.*rt.*$\")).head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zusätzlich gibt es auch die Möglichkeit alle Spalten zu selektieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.select(pl.all()).head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oder auch bestimmte Spalten auszuschließen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alle Spalten, aber nicht \"url\"\n",
    "df.select(pl.exclude(\"url\")).head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alle Utf8-Spalten, aber nicht \"url\"\n",
    "df.select(pl.col(pl.Utf8).exclude(\"url\")).head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auf so einer Spaltenselektion, die mehr als eine Spalte beinhaltet, können wir auch \"horizontale\" Berechnungen durchführen. Dafür gibt es die Methoden `pl.horizontal_sum`, `pl.horizontal_min` und `pl.horizontal_max`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.select(pl.sum_horizontal(pl.exclude(pl.Utf8))).head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Übungen (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q19.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q19_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q19.check(q19_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frage 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q20.question()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q20_df = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q20.check(df, q20_df)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": ".venv",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}