Class_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Statistics with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Koen Plevoets\n",
    "Last modified: 2020-12-11\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 6: Visualization with Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 6.1: Creating graphs with Matplotlib\n",
    "- 6.2: Statistical graphs with Matplotlib\n",
    "- 6.3: Style sheets\n",
    "- 6.4: Object-oriented approach\n",
    "- 6.5: Graphical methods in pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has some interesting modules for visualizing data. The main one is **Matplotlib**, which builds on NumPy.\n",
    "\n",
    "The Matplotlib module consists of many submodules which provide flexible ways of making graphs. There are **two** common **approaches** (API's) in Matplotlib:\n",
    "\n",
    " - The various **functions** in the submodule `pyplot` which create graphs like in MATLAB or R.\n",
    " - The **object-oriented** creation of graphs which involve methods equivalent to `pyplot` functions.\n",
    "\n",
    "**Caution**: There used to be a third approach making use of the `pylab` module but this is now **deprecated**! The reason is that `pylab` conflicts with other functionalities in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important step **before** you import matplotlib is to specify your \"**backend**\". The backend is the \"**engine**\" which makes your graphs (the frontend is your code). See more details on [this FAQ page](https://matplotlib.org/faq/usage_faq.html#what-is-a-backend).\n",
    "\n",
    "In **IPython** or **Jupyter Notebook**, the backend can be selected with the following (\"magic\") commands:\n",
    " - `%matplotlib inline`\n",
    " - `%matplotlib qt4`\n",
    " - `%matplotlib qt5`\n",
    " - `%matplotlib tk`\n",
    " - Etc.\n",
    "\n",
    "In **Spyder**, the backend can be set in the menu **Tools > Preferences > IPython console > Graphics**. If you wish your graphs in external windows, then you can select the option \"Automatic\".\n",
    "\n",
    "For a **Jupyter Notebook**, inline plots make most sense:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you have specified the backend, you can import (submodule `pyplot` of) Matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 Creating graphs with Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic function in `pyplot` is `plot()` which produces a **2-D line plot** by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you make plots in **external windows**, they may not appear immediately. In that case the function `show()` will make the external window visible. That is why the `show()` function often concludes a block of visualization commands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A plot in an **external window** will be **updated as long as it stays open**. New plot commands will automatically adjust the outlook of the plot, e.g. the axis scales. **Inline plots**, on the other hand, are fully defined by **one code block**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])\n",
    "plt.plot([1, 2, 3, 4, 5], [3, 6, 9, 12, 15])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that external plot windows need to be **closed** before you can work on. This can be done **manually** or with the function `close()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])\n",
    "plt.plot([1, 2, 3, 4, 5], [3, 6, 9, 12, 15])\n",
    "plt.close()    # Disappears"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `savefig()` **saves** the current plot to an external file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5], [1, 8, 27, 64, 125])\n",
    "plt.savefig('cubeplot.png')    # See your working directory.\n",
    "plt.savefig('cubeplot.pdf')    # Idem.\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **available graphical formats** depend on your **backend**. Usually, all the common formats are supported: `ps`, `eps`, `jpg`, `jpeg`, `pdf`, `pgf`, `png`, `raw`, `rgba`, `svg`, `svgz`, `tif` and `tiff`. See the help file of the `savefig()` function for other useful arguments such as `dpi`, `transparent`,  etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to visualize **multiple datasets** by simply specifying the **coordinates next to each other**. Python figures out that the **odd arguments** relate to the **horizontal axis** and the **even arguments** to the **vertical axis**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [1, 2, 3, 4], [3, 6, 9, 12], [1, 2, 3], [1, 8, 27])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When your data are in an object with **column names** (e.g. a **DataFrame**), you can specify the strings of the column names. The **data object** then has to be specified as the argument `data`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "dat = pd.DataFrame( {\n",
    "        'one' : [1, 2, 3, 4, 5],\n",
    "        'two' : [2, 4, 6, 8, 10],\n",
    "        'tri' : [3, 6, 9, 12, 15],\n",
    "        'cub' : [1, 8, 27, 64, 125]\n",
    "        } )\n",
    "print(dat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'tri', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the specification of **multiple column names** next to each other is **not possible**. Instead, you have to make **several calls** to `plot()` in an open window/one code block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', 'one', 'tri', 'one', 'cub', data = dat)    # Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', data = dat)\n",
    "plt.plot('one', 'tri', data = dat)\n",
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The outlook of a plot can be specified with the **third argument**, called \"**format**\". It is an **abbreviation** of the **color**, the **marker type**, and optionally the **line style**:\n",
    "\n",
    "- Color:\n",
    "  - `b` : blue\n",
    "  - `g` : green\n",
    "  - `r` : red\n",
    "  - `c` : cyan\n",
    "  - `m` : magenta\n",
    "  - `y` : yellow\n",
    "  - `k` : black\n",
    "  - `w` : white\n",
    "\n",
    "- Marker:\n",
    "  - `.` : point marker\n",
    "  - `,` : pixel marker\n",
    "  - `o` : circle marker\n",
    "  - `v` : triangle_down marker\n",
    "  - `^` : triangle_up marker\n",
    "  - `<` : triangle_left marker\n",
    "  - `>` : triangle_right marker\n",
    "  - `1` : tri_down marker\n",
    "  - `2` : tri_up marker\n",
    "  - `3` : tri_left marker\n",
    "  - `4` : tri_right marker\n",
    "  - `s` : square marker\n",
    "  - `p` : pentagon marker\n",
    "  - `*` : star marker\n",
    "  - `h` : hexagon1 marker\n",
    "  - `H` : hexagon2 marker\n",
    "  - `+` : plus marker\n",
    "  - `x` : x marker\n",
    "  - `D` : diamond marker\n",
    "  - `d` : thin diamond marker\n",
    "  - `|` : vline marker\n",
    "  - `_` : hline marker\n",
    "\n",
    "- Line:\n",
    "  - `-` : solid line\n",
    "  - `--` : dashed line\n",
    "  - `-.` : dash-dot line\n",
    "  - `:` : dotted line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', 'o', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', '+', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', 'ro', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', 'bs', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', 'g^--', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', 'kx:', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple **scatter plot** can also be made with the function `scatter()` but the arguments differ: the format needs to be separated into two arguments `color` and `marker`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter('one', 'cub', color = 'g', marker = '*', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many more **colors** in Matplotlib than the eight ones above, of course. Colors can be specified in a multitude of ways. The following is taken from [this webpage](https://matplotlib.org/api/colors_api.html):\n",
    "\n",
    " - an **RGB** or **RGBA tuple** of **float values** in (0, 1) (e.g. `(0.1, 0.2, 0.5)` or `(0.1, 0.2, 0.5, 0.3)`)\n",
    " - a **hex RGB** or **RGBA string** (e.g. `'#0F0F0F'` or `'#0F0F0F0F'`)\n",
    " - a **string** representation of a **float value** in (0, 1) inclusive for **gray level** (e.g. `'0.5'`)\n",
    " - one of {`'b'`, `'g'`, `'r'`, `'c'`, `'m'`, `'y'`, `'k'`, `'w'`}\n",
    " - a [X11/CSS4 color name](https://matplotlib.org/gallery/color/named_colors.html)\n",
    " - a name from the [xkcd color survey](https://xkcd.com/color/rgb/); prefixed with `xkcd:` (e.g., `'xkcd:sky blue'`)\n",
    " - one of {`'tab:blue'`, `'tab:orange'`, `'tab:green'`, `'tab:red'`, `'tab:purple'`, `'tab:brown'`, `'tab:pink'`, `'tab:gray'`, `'tab:oliv'`, `'tab:cyan'`} which are the **Tableau Colors** from the \"T10\" categorical palette (which is the default color cycle)\n",
    " - a \"**CN**\" color spec, i.e. `C` followed by a single digit, which is an index into the default property cycle (`matplotlib.rcParams['axes.prop_cycle']`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = (1, 0.65, 0), marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = '#40E0D0', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = '0.3', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = '0.7', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = 'k', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = 'lime', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = 'xkcd:ocean green', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = 'tab:olive', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', color = 'C3', marker = 'D', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to select and even create **colormaps** in Matplotlib, but we will not cover that here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you use the `marker` argument, then you can select other **markers**. The full list can be found on [this webpage](https://matplotlib.org/api/markers_api.html). There are also some arguments for changing the outlook of the marker:\n",
    "\n",
    "- `markeredgecolor`\n",
    "- `markeredgewidth`\n",
    "- `markerfacecolor`\n",
    "- `markersize`\n",
    "- Etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', marker = 'D', markersize = 1, data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', marker = 'D', markersize = 10,\n",
    "         markeredgecolor = 'crimson', markeredgewidth = 2, data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **line style** can also be selected with the argument `linestyle`. The **line width** can be changed with the argument `linewidth`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', marker = '*', linestyle = '-.', data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', linestyle = '-.', linewidth = 3, data = dat)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `plot()` function always creates (a list of) objects of the **class** `Line2D`. See all its attributes/arguments at [this webpage](https://matplotlib.org/api/_as_gen/matplotlib.lines.Line2D.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, `plot()` by default selects (and updates) **axis scales** so that it can visualize all data coordinates. You can set **axis limits** yourself with the function `axis()` which requires a sequence of four numbers: the lower limit of horizontal axis, its upper limit, the lower limit of the vertical axis and its upper limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.axis( [-2, 7, -2, 100] )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The values in `axis()`  in fact map onto the **methods** `.set_xlim()` and `.set_ylim()` in the **object-oriented approach**.  The tick locations and formats can also be changed but we will not cover that here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **scale** of the axes can be changed with the function `xscale()` and `yscale()` which take a string argument: `'linear'`, `'log'`, `'symlog'` or `'logit'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The outlook of a graph can also be modified by adding **text** to it. The Matplotlib module has the functions `xlabel()`, `ylabel()`, `title()` and `text()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('$y = x^3$')\n",
    "plt.title('Cubic graph')\n",
    "plt.text(4, 64, '64 = 4*4*4')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `xlabel()` and `ylabel()` functions can be used with the argument `labelpad` which controls the distance to the axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.xlabel('x', labelpad = 0.1)\n",
    "plt.ylabel('$y = x^3$', labelpad = 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `title()` function can be used with an argument `loc` in order to determine its position. It can take the values `'center'`, `'left'` or `'right'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.title('Cubic graph', loc = 'left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, all the text functions can have arguments controlling the text properties:\n",
    "\n",
    "- `color`\n",
    "- `family` : one of `'serif'`, `'sans-serif'`, `'cursive'`, `'fantasy'` or `'monospace'`\n",
    "- `fontname` : one of `'Courier'`, `'Helvetica'` , `'Times New Roman'`, ...\n",
    "- `fontsize` : number or one of `'xx-small'`, `'x-small'`, `'small'`, `'medium'`, `'large'`, `'x-large'` or `'xx-large'`\n",
    "- `fontstyle` : one of `'normal'`, `'italic'` or `'oblique'`\n",
    "- `fontweight` : one of `'normal'`, `'bold'`, `'heavy'`, `'light'`, `'ultrabold'` or `'ultralight'`\n",
    "- `horizontalalignment` : one of `'center'`, `'right'` or `'left'`\n",
    "- `ha` : idem as `horizontalalignment`\n",
    "- `name` : idem as `fontname`\n",
    "- `rotation` : angle in degrees or one of `'vertical'` or `'horizontal'`\n",
    "- `size` : idem as `fontsize`\n",
    "- `style` : idem as `fontstyle`\n",
    "- `variant` : one of `'normal'` or `'small-caps'`\n",
    "- `verticalalignment` : one of `'center'`, `'top'`, `'bottom'`, `'baseline'` or `'center_baseline'`\n",
    "- `va` : idem as `verticalalignment`\n",
    "- `weight` : idem as `fontweight`\n",
    "- Etc.\n",
    "\n",
    "See the full list at [this webpage](https://matplotlib.org/tutorials/text/text_props.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.title('Cubic graph', loc = 'left', size = 3)\n",
    "plt.show()   # Poor layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.title('Cubic graph', size = 'x-large', style = 'oblique', weight = 'bold')\n",
    "plt.ylabel('$y = x^3$', labelpad = 12, rotation = 'horizontal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important feature of the `text()` function is that it **cannot** take **sequences/vectors** of values. That means that you have to run a **loop** if you wish to depict several text labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'cub', data = dat)\n",
    "xx = [2, 3, 4]\n",
    "yy = [8, 27, 64]\n",
    "for x, y in zip(xx, yy):\n",
    "    plt.text(x, y, str(y) + '=' + str(x) + '$^3$', ha = 'right')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your plot contains multiple data sets, then you can add a **legend** with clarifying labels. The function `legend()` **automatically** figures out which line type or marker type belongs with which label:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', data = dat, color = 'blue')\n",
    "plt.plot('one', 'tri', data = dat, color = 'red')\n",
    "plt.plot('one', 'cub', data = dat, color = 'green')\n",
    "plt.legend( ['Double', 'Triple', 'Cubic'] )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', 'bo', data = dat)\n",
    "plt.plot('one', 'tri', 'r+', data = dat)\n",
    "plt.plot('one', 'cub', 'g*', data = dat)\n",
    "plt.legend( ['Double', 'Triple', 'Cubic'] )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', 'bo-', data = dat)\n",
    "plt.plot('one', 'tri', 'r+--', data = dat)\n",
    "plt.plot('one', 'cub', 'g*:', data = dat)\n",
    "plt.legend( ['Double', 'Triple', 'Cubic'] )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, the `plot()` function can be used with an argument `label` which `legend()` will retrieve:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', 'bo-', data = dat, label = 'Double')\n",
    "plt.plot('one', 'tri', 'r+--', data = dat, label = 'Triple')\n",
    "plt.plot('one', 'cub', 'g*:', data = dat, label = 'Cubic')\n",
    "plt.legend() # No arguments necessary!\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `legend()` function also has an argument `loc` for its placement. It can take either a string value or a numeric code from the following list:\n",
    "\n",
    "- `'best'` or `0`\n",
    "- `'upper right'` or `1`\n",
    "- `'upper left'` or `2`\n",
    "- `'lower left'` or `3`\n",
    "- `'lower right'` or `4`\n",
    "- `'right'` or `5`\n",
    "- `'center left'` or `6`\n",
    "- `'center right'` or `7`\n",
    "- `'lower center'` or `8`\n",
    "- `'upper center'` or `9`\n",
    "- `'center'` or `10`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', 'bo-', data = dat)\n",
    "plt.plot('one', 'tri', 'r+--', data = dat)\n",
    "plt.plot('one', 'cub', 'g*:', data = dat)\n",
    "plt.legend( ['Double', 'Triple', 'Cubic'], loc = 'center left' )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2 Statistical graphs with Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, Matplotlib has other plot types than the 2D line plot. For **univariate** data, there is the **histogram** with `hist()` and the **boxplot** with `boxplot()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(scores)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(scores, density = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(scores)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(scores, notch = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(scores, vert = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `boxplot()` function can also be used with a **matrix** in order to produce a **grouped boxplot**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores2 = [8, 5, 4, 7, 7, 8, 9, 10, 10, 9, 8, 5, 3, 9, 8, 5, 6, 10, 7, 9]\n",
    "scr_grp = [ scores, scores2]\n",
    "scr_grp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(scr_grp, labels = ['Group 1', 'Group 2'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For **categorical** data, there is the **bar chart** with both `bar()` and `barh()` and there is the **pie chart** with `pie()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], height = [10, 30, 70, 90], width = 0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.barh(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.barh(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], width = [10, 30, 70, 90], height = 0.5)\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both a **stacked bar chart** and a **grouped bar chart** are only possible with the **methods** of either Matplotlib or pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.pie([10, 30, 70, 90])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.pie([10, 30, 70, 90], explode = [0, 0, 0, 0], labels = ['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'],\n",
    "        colors = ['blue', 'red', 'green', 'purple'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.pie([10, 30, 70, 90], explode = [0, 0.1, 0, 0], labels = ['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'],\n",
    "        colors = ['blue', 'red', 'green', 'purple'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many more plot types in Matplotlib, but will will not cover them here. See the overview on [this webpage](https://matplotlib.org/tutorials/introductory/sample_plots.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3 Style sheets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One last but not least way of customizing graphs is by using **style sheets**. The following style sheets are supported:\n",
    "\n",
    "- `'bmh'`\n",
    "- `'classic'`\n",
    "- `'dark_background'`\n",
    "- `'fast'`\n",
    "- `'fivethirtyeight'`\n",
    "- `'ggplot'`\n",
    "- `'grayscale'`\n",
    "- `'seaborn'` with its variants (`'seaborn-bright'`, `'seaborn-darkgrid'` etc.)\n",
    "- `'Solarize_Light2'`\n",
    "- `'tableau-colorblind10'`\n",
    "- `'_classic_test'`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You import a style sheet with the function `use()` of the submodule `style`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('dark_background')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', data = dat)\n",
    "plt.plot('one', 'tri', data = dat)\n",
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.legend( ['Double', 'Triple', 'Cubic'] )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(scores)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(scr_grp, labels = ['Group 1', 'Group 2'])\n",
    "plt.show()    # Poor choice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GPLOT style:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', data = dat)\n",
    "plt.plot('one', 'tri', data = dat)\n",
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.legend( ['Double', 'Triple', 'Cubic'] )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(scores)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(scr_grp, labels = ['Group 1', 'Group 2'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bayesian Methods for Hackers style:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('bmh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot('one', 'two', data = dat)\n",
    "plt.plot('one', 'tri', data = dat)\n",
    "plt.plot('one', 'cub', data = dat)\n",
    "plt.legend( ['Double', 'Triple', 'Cubic'] )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(scores)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(scr_grp, labels = ['Group 1', 'Group 2'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default style of matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('default')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can also change the graphical settings with the attribute `rcParams` and/or the `matplotlibrc` file. We will not cover that here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4 Object-oriented approach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All `pyplot`'s functions are essentially pointers to Matplotlib's **methods**, which offer much more flexibility. Incidentally, the **object-oriented** API/approach is also the way to visualize **multiple plots** in a window."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object-oriented creation of graphs always starts with objects of the class `Figure` and `Axes`. The first is made with the function `figure()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()    # Empty Figure object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `figure()` function can take an argument `figsize` specifying the height and the width of the Figure window:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize = [7.5, 7.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to divide the Figure up into \"plots\". In Matplotlib these are objects of the class `Axes`. An Axes object is made with the Figure method `.add_subplot()` which needs to specified with three arguments at least:\n",
    "\n",
    "- The first argument is the number of **plot rows** in your figure.\n",
    "- The second argument is the number of **plot columns** in your figure.\n",
    "- The third argument is the **sequence number** of the individual plot in question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot(1, 1, 1)    # Plot with axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(axs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Axes object can also be made with the function `axes()` which is just a pointer to the `.add_subplot()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = plt.axes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(axs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.add_subplot()` method can even be specified with one **string** of three numbers instead of three arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot('111')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(axs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Axes objects have many **methods** for customizing the region of the plot. The most useful ones are `.set_xlim()`, `.set_ylim()`, `.set_xlabel()`, `.set_ylabel()` and `.set_title()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.set_xlim()` and `.set_ylim()` methods set the **limits** of the **horizontal** and the **vertical axis**, respectively. (As mentioned above, the `axis()` function calls these methods, in fact.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axs.set_xlim(-2, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axs.set_ylim(-5, 145)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.set_xlabel()` and `.set_ylabel()` methods do the same as the `xlabel()` and `ylabel()` functions, respectively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axs.set_xlabel('x', labelpad = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axs.set_ylabel('$y = x^3$', labelpad = 12, rotation = 'horizontal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, the `.set_title()` method corresponds to the `title()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axs.set_title('Cubic function', loc = 'left', weight = 'bold')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An Axes object also has a method `.plot()` which adds data to the figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axs.plot('one', 'cub', 'g*:', data = dat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Figure itself can then finally be **visualized** by simply **calling/printing** it (or by calling `fig.show()` for an external window):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it is customary for the `.plot()` method to end a **code block** starting with the `figure()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot('111')\n",
    "axs.set_xlim(-2, 8)\n",
    "axs.set_ylim(-5, 145)\n",
    "axs.set_xlabel('x', labelpad = 10)\n",
    "axs.set_ylabel('$y = x^3$', labelpad = 12, rotation = 'horizontal')\n",
    "axs.set_title('Cubic function', loc = 'left', weight = 'bold')\n",
    "axs.plot('one', 'cub', 'g*:', data = dat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides the `.plot()` method, Axes objects have methods for **other plot types** as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot(1, 1, 1)\n",
    "axs.hist(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot(1, 1, 1)\n",
    "axs.barh(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another possibility is to use these methods **multiple times** for visualizing **different data** (this works because the Figure will be updated as long as it stays open):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot(1, 1, 1)\n",
    "axs.set_xlim(-2, 8)\n",
    "axs.set_ylim(-5, 145)\n",
    "axs.plot('one', 'two', 'bo-', data = dat)\n",
    "axs.plot('one', 'tri', 'r+--', data = dat)\n",
    "axs.plot('one', 'cub', 'g*:', data = dat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.legend()` method of Axes objects helps to clarify such a plot (identically to the `legend()` function):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot(1, 1, 1)\n",
    "axs.set_xlim(-2, 8)\n",
    "axs.set_ylim(-5, 145)\n",
    "axs.plot('one', 'two', 'bo-', data = dat)\n",
    "axs.plot('one', 'tri', 'r+--', data = dat)\n",
    "axs.plot('one', 'cub', 'g*:', data = dat)\n",
    "axs.legend(['Double', 'Triple', 'Cubic'], loc = 'center right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `.legend()` method is again compatible with the `label` argument of the `.plot()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "axs = fig.add_subplot(1, 1, 1)\n",
    "axs.set_xlim(-2, 8)\n",
    "axs.set_ylim(-5, 145)\n",
    "axs.plot('one', 'two', 'bo-', data = dat, label = 'Double')\n",
    "axs.plot('one', 'tri', 'r+--', data = dat, label = 'Triple')\n",
    "axs.plot('one', 'cub', 'g*:', data = dat, label = 'Cubic')\n",
    "axs.legend(loc = 'center right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Working with Figure and Axes objects is necessary when one wants to arange **multiple plots** in **one window**. Then the `.add_subplot()` method takes values **larger than one** for the first and/or the second argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(2, 2, 1)\n",
    "ax2 = fig.add_subplot(2, 2, 2)\n",
    "ax3 = fig.add_subplot(2, 2, 3)\n",
    "ax4 = fig.add_subplot(2, 2, 4)\n",
    "ax1.plot('one', 'two', 'bo-', data = dat)\n",
    "ax2.plot('one', 'tri', 'r+--', data = dat)\n",
    "ax3.plot('one', 'cub', 'g*:', data = dat)\n",
    "ax4.bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Such a \"plot matrix\" can be given a **main title** with the method `.suptitle()` (of the Figure object):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(2, 2, 1)\n",
    "ax2 = fig.add_subplot(2, 2, 2)\n",
    "ax3 = fig.add_subplot(2, 2, 3)\n",
    "ax4 = fig.add_subplot(2, 2, 4)\n",
    "ax1.plot('one', 'two', 'bo-', data = dat)\n",
    "ax2.plot('one', 'tri', 'r+--', data = dat)\n",
    "ax3.plot('one', 'cub', 'g*:', data = dat)\n",
    "ax4.bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])\n",
    "fig.suptitle('Four plots in 2x2', size = 'x-large', weight = 'heavy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the arrangement of multiple plots in one Figure, Matplotlib also has the **single function** `subplots()`. It is specified with the number of plot rows and columns in the Figure (the default is `1, 1` for a single plot). Its return value is the **tuple** of the Figure object and the (array of) Axes objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs_lst = plt.subplots(2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(axs_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axs_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(axs_lst[0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs_lst = plt.subplots(2, 2)\n",
    "axs_lst[0,0].plot('one', 'two', 'bo-', data = dat)\n",
    "axs_lst[1,0].plot('one', 'tri', 'r+--', data = dat)\n",
    "axs_lst[0,1].plot('one', 'cub', 'g*:', data = dat)\n",
    "axs_lst[1,1].bar(['Grp 1', 'Grp 2', 'Grp 3', 'Grp 4'], [10, 30, 70, 90])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us again work with the `iris` dataset (which should be in your working directory):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = pd.read_table('iris.csv', sep = ';')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs_lst = plt.subplots(2, 2)\n",
    "axs_lst[0, 0].plot('Sepal_Length', 'Sepal_Width', 'g.', data = iris)\n",
    "axs_lst[1, 0].plot('Sepal_Length', 'Petal_Length', 'g.', data = iris)\n",
    "axs_lst[0, 1].plot('Petal_Width', 'Sepal_Width', 'g.', data = iris)\n",
    "axs_lst[1, 1].plot('Petal_Width', 'Petal_Length', 'g.', data = iris)\n",
    "axs_lst[0, 0].set_ylabel('Sepal width')\n",
    "axs_lst[1, 0].set_ylabel('Petal length')\n",
    "axs_lst[1, 0].set_xlabel('Sepal length')\n",
    "axs_lst[1, 1].set_xlabel('Petal width')\n",
    "fig.suptitle('Iris dataset', size = 'xx-large')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poor outlook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind_set = iris.Species == 'setosa'\n",
    "ind_ver = iris.Species == 'versicolor'\n",
    "ind_vir = iris.Species == 'virginica'\n",
    "fig3, ax3_lst = plt.subplots(2, 2)\n",
    "ax3_lst[0, 0].set_title('Setosa')\n",
    "ax3_lst[0, 1].set_title('Versicolor')\n",
    "ax3_lst[1, 1].set_title('Virginica')\n",
    "ax3_lst[0, 0].plot(iris.Sepal_Length[ind_set], iris.Sepal_Width[ind_set], 'g.')\n",
    "ax3_lst[0, 1].plot(iris.Sepal_Length[ind_ver], iris.Sepal_Width[ind_ver], 'g.')\n",
    "ax3_lst[1, 1].plot(iris.Sepal_Length[ind_vir], iris.Sepal_Width[ind_vir], 'g.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Better outlook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig3 = plt.figure()\n",
    "ax1 = fig3.add_subplot(2, 2, 1)\n",
    "ax2 = fig3.add_subplot(2, 2, 2)\n",
    "ax3 = fig3.add_subplot(2, 2, 3)\n",
    "ax1.set_xlim(4, 8)\n",
    "ax1.set_ylim(2, 6)\n",
    "ax2.set_xlim(4, 8)\n",
    "ax2.set_ylim(2, 6)\n",
    "ax3.set_xlim(4, 8)\n",
    "ax3.set_ylim(2, 6)\n",
    "ax1.set_title('Setosa', color = 'green')\n",
    "ax2.set_title('Versicolor', color = 'red')\n",
    "ax3.set_title('Virginica', color = 'blue')\n",
    "ax1.plot(iris.Sepal_Length[ind_set], iris.Sepal_Width[ind_set], 'g.')\n",
    "ax2.plot(iris.Sepal_Length[ind_ver], iris.Sepal_Width[ind_ver], 'r.')\n",
    "ax3.plot(iris.Sepal_Length[ind_vir], iris.Sepal_Width[ind_vir], 'b.')\n",
    "fig3.suptitle('Sepal length x Sepal width')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Best outlook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig3,  axs = plt.subplots()    # 1x1 plot\n",
    "axs.set_xlim([4, 8])\n",
    "axs.set_ylim([2, 6])\n",
    "axs.set_xlabel('Sepal length')\n",
    "axs.set_ylabel('Sepal width')\n",
    "axs.plot(iris.Sepal_Length[ind_set], iris.Sepal_Width[ind_set], 'g.', label = 'Setosa')\n",
    "axs.plot(iris.Sepal_Length[ind_ver], iris.Sepal_Width[ind_ver], 'r.', label = 'Versicolor')\n",
    "axs.plot(iris.Sepal_Length[ind_vir], iris.Sepal_Width[ind_vir], 'b.', label = 'Virginica')\n",
    "axs.legend(loc = 'upper right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.5 Graphical methods in pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A convenient feature of pandas is that it has compatible **methods** for **graphical output**. For instance, the scatter plot above can also be made as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris.plot('Sepal_Length', 'Sepal_Width', kind = 'scatter')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Histograms** and **boxplots** can be made by changing the `kind` argument. There are also **density plots** in pandas (All three plot types have different methods as well, however)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris['Sepal_Length'].plot(kind = 'hist')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris['Sepal_Length'].plot(kind = 'box')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris['Sepal_Length'].plot(kind = 'kde')    # Takes a little time to compute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris['Sepal_Length'].plot.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris['Sepal_Length'].plot.box()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris['Sepal_Length'].plot.kde()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The histograms and boxplot can also be made as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris.hist('Sepal_Length')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris.hist('Sepal_Length', by = 'Species')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris.boxplot('Sepal_Length')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris.boxplot('Sepal_Length', by = 'Species')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bar plots** visualize frequencies of various groups, so we use the categorical variables in the dataset `chol.txt`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol = pd.read_table('chol.txt')\n",
    "print(chol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol_tab = pd.crosstab(chol.Mortality, chol.SmokeGroup)\n",
    "print(chol_tab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "smok_frq = chol_tab.sum(axis = 0)\n",
    "print(smok_frq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "smok_frq.plot(kind = 'bar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "smok_frq.plot(kind = 'bar', rot = 0, color = ['green', 'orange', 'red'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "smok_frq.plot.bar(rot = 0, color = ['green', 'orange', 'red'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "smok_frq.plot(kind = 'barh', color = ['green', 'orange', 'red'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "smok_frq.plot.barh(color = ['green', 'orange', 'red'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, you can make **grouped** or **stacked** bar plots for several variables. However, Python groups all **columns per row**, so one may have to transpose the data object first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol_tab.plot(kind = 'bar', rot = 0, color = ['green', 'orange', 'red'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol_swp = chol_tab.T\n",
    "print(chol_swp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol_swp.plot(kind = 'bar', rot = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol_swp.plot(kind = 'bar', rot = 0, stacked = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol_swp.plot(kind = 'bar', rot = 0, stacked = True, color = ['blue', 'red'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chol_swp.plot(kind = 'bar', rot = 0, subplots = True, color = ['green', 'orange', 'red'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pie plots can be made in the same way (by setting `kind` equal to `'pie'`) but we will not go into the details here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "\n",
    "12. Graphics of the `cholesterol` dataset\n",
    "\n",
    "  12.1 Make histograms and boxplots of the variable `Cholesterol` for every category in `SmokeGroup`.\n",
    "\n",
    "  12.2 Make a scatterplot of the variables `Age` and `Cholesterol` (on the x-axis and y-axis respectively). Separate the three categories in `SmokeGroup` by means of colors, plotting symbols etc. and add a legend.\n",
    "\n",
    "\n",
    "13. Graphics of the `substance` dataset\n",
    "\n",
    "  13.1 Read in the dataset `substance.txt` and construct three frequency tables of `Gender` with the three substances. Create a single Figure with three subplots, each showing the bar chart of the genders in the `Yes` columns.\n",
    "\n",
    "  13.2 Create a single (grouped) bar chart showing the frequencies of `Race` for the three substances. The bars of the three substances should be grouped per race. You again need to use only the `Yes` frequencies."
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}