python_viz_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f34154f5",
   "metadata": {},
   "source": [
    "# Data Viz with Matplotlib 2\n",
    "\n",
    "Welcome back. Yesterday, we introduced the main (Object Oriented) syntax for `matplotlib`. Today we will take a closer look at how to plot data and introduce the main arguments to know when using `matplotlib`.\n",
    "\n",
    "We start by importing the usual packages and specifying the `inline` backend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a8e7bdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a8ce609",
   "metadata": {},
   "source": [
    "Today, we will be working with extract from the US Baby Names dataset. It contains information about first names' use in the US from 1965 to 2014. Originally, the data is distributed by the Social Security Administration. It contains the frequency and associated Gender for all names given to newborns in the US in any given year from from 1880 -- conditional on the name being used at least 5 time in that year. I downloaded the original data from <a href=\"https://www.kaggle.com/kaggle/us-baby-names/data?select=NationalNames.csv\">Kaggle</a> and re-worked it to minimize `pandas` code in this workshop.\n",
    "\n",
    "Here we load data about the use of the names `Barack` and `Ronald`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16d4ab40",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data directly from the repository on github\n",
    "barack_data_url = r'https://raw.githubusercontent.com/non87/python-viz-workshop/main/data/barack.csv'\n",
    "barack = pd.read_csv(barack_data_url)\n",
    "\n",
    "# Same with Ronald data\n",
    "ronald_data_url = r'https://raw.githubusercontent.com/non87/python-viz-workshop/main/data/ronald.csv'\n",
    "ronald = pd.read_csv(ronald_data_url)\n",
    "\n",
    "# Show the first 5 rows of the barack data\n",
    "barack.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b057a55",
   "metadata": {},
   "source": [
    "### Colors, Markers & Lines\n",
    "\n",
    "We want to visualize whether the popularity of the name \"Barack\" changed during the Obama presidency. Our data for the x axis will be the `Year` column from the `barack` dataframe. Our y data will be the `Count` column from the same dataframe.\n",
    "\n",
    "Let's start with the simplest plot. We have already seen all of these commands last time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50e2a2af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "ax.plot(barack['Year'], barack['Count'])\n",
    "# Usual settings, we saw this above\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbce70a4",
   "metadata": {},
   "source": [
    "#### Colors\n",
    "\n",
    "The first thing we want to do is to specify a color for our plot. This will show how `matplotlib` handles colors more in general -- something very helpful to know! \n",
    "\n",
    "To specify that we want to change the color of our line in the plot, we have to use the argument `color` of the `ax.plot()` method. In general, when there is a color to be changed in `matplotlib`, you can use the argument `color` -- for example, we will see this hold true for the `ax.histogram()` method. \n",
    "\n",
    "Yet, what do we pass to the `color` argument? How do we communicate the color we want to `matplotlib`?\n",
    "\n",
    "In general there are three ways to refer to a color in `matplotlib`:\n",
    "\n",
    "1. Use a pre-specified color name. `Matplotlib` uses special names to refer to specific colors -- for example, the name \"red\". You can find the complete list of named colors in this [page from the official documentation](https://matplotlib.org/stable/gallery/color/named_colors.html).\n",
    "\n",
    "2. Specify the color coordinates through a RGB or RBGA code. This allows for more fine control.\n",
    "\n",
    "3. Hex strings -- which are another way to specify RGB (or RGBA) coordinates.\n",
    "\n",
    "\n",
    " <div class=\"alert alert-block alert-success\">\n",
    "<b> Specify Colors </b>: For a more complete guide on how to specify colors in <code>matplotlib</code>, check the <a href=https://matplotlib.org/stable/tutorials/colors/colors.html>official tutorial</a>.\n",
    "        </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2736747e",
   "metadata": {},
   "source": [
    "##### Named Color\n",
    "\n",
    "Color names are special string that `matplotlib` maps to specific color once you pass such strings in a `color` argument. For example, the string `g` is mapped to a green color if passed in the `color` argument, the string `r` is mapped to a red color, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "926d773a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# notice the color argument\n",
    "ax.plot(barack['Year'], barack['Count'], color='g')\n",
    "# Usual settings, we saw this above\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad78e520",
   "metadata": {},
   "source": [
    "##### RGB(A)\n",
    "\n",
    "But sometimes we want to reproduce a specific color and we need more control than a simple string code. In these cases, we can use an RGB color code.\n",
    "\n",
    "The RGB code is a 3-elements `tuple` (but `matplotlib` will not complain if you pass a `list` or other `tuple`-like objects) specifying the red, green, blue component of the color you want -- following the well known [RGB color model](https://en.wikipedia.org/wiki/RGB_color_model). Unlike many other applications dealing with color specification, `matplotlib` expect you to specify the RGB component as a number from 0 to 1. \n",
    "\n",
    "For example, the RGB code `(0,0,1)` has no Red component, no Green component, but goes all-in on the Blue component. This is the bluest blue you can get. Another example, the code `(0, 0, 0)` is the darkest black while `(1, 1, 1)` is the whitest white.\n",
    "\n",
    "In the following example we go for a mid-gray.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    <b>Color Models</b>: The RGBA coordinate color scheme is in no way the only possible way to create a reference system for colors. Other popular options are the <a href=https://en.wikipedia.org/wiki/HSL_and_HSV>Hue-Saturation-Light model</a>, the <a href=https://en.wikipedia.org/wiki/HSL_and_HSV>Hue-Saturation-Value system</a>, the <a href=https://en.wikipedia.org/wiki/Web_colors>hexadecimal model</a>, the <a href=https://en.wikipedia.org/wiki/CMYK_color_model>Ciano-Magenta-Yellow-Black model</a> and the <a href=https://en.wikipedia.org/wiki/CIELAB_color_space>CIELAB model</a>. Each model emphasizes different characteristics of colors and it is helpful in its own way. Matplotlib supports the Hue-Saturation-Value system in its sub-module color.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40c853d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# notice the color argument\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5))\n",
    "# Usual settings, we saw this above\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cee9b9d",
   "metadata": {},
   "source": [
    "##### Setting transparency with the alpha parameter\n",
    "\n",
    "Finally, we can use a RBGA code to specify a color *and* a transparency parameter. The transparency parameter is commonly known as `alpha`. This can be done by simply passing a 4-elements `tuple` (instead of a 3-elements `tuple`) in the `color` argument. As for the RGB components, the `alpha` components should be between 0 (full transparency, no show) to 1 (full opacity)\n",
    "\n",
    "For example, what happens to the previous plot when we set transparency to 0.5?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df00ee39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# notice the color argument\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5))\n",
    "# Usual settings, we saw this above\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')\n",
    "# Compare the result with the previous plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6ade3b4",
   "metadata": {},
   "source": [
    "##### Exercise 1\n",
    "\n",
    "Modify the code to replicate the same plot as above, but this time, use another named color of your choice from the CSS section of [this page](https://matplotlib.org/stable/gallery/color/named_colors.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3188b37b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# Use another color for the plot\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5))\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22a81de",
   "metadata": {},
   "source": [
    "##### Markers & Lines: Emphasize data over interpolation\n",
    "\n",
    "Once the color is set, we may also want to change the line style (and width) or add some markers. Notice that, so far, we are showing the data as a continous function, but we actually only have 8 data-points -- everything else we show is a linear interpolation that `ax.plot()` will add for us by default. The linear interpolation is helpful to see trends in the data, but we may want to remark that actually we only have a sample of 8 points. \n",
    "\n",
    "We will do this in 2 stages. First, we will de-emphasize the line: we will dash it, make it thinner and half transparent. This will diminsh the emphasis on the line. This can be achieved through the `color`, `linestyle` and `linewidth` arguments of `ax.plot()`. The `linestyle` and `linewidth` arguments do what their names suggest: `linestyle` accept a string indicating a specific line style, `linewidth` accept a float indicating the width of the line (by default, this argument is set to 1.5). \n",
    "\n",
    "Exactly as was the case for the `color` argument, the `linestyle` and `linewidth` argument are not specific to `ax.plot()` and you can use them to change the style and width of lines any time you plot one (be it with the `ax.plot()` method or otherwise).\n",
    "\n",
    " <div class=\"alert alert-block alert-success\">\n",
    "    <b> Linestyle </b>: Above, I simplify the <code>linestyle</code> argument when I write that it accepts strings. You can actually specify your own linestyle by means of <code>tuples</code> code. For example, the \"dashed\" style used below corresponds to the tuple code <code>(0, (5, 1))</code>: if you substitute the string <code>\"dashed\"</code> with <code>(0, (5, 1))</code>, you will obtain no change. You can check the <a href=https://matplotlib.org/stable/gallery/lines_bars_and_markers/linestyles.html>official tutorial</a> for more information on this way of specifying linestyles.\n",
    "        </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3968d13f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# the dark side of khaki\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashed', linewidth=1.)\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1151dca8",
   "metadata": {},
   "source": [
    "So far, so good. The second part of the strategy is to plot those data-points we really have _above_ the line (in full opacity) _as markers_. This way, it will be clear that the line is secondary with respect to the the data-points. How can we do this? This is another important principle of `matplotlib` (and other visualization libraries): you create your plot sequentially by adding one plot-stratum at the time, with the last stratum added being the one on top. \n",
    "\n",
    "In the case at hand, this means that we will first call `ax.plot()` to draw the linearly-interpolated data -- we have already done this multiple times. After this, we will call `ax.plot()` again to plot the data as points (as opposed to lines!). In this second call to `ax.plot()`, we will change the `linestyle` argument to `'None'` to plot _no_ line. We will change the `color` argument to a solid black, indicated with the color name `'b'`. Then, we will specify a `marker` argument to draw the markers and a `markersize` (or `ms`) argument to make the markers bigger.\n",
    "\n",
    "In a way, this produce a scatter plot on top of the line we have drawn so far. In fact, we could swap the second `ax.plot()` call with a call to `ax.scatter()` -- the method to draw scatter plots that we will explore tomorrow. The point is that,  in the same `Axes`, you can overlap drawing generated from any method (or function).\n",
    "\n",
    " <div class=\"alert alert-block alert-success\">\n",
    "    <b> Format string </b>: It is possible to condense the two calls of the <code>ax.plot()</code> method to only one call, thanks to the special argument <code>fmt</code> (abbreviation of \"format string\") of this method. Here, we do not discuss the use of this argument because it is very specific to the <code>ax.plot()</code> method, but check the <a href=https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.plot.html>official documentation</a> for an overview of how it works.\n",
    "        </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec489471",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# Same call as above\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashed', linewidth=1.)\n",
    "# New line, plot the data as scatter plot. Notice the marker and ms arguments\n",
    "ax.plot(barack['Year'], barack['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2d6a0d3",
   "metadata": {},
   "source": [
    "##### Exercise 2\n",
    "\n",
    "Modify the plot below so as to reproduce the same plot as the last one, but \n",
    "\n",
    "1. Use a `dashdot` linestyle;\n",
    "2. Use a different marker of your choice from [this list](https://matplotlib.org/stable/api/markers_api.html);\n",
    "3. Increase the markersize to 20;\n",
    "4. Change the color of the markers to any shade of blue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aec82672",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# Choose line style and line width\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5)) # add arguments\n",
    "# Choose marker, marker size, color\n",
    "ax.plot(barack['Year'], barack['Count'], linestyle='None') # add arguments\n",
    "ax.set_title('The Obama Effect')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named \"Obama\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbcf31b6",
   "metadata": {},
   "source": [
    "#### Comparing Data: Setting the Scale\n",
    "\n",
    "In this section we will compare the popularity of the name \"Obama\" with the popularity of the name \"Ronald\", the first name of the former US President Ronald Reagan. One possible strategy is to plot the two series in two independent `Axes` of the same `Figure`. We will see that the main difficulty here is making sure that the the two `Axes` are on the same meaningful scale, so that the  user can easily grasp the narrative by comparing the plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "367a989c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line\n",
    "fig, ax = plt.subplots(nrows=2, ncols=1, figsize= (10,8))\n",
    "# Obama call as above\n",
    "ax[0].plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[0].plot(barack['Year'], barack['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[0].set_title('The Obama Effect')\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Number of newborns named \"Obama\"')\n",
    "# New Ronald call\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[1].set_title('The Reagan Effect')\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Number of newborns named \"Ronald\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "516ef72a",
   "metadata": {},
   "source": [
    "This is terrible in so many ways! We should, at least, put the two plots on the same x and y scale. Second, let's make sure the two titles do not overlap. Third, let's give the entire `Figure` (not the single `Axes`) an overall title."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8bf7deb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We make the same calls as above, but we change their scale with xlim and ylim\n",
    "# We know that ronald is the datasets having larger x and y spans, so we use its\n",
    "# minimum/maximum on both axis as our limits.\n",
    "x_lim = [ronald['Year'].min(), ronald['Year'].max()]\n",
    "# For aesthetic purposes I leave a little more room on the right/left and top/bottom\n",
    "span_x = x_lim[1]-x_lim[0]\n",
    "x_lim = [x_lim[0] - (0.05*span_x), x_lim[1] + (0.05*span_x)]\n",
    "# Let's fix the y minimum to 0\n",
    "y_lim = [0, ronald['Count'].max()]\n",
    "# Same as above, I expand the span a little\n",
    "span_y = y_lim[1]- y_lim[0]\n",
    "y_lim = [y_lim[0] - (0.05*span_y), y_lim[1] + (0.05*span_y)]\n",
    "\n",
    "\n",
    "\n",
    "# The Fundamental Line. We make some more vertical room with the hspace gridspec kw\n",
    "# if you wondering I chose the value .3 with trial and error\n",
    "fig, ax = plt.subplots(nrows=2, ncols=1, figsize= (10,8), gridspec_kw={'hspace':.3})\n",
    "# The overall title, notice that it is a method of the containing figure, this is logical!\n",
    "fig.suptitle(\"Obama Vs Reagan\", fontsize=24)\n",
    "\n",
    "# Obama call as above\n",
    "ax[0].plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[0].plot(barack['Year'], barack['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[0].set_title('The Obama Effect')\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Number of newborns named \"Obama\"')\n",
    "# But now we pass the xlim and ylim explicitly to the axis\n",
    "ax[0].set_xlim(x_lim)\n",
    "ax[0].set_ylim(y_lim)\n",
    "# New Ronald call\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[1].set_title('The Reagan Effect')\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Number of newborns named \"Ronald\"')\n",
    "# Pass the xlim and ylim explicitly to the axis, for this axes as well\n",
    "ax[1].set_ylim(y_lim)\n",
    "ax[1].set_xlim(x_lim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a256280",
   "metadata": {},
   "source": [
    "Now we start to have a better plot...but notice that we killed any movement we could observe in the Obama plot due to rescaling. For cases like these, we can use a log scale to represent the data.\n",
    "\n",
    "There are two ways to do this. We can manually transform the data _before_ sending it to the plot. This implies that we will recalculate the `y_lim` manually. Otherwise, we can ask `matplotlib` to transform the data for us _after_ having called the `ax.plot()` method. The latter option spares us the need to recalculate the limits since `matplotlib` will take care of rescaling those as well -- with the caveat that we need to make sure we do not pass a negative value to a `log` transformation! There is a catch though, you "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87171829",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"The lower y limit is currently {y_lim[0]}. Since it is negative, we change it to 1\")\n",
    "y_lim[0] = 1\n",
    "\n",
    "# The Fundamental Line.\n",
    "fig, ax = plt.subplots(nrows=2, ncols=1, figsize= (10,8), gridspec_kw={'hspace':.3})\n",
    "fig.suptitle(\"Obama Vs Reagan\", fontsize=24)\n",
    "\n",
    "# Obama call as above\n",
    "ax[0].plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[0].plot(barack['Year'], barack['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[0].set_title('The Obama Effect')\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Number of newborns named \"Obama\"')\n",
    "\n",
    "# Pass the same xlim and ylim to the axis\n",
    "ax[0].set_xlim(x_lim)\n",
    "ax[0].set_ylim(y_lim)\n",
    "# Transform the scale\n",
    "ax[0].set_yscale('log')\n",
    "\n",
    "# New Ronald call\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[1].set_title('The Reagan Effect')\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Number of newborns named \"Ronald\"')\n",
    "# Pass the same xlim and ylim to the axis\n",
    "ax[1].set_xlim(x_lim)\n",
    "ax[1].set_ylim(y_lim)\n",
    "# Transform the scale\n",
    "ax[1].set_yscale('log')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d19166f",
   "metadata": {},
   "source": [
    "As a final touch, we will add vertical lines to signal the beginning and end of the presidential terms for Reagan and Obama. We will use `ax.axline()` to draw the vertical lines. To draw a line with `ax.axline()` we will specify two points through which we want the line to pass. The points coordinate can be passed as a `tuple` -- for example, `(0, 0)` is the coordinate of the origin. Notice that `ax.axline()` will create an infinite line passing for the two points, not just a segment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f8930fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Fundamental Line.\n",
    "fig, ax = plt.subplots(nrows=2, ncols=1, figsize= (10,8), gridspec_kw={'hspace':.3})\n",
    "fig.suptitle(\"Obama Vs Reagan\", fontsize=24)\n",
    "\n",
    "# Obama call as above\n",
    "ax[0].plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[0].plot(barack['Year'], barack['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[0].set_title('The Obama Effect')\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Number of newborns named \"Obama\"')\n",
    "# Pass the same xlim and ylim to the axis\n",
    "ax[0].set_xlim(x_lim)\n",
    "ax[0].set_yscale('log')\n",
    "ax[0].set_ylim(y_lim)\n",
    "# Draw the vertical line\n",
    "first_obama_point = (2008, 0.1)\n",
    "second_obama_point = (2008, y_lim[1])\n",
    "# This command draw the line. Notice the usual color, etc. to style the line as we want\n",
    "ax[0].axline(first_obama_point, second_obama_point, color='black', linewidth=0.8, linestyle='dotted')\n",
    "\n",
    "# New Ronald call\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[1].plot(ronald['Year'], ronald['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[1].set_title('The Reagan Effect')\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Number of newborns named \"Ronald\"')\n",
    "# Pass the same xlim and ylim to the axis\n",
    "ax[1].set_xlim(x_lim)\n",
    "ax[1].set_yscale('log')\n",
    "ax[1].set_ylim(y_lim)\n",
    "# Draw the vertical lines\n",
    "# Notice that we have both the beginning and the end of the Reagan's presidency in the data\n",
    "first_reagan_point = (1980, 0.1)\n",
    "second_reagan_point = (1980, y_lim[1])\n",
    "third_reagan_point = (1988, 0.1)\n",
    "fourth_reagan_point = (1988, y_lim[1])\n",
    "# This command draw the line. Notice the usual color, etc. to style the line as we want\n",
    "ax[1].axline(first_reagan_point, second_reagan_point, color='black', linewidth=0.8, linestyle='dotted')\n",
    "ax[1].axline(third_reagan_point, fourth_reagan_point, color='black', linewidth=0.8, linestyle='dotted')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c773fc6",
   "metadata": {},
   "source": [
    "##### Exercise 3\n",
    "\n",
    "It seems that Obama had some effect on babies' names, but Reagan had no such effect. What about first ladies?\n",
    "\n",
    "In the following cell, I load the name data for \"Michelle\" (Obama) and \"Nancy\" (Reagan)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e296f99a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data directly from the repository on github\n",
    "michelle_data_url = r'https://raw.githubusercontent.com/non87/python-viz-workshop/main/data/michelle.csv'\n",
    "michelle = pd.read_csv(michelle_data_url)\n",
    "\n",
    "# Load the data directly from the repository on github\n",
    "nancy_data_url = r'https://raw.githubusercontent.com/non87/python-viz-workshop/main/data/nancy.csv'\n",
    "nancy = pd.read_csv(nancy_data_url)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da89322",
   "metadata": {},
   "source": [
    "Now, complete the code below to reproduce the same plot we created for the \"Barack\"-\"Ronald\" comparison. That is,\n",
    "\n",
    "1. Create the `Figure` and `Axes`:\n",
    "    1. Create a new `y_lim` variable\n",
    "    2. Create two `Axes` in the same column with the _fundamental line_.\n",
    "    3. Set the `fig.suptitle()` to \"Obama Vs Reagan, First Ladies\"\n",
    "2. \"Michelle\" `Axes:\n",
    "    1. Plot the `michelle` data in the top `Axes`\n",
    "    2. Set the `xlim` and `ylim` of the top `Axes`, **do not** change the scale to log\n",
    "    3. Create a vertical line indicating the beginning of the Obama presidency\n",
    "    4. Change the x label to \"Year\"; change the y label to \"Number of newborns named 'Michelle'\"; change the `Axes` title to \"The Obama Effect\"\n",
    "\n",
    "3. \"Nancy\" `Axes`:\n",
    "    1. Plot the `nancy` data in the bottom `Axes`\n",
    "    2. Set the `xlim` and `ylim` of the top `Axes`, **do not** change the scale to log\n",
    "    3. Create a vertical line indicating the beginning of the Reagan presidency\n",
    "    4. Create a vertical line indicating the end of the Reagan presidency\n",
    "    5. Change the x label to \"Year\"; change the y label to \"Number of newborns named 'Nancy'\"; change the `Axes` title to \"The Reagan Effect\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ae053e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_lim = [nancy['Year'].min(), nancy['Year'].max()]\n",
    "span_x = x_lim[1] - x_lim[0]\n",
    "x_lim = [x_lim[0] - (0.05*span_x), x_lim[1] + (0.05*span_x)]\n",
    "# Find the y max with np.max()\n",
    "data_max = np.max([nancy['Count'].max(), michelle['Count'].max()])\n",
    "# Create the new y_lim. \n",
    "# The y should span from 0 to the maximum in the data\n",
    "y_lim = \n",
    "# Same as above, I expand the span a little\n",
    "span_y = y_lim[1]- y_lim[0]\n",
    "y_lim = [y_lim[0], y_lim[1] + (0.05*span_y)]\n",
    "print(y_lim)\n",
    "print(x_lim)\n",
    "\n",
    "# Re-create points for the vertical lines\n",
    "# Draw the vertical line\n",
    "first_obama_point = (2008, 0.1)\n",
    "second_obama_point = (2008, y_lim[1])\n",
    "first_reagan_point = (1980, 0.1)\n",
    "second_reagan_point = (1980, y_lim[1])\n",
    "third_reagan_point = (1988, 0.1)\n",
    "fourth_reagan_point = (1988, y_lim[1])\n",
    "\n",
    "\n",
    "\n",
    "# The Fundamental Line. \n",
    "# Complete the code\n",
    "fig, ax = plt.subplots(nrows= 2, ncols= 1, figsize= (10,8), gridspec_kw={'hspace':.3})\n",
    "# Set the sup title\n",
    "fig.suptitle(\"Obama Vs Reagan\", fontsize=24)\n",
    "\n",
    "# Obama call as above\n",
    "# Plot the Michelle data \n",
    "ax[0].plot(, , color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax[0].plot(, , color='black', linestyle='None', marker='.', ms=10)\n",
    "ax[0].set_title('The Obama Effect')\n",
    "ax[0].set_xlabel('Year')\n",
    "# Set x lim and y lim for this Axes\n",
    "ax[0].set_xlim()\n",
    "ax[0].set_ylim()\n",
    "# Complete the call to draw the line\n",
    "ax[0].axline(, , color='black', linewidth=0.8, linestyle='dotted')\n",
    "# Set the y-axis label\n",
    "ax[0].\n",
    "\n",
    "# Plot the Michelle data \n",
    "ax[1].plot()\n",
    "ax[1].plot()\n",
    "ax[1].set_title('The Reagan Effect')\n",
    "ax[1].set_xlabel('Year')\n",
    "# Set x lim and y lim for this Axes\n",
    "ax[1].set_xlim()\n",
    "ax[1].set_ylim()\n",
    "# Draw the first vertical line\n",
    "ax[1].axline(, , color='black', linewidth=0.8, linestyle='dotted')\n",
    "# Draw the second vertical line\n",
    "ax[1].\n",
    "# Set the y-axis label\n",
    "ax[1]."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18b1b51f",
   "metadata": {},
   "source": [
    "#### Comparing Data: Rectangles, Legends and Styles\n",
    "\n",
    "As our last plot of today, we will compare the Barack and Ronald data in one plot. In general, this will eliminate the necessity of harmonizing the scale between two `Axes`, but we will need a legend to make the plot legible.\n",
    "\n",
    "Let's start with our basic plot, which we will enrich step by step. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff7ec48e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Only one Axes\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "\n",
    "# Obama and ronal plot, as above\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(barack['Year'], barack['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax.plot(ronald['Year'], ronald['Count'], color=(0.5, 0.5, 0.5, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(ronald['Year'], ronald['Count'], color='black', linestyle='None', marker='.', ms=10)\n",
    "ax.set_title('Obama Vs Reagan')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named like the president')\n",
    "# Still on the log scale to help see trends\n",
    "ax.set_yscale('log')\n",
    "# Draw the vertical line indicating the presidential mandates\n",
    "first_obama_point = (2008, 0.1)\n",
    "second_obama_point = (2008, ronald['Count'].max())\n",
    "first_reagan_point = (1980, 0.1)\n",
    "second_reagan_point = (1980, ronald['Count'].max())\n",
    "third_reagan_point = (1988, 0.1)\n",
    "fourth_reagan_point = (1988, ronald['Count'].max())\n",
    "ax.axline(first_obama_point, second_obama_point, color='black', linewidth=0.8, linestyle='dotted')\n",
    "ax.axline(first_reagan_point, second_reagan_point, color='black', linewidth=0.8, linestyle='dotted')\n",
    "ax.axline(third_reagan_point, fourth_reagan_point, color='black', linewidth=0.8, linestyle='dotted')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f7e898a",
   "metadata": {},
   "source": [
    "##### Legend\n",
    "\n",
    "Quite clearly, the main problem of the previous plot is impossibility of distinguishing the \"Barack\" data from the \"Ronald\" data. For this purpose, we will use a legend. \n",
    "\n",
    "In `matplotlib` building a legend is composed of two phases. First, you must specify an argument `label` for those element of the plot you want to refer to in the legend. In our case, we must specify a `label` when we plot the markers showing the \"Barack\" and the \"Ronald\" data. Second, you will call the method `ax.legend()` to actually build the legend in the plot. Notice that `ax.legend()` will understand which element you want to mention in the legend thanks to the `label` argument. \n",
    "\n",
    "Naturally, you must also ensure that the elements you want to distinguish look different in the plot! In our case we will color the lines and markers for the two names of blue and red, for \"Barack\" and \"Reagan\" respectively.\n",
    "\n",
    "Finally, while we are here, we will set the y limit manually. The automatic y limit occupy a lot of space with values that are impossible given the nature of the data -- on the log scale, the values below $10^0$ are not relevant for us, since we only deal with integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18ddd976",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's fix the y minimum to 1 = 10^0\n",
    "y_lim = [1, ronald['Count'].max()]\n",
    "# Same as above, I expand the span a little\n",
    "span_y = y_lim[1]- y_lim[0]\n",
    "y_lim = [y_lim[0], y_lim[1] + (0.1*span_y)]\n",
    "print(y_lim)\n",
    "\n",
    "# Remake the plot\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# We go full blue for the Obama data\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0, 0, 1, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "# Notice the Label\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0, 0, 1), linestyle='None', marker='.', ms=10, label='Barack')\n",
    "ax.plot(ronald['Year'], ronald['Count'], color=(1, 0, 0, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(ronald['Year'], ronald['Count'], color=(1,0,0), linestyle='None', marker='.', ms=10, label='Ronald')\n",
    "ax.set_title('Obama Vs Reagan')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named like the president')\n",
    "# New y limit\n",
    "ax.set_ylim(y_lim)\n",
    "ax.set_yscale('log')\n",
    "# We also change the color of the vertical lines\n",
    "ax.axline(first_obama_point, second_obama_point, color=(0,0,1), linewidth=0.8, linestyle='dotted')\n",
    "ax.axline(first_reagan_point, second_reagan_point, color=(1,0,0), linewidth=0.8, linestyle='dotted')\n",
    "ax.axline(third_reagan_point, fourth_reagan_point, color=(1,0,0), linewidth=0.8, linestyle='dotted')\n",
    "\n",
    "# Now the legend is easy to get\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d20ce1",
   "metadata": {},
   "source": [
    "##### Exercise 4\n",
    "\n",
    "Below, you can find the code to create the same plot for the names \"Michelle\" and \"Nancy\". However, the plot lacks a legend. Complete/modify the code: Add the legend and make sure the two data-lines look different (you may choose colors different from blue and red if you prefer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc104e6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fix the y minimum to 1 = 10^0\n",
    "y_lim = [1, data_max]\n",
    "# Expand the y-span a little\n",
    "span_y = y_lim[1]- y_lim[0]\n",
    "y_lim = [y_lim[0], y_lim[1] + (0.1*span_y)]\n",
    "print(y_lim)\n",
    "\n",
    "# Remake the plot\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "\n",
    "# Add the label to the Michelle data\n",
    "ax.plot(michelle['Year'], michelle['Count'], color=(0, 0, 1, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(michelle['Year'], michelle['Count'], color=(0, 0, 1), linestyle='None', marker='.', ms=10)\n",
    "\n",
    "# Add the label to the nancy data\n",
    "ax.plot(nancy['Year'], nancy['Count'], color=(1, 0, 0, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(nancy['Year'], nancy['Count'], color=(1,0,0), linestyle='None', marker='.', ms=10)\n",
    "\n",
    "# Take care of the rest\n",
    "ax.set_title('Obama Vs Reagan, First Ladies')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named like the president')\n",
    "# Set y limit\n",
    "ax.set_ylim(y_lim)\n",
    "# Vertical lines\n",
    "ax.axline(first_obama_point, second_obama_point, color=(0,0,1), linewidth=0.8, linestyle='dotted')\n",
    "ax.axline(first_reagan_point, second_reagan_point, color=(1,0,0), linewidth=0.8, linestyle='dotted')\n",
    "ax.axline(third_reagan_point, fourth_reagan_point, color=(1,0,0), linewidth=0.8, linestyle='dotted')\n",
    "\n",
    "# Add the legend\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbeeb44f",
   "metadata": {},
   "source": [
    "##### Rectangle Patches\n",
    "\n",
    "The vertical lines are fine, but we should be more explicit on their meaning. We can shade the relevant area with red and blue to indicate that those years were associated with one of the two presidents. Then, we can even add the meaning of the shaded area in the legend, to be very explicit on their meaning.\n",
    "\n",
    "To do this, we will need to go down one level in the `matplotlib` API. That is, we will need to explicitly build rectangles and fill them with a blue/red shade. The shaded rectangle will occupy all the area now delimited by the vertical lines.\n",
    "\n",
    "This cannot be done directly within the `plt` submodule, but we need to import a new part of `matplotlib`. Specifically, `matplotlib.patches`, which contains an object representing a rectangle. Unsurprisingly, the object is simply named `matplotlib.patches.Rectangle()`. More in general, you will use `matplotlib.patches` when you want to add a simple shape to your plot, such as a circle, a square, an arrow, etc. For example, in my research, I used the `matplotlib.patches` module to plot the level curves of a bivariate normal distribution. \n",
    "\n",
    "Now, creating a rectangle with `matplotlib.patches.Rectangle()` is easy. You need to indicate the bottom left point of the rectangle (named `xy` below). To do this, you will include the coordinate of the point in a `tuple`. We have already created our `xy` points above, for example with the `tuple` named `first_obama_point`. After that you will need to indicate the `width` and the `height` of the rectangle, as the official documentation explains very clearly:\n",
    "\n",
    "```\n",
    "The rectangle extends from xy[0] to xy[0] + width in x-direction and from xy[1] to xy[1] + height in y-direction.\n",
    "\n",
    ":                +------------------+\n",
    ":                |                  |\n",
    ":              height               |\n",
    ":                |                  |\n",
    ":               (xy)---- width -----+\n",
    "```\n",
    "\n",
    "In the next block import `matplotlib.patches` and instantiate two `Rectangle()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9621ddfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.patches as patches\n",
    "'''\n",
    "Create the Reagan rectangle. Let's go through the argument one by one\n",
    "xy: the bottom-left point of the rectangle. We created this above\n",
    "width: The number 8 as width comes from Reagan having being president for 8 years (x-axis is in years!)\n",
    "height: the height of y_lim[1] makes sure the rectangle occupies the plot until the very top\n",
    "color: this is full red but with a low transparency\n",
    "label: We want to have this rectangle in the legend by the end\n",
    "'''\n",
    "rect_reagan = patches.Rectangle(xy=first_reagan_point, width=8, height=y_lim[1], color=(1,0,0,0.2), \n",
    "                                label='Reagan Presidency')\n",
    "'''\n",
    "The Obama rectangle is substantially identical, with few modifications.\n",
    "The only noticeable difference is the width, that I put to 15 because the end of the Obama\n",
    "second term is outside the data. I want to make sure the rectangle occupies all the area on the \n",
    "right of the plot, untill the very end. Below, we will explicitly set the xlim of the Axes to enforce this.\n",
    "Notice that I do not use keywords argument anymore for xy, width and height\n",
    "I pass xy, width and height as *positional* arguments\n",
    "'''\n",
    "rect_obama = patches.Rectangle(first_obama_point, 15, y_lim[1], color=(0,0,1,0.2), label='Obama Presidency')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8029a4f",
   "metadata": {},
   "source": [
    "Now, you may have noticed that this `Rectangle`s do not belong to any `Axes` or `Figure`: we just created an abstract rectangle and specified its coordinates, color and label. At this point, we need to make sure that the `Axes` actually plots these `Rectangle`s. To do this, we can pass the two `Rectangle`s to the method `ax.add_patch()`. We will add them one at the time (so we will call the method twice). \n",
    "\n",
    "There is a catch though, **once a `Rectangle` (or `Patch` in general) is added to an `Axes` you cannot add it to a different `Axes`**. So you cannot create a `Rectangle` once and then plot it multiple times in different places. This will become immediately relevant in the next exercise.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    <b>Collections</b>: Calling the method <code>ax.add_patch()</code> works fine here, but it will be extremely slow if we have a large number of `patches` to add. To speed up things, we can use a <code>PatchCollection</code> obejct from the <code>matplotlib.collections</code> submodule. This object can contain any list of <code>Patches</code>, including a list of two <code>Rectangle</code>s. Then, we will pass the <code>PatchCollection</code> to the method <code>ax.add_collection()</code> of the relevant <code>Axes</code>. As an example, you may check <a href=https://matplotlib.org/stable/gallery/statistics/errorbars_and_boxes.html#sphx-glr-gallery-statistics-errorbars-and-boxes-py>this tutorial</a>.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fba18be",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import PatchCollection to draw rectangles\n",
    "from matplotlib.collections import PatchCollection\n",
    "\n",
    "# Recalculate the x limits, just to be safe\n",
    "x_lim = [ronald['Year'].min(), ronald['Year'].max()]\n",
    "span_x = x_lim[1] - x_lim[0]\n",
    "x_lim = [x_lim[0] - (0.05*span_x), x_lim[1] + (0.05*span_x)]\n",
    "\n",
    "\n",
    "# Nothing changes here\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0, 0, 1, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0, 0, 1), linestyle='None', marker='.', ms=10, label='Barack')\n",
    "ax.plot(ronald['Year'], ronald['Count'], color=(1, 0, 0, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(ronald['Year'], ronald['Count'], color=(1,0,0), linestyle='None', marker='.', ms=10, label='Ronald')\n",
    "ax.set_title('Obama Vs Reagan')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named like the president')\n",
    "ax.set_ylim(y_lim)\n",
    "ax.set_yscale('log')\n",
    "\n",
    "# Plot rectangles\n",
    "ax.add_patch(rect_reagan)\n",
    "ax.add_patch(rect_obama)\n",
    "\n",
    "# Set the x limit to make sure the Obama rect covers all of the right side\n",
    "ax.set_xlim(x_lim)\n",
    "\n",
    "\n",
    "# Finally we add the legend, as we did before.\n",
    "# Question, why is it in the bottom left corner now?\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1383b46a",
   "metadata": {},
   "source": [
    "##### Exercise 5\n",
    "\n",
    "We want the two `Rectangle`s above to the plot (and legend) below regarding the \"Michelle\" and \"Nancy\" data. Complete the code below:\n",
    "\n",
    "1. Create (identical) `Rectangle`s as the one above\n",
    "2. Plot them in the `Axes`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f692160",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate x and y limits for the nancy-michelle data\n",
    "x_lim = [nancy['Year'].min(), nancy['Year'].max()]\n",
    "span_x = x_lim[1] - x_lim[0]\n",
    "x_lim = [x_lim[0] - (0.05*span_x), x_lim[1] + (0.05*span_x)]\n",
    "y_lim = [1, data_max]\n",
    "span_y = y_lim[1]- y_lim[0]\n",
    "y_lim = [y_lim[0], y_lim[1] + (0.1*span_y)]\n",
    "\n",
    "# Remake the plot with the new data\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "ax.plot(michelle['Year'], michelle['Count'], color=(0, 0, 1, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(michelle['Year'], michelle['Count'], color=(0, 0, 1), linestyle='None', marker='.', ms=10, label='Michelle')\n",
    "ax.plot(nancy['Year'], nancy['Count'], color=(1, 0, 0, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(nancy['Year'], nancy['Count'], color=(1,0,0), linestyle='None', marker='.', ms=10, label='Nancy')\n",
    "ax.set_title('Obama Vs Reagan, First Ladies')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named like the president')\n",
    "ax.set_ylim(y_lim)\n",
    "ax.set_xlim(x_lim)\n",
    "\n",
    "# Complete the code:\n",
    "# Create new (but identical) Obama rectangle for the plot\n",
    "rect_obama = patches.Rectangle(xy=, width= , height=, color= , \n",
    "                               label='Obama Presidency')\n",
    "# Create new (identical) Reagan rectangle for the plot\n",
    "rect_reagan = patches.Rectangle()\n",
    "\n",
    "# Complete the code:\n",
    "# Add Obama rectangle\n",
    "ax.add_patch()\n",
    "# Add Reagan Rectangle\n",
    "ax\n",
    "\n",
    "\n",
    "# Now the legend is easy to get\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e1e44f",
   "metadata": {},
   "source": [
    "##### Style\n",
    "\n",
    "A style is a bundle of settings regarding how `matplotlib` plots elements. If we do not specify otherwise, `matplotlib` uses default values that are set by the style we use. For example, the white background we observed so far is determined by the style we have used. In particular, throughout this workhshop we have used the \"default\" style, but we can easily swap style if we would like to do so.\n",
    "\n",
    "If you use `matplotlib` regularly, you may eventually want to create your own style and load it every time you open `matplotlib`. For now, let's use one of the pre-installed styles. First, let's check what is available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0f270ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(plt.style.available)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b4d6afe",
   "metadata": {},
   "source": [
    "You may be wondering, what is the \"fivethirtyeight\" style? How does it look? Only one way to find out. We will replicate the plot above, but in the new style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6939a98c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Changed the y_lim in the previous exercise\n",
    "y_lim = [1, ronald['Count'].max()]\n",
    "span_y = y_lim[1]- y_lim[0]\n",
    "y_lim = [y_lim[0], y_lim[1] + (0.1*span_y)]\n",
    "\n",
    "\n",
    "# Change style!\n",
    "plt.style.use('fivethirtyeight')\n",
    "\n",
    "# Replicate the same plot\n",
    "# Create new rectangles for the plot. \n",
    "rect_reagan = patches.Rectangle(xy=first_reagan_point, width=8, height=y_lim[1], color=(1,0,0,0.2), \n",
    "                                label='Reagan Presidency')\n",
    "rect_obama = patches.Rectangle(first_obama_point, 15, y_lim[1], color=(0,0,1,0.2), label='Obama Presidency')\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0, 0, 1, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(barack['Year'], barack['Count'], color=(0, 0, 1), linestyle='None', marker='.', ms=10, label='Barack')\n",
    "ax.plot(ronald['Year'], ronald['Count'], color=(1, 0, 0, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(ronald['Year'], ronald['Count'], color=(1,0,0), linestyle='None', marker='.', ms=10, label='Ronald')\n",
    "ax.set_title('Obama Vs Reagan')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named like the president')\n",
    "ax.set_ylim(y_lim)\n",
    "ax.set_yscale('log')\n",
    "ax.add_patch(rect_reagan)\n",
    "ax.add_patch(rect_obama)\n",
    "ax.set_xlim(x_lim)\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8b22910",
   "metadata": {},
   "source": [
    "##### Exercise 6\n",
    "\n",
    "Replicate the \"Michelle\", \"Nancy\" plot with a new style of your choice. You can see the available styles with `print(plt.style.available)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc8fd3ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate x and y limits for the nancy-michelle data\n",
    "y_lim = [1, data_max]\n",
    "span_y = y_lim[1]- y_lim[0]\n",
    "y_lim = [y_lim[0], y_lim[1] + (0.1*span_y)]\n",
    "x_lim = [nancy['Year'].min(), nancy['Year'].max()]\n",
    "span_x = x_lim[1] - x_lim[0]\n",
    "x_lim = [x_lim[0] - (0.05*span_x), x_lim[1] + (0.05*span_x)]\n",
    "\n",
    "# Change style!\n",
    "plt.\n",
    "\n",
    "# Replicate the same plot with same data\n",
    "fig, ax = plt.subplots(figsize= (10,8))\n",
    "# Plot data\n",
    "ax.plot(michelle['Year'], michelle['Count'], color=(0, 0, 1, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(michelle['Year'], michelle['Count'], color=(0, 0, 1), linestyle='None', marker='.', ms=10, label='Barack')\n",
    "ax.plot(nancy['Year'], nancy['Count'], color=(1, 0, 0, 0.5), linestyle='dashdot', linewidth=1.)\n",
    "ax.plot(nancy['Year'], nancy['Count'], color=(1,0,0), linestyle='None', marker='.', ms=10, label='Ronald')\n",
    "# spand and labels\n",
    "ax.set_title('Obama Vs Reagan')\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Number of newborns named like the president')\n",
    "ax.set_ylim(y_lim)\n",
    "ax.set_xlim(x_lim)\n",
    "# rectangles\n",
    "rect_reagan = patches.Rectangle(xy=first_reagan_point, width=8, height=y_lim[1], color=(1,0,0,0.2), \n",
    "                                label='Reagan Presidency')\n",
    "rect_obama = patches.Rectangle(first_obama_point, 15, y_lim[1], color=(0,0,1,0.2), label='Obama Presidency')\n",
    "ax.add_patch(rect_reagan)\n",
    "ax.add_patch(rect_obama)\n",
    "# Legend\n",
    "ax.legend()"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}