05_Libraries_using_Matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other libraries using Matplotlib\n",
    "\n",
    "- Matplotlib provides building blocks and configuration capabilities to adapt a plot completely to your needs.\n",
    "- That's usually a couple of lines of code.\n",
    "- Providing ready made domain-specific plots is beyond the scope.\n",
    "\n",
    "There are many libraries building on top of Matplotlib https://matplotlib.org/thirdpartypackages/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write your own wrapper function\n",
    "\n",
    "Generally, you have two types:\n",
    "\n",
    "- Functions that create a complete figure\n",
    "- Functions that plot data into an existing axes\n",
    "\n",
    "\n",
    "### Creating a whole figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame.from_dict({\n",
    "    'Question 1': [10, 15, 17, 32, 26],\n",
    "    'Question 2': [26, 22, 29, 10, 13],\n",
    "    'Question 3': [35, 37, 7, 2, 19],\n",
    "    'Question 4': [32, 11, 9, 15, 33],\n",
    "    'Question 5': [21, 29, 5, 5, 40],\n",
    "    'Question 6': [8, 19, 5, 30, 38]\n",
    "    },\n",
    "    orient='index',\n",
    "    columns=[\n",
    "        'Strongly disagree', 'Disagree', 'Neither agree nor disagree', 'Agree', 'Strongly agree']\n",
    ")\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recommendation:\n",
    "\n",
    "- **Inputs:** The data  \n",
    "  Optionally add config parameters to make the plot more customizable.\n",
    "- **Output:** The created `Figure` and `Axes` (or `Axes`es), often the same as the `subplots()` return value.  \n",
    "  This gives users access to the fundamental objects and allows further customization.\n",
    "  \n",
    "\n",
    "Example: https://matplotlib.org/stable/gallery/lines_bars_and_markers/horizontal_barchart_distribution.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def survey(df):\n",
    "    \"\"\"\n",
    "    Parameters\n",
    "    ----------\n",
    "    df : DataFrame\n",
    "        A DataFrame with one row per questiong and the agreement categories\n",
    "        in the columns.\n",
    "    \"\"\"\n",
    "    data = df.to_numpy()\n",
    "    data_cum = data.cumsum(axis=1)\n",
    "    category_colors = plt.colormaps['RdYlGn'](\n",
    "        np.linspace(0.15, 0.85, data.shape[1]))\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(9.2, 5))\n",
    "    ax.invert_yaxis()\n",
    "    ax.xaxis.set_visible(False)\n",
    "    ax.set_xlim(0, np.sum(data, axis=1).max())\n",
    "\n",
    "    for i, (colname, color) in enumerate(zip(df.columns, category_colors)):\n",
    "        widths = data[:, i]\n",
    "        starts = data_cum[:, i] - widths\n",
    "        rects = ax.barh(df.index, widths, left=starts, height=0.5,\n",
    "                        label=colname, color=color)\n",
    "\n",
    "        r, g, b, _ = color\n",
    "        text_color = 'white' if r * g * b < 0.5 else 'darkgrey'\n",
    "        ax.bar_label(rects, label_type='center', color=text_color)\n",
    "    ax.legend(ncol=len(category_names), bbox_to_anchor=(0, 1),\n",
    "              loc='lower left', fontsize='small')\n",
    "\n",
    "    return fig, ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = survey(df)\n",
    "\n",
    "fig.suptitle('Test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper function to plot data\n",
    "\n",
    "- **Inputs:**\n",
    "  - The `Axes` to plot into.\n",
    "  - The data.\n",
    "  - Addtional configuration parameters. - It's often reasonable to pass through arbitrary parameters using `**kwargs`.\n",
    "- **Output:** Usually not needed, but it may be a good idea to return the created `Artist`s - like the builtin plot functions do.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_errorband(ax, x, y, err, **kwargs):\n",
    "    \"\"\"\n",
    "    Plot a line (x, y) and the corresponding error band y +/- err into the given Axes *ax*.\n",
    "    \"\"\"\n",
    "    poly = ax.fill_between(x, y-err, y+err, alpha=0.5, **kwargs)\n",
    "    line = ax.plot(x, y, **kwargs)\n",
    "    return line, poly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n",
    "np.random.seed(1)\n",
    "x = np.linspace(0, 8, 16)\n",
    "y = 3 + 4*x/8 + np.random.uniform(0.0, 0.5, len(x))\n",
    "err = 5 + np.random.normal(size=len(x))\n",
    "\n",
    "# plot\n",
    "fig, ax = plt.subplots()\n",
    "plot_errorband(ax, x, y, err)\n",
    "plot_errorband(ax, x, y+10, err, color='green')  # color='green'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Alternative: more `pyplot`-like interface\n",
    "\n",
    "Make the `Axes` *ax* an optional parameter and use `plt.gca()` if not provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_errorband(x, y, err, ax=None, **kwargs):\n",
    "    if ax is None:\n",
    "        ax = plt.gca()\n",
    "    \n",
    "    poly = ax.fill_between(x, y-err, y+err, alpha=0.5, **kwargs)\n",
    "    line = ax.plot(x, y, **kwargs)\n",
    "    return line, poly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_errorband(x, y, err)\n",
    "plot_errorband(x, y+10, err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `pandas` and matplotlib\n",
    "\n",
    "`pandas.plot` provides a high-level plotting interface to draw content of DataFrames using Matplotllib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "#import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'A': [1, 2, 4, 8], 'B': [4, 6, 3, 5]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pure Matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(df.index, df.A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `DataFrame.plot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot.line(y='A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note*: `DataFrame.plot` has originally been a single function. The kind of plot (line, bar, ...) could be chosen by the `kind` parameter. This is a bit too generic.\n",
    "\n",
    "Nowadays, `DataFrame.plot` can also be regarded as a namespace with sub-functions `DataFrame.plot.line()`, `DataFrame.plot.bar()`, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Which Axes do my data go to?\n",
    "\n",
    "Handling of Axes:\n",
    "\n",
    "- `matplotlib.pyplot`: Plot into current axes (create one if necessary)\n",
    "- `matplotlib` OOP: Explicitly create axes\n",
    "- `pandas.plot`: Creates a new axes and plots into that. Alternatively, pass an existing axes via the `ax` keyword argument.\n",
    "\n",
    "Return value:\n",
    "- `matplotlib` plotting functions return the created Artist.\n",
    "- `pandas.plot` plotting functions return the axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1, 2)\n",
    "df.plot.line(y='A')\n",
    "#df.plot.line(y='A', ax=axs[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Philosophies\n",
    "\n",
    "- Matplotlib: Every aspect of the plot is configured by a separate function.\n",
    "- `pandas.plot`: Convenience function to quickly draw data with some common settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot.line(ylim=(0, None), title='My data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(df.index, df.A, label='A')\n",
    "plt.plot(df.index, df.B, label='B')\n",
    "plt.ylim(0, None)\n",
    "plt.xlim(0, max(df.index))\n",
    "plt.legend()\n",
    "plt.title('My data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You combine both worlds:\n",
    "- Use conveninece functions to draw the main part of the figure.\n",
    "- Fine-tune further using Matplotlib functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = df.plot.line(ylim=(0, None), marker='o', title='My data')\n",
    "ax.annotate('Look here', (1, 6), xytext=(1.3, 7.2), arrowprops={'arrowstyle': '->'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.index = [f'Row {i}' for i in df.index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot.bar(rot=45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}