vis-matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(vis-matplotlib)=\n",
    "# Powerful Data Visualisation with **Matplotlib**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Here you'll see how to make just about any plot you can possibly imagine using the ferociously powerful *imperative* graphing package, **matplotlib**. Here, it will be about explaining the basics. If you read on to the chapter on {ref}`vis-narrative`, you'll see just how flexible it is and how it can produce commercial-quality graphics. Additionally, **matplotlib** is the foundation stone of quite a few other data visualisation libraries (including **plotnine** and **seaborn**) which shows how much it can do. It was famously used to create the first ever image of a black hole by {cite:t}`akiyama2019first`.\n",
    "\n",
    "```{note}\n",
    "**matplotlib** is an incredibly powerful and customisable visualisation package.\n",
    "```\n",
    "\n",
    "It's worth saying that **matplotlib** has a very different philosophy than, for example, **lets-plot**. Apart from being *imperative* rather than *declarative*, it also prefers unstacked data to tidy data: so, to create plots quickly, instead of every line you want to plot being stored in a single column called \"country\" as it would be using tidy data, it prefers *each* column to have a different country in.\n",
    "\n",
    "For a more in-depth introduction to **matplotlib**, head over to [this tutorial](https://github.com/rougier/matplotlib-tutorial). This chapter is indebted to that tutorial, to the excellent [**matplotlib** documentation](https://matplotlib.org/stable/tutorials/index.html), and to the book *Scientific Visualization in Matplotlib* {cite:ps}`rougier2021scientific`.\n",
    "\n",
    "As ever, we'll start by importing some key packages and initialising any settings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Set seed for random numbers\n",
    "seed_for_prng = 78557\n",
    "prng = np.random.default_rng(\n",
    "    seed_for_prng\n",
    ")  # prng=probabilistic random number generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51a55374",
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "import matplotlib_inline.backend_inline\n",
    "\n",
    "# Plot settings\n",
    "plt.style.use(\n",
    "    \"https://github.com/aeturrell/coding-for-economists/raw/main/plot_style.txt\"\n",
    ")\n",
    "matplotlib_inline.backend_inline.set_matplotlib_formats(\"svg\")\n",
    "\n",
    "# Set max rows displayed for readability\n",
    "pd.set_option(\"display.max_rows\", 6)\n",
    "pd.set_option(\"display.max_columns\", 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll see we imported `matplotlib.pyplot as plt` above; this is the main part of **matplotlib** that we'll use in practice.\n",
    "\n",
    "### The **matplotlib** API\n",
    "\n",
    "**matplotlib** {cite:ps}`hunter2007matplotlib` has its origin in an attempt to replicate the plotting functionality of the paid programming language Matlab but has since outgrown these roots. Because **matplotlib** has been around a long time and there are different ways to use it, much of the material online about how to use **matplotlib** uses the old, Matlab-inspired approach---which is not what this book recommends; instead, we strongly recommend the modern object oriented API. If you see a plot feature that begins `plt.scatter` or similar, then it's using the legacy API rather than the now recommended \"object oriented API\" which is focused around axes, eg `ax.scatter` and similar. You want to follow examples that use the object-oriented approach.\n",
    "\n",
    "Everything you see below will use the 'object-oriented API'. This means that we create objects, like *figures* and *axes*, that have state (they remember what you did to them).\n",
    "\n",
    "Also worth saying: the **matplotlib** API (application programming interface) is huge so there's no way we'll be able to cover *everything* it can do!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object-oriented API is most often used by creating two fundamental objects that are used by almost every chart: the figure and the axes. You should think of the figure object, `fig`, as the canvas on which you can put any number of charts. Each ax (short for 'axis') object is one chart within a figure. Of course, most of the time you're likely only to have one axis per figure, but in the cases when you don't it's a really useful setup. The plotting of elements such as lines, points, bars, and so, are controlled by the `ax` objects while the overall settings are controlled by `fig`.\n",
    "\n",
    "The most simple chart we can think of would be a line plot. Let's see how to do that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()  # Get the figure and one axis as a subplot\n",
    "ax.plot(\n",
    "    [1, 2, 3, 4, 5, 6],  # Add some data on the x and y axes\n",
    "    [1, 4, 2, 3, 1, 7],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that, unlike **seaborn**, **matplotlib** will happily accept raw data (but will work with dataframes too).\n",
    "\n",
    "```{admonition} Tip\n",
    ":class: tip\n",
    "**Matplotlib** returns an object when used in certain contexts, eg it might return `[<matplotlib.lines.Line2D at...` above. To suppress this, end the command with a semi-colon, `;`, or call `plt.show()` as the last command.\n",
    "```\n",
    "\n",
    "Let's see an example of a scatter plot using this object-oriented approach. Note that we begin in the same way, with getting a figure and an axis. But now we're going to use `ax.scatter` instead, plus throw in a couple of extra settings (can you guess what they do?)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()  # Create a figure containing a single axes.\n",
    "ax.scatter(\n",
    "    [1, 2, 3, 4, 5, 6],\n",
    "    [1, 4, 2, 3, 1, 7],\n",
    "    s=150,\n",
    "    c=\"b\",  # Plot some data on the axes.\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`s=150` sets the area of the points (ie the size of each marker), and `c='b'` sets the colour. Many of these features will accept an *array* of values (like `s = [1, 2, 3, 4, 5, 6]`) instead of a single value and will map them into the plot in the way you'd expect. \n",
    "\n",
    "Let's see that in practice. For the sizes, we'll linearly increment the points between 300 and 2000 in 6 steps. For the colours, we'll just type out six distinct values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(\n",
    "    [1, 2, 3, 4, 5, 6],\n",
    "    [1, 4, 2, 3, 1, 7],\n",
    "    s=np.linspace(300, 2000, 6),\n",
    "    c=[\"b\", \"r\", \"g\", \"k\", \"cyan\", \"yellow\"],\n",
    "    edgecolors=\"k\",\n",
    "    alpha=0.5,\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also asked for partly transparent points via the `alpha` setting (the default is `alpha=1`, which is a solid colour), and a black (`color='k'`) line-edge colour.\n",
    "\n",
    "As ever, you can call help on a specific command in order to understand what options (keyword arguments) it accepts. And, in Visual Studio Code, you can just hover over the function or method name.\n",
    "\n",
    "Here is what `help` returns when you run it on the `scatter()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "output-scroll"
    ]
   },
   "outputs": [],
   "source": [
    "help(ax.scatter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **pandas** and **matplotlib**\n",
    "\n",
    "**matplotlib** will accept any array-like data, but it's fair to say it *much* prefers data frames to be in wide data format than tidy format (fortunately **pandas** makes it easy to switch between the two using `unstack()` or `pivot()`). **pandas** also has built-in plotting methods that make use of **matplotlib**; these can be accessed via `DataFrame.plot.*`, for example `df.plot()`.\n",
    "\n",
    "Let's see an example of this. First we generate some data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_samples = 1000\n",
    "df = pd.DataFrame(\n",
    "    prng.standard_normal(size=(num_samples, 4)),\n",
    "    index=pd.date_range(\"1/1/2000\", periods=num_samples),\n",
    "    columns=list(\"ABCD\"),\n",
    ")\n",
    "df = df.cumsum()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, what happens when we use `df.plot()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This works pretty much as expected. But what if we had tidy data?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tidy_df = df.reset_index().melt(id_vars=\"index\")\n",
    "tidy_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's just throw this into `.plot()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tidy_df.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uh oh! This isn't what we wanted at all! It's *combined* all of the series. If you have this issue with tidy data, you can switch to wide format like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tidy_df.pivot(index=\"index\", columns=\"variable\", values=\"value\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary\n",
    "\n",
    "There are a huge number of options for what to put on axes; the table below gives a guide to the most essential ones for 2D plots.\n",
    "\n",
    "| Code | What it does |\n",
    "|---|---|\n",
    "| `Axes.plot` | Plot y versus x as lines and/or markers. |\n",
    "| `Axes.errorbar` | Plot y versus x as lines and/or markers with attached errorbars. |\n",
    "| `Axes.scatter` | A scatter plot of y vs x |\n",
    "| `Axes.step` | Make a step plot. |\n",
    "| `Axes.loglog` | Make a plot with log scaling on both the x and y axis. |\n",
    "| `Axes.semilogx` | Make a plot with log scaling on the x axis. |\n",
    "| `Axes.semilogy` | Make a plot with log scaling on the y axis. |\n",
    "| `Axes.fill_between` | Fill the area between two horizontal curves. |\n",
    "| `Axes.fill_betweenx` | Fill the area between two vertical curves. |\n",
    "| `Axes.bar` | Make a bar plot. |\n",
    "| `Axes.barh` | Make a horizontal bar plot. |\n",
    "| `Axes.bar_label` | Label a bar plot. |\n",
    "| `Axes.stem` | Create a stem plot. |\n",
    "| `Axes.eventplot` | Plot identical parallel lines at the given positions. |\n",
    "| `Axes.pie` | Plot a pie chart. |\n",
    "| `Axes.stackplot` | Draw a stacked area plot. |\n",
    "| `Axes.broken_barh` | Plot a horizontal sequence of rectangles. |\n",
    "| `Axes.vlines` | Plot vertical lines at each x from ymin to ymax. |\n",
    "| `Axes.hlines` | Plot horizontal lines at each y from xmin to xmax. |\n",
    "| `Axes.axhline` | Add a horizontal line across the Axes. |\n",
    "| `Axes.axhspan` | Add a horizontal span (rectangle) across the Axes. |\n",
    "| `Axes.axvline` | Add a vertical line across the Axes. |\n",
    "| `Axes.axvspan` | Add a vertical span (rectangle) across the Axes. |\n",
    "| `Axes.axline` | Add an infinitely long straight line. |\n",
    "| `Axes.fill` | Plot filled polygons. |\n",
    "| `Axes.boxplot` | Draw a box and whisker plot. |\n",
    "| `Axes.violinplot` | Make a violin plot. |\n",
    "| `Axes.violin` | Drawing function for violin plots. |\n",
    "| `Axes.bxp` | Drawing function for box and whisker plots. |\n",
    "| `Axes.hexbin` | Make a 2D hexagonal binning plot of points x, y. |\n",
    "| `Axes.hist` | Compute and plot a histogram. |\n",
    "| `Axes.hist2d` | Make a 2D histogram plot. |\n",
    "| `Axes.stairs` | A stepwise constant function as a line with bounding edges or a filled plot. |\n",
    "| `Axes.contour` | Plot contour lines. |\n",
    "| `Axes.contourf` | Plot filled contours. |\n",
    "\n",
    "Now, it might not seem like it, but you already have the makings of a wide range of **matplotlib** plots. You just need to follow this recipe:\n",
    "\n",
    "1. `fig, ax = plt.subplots()`\n",
    "2. Choose what you want to put on your axis, for example `axes[0].scatter` or `axes[0].plot`\n",
    "3. Put data into the method you chose in 2 in the required format (and remember you can check the documentation to get the right format; either using `help`, hovering over the method name in Visual Studio Code, or heading to the **matplotlib** documentation, where there are often also examples to look at---here are the [examples for hex bins](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.hexbin.html#examples-using-matplotlib-axes-axes-hexbin)).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Anatomy of a **matplotlib** graph\n",
    "\n",
    "So, you've made a nice plot and now you want to tweak it. Well, **matplotlib** certainly has a LOT of choice when it comes to tweaking! Rather than go through all of the many, many options for customisation, the figure below (from the documentation) gives an overview of the options:\n",
    "\n",
    "![Anatomy of a matplotlib figure](https://matplotlib.org/_images/anatomy.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run through a few of the most important plot elements:\n",
    "\n",
    "- **Artists** (not explicitly labelled above): There are two types of Artists: primitives and containers. The primitives represent the standard graphical objects we want to paint onto our canvas: `Line2D`, `Rectangle`, `Text`, `AxesImage`, etc., and the containers are places to put them (`Axis`, `Axes` and `Figure`).\n",
    "\n",
    "- **Figure**, or 'fig': the figure keeps track of all the child Axes that are on it and a smattering of 'special' artists (titles, figure legends, etc). A figure can contain any number of Axes, but will typically have at least one if it is to be interesting!\n",
    "\n",
    "- **Axes**, or 'ax': this is the plot, the region of the image that traces out the data. A given Figure can contain many Axes, but a given Axes object can only be in one Figure. The Axes contains two (or three in the case of 3D) Axis objects (Axes and Axis are different things!) that record the data limits (you can override these via the `axes.Axes.set_xlim()` and `axes.Axes.set_ylim()` methods). Each Axes object has a title (set via `set_title()`), an x-label (set via `set_xlabel()`), and a y-label set via `set_ylabel()`). When you add, say, a line chart to an Axes object it appears as a Line2D object associated that that axis and it is created by calling a method on an Axes object.\n",
    "\n",
    "- **Axis**: these are the number-line objects that control the limits of what the viewer can see. They also provide the means to access the ticks (the marks on the axis) and ticklabels (strings labeling the ticks). The location of the ticks is determined by a Locator object and the ticklabel strings are formatted by a Formatter. The combination of Locator and Formatter gives very fine control over the tick locations and labels.\n",
    "\n",
    "- **Markers**: these are what are produced by scatter plots.\n",
    "\n",
    "- **Labels and titles**: text to help the viewers of the chart make sense of what they're seeing.\n",
    "\n",
    "- **Legend**: if needed, contains the key to understand the shapes or colours used in lines or markers or bars (or ...) that are on the chart."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customising Charts\n",
    "\n",
    "While the **matplotlib** API is too extensive for us to cover every detail, it's important to know about some standard customisations that you might need to get going.\n",
    "\n",
    "### Limits and Labels\n",
    "\n",
    "We've only seen aspects of the plot that are customisable through the `scatter()` keyword so far; let's now see an example that's a bit more real (and useful!) in which we'll want to add labels, a title, and more. Note that **matplotlib** supports LaTeX equations in text.\n",
    "\n",
    "We'll plot some data from the US Midwest demographics dataset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\n",
    "    \"https://vincentarelbundock.github.io/Rdatasets/csv/ggplot2/midwest.csv\",\n",
    "    index_col=\"PID\",\n",
    ")\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, as well as a scatter, let's add some context to the chart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(\n",
    "    df[\"area\"], df[\"poptotal\"], edgecolors=\"k\", alpha=0.6\n",
    ")  # Make a scatter plot on \"ax\"\n",
    "ax.set_xlim(0, 0.1)  # Set the limits on the x-axis\n",
    "ax.set_ylim(0, 1e6)  # Set the limits on the y-axis\n",
    "ax.set_xlabel(\"Area\")  # Set the x label\n",
    "ax.set_ylabel(\"Population\")  # Set the y label\n",
    "ax.set_title(\n",
    "    \"Area vs. Population\", loc=\"right\"\n",
    ");  # Add a title and say where it should go"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're not quite done with titles. Often it's useful to have a y-axis title that is horizontal, and so easier to read. And, additionally, it's good practice to have a title that tells the viewer what they should take away from the graph. To achieve both of these together, you can i) use `plt.suptitle()` for a figure-level title whose position can be fine-tuned using `x` and `y` keyword arguments; and ii) use `ax.set_title()` to provide the y-axis label. The chart below demonstrates this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df[\"area\"], df[\"poptotal\"] / 1e6, edgecolors=\"k\", alpha=0.6, s=150)\n",
    "ax.set_ylim(0, None)\n",
    "ax.set_xlim(0, None)\n",
    "ax.set_xlabel(\"Area\")\n",
    "ax.set_title(\"Population (millions)\", loc=\"left\", fontsize=14)\n",
    "plt.suptitle(\"Little correlation between population and area\", y=1.02, x=0.45);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Customising Axes\n",
    "\n",
    "Each Axes has two (or three) Axis objects representing the x- and y-axis. These control the scale of the Axis, the tick locators and the tick formatters. Additional Axes can be attached to display further Axis objects.\n",
    "\n",
    "First, we're going to make some random data that will help explain some of the concepts in the rest of the chapter.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data1, data2 = prng.standard_normal(size=(2, 100))  # make 2 random data sets\n",
    "xdata = np.arange(len(data1))  # make an ordinal for this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ticks Locators and Formatters\n",
    "\n",
    "Each Axis has a tick *locator* and *formatter* that choose where along the Axis objects to put tick marks.  A simple interface to this is `Axes.set_xticks()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(2, 1, layout=\"constrained\")\n",
    "axs[0].plot(xdata, data1)\n",
    "axs[0].set_title(\"Automatic ticks\")\n",
    "\n",
    "axs[1].plot(xdata, data1)\n",
    "axs[1].set_xticks(np.arange(0, 100, 30), [\"zero\", \"30\", \"sixty\", \"90\"])\n",
    "axs[1].set_yticks([-1.5, 0, 1.5])  # note that we don't need to specify labels\n",
    "axs[1].set_title(\"Manual ticks\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the **matplotlib** documentation on [Tick locators](https://matplotlib.org/stable/gallery/ticks/tick-locators.html) and [Tick formatters](https://matplotlib.org/stable/gallery/ticks/tick-formatters.html) for other formatters and locators and information for writing your own."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returning to our Midwest examples, we had the makings of a basic chart, with axes labels and even a title. \n",
    "\n",
    "But what we know from the data is that \"Area\" is actually a percentage. We could represent this by doing\n",
    "\n",
    "```python\n",
    "ax.set_xlabel(\"Area, %\")\n",
    "```\n",
    "\n",
    "but as **matplotlib** is infinitely customisable, there is another option too---changing the tick labels.\n",
    "\n",
    "On the x-axis, we'll add a percentage suffix on the numbers plus some minor tick marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.ticker import AutoMinorLocator\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df[\"area\"], df[\"poptotal\"], edgecolors=\"k\", alpha=0.6)\n",
    "ax.set_xlim(0, 0.1)\n",
    "ax.set_ylim(0, 1e6)\n",
    "ax.set_xlabel(\"Area\")\n",
    "ax.set_ylabel(\"Population\")\n",
    "ax.set_title(\"Area vs. Population\", loc=\"right\")\n",
    "ax.xaxis.set_minor_locator(\n",
    "    AutoMinorLocator(4)\n",
    ")  # Add minor tick marks, four between every major one\n",
    "ax.xaxis.set_major_formatter(\n",
    "    \"{x:.2f}%\"\n",
    ");  # Every x value has 2 decimal places and is followed by a '%' sign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `AutoMinorLocator(4)` inserts 4 minor tick marks between each major tick mark. The major formatter is `'{x:.2f}%'`, which says print 2 decimal places followed by a % sign."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scales\n",
    "\n",
    "\n",
    "In addition to the linear scale, **matplotlib** supplies non-linear scales, such as a log-scale.  Since log-scales are used so much there are also direct methods like `Axes.loglog`, `Axes.semilogx`, and\n",
    "`Axes.semilogy`. There are a number of scales (see the **matplotlib** [scales](https://matplotlib.org/stable/gallery/scales/scales.html) docs for other examples).  Here we set the scale\n",
    "manually:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(1, 2, layout=\"constrained\")\n",
    "xdata = np.arange(len(data1))  # make an ordinal for this\n",
    "data = 10**data1\n",
    "axs[0].plot(xdata, data, lw=1)\n",
    "axs[0].set_ylim(0, None)\n",
    "axs[1].set_yscale(\"log\")\n",
    "axs[1].plot(xdata, data, lw=1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Loops to Achieve Customisation Effects\n",
    "\n",
    "Let's say we want to now differentiate these points with colour according to which state they belong to and add a legend that says which states have which colour. The easiest way to do this is by creating a `for` loop.\n",
    "\n",
    "We're going to loop over `state`. We do it using `for state in df[\"state\"].unique():`, which runs over states. The different colours are provided by passing `cmap=\"colourmap-name\"`. This generates a different colour for each state and cycles to the next colour each time `ax.scatter()` is called in the loop.\n",
    "\n",
    "Now we have colour capturing a new dimension of the data (state), we also need to have a legend that shows which colour each state corresponds to. By passing `lable=state` within the `for` loop, we build up state<==>colour equivalences that appears on the chart when we call `ax.legend`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "for state in df[\"state\"].unique():\n",
    "    xf = df.loc[df[\"state\"] == state]\n",
    "    ax.scatter(\n",
    "        xf[\"area\"],\n",
    "        xf[\"poptotal\"],\n",
    "        cmap=\"Dark2\",  # Note that we have qualitative data so we use a colour map\n",
    "        label=state,\n",
    "        s=100,\n",
    "        edgecolor=\"k\",\n",
    "        alpha=0.8,\n",
    "    )\n",
    "ax.set_xlim(0, 0.1)\n",
    "ax.set_ylim(0, 1e6)\n",
    "ax.set_xlabel(\"Area\")\n",
    "ax.set_ylabel(\"Population\")\n",
    "ax.set_title(\"Area vs. Population\", loc=\"center\")\n",
    "ax.xaxis.set_minor_locator(AutoMinorLocator(4))\n",
    "ax.xaxis.set_major_formatter(\"{x:.2f}%\")\n",
    "ax.legend(title=\"State\", loc=\"upper right\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We used a colourmap to get 5 qualitatively different colours; there are also sequential colormaps for continuous (as opposed to discrete) variables. You can find out more about the colormaps available in base **matplotlib** [here](https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Text Annotations\n",
    "\n",
    "It's possible to point out specific values with a text label. Adding extra information like this can be useful in all kinds of circumstances; for example, showing the biggest or smallest, drawing attention to a particular story, or simply flagging a special value.\n",
    "\n",
    "Let's add a couple of text annotations. Let's say we want to annotate the county with the biggest area, and the county with the highest population. For the biggest area, we'll just pop the label next to the point. First we need to *find* the position of the point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_area_row = df.iloc[df[\"area\"].argmax()]\n",
    "max_area_row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we use `ax.annotate()` to add this information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "for state in df[\"state\"].unique():\n",
    "    xf = df.loc[df[\"state\"] == state]\n",
    "    ax.scatter(\n",
    "        xf[\"area\"],\n",
    "        xf[\"poptotal\"],\n",
    "        cmap=\"Dark2\",  # Note that we have qualitative data so we use a colour map\n",
    "        label=state,\n",
    "        s=100,\n",
    "        edgecolor=\"k\",\n",
    "        alpha=0.8,\n",
    "    )\n",
    "ax.set_xlim(0, 0.12)\n",
    "ax.set_ylim(0, 1e6)\n",
    "ax.set_xlabel(\"Area\")\n",
    "ax.set_ylabel(\"Population\")\n",
    "ax.set_title(\"Area vs. Population\", loc=\"center\")\n",
    "ax.legend()\n",
    "ax.annotate(\n",
    "    text=f'Max. area: {max_area_row.loc[\"county\"].title()}',\n",
    "    xy=tuple(max_area_row[[\"area\", \"poptotal\"]]),\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to put text somewhere *other* than right next to the datapoint? We can do that and have an arrow to connect the label to the data point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_pop_row = df.iloc[df[\"poptotal\"].argmax()]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for state in df[\"state\"].unique():\n",
    "    xf = df.loc[df[\"state\"] == state]\n",
    "    ax.scatter(\n",
    "        xf[\"area\"],\n",
    "        xf[\"poptotal\"],\n",
    "        cmap=\"Dark2\",  # Note that we have qualitative data so we use a colour map\n",
    "        label=state,\n",
    "        s=100,\n",
    "        edgecolor=\"k\",\n",
    "        alpha=0.8,\n",
    "    )\n",
    "ax.set_xlim(0, 0.12)\n",
    "ax.set_ylim(0, 6e6)\n",
    "ax.set_xlabel(\"Area\")\n",
    "ax.set_ylabel(\"Population\")\n",
    "ax.set_title(\"Area vs. Population\", loc=\"center\")\n",
    "ax.legend()\n",
    "ax.annotate(\n",
    "    text=f'Max. area: {max_area_row.loc[\"county\"].title()}',\n",
    "    xy=tuple(max_area_row[[\"area\", \"poptotal\"]]),\n",
    "    xytext=(-100, 20),\n",
    "    textcoords=\"offset points\",\n",
    "    arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"angle3\"),\n",
    ")\n",
    "ax.annotate(\n",
    "    text=f'Max. pop: {max_pop_row[\"county\"].title()}',\n",
    "    xy=tuple(max_pop_row[[\"area\", \"poptotal\"]]),\n",
    "    xytext=(-100, -50),\n",
    "    textcoords=\"offset points\",\n",
    "    arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"angle3\"),\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get really creative with text annotations---as the image below, taken from [*Scientific Visualisation: Python + Matplotlib*](https://github.com/rougier/scientific-visualization-book) {cite:ps}`rougier2021scientific` shows. You can learn more about text annotations [here](https://matplotlib.org/stable/tutorials/text/annotations.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "import matplotlib.patheffects as path_effects\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(6, 6))\n",
    "plt.setp(axes, xlim=[-1, +1], xticks=[], ylim=[-1, +1], yticks=[], aspect=1)\n",
    "\n",
    "X = prng.normal(0, 0.35, 1000)\n",
    "Y = prng.normal(0, 0.35, 1000)\n",
    "\n",
    "I_vec = prng.choice(len(X), size=5, replace=False)\n",
    "Px, Py = X[I_vec], Y[I_vec]\n",
    "I_vec = np.argsort(Y[I_vec])[::-1]\n",
    "Px, Py = Px[I_vec], Py[I_vec]\n",
    "\n",
    "for ax in axes:\n",
    "    ax.scatter(X, Y, edgecolor=\"None\", facecolor=\"C1\", alpha=0.5)\n",
    "    ax.scatter(Px, Py, edgecolor=\"black\", facecolor=\"white\", zorder=20)\n",
    "    ax.scatter(Px, Py, edgecolor=\"None\", facecolor=\"C1\", alpha=0.5, zorder=30)\n",
    "\n",
    "# first subplot\n",
    "y, dy = 1.0, 0.125\n",
    "style = \"arc,angleA=-0,angleB=0,armA=-100,armB=0,rad=0\"\n",
    "\n",
    "for i in range(len(I_vec)):\n",
    "    text = axes[0].annotate(\n",
    "        \"Point \" + chr(ord(\"A\") + i),\n",
    "        xy=(Px[i], Py[i]),\n",
    "        xycoords=\"data\",\n",
    "        xytext=(0, 30),\n",
    "        textcoords=\"offset points\",\n",
    "        ha=\"center\",\n",
    "        size=\"small\",\n",
    "        arrowprops=dict(\n",
    "            arrowstyle=\"->\", shrinkA=0, shrinkB=5, color=\"black\", linewidth=0.75\n",
    "        ),\n",
    "    )\n",
    "    text.set_path_effects(\n",
    "        [path_effects.Stroke(linewidth=2, foreground=\"white\"), path_effects.Normal()]\n",
    "    )\n",
    "    text.arrow_patch.set_path_effects(\n",
    "        [path_effects.Stroke(linewidth=2, foreground=\"white\"), path_effects.Normal()]\n",
    "    )\n",
    "\n",
    "# 2nd subplot\n",
    "for i in range(len(I_vec)):\n",
    "    text = axes[1].annotate(\n",
    "        \"Point \" + chr(ord(\"A\") + i),\n",
    "        xy=(Px[i], Py[i]),\n",
    "        xycoords=\"data\",\n",
    "        xytext=(1.25, y - i * dy),\n",
    "        textcoords=\"data\",\n",
    "        arrowprops=dict(\n",
    "            arrowstyle=\"->\",\n",
    "            color=\"black\",\n",
    "            linewidth=0.75,\n",
    "            shrinkA=20,\n",
    "            shrinkB=5,\n",
    "            patchA=None,\n",
    "            patchB=None,\n",
    "            connectionstyle=style,\n",
    "        ),\n",
    "    )\n",
    "    text.arrow_patch.set_path_effects(\n",
    "        [path_effects.Stroke(linewidth=2, foreground=\"white\"), path_effects.Normal()]\n",
    "    )\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Special Lines\n",
    "\n",
    "Next, we're going to add some special lines to our chart. This is surprisingly useful in practice, and there are a few commands. If we just want a horizontal or vertical line, our best bet is `ax.axhline()` and `ax.axvline()` respectively.\n",
    "\n",
    "Let's add a special line to our example to show where the *mean area* of counties appears. First we need the mean area:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_county_area = df[\"area\"].mean()\n",
    "mean_county_area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we're going to add the line, using `ax.axvline`, but also a corresponding annotation that tells viewers what this line is showing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "for state in df[\"state\"].unique():\n",
    "    xf = df.loc[df[\"state\"] == state]\n",
    "    ax.scatter(\n",
    "        xf[\"area\"],\n",
    "        xf[\"poptotal\"],\n",
    "        cmap=\"Dark2\",  # Note that we have qualitative data so we use a discrete colour map\n",
    "        label=state,\n",
    "        s=100,\n",
    "        edgecolor=\"k\",\n",
    "        alpha=0.8,\n",
    "    )\n",
    "ax.set_xlim(0, 0.12)\n",
    "ax.set_ylim(0, 6e6)\n",
    "ax.set_xlabel(\"Area\")\n",
    "ax.set_ylabel(\"Population\")\n",
    "ax.set_title(\"Area vs. Population\", loc=\"center\")\n",
    "ax.legend()\n",
    "ax.annotate(\n",
    "    text=f'Max. area: {max_area_row.loc[\"county\"].title()}',\n",
    "    xy=tuple(max_area_row[[\"area\", \"poptotal\"]]),\n",
    "    xytext=(-100, 20),\n",
    "    textcoords=\"offset points\",\n",
    "    arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"angle3\"),\n",
    ")\n",
    "ax.annotate(\n",
    "    text=f'Max. pop: {max_pop_row[\"county\"].title()}',\n",
    "    xy=tuple(max_pop_row[[\"area\", \"poptotal\"]]),\n",
    "    xytext=(20, -50),\n",
    "    textcoords=\"offset points\",\n",
    "    arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"angle3\"),\n",
    ")\n",
    "ax.axvline(x=mean_county_area, linewidth=0.5, linestyle=\"-.\")\n",
    "ax.annotate(\n",
    "    \"Mean county area\",\n",
    "    xy=(mean_county_area, 0.5),\n",
    "    xycoords=(\"data\", \"axes fraction\"),\n",
    "    rotation=-90,\n",
    "    fontsize=11,\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the second co-ordinate of the text annotation is in terms of fraction of the figure's y-axis rather than in the co-ordinates of the data. This is useful because now, whatever else changes in the chart, we know the text will appear half-way up the axis. There are several different co-ordinate systems that **matplotlib** accepts depending on what you're trying to achieve:\n",
    "\n",
    "- the co-ordinates of the *data*, eg area and population in the chart above\n",
    "- the fraction of the figure axes, aka the *\"axes fraction\"*\n",
    "- *offset points*, relative to another point (used for text relative to a data point)\n",
    "- various options using *pixels*\n",
    "- and more, including *polar* co-ordinates\n",
    "\n",
    "You can find out a bit more about the different co-ordinate systems on the [**matplotlib** documentation](https://matplotlib.org/stable/tutorials/advanced/transforms_tutorial.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Styling Artists\n",
    "\n",
    "Most plotting methods have styling options for the Artists, accessible either\n",
    "when a plotting method is called, or from a \"setter\" on the Artist.  In the\n",
    "plot below we manually set the *color*, *linewidth*, and *linestyle* of the\n",
    "Artists created by `Axes.plot()`, and we set the linestyle of the second line\n",
    "after the fact with `Line2D.set_linestyle()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "x = np.arange(len(data1))\n",
    "ax.plot(x, np.cumsum(data1), color=\"blue\", linewidth=3, linestyle=\"--\")\n",
    "(line,) = ax.plot(x, np.cumsum(data2), color=\"orange\", linewidth=2)\n",
    "line.set_linestyle(\":\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Charts on one Figure\n",
    "\n",
    "One basic bit of functionality that you might need is to put more than one type of information on a single overall figure. This could mean having multiple subplots or it could be about putting more information on a single set of axes.\n",
    "\n",
    "### Mutiples features on one set of axes\n",
    "\n",
    "This is the kind of task where **matplotlib**'s build-what-you-want philosophy starts to win out. To add another feature on an `ax` that you've already created is as simple as calling `ax.<method>` again. You can add as many features as you like.\n",
    "\n",
    "In the example below, we'll call `ax.hist()` followed by `ax.plot()` to get a the theoretical curve for a normal distribution (aka Gaussian) overlaid on a kernel density estimate based on many draws from the relevant distribution using **numpy**.\n",
    "\n",
    "While we're at it, let's add an equation that describes the theoretical curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand_draws = prng.standard_normal(5000)\n",
    "grid_x = np.linspace(-5, 5, 1000)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.hist(rand_draws, bins=50, density=True, label=\"Data\")\n",
    "ax.plot(\n",
    "    grid_x,\n",
    "    1 / np.sqrt(2 * np.pi) * np.exp(-(grid_x**2) / 2),\n",
    "    linewidth=4,\n",
    "    label=r\"$\\frac{1}{2\\pi}e^{-\\frac{x^2}{2}}$\",\n",
    ")\n",
    "ax.legend(fontsize=14);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Facets\n",
    "\n",
    "Another way to put more information on a single figure is to have different *facets*. To illustrate some of the ideas we're about to see, it's going to be useful to have some data. Let's pull down GDP per capita for a selection of countries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas_datareader import wb\n",
    "\n",
    "start_year = 2000\n",
    "end_year = 2022\n",
    "\n",
    "df_cc_gdp = wb.download(\n",
    "    indicator=[\"NY.GDP.PCAP.KD\"],  # GDP per capita in 2015 USD\n",
    "    country=[\"US\", \"GB\", \"FR\", \"DE\", \"IT\", \"JP\"],\n",
    "    start=start_year,\n",
    "    end=end_year,\n",
    ")\n",
    "df_cc_gdp = df_cc_gdp.reset_index()  # drop country as index (for plots)\n",
    "df_cc_gdp[\"year\"] = df_cc_gdp[\"year\"].astype(\"int\")  # ensure year is a number\n",
    "# sort by year, then country (important for next step)\n",
    "df_cc_gdp = df_cc_gdp.sort_values([\"year\", \"country\"])\n",
    "# index to that country's value in first entry by country\n",
    "df_cc_gdp[\"GDP per capita\"] = (\n",
    "    100\n",
    "    * df_cc_gdp[\"NY.GDP.PCAP.KD\"]\n",
    "    / df_cc_gdp.groupby(\"country\")[\"NY.GDP.PCAP.KD\"].transform(lambda row: row.iloc[0])\n",
    ")\n",
    "df_cc_gdp.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Subplots\n",
    "\n",
    "The first way to put data on multiple charts that are part of the same overall figure is to use the built-in subplot function. `plt.subplots()` accepts arguments for `nrows=` and `ncols=` that we can specify the number of figures with. We have six countries so let's do two rows of three columns.\n",
    "\n",
    "We can use a `for` loop to go over these. Actually, though, the structure of the `axes` object that comes back from `plt.subplots()` is a 2x3 matrix (or array), and you can't loop over that. But we can loop over a \"flattened\" version of it, which you can create with `axes.flatten()`.\n",
    "\n",
    "Once we're in the loop, we subset the data by country for each loop and add it to the chart using `ax.plot()`. Finally, we'll use the same limits for every subplot to make the chart easier to read.\n",
    "\n",
    "Let's see this with the data we just pulled down."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(2, 3, figsize=(10, 6))\n",
    "for i, ax in enumerate(axes.flatten()):\n",
    "    country = df_cc_gdp[\"country\"].unique()[i]\n",
    "    country_df = df_cc_gdp.loc[df_cc_gdp[\"country\"] == country, :]\n",
    "    ax.plot(\n",
    "        country_df[\"year\"],\n",
    "        country_df[\"GDP per capita\"],\n",
    "        lw=3,\n",
    "        color=plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"][i],\n",
    "    )\n",
    "    ax.set_title(country, loc=\"center\", fontsize=13)\n",
    "    ax.yaxis.tick_right()\n",
    "    ax.spines[\"right\"].set_visible(True)\n",
    "    ax.spines[\"left\"].set_visible(False)\n",
    "    ax.spines[\"top\"].set_visible(False)\n",
    "    ax.set_xlim(start_year, end_year)\n",
    "    ax.set_ylim(df_cc_gdp[\"GDP per capita\"].min(), df_cc_gdp[\"GDP per capita\"].max())\n",
    "fig.suptitle(f\"GDP per capita (indexed to 100 in {start_year})\", fontsize=15)\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A nice extra you can do with this sort of chart is to add the other countries but greyed out so that it's clear which country is featured but the cross-country comparison is a bit easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(2, 3, figsize=(10, 6))\n",
    "for i, ax in enumerate(axes.flatten()):\n",
    "    country = df_cc_gdp[\"country\"].unique()[i]\n",
    "    # grab the other countries\n",
    "    other_countries = [x for x in df_cc_gdp[\"country\"].unique() if x != country]\n",
    "    for other in other_countries:\n",
    "        o_country_df = df_cc_gdp.loc[df_cc_gdp[\"country\"] == other, :]\n",
    "        ax.plot(\n",
    "            o_country_df[\"year\"],\n",
    "            o_country_df[\"GDP per capita\"],\n",
    "            lw=1,\n",
    "            color=\"k\",\n",
    "            alpha=0.1,\n",
    "        )\n",
    "    country_df = df_cc_gdp.loc[df_cc_gdp[\"country\"] == country, :]\n",
    "    ax.plot(\n",
    "        country_df[\"year\"],\n",
    "        country_df[\"GDP per capita\"],\n",
    "        lw=3,\n",
    "        color=plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"][i],\n",
    "    )\n",
    "    ax.set_title(country, loc=\"center\", fontsize=13)\n",
    "    ax.yaxis.tick_right()\n",
    "    ax.spines[\"right\"].set_visible(True)\n",
    "    ax.spines[\"left\"].set_visible(False)\n",
    "    ax.spines[\"top\"].set_visible(False)\n",
    "    ax.set_xlim(start_year, end_year)\n",
    "    ax.set_ylim(df_cc_gdp[\"GDP per capita\"].min(), df_cc_gdp[\"GDP per capita\"].max())\n",
    "fig.suptitle(f\"GDP per capita (indexed to 100 in {start_year})\", fontsize=15)\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Gridspec\n",
    "\n",
    "This is a more complicated way of creating multiple subplots, but it is more flexible too: although it still relies on an underlying grid structure, the units of that grid don't have to all equate to a single subplot. It's easier to see than to describe!\n",
    "\n",
    "Here's an example that shows what's possible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "X = np.linspace(-np.pi, np.pi, 257, endpoint=True)\n",
    "C, S = np.cos(X), np.sin(X)\n",
    "\n",
    "fig = plt.figure(constrained_layout=True)\n",
    "nrows, ncols = 3, 3\n",
    "gspec = gridspec.GridSpec(ncols=ncols, nrows=nrows, figure=fig)\n",
    "\n",
    "\n",
    "def plot(ax, text):\n",
    "    ax.set_xlim(0, 1)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_xlabel(\"X Label\", fontsize=10)\n",
    "    ax.set_ylim(0, 1)\n",
    "    ax.set_yticks([])\n",
    "    ax.set_ylabel(\"Y Label\", fontsize=10)\n",
    "    ax.text(\n",
    "        0.5, 0.5, text, alpha=0.75, ha=\"center\", va=\"center\", weight=\"bold\", size=12\n",
    "    )\n",
    "    ax.set_title(\"Title\", family=\"Roboto\", weight=500, fontsize=12)\n",
    "\n",
    "\n",
    "for i in range(ncols):\n",
    "    plot(plt.subplot(gspec[0, i]), \"subplot(gspec[0,%d])\" % i)\n",
    "for i in range(1, nrows):\n",
    "    plot(plt.subplot(gspec[i, 0]), \"subplot(gspec[%d,0])\" % i)\n",
    "plot(plt.subplot(gspec[1:, 1:]), \"subplot(gspec[1:,1:])\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we wanted to really feature a single country more than the others: we might want to give it a full height spot. We can do this with `gridspec`.\n",
    "\n",
    "Taking our example, let's \"focus\" on the UK. We're going to use the layout above, with one corner having the UK in and covering the grid from units 1 to 2 on both dimensions. Meanwhile, positions (0, 0), (0, 1), (1, 0), (2, 0), and (0, 2) will have the other five countries on.\n",
    "\n",
    "We can produce this pattern using code: first a double list comprehension to pick out those specific values, then reducing it to a single list of co-ordinates (because double list comprehensions lead to nested lists). Here's the set of positions for the other five countries in code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "nested_list = [\n",
    "    [(i, j) for i in [0, 1, 2] if (i != j or i == 0) and (i + j <= 2)]\n",
    "    for j in [0, 1, 2]\n",
    "]\n",
    "other_country_indices = list(itertools.chain(*nested_list))\n",
    "other_country_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's a bit labourious to do this in code, but it's often good practice to think about how to solve the general problem rather than manually typing out the solution because the former scales better to other problems. As you code more, you'll find yourself writing these little helper lines again and again in different contexts. GitHub even has a service called [*gists*](https://gist.github.com/) to help you keep track of code snippets that may be useful across lots of projects.\n",
    "\n",
    "Now let's convert our grid into some plots!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "fig = plt.figure(constrained_layout=True)\n",
    "nrows, ncols = 3, 3\n",
    "gspec = gridspec.GridSpec(ncols=ncols, nrows=nrows, figure=fig)\n",
    "# create a list of the five spots we don't want to feature UK on\n",
    "non_uk_axes = [fig.add_subplot(gspec[i, j]) for i, j in other_country_indices]\n",
    "uk_ax = fig.add_subplot(gspec[1:, 1:])\n",
    "all_axes = non_uk_axes + [uk_ax]\n",
    "# Plot the other countries\n",
    "o_countries_df = df_cc_gdp.loc[df_cc_gdp[\"country\"] != \"United Kingdom\", :]\n",
    "o_country_names = o_countries_df[\"country\"].unique()\n",
    "for i, ax in enumerate(non_uk_axes):\n",
    "    # grab the other country's data\n",
    "    o_country = o_country_names[i]\n",
    "    o_country_df = o_countries_df.loc[o_countries_df[\"country\"] == o_country, :]\n",
    "    ax.plot(\n",
    "        o_country_df[\"year\"],\n",
    "        o_country_df[\"GDP per capita\"],\n",
    "        lw=3,\n",
    "        color=plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"][i],\n",
    "    )\n",
    "    ax.set_title(o_country, loc=\"center\", fontsize=13)\n",
    "# Now do UK\n",
    "uk_df = df_cc_gdp.loc[df_cc_gdp[\"country\"] == \"United Kingdom\", :]\n",
    "uk_ax.set_title(\"United Kingdom\", loc=\"center\", fontsize=15)\n",
    "uk_ax.plot(\n",
    "    uk_df[\"year\"],\n",
    "    uk_df[\"GDP per capita\"],\n",
    "    lw=3,\n",
    "    color=plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"][len(o_country_names)],\n",
    ")\n",
    "# global settings\n",
    "for ax in all_axes:\n",
    "    ax.yaxis.tick_right()\n",
    "    ax.spines[\"right\"].set_visible(True)\n",
    "    ax.spines[\"left\"].set_visible(False)\n",
    "    ax.spines[\"top\"].set_visible(False)\n",
    "    ax.set_xlim(start_year, end_year)\n",
    "    ax.set_ylim(100, 150)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should note, though, that this kind of chart can be quite confusing and---generally---it's better to have consistent axes and subplot sizes if you're trying to make comparisons easy.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using Subplot Mosaic to Specify a Layout\n",
    "\n",
    "We told you that the **matplotlib** API was ferociously powerful. Well, subplot grids and GridSpec aren't the only ways to build up multiple subplots: you can build a layout of Axes based on ASCII art or nested lists! The method that does this, `subplot_mosaic()`, is a helper function to build complex GridSpec layouts visually.\n",
    "\n",
    "Here's an example of using text to specify a layout:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axd = plt.figure(constrained_layout=True).subplot_mosaic(\n",
    "    \"\"\"\n",
    "    ABD\n",
    "    CCD\n",
    "    CC.\n",
    "    \"\"\"\n",
    ")\n",
    "kw = dict(ha=\"center\", va=\"center\", fontsize=60, color=\"darkgrey\")\n",
    "for k, ax in axd.items():\n",
    "    ax.text(0.5, 0.5, k, transform=ax.transAxes, **kw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we did a little trick with the font settings too: we put them in a keyword argument dictionary called `kw` and passed these into the `ax.text()` function with the \"splatty-splat\" operator, which unpacks them.\n",
    "\n",
    "Let's now see another way to use `subplot_mosiac()`, this time using lists to achieve a particular layout:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax_dict = plt.figure(constrained_layout=True).subplot_mosaic(\n",
    "    [[\"A\", \"B\", \"C\", \"C\", \"D\", \"D\"]]\n",
    ")\n",
    "kw = dict(ha=\"center\", va=\"center\", fontsize=30, color=\"darkgrey\")\n",
    "for k, ax in ax_dict.items():\n",
    "    ax.text(0.5, 0.5, k, transform=ax.transAxes, **kw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An Advanced Example: Zoomed Plots\n",
    "\n",
    "This is taken from the online book [*Scientific Visualization in Matplotlib*](https://github.com/rougier/scientific-visualization-book) {cite:ps}`rougier2021scientific`. It's quite a complex example, but does show what can be achieved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.gridspec import GridSpec\n",
    "from matplotlib.patches import ConnectionPatch, Rectangle\n",
    "\n",
    "fig = plt.figure(figsize=(5, 4))\n",
    "\n",
    "n = 5\n",
    "gs = GridSpec(n, n + 1)\n",
    "\n",
    "ax = plt.subplot(\n",
    "    gs[:n, :n], xlim=[-1, +1], xticks=[], ylim=[-1, +1], yticks=[], aspect=1\n",
    ")\n",
    "\n",
    "X = prng.normal(0, 0.35, 1000)\n",
    "Y = prng.normal(0, 0.35, 1000)\n",
    "ax.scatter(X, Y, edgecolor=\"None\", facecolor=\"C1\", alpha=0.5)\n",
    "\n",
    "I_vec = prng.choice(len(X), size=n, replace=False)\n",
    "Px, Py = X[I_vec], Y[I_vec]\n",
    "I_vec = np.argsort(Y[I_vec])[::-1]\n",
    "Px, Py = Px[I_vec], Py[I_vec]\n",
    "\n",
    "ax.scatter(Px, Py, edgecolor=\"black\", facecolor=\"None\", linewidth=0.75)\n",
    "\n",
    "dx, dy = 0.075, 0.075\n",
    "for i, (x, y) in enumerate(zip(Px, Py)):\n",
    "    sax = plt.subplot(\n",
    "        gs[i, n],\n",
    "        xlim=[x - dx, x + dx],\n",
    "        xticks=[],\n",
    "        ylim=[y - dy, y + dy],\n",
    "        yticks=[],\n",
    "        aspect=1,\n",
    "    )\n",
    "    sax.scatter(X, Y, edgecolor=\"None\", facecolor=\"C1\", alpha=0.5)\n",
    "    sax.scatter(Px, Py, edgecolor=\"black\", facecolor=\"None\", linewidth=0.75)\n",
    "\n",
    "    sax.text(\n",
    "        1.1,\n",
    "        0.5,\n",
    "        \"Point \" + chr(ord(\"A\") + i),\n",
    "        rotation=90,\n",
    "        size=8,\n",
    "        ha=\"left\",\n",
    "        va=\"center\",\n",
    "        transform=sax.transAxes,\n",
    "    )\n",
    "\n",
    "    rect = Rectangle(\n",
    "        (x - dx, y - dy),\n",
    "        2 * dx,\n",
    "        2 * dy,\n",
    "        edgecolor=\"black\",\n",
    "        facecolor=\"None\",\n",
    "        linestyle=\"--\",\n",
    "        linewidth=0.75,\n",
    "    )\n",
    "    ax.add_patch(rect)\n",
    "\n",
    "    con = ConnectionPatch(\n",
    "        xyA=(x, y),\n",
    "        coordsA=ax.transData,\n",
    "        xyB=(0, 0.5),\n",
    "        coordsB=sax.transAxes,\n",
    "        linestyle=\"--\",\n",
    "        linewidth=0.75,\n",
    "        patchA=rect,\n",
    "        arrowstyle=\"->\",\n",
    "    )\n",
    "    fig.add_artist(con)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with Times and Dates\n",
    "\n",
    "Python has really amazing support for \"datetimes\", and you can find out more about the general capabilities in {ref}`time-intro`.\n",
    "\n",
    "It's also *very* important to know how to make charts with times and dates in economics, so we're going to give this one some special attention.\n",
    "\n",
    "To demonstrate some of the principles, we're going to work with real data on UK and US GDP growth. First let's pull in that data and take a look at it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "from pandas_datareader import wb\n",
    "\n",
    "ts_start_date = pd.to_datetime(\"1999-01-01\")\n",
    "ts_end_date = datetime.now()\n",
    "countries = [\"GBR\", \"USA\"]\n",
    "gdf_const_2015_usd_code = \"NY.GDP.MKTP.KD\"\n",
    "df = wb.download(\n",
    "    indicator=gdf_const_2015_usd_code,\n",
    "    country=countries,\n",
    "    start=ts_start_date,\n",
    "    end=ts_end_date,\n",
    ").reset_index()\n",
    "df = df.sort_values(by=\"year\")  # this is very important!\n",
    "# note that we are computing the percent change on a by-country basis!\n",
    "# Otherwise, you'd mix up the UK and US values\n",
    "df[\"growth, %\"] = df.groupby(\"country\")[gdf_const_2015_usd_code].transform(\n",
    "    lambda x: 100 * x.pct_change(1)\n",
    ")\n",
    "df = df.reset_index(drop=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can see that this is annual data, and what's been returned by the World Bank has given us a \"year\" field that is of type \"object\", basically the lowest common denominator data type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're going to turn it back into a *datetime*. This is a special type that helps with dates and times. In the below code snippet, the year we get from running `pd.to_datetime()` defaults to the 1st of January. But really, these dates represent the year that has already passed, so we'll end on a *time offset*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"year\"] = pd.to_datetime(df[\"year\"], format=\"%Y\") + pd.offsets.BYearEnd()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, we're now going to do a couple of other things that will help **matplotlib**. Unlike, say, **lets-plot**, **matplotlib** expects each line of interest in your data to appear *across* columns, ie in wide format. So we're going to transform our data to be wide, and make the datetime column, `\"year\"`, into the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_wide = df.pivot(index=\"year\", values=\"growth, %\", columns=\"country\")\n",
    "df_wide = df_wide.sort_index()\n",
    "df_wide.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also set the index to be the year, beause \n",
    "\n",
    "By running `df_wide.info()`, we can learn what data types we now have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_wide.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, note that i) the index is composed of dates, and ii) those dates have datatype \"DatetimeIndex\".\n",
    "\n",
    "Alright, let's just make a plot here without worrying too much about what might happen. We'll do a line chart showing the growth rates over time of these two large economies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "df_wide.plot(ax=ax, lw=3)\n",
    "ax.set_title(\"GDP growth, %\", loc=\"right\")\n",
    "ax.spines[\"right\"].set_visible(True)\n",
    "ax.spines[\"left\"].set_visible(False)\n",
    "ax.spines[\"top\"].set_visible(False)\n",
    "ax.yaxis.tick_right()  # Put tick marks and tick labels on right-hand side"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice straight away that because we *began* with a datetime index, when we called the convenience function `df.plot(ax=...)`, we automatically got an x-axis that understands and renders datetimes. More than that, the scale is sensible: it's only showing years on the major tick labels, even though we have quarterly data.\n",
    "\n",
    "Also note that the data are in wide format, which **matplotlib** prefers.\n",
    "\n",
    "We could achieve the same outcome without using **pandas** built-in plotting methods, though it's a tad more verbose (we need two separate commands for the two countries and to explicitly add a legend):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "for name in [\"United Kingdom\", \"United States\"]:\n",
    "    ax.plot(df_wide.index, df_wide[name], lw=3, label=name)\n",
    "ax.set_title(\"Real GDP growth, %\", loc=\"right\")\n",
    "ax.spines[\"right\"].set_visible(True)\n",
    "ax.spines[\"left\"].set_visible(False)\n",
    "ax.spines[\"top\"].set_visible(False)\n",
    "ax.legend()\n",
    "ax.yaxis.tick_right()  # Put tick marks and tick labels on right-hand side"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see what happens if we *change the axis limits*. Because we're using datetime data type for the x-axis variable, we'll need to pass a datetime in to the limits too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "df_wide.plot(ax=ax, lw=3)\n",
    "ax.set_title(\"Real GDP growth, %\", loc=\"right\")\n",
    "ax.spines[\"right\"].set_visible(True)\n",
    "ax.spines[\"left\"].set_visible(False)\n",
    "ax.spines[\"top\"].set_visible(False)\n",
    "ax.yaxis.tick_right()  # Put tick marks and tick labels on right-hand side\n",
    "ax.set_xlim(pd.to_datetime(\"2018-01-01\"), pd.to_datetime(\"2021-01-01\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the plot dynamically responded to the shorter time period by putting more details in, here of quarters (as the minor ticks). You can specify exactly what you want with the tick label formatters that cater to datetimes, but the defaults are pretty well-behaved."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced Topics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Styles\n",
    "\n",
    "It can feel a bit tedious to apply different styles to every single ax, subplot, and even figure! Fortunately, there are ways to make applying styles more efficient. In this section, we'll see how to do this concisely.\n",
    "\n",
    "There are essentially four ways to apply styles:\n",
    "\n",
    "1. modify each `ax` object one-by-one (works at the axis level)\n",
    "2. use a dictionary once to pass keyword arguments to all objects of a similar type (works at the axis level)\n",
    "3. temporarily change the global style (works at the figure level)\n",
    "4. change the global style (works on every figure!)\n",
    "\n",
    "We've seen plenty of 1. already, so we won't do more on that. Let's home in on 2. first. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Consistent Styling Across Axes and Subplots using Dictionaries\n",
    "\n",
    "Let's say we have multiple text annotations that we want to make consistent in *most* details. We can use the cross-country GDP per capita example from earlier. Essentially, we define a dictionary of all the properties (and here, even a nested dictionary with *further* keyword arguments), and pass this using the splaty-splat (`**`) operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kw_settings = dict(\n",
    "    xycoords=\"data\",\n",
    "    ha=\"center\",\n",
    "    va=\"center\",\n",
    "    fontweight=\"bold\",\n",
    "    fontsize=12,\n",
    "    xytext=(-20, +50),\n",
    "    textcoords=\"offset points\",\n",
    "    arrowprops=dict(\n",
    "        arrowstyle=\"->\",\n",
    "        connectionstyle=\"arc3,rad=-0.3\",\n",
    "        alpha=0.7,\n",
    "    ),\n",
    "    bbox=dict(facecolor=\"white\", edgecolor=\"None\", alpha=0.85),\n",
    ")\n",
    "\n",
    "# spread out x text annotations for each country\n",
    "years_array = np.arange(\n",
    "    start_year + 1, end_year, len(df_cc_gdp[\"country\"].unique()) - 2\n",
    ")\n",
    "# get countries in order of lowest to highest end value\n",
    "countries = (\n",
    "    df_cc_gdp.sort_values(\"GDP per capita\")\n",
    "    .loc[df_cc_gdp[\"year\"] == df_cc_gdp[\"year\"].max(), \"country\"]\n",
    "    .values\n",
    ")\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for i, country in enumerate(countries):\n",
    "    country_df = df_cc_gdp.loc[df_cc_gdp[\"country\"] == country, :]\n",
    "    ax.plot(\n",
    "        country_df[\"year\"],\n",
    "        country_df[\"GDP per capita\"],\n",
    "        lw=3,\n",
    "        color=plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"][i],\n",
    "    )\n",
    "    ax.annotate(\n",
    "        country,\n",
    "        (\n",
    "            years_array[i],\n",
    "            country_df.loc[country_df[\"year\"] == years_array[i], \"GDP per capita\"],\n",
    "        ),\n",
    "        **kw_settings,\n",
    "        color=plt.gca().lines[-1].get_color(),\n",
    "    )\n",
    "\n",
    "\n",
    "ax.yaxis.tick_right()\n",
    "ax.spines[\"right\"].set_visible(True)\n",
    "ax.spines[\"left\"].set_visible(False)\n",
    "ax.spines[\"top\"].set_visible(False)\n",
    "ax.set_xlim(start_year - 1, end_year)\n",
    "ax.set_ylim(df_cc_gdp[\"GDP per capita\"].min(), df_cc_gdp[\"GDP per capita\"].max() * 1.05)\n",
    "fig.suptitle(f\"GDP per capita (indexed to 100 in {start_year})\", fontsize=15)\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Temporarily Change the Global Style\n",
    "\n",
    "Python has a powerful notion called *contexts* that can change the apparent global settings to any code run within them. You can identify them by the `with` command. Now, we'll show how to use these to completely change the style of a plot.\n",
    "\n",
    "The first, simple example is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = prng.standard_normal(50)\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(data)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's say, just for this plot, we want to make a change. We can do this by setting the \"rc context\". This changes global settings that relate to figures. You can pass keyword arguments to it as dictionary items. In this case, we'll change the linewidth and the linestyle. The `with` command means any *indented* code following the `with` gets changed. But, after the indented block is over, everything reverts back to the usual settings.\n",
    "\n",
    "You can find a full list of the settings you can pass [here](https://matplotlib.org/stable/users/explain/customizing.html#the-default-matplotlibrc-file)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "\n",
    "with mpl.rc_context({\"lines.linewidth\": 4, \"lines.linestyle\": \":\"}):\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.plot(data)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some built-in styles that you can take advantage of for this too. These are called via `plt.style.context(<style name>)`, and you can find a list [here](https://matplotlib.org/stable/gallery/style_sheets/style_sheets_reference.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with plt.style.context(\"grayscale\"):\n",
    "    fig, ax = plt.subplots()\n",
    "    for i, country in enumerate(countries):\n",
    "        country_df = df_cc_gdp.loc[df_cc_gdp[\"country\"] == country, :]\n",
    "        ax.plot(\n",
    "            country_df[\"year\"],\n",
    "            country_df[\"GDP per capita\"],\n",
    "            lw=3,\n",
    "        )\n",
    "        ax.annotate(\n",
    "            country,\n",
    "            (\n",
    "                years_array[i],\n",
    "                country_df.loc[country_df[\"year\"] == years_array[i], \"GDP per capita\"],\n",
    "            ),\n",
    "            **kw_settings,\n",
    "            color=plt.gca().lines[-1].get_color(),\n",
    "        )\n",
    "    ax.yaxis.tick_right()\n",
    "    ax.spines[\"right\"].set_visible(True)\n",
    "    ax.spines[\"left\"].set_visible(False)\n",
    "    ax.spines[\"top\"].set_visible(False)\n",
    "    ax.set_xlim(start_year - 1, end_year)\n",
    "    ax.set_ylim(\n",
    "        df_cc_gdp[\"GDP per capita\"].min(), df_cc_gdp[\"GDP per capita\"].max() * 1.05\n",
    "    )\n",
    "    fig.suptitle(f\"GDP per capita (indexed to 100 in {start_year})\", fontsize=15)\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setting the Style for an Entire Script or Notebook\n",
    "\n",
    "This book uses a special style file to set its RC params and over-ride the default values found in the [default rc file](https://matplotlib.org/stable/users/explain/customizing.html#the-default-matplotlibrc-file). Once loaded, using\n",
    "\n",
    "```python\n",
    "plt.style.use(\n",
    "    \"plot_style.txt\"\n",
    ")\n",
    "```\n",
    "\n",
    "all charts use whatever settings are in \"plot_style.txt\" unless those settings are explicitly over-ridden by other commands. \n",
    "\n",
    "You can see the first few lines of the \"plot_style.txt\" file used for this book below, or you can browse it yourself [here](https://github.com/aeturrell/coding-for-economists/blob/main/plot_style.txt)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!head -10 plot_style.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review\n",
    "\n",
    "That concludes our tour of the basics of **matplotlib**. You should now feel comfortable making basic charts using data and \n",
    "\n",
    "You can find much more advanced uses of it over at the [**matplotlib** documentation](https://matplotlib.org/stable/tutorials/index.html) and in the online book [*Scientific Visualization in Matplotlib*](https://github.com/rougier/scientific-visualization-book) {cite:ps}`rougier2021scientific`."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "codeforecon",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}