vis-plotnine.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(vis-plotnine)=\n",
    "# Data Visualisation using the Grammar of Graphics with **Plotnine**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Here you'll see how to use declarative plotting library **plotnine**.\n",
    "\n",
    "```{note}\n",
    "We recommend you use **letsplot** for declarative plotting but **plotnine** is an excellent alternative.\n",
    "```\n",
    "\n",
    "[**plotnine**](https://plotnine.readthedocs.io/en/stable/) is, like **seaborn**, a declarative library. Unlike **seaborn**, it adopts the 'grammar of graphics' approach inspired by the book 'The Grammar of Graphics' by Leland Wilkinson. **plotnine** is heavily inspired by the API of the popular **ggplot2** plotting package in the statistical programming language R. The point behind the grammar of graphics approach is that users can compose plots by explicitly mapping data to the various elements that make up the plot. It is a particularly effective approach for a whole slew of standard plots created from tidy data.\n",
    "\n",
    "As ever, we'll start by importing some key packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns  # Just for some data\n",
    "\n",
    "# Set seed for random numbers\n",
    "seed_for_prng = 78557\n",
    "prng = np.random.default_rng(seed_for_prng)  # prng=probabilistic random number generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51a55374",
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "import matplotlib_inline.backend_inline\n",
    "\n",
    "matplotlib_inline.backend_inline.set_matplotlib_formats(\"svg\")\n",
    "\n",
    "# Set max rows displayed for readability\n",
    "pd.set_option(\"display.max_rows\", 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at how to do a simple scatter plot in **plotnine**. We'll use the *mtcars* dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotnine import ggplot, geom_point, aes\n",
    "from plotnine.data import mtcars\n",
    "\n",
    "(ggplot(mtcars, aes(\"wt\", \"mpg\")) + geom_point())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, `ggplot` is the organising framework for creating a plot and `mtcars` is a dataframe with the data in that we'd like to plot. `aes` stands for aesthetic mapping and it tells **plotnine** which columns of the dataframe to treat as the x and y axis (in that order). Finally, `geom_point()` tells **plotnine** to add scatter points to the plot.\n",
    "\n",
    "If we want to add colour, we pass a colour keyword argument to `aes` like so (with 'factor' meaning treat the variable like it's a categorical):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(ggplot(mtcars, aes(\"wt\", \"mpg\", color=\"factor(gear)\")) + geom_point())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the nice aspects of the grammar of graphics approach, perhaps its best feature, is that switching to other types of 'geom' (aka chart type) is as easy as calling the same code but with a different 'geom' switched in. Note that, because we only imported one element at a time from **plotnine** we do need to explicitly import any other 'geoms' that we'd like to use, as in the next example below. But we *could* have just imported everything from **plotnine** instead using `from plotnine import *`.\n",
    "\n",
    "The next example shows how easy it is to switch between 'geoms'.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotnine import geom_smooth\n",
    "\n",
    "(ggplot(mtcars, aes(\"wt\", \"mpg\")) + geom_smooth())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, we can add *multiple* geoms to the same chart by layering them within the same call to the `ggplot()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(ggplot(mtcars, aes(\"wt\", \"mpg\")) + geom_smooth(color=\"blue\") + geom_point())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like **seaborn** and **matplotlib**, we can create facet plots too--but this time they're just a variation on the same underlying call to `ggplot()`. Let's see that same example of GDP by country rendered with **plotnine**. First, we need to grab the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas_datareader import wb\n",
    "from datetime import datetime\n",
    "\n",
    "ts_start_date = pd.to_datetime(\"1999-01-01\")\n",
    "ts_end_date = datetime.now()\n",
    "countries = [\"GBR\", \"USA\"]\n",
    "gdf_const_2015_usd_code = 'NY.GDP.MKTP.KD'\n",
    "df = wb.download(indicator=gdf_const_2015_usd_code, country=countries, start=ts_start_date, end=ts_end_date).reset_index()\n",
    "df[\"growth, %\"] = df.groupby(\"country\")[gdf_const_2015_usd_code].transform(lambda x: 100*x.pct_change(1))\n",
    "df = df.sort_values(by=\"year\")\n",
    "df = df.reset_index(drop=True)\n",
    "df[\"year\"] = df[\"year\"].astype(\"float\")  # needed for plotnine\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can get on with plotting it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotnine import geom_line, facet_wrap, theme, element_text\n",
    "(\n",
    "    ggplot(df.dropna(), aes(x=\"year\", y=\"growth, %\", color=\"country\"))\n",
    "    + geom_line()\n",
    "    + facet_wrap(\"country\", nrow=2)\n",
    "    + theme(axis_text_x=element_text(rotation=90))\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**plotnine** can do many of the same types of charts as **seaborn**; let's see some similar examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotnine import geom_violin, scale_fill_manual\n",
    "\n",
    "tips = sns.load_dataset(\"tips\")\n",
    "\n",
    "(\n",
    "    ggplot(tips, aes(\"day\", \"total_bill\", fill=\"smoker\"))\n",
    "    + geom_violin(tips)\n",
    "    + scale_fill_manual(values=[\"dodgerblue\", \"darkorange\"])\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotnine import labs\n",
    "\n",
    "penguins = sns.load_dataset(\"penguins\")\n",
    "\n",
    "(\n",
    "    ggplot(penguins, aes(x=\"bill_length_mm\", y=\"bill_depth_mm\", color=\"factor(species)\"))\n",
    "    + geom_point()\n",
    "    + geom_smooth(method=\"lm\")\n",
    "    + labs(x=\"Bill length (mm)\", y=\"Bill depth (mm)\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, an example of great practical use during exploratory analysis, the kernel density plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotnine import geom_density\n",
    "from plotnine.data import mpg\n",
    "\n",
    "(ggplot(mpg, aes(x=\"cty\", color=\"drv\", fill=\"drv\")) + geom_density(alpha=0.1))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3.10.12 ('codeforecon')",
   "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.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "c4570b151692b3082981c89d172815ada9960dee4eb0bedb37dc10c95601d3bd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}