python_viz_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1877a49d",
   "metadata": {
    "id": "1877a49d"
   },
   "source": [
    "# Data Viz with Matplotlib 4\n",
    "\n",
    "Welcome to the last workshop of this series. Today we are exploring histograms and, if time permits, we will check an interactive backend for `matplotlib`.\n",
    "\n",
    "First, we will load the same data as yesterday. We will use the same code we used before to load data directly from GitHub."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8422fdd",
   "metadata": {
    "id": "d8422fdd"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Morgan data\n",
    "morgan_data_url = r'https://raw.githubusercontent.com/non87/python-viz-workshop/main/data/morgan.csv'\n",
    "morgan = pd.read_csv(morgan_data_url)\n",
    "\n",
    "# Taylor data\n",
    "taylor_data_url = r'https://raw.githubusercontent.com/non87/python-viz-workshop/main/data/taylor.csv'\n",
    "taylor = pd.read_csv(taylor_data_url)\n",
    "\n",
    "# Look at the column names and data type\n",
    "print(f'{morgan.info()}')\n",
    "print(f\"This is how the Morgan data looks like:\\n\\n{morgan.head()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97702366",
   "metadata": {
    "id": "97702366"
   },
   "source": [
    "To produce histograms we will need to massage the data a little and transform it in a different (clearly less convenient) format. More explanation on the format below. \n",
    "\n",
    "I will use `numpy` and `pandas` for this passage, do not worry about understanding the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da8a8eec",
   "metadata": {
    "id": "da8a8eec"
   },
   "outputs": [],
   "source": [
    "# Morgan data\n",
    "# Collect the data from the DataFrame\n",
    "morgan_girls = np.int_(morgan.Proportion * morgan.Total)\n",
    "morgan_girls_yr = np.int_(morgan.loc[morgan['Proportion'] > 0, 'Year'])\n",
    "morgan_boys =  np.int_((1-morgan.Proportion) * morgan.Total)\n",
    "morgan_boys_yr = np.int_(morgan.loc[morgan['Proportion'] < 1, 'Year'])\n",
    "# Create the actual array\n",
    "morgan_girls = np.repeat(morgan_girls_yr, morgan_girls)\n",
    "morgan_boys = np.repeat(morgan_boys_yr, morgan_boys)  \n",
    "\n",
    "# Taylor data\n",
    "taylor_girls = np.int_(taylor.Proportion * taylor.Total)\n",
    "taylor_girls_yr = np.int_(taylor.loc[taylor['Proportion'] > 0, 'Year'])\n",
    "taylor_boys =  np.int_((1-taylor.Proportion) * taylor.Total)\n",
    "taylor_boys_yr = np.int_(taylor.loc[taylor['Proportion'] < 1, 'Year'])\n",
    "\n",
    "\n",
    "taylor_girls = np.repeat(taylor_girls_yr, taylor_girls)  \n",
    "taylor_boys = np.repeat(taylor_boys_yr, taylor_boys)  \n",
    "\n",
    "morgan_girls"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ebd8ee0",
   "metadata": {
    "id": "7ebd8ee0"
   },
   "source": [
    "Let's not forget to import `plt` and set the backend to `inline`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb9a297e",
   "metadata": {
    "id": "cb9a297e"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d56f5b21",
   "metadata": {
    "id": "d56f5b21"
   },
   "source": [
    "### Histograms \n",
    "\n",
    "We will analyze the distribution of \"Morgan\" and \"Taylor\" birthdays with histograms. I believe histograms need no presentation. They represent the data distribution over a continous variables with rectangles. Matplotlib offers a simple syntax to draw histograms based on the method `ax.hist()`. \n",
    "\n",
    "In the code above, I prepare the data for `ax.hist()`. create four `np.array` containing the birth year of each boy named \"Morgan\" born in the US between 1965 and 2014; the birty year of each girl named \"Morgan\", etc. This `np.array` are nothing but a long list (_not_ in a technical Pythonic sense) of birth years. We did this because the method `ax.hist()` takes in input raw data. This is opposed to more convenient tabulated data (as the data was originally arranged in the `DataFrame` we loaded). This is the same difference as having a list containing 1965 three times (`[1965, 1965, 1965]`) versus having a dictionary telling us that there are 3 individual named \"Morgan\" born in 1965 (`{1965:3}`).\n",
    "\n",
    "The only other argument of `ax.hist()` we (almost) always need to specify is _bins_ . This argument regulate the creation of bins for the histogram. You can pass an integer number k and `ax.hist()` will create k equally speced bins -- by default, `ax.hist()` will create k=10 equally-spaced bins, but this is rarely what we want. Otherwise, you can pass an array showing the boundaries of each bin. We will explore this option later. \n",
    "\n",
    "Let's start with a simple histogram of the year distribution for the boys named \"Morgan\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0c3d95e",
   "metadata": {
    "id": "b0c3d95e"
   },
   "outputs": [],
   "source": [
    "# The fundamental line\n",
    "fig, ax = plt.subplots()\n",
    "# the argument bins control the number of bins and their exact position \n",
    "# by default, matplotlib will use 10 equally-spaced bins\n",
    "ax.hist(morgan_boys, bins = 15)\n",
    "ax.set_title(\"Birthday of Boys Named Morgan\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b89ab6ac",
   "metadata": {
    "id": "b89ab6ac"
   },
   "source": [
    "##### Exercise 1\n",
    "\n",
    "Complete the code by creating an histogram showing the distribution of birth year for girls named \"Taylor\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c942e60f",
   "metadata": {
    "id": "c942e60f"
   },
   "outputs": [],
   "source": [
    "# The fundamental line\n",
    "fig, ax = plt.subplots()\n",
    "# labels, etc.\n",
    "ax.set_title(\"Birthday of Girls Named Taylor\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')\n",
    "# Create the histogram\n",
    "ax\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0800978",
   "metadata": {
    "id": "d0800978"
   },
   "source": [
    "#### Binning\n",
    "\n",
    "When we compare data, we often want the data in the histogram to be binned identically. Other times, we may want more control on the binning because we care about extracting most information possible from the data. In these cases, we need to take more control of the binning. Fortunately, `ax.hist()` makes it easier to control binning.\n",
    "\n",
    "##### Use the output\n",
    "\n",
    "Here, we will compare the birth year distribution for girls named \"Morgan\" with the birth year distribution of boys named \"Morgan\". We will create the histograms in two separate `Axes`, but we will make sure the binning of the two histograms are identical. As a first strategy to do so, we will use the output of `ax.hist()`. When called, `ax.hist()` returns three thing:\n",
    "\n",
    "1. _n_: the height of each bin\n",
    "2. _bins_: the binning used in the histogram\n",
    "3. _patches_: the `Patches` created by the histogram (you can pass this to `fig.colorbar()`, for example)\n",
    "\n",
    "We will be using the second output to control our binning: this output can be directly input in the `bins` argument of `ax.hist()` to create a new histogram with the same binning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "775dd89d",
   "metadata": {
    "id": "775dd89d"
   },
   "outputs": [],
   "source": [
    "# The fundamental line. We make sure the axis label are displayed correctly by augmenting the height space\n",
    "fig, ax = plt.subplots(nrows=2, gridspec_kw={'hspace': .7})\n",
    "# Save the output now ; by convention _ is used as a name for something we do not care\n",
    "_, bins, _ = ax[0].hist(morgan_girls, bins = 15)\n",
    "ax[0].set_title(\"Birthday of Girls Named Morgan\")\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Count')\n",
    "# Notice the bins argument\n",
    "ax[1].hist(morgan_boys, bins=bins)\n",
    "ax[1].set_title(\"Birthday of Boys Named Morgan\")\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a3ee9e",
   "metadata": {
    "id": "32a3ee9e"
   },
   "source": [
    "##### Exercise 2\n",
    "\n",
    "Complete the following code to display two histograms with the same binning for girls and boys named \"Morgan\". Use a number of bins equal to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a766ec0e",
   "metadata": {
    "id": "a766ec0e"
   },
   "outputs": [],
   "source": [
    "# The fundamental line, with the same arguments as above\n",
    "fig, ax = plt.subplots(nrows=2, gridspec_kw={'hspace': .7})\n",
    "# We take care of the labels, titles for both Axes\n",
    "ax[0].set_title(\"Birthday of Girls Named Taylor\")\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Count')\n",
    "ax[1].set_title(\"Birthday of Boys Named Taylor\")\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Count')\n",
    "\n",
    "# Complete the code:\n",
    "# Create the histogram for the taylor_girls data. Remember to save the output!\n",
    " = ax[0].\n",
    "# Create the histogram for the taylor_boys data.\n",
    "ax[1].hist(taylor_boys, bins= )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b837525",
   "metadata": {
    "id": "1b837525"
   },
   "source": [
    "#### Binning for estimation\n",
    "\n",
    "If you want to use histograms in a pricipled way to provide a statistical estimation of the data distribution, you will need to implement one of the many binning strategies presented in the literature. Fortunately, `np` provides some ready-available implementation of the most popular statistical binning strategy. In particular, the function `np.histogram_bin_edges()` will calculate the binning following the popular Freedman-Diaconis and Sturgis (R default) binning strategies. We can use the output of this function directly in the `bins` argument of `ax.hist()`. Even if you do not want to adventure in the literature, the Freedman-Diaconis rule is usually a good choice and most likely superior than simply using an arbitrary number of equally-spaced bins (as we have done so far).\n",
    "\n",
    "Here, we will use the Freedman-Diaconis rule to compare the \"Morgan\" data, boys and girls. A little care must be put on the input to the Freedman-Diaconis binning rule. The binning will depend on the data size and will become progressively finer as the size increases. Yet, notice that we have ~10 times more girls than boys named \"Morgan\". So the binning we would get for the boy data would be much coarser than the binning we would get for the girl data. A quick rule of thumb for these cases: when you compare datasets having different data sizes you will want to use the coarser binning to err on the side of robustness. So, we will input the boy data (`morgan_boys`) to the `np.histogram_bin_edges()` function.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    <b>Binning</b>: The choice of the right binning is fundamental to construct a good histogram. Indeed, you can see the histogram as an estimator. Too many bins means that you put too much confidence in your data. Too few bins means that you are not using your data optimally. And your confidence should change depending on the region of the space -- some region will be more populated than others in your data. <a href=\"https://docs.astropy.org/en/stable/visualization/histogram.html\">This tutorial</a> from AstroPy shows how different binning strategies can tell completely different stories based on the same data. Researchers have investigated binning strategy for decades. The function histogram_bin_edges() implements some of the most popular binning strategies available from literature. These strategy are completely automatic (you do not need to specify the number of bins) and provide a strong theoretical justification for your bins. See <a href=\"https://docs.astropy.org/en/stable/visualization/histogram.html\">the official numpy documentation</a> for an overview of what is available.\n",
    "        </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf573773",
   "metadata": {
    "id": "bf573773"
   },
   "outputs": [],
   "source": [
    "# Calculate binning with the freedman-diaconis rule\n",
    "# First argument: data, bins: what strategy we use for binning ('fd' is Freedman-Diaconis)\n",
    "# As data we input the boys data, as discussed above\n",
    "bins = np.histogram_bin_edges(morgan_boys, bins='fd')\n",
    "\n",
    "# The fundamental line. We make sure the axis label are displayed correctly by augmenting the height space\n",
    "fig, ax = plt.subplots(nrows=2, gridspec_kw={'hspace': .7})\n",
    "# Save the output now ; by convention _ is used as a name for something we do not care\n",
    "ax[0].hist(morgan_girls, bins=bins)\n",
    "ax[0].set_title(\"Birthday of Girls Named Morgan\")\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Count')\n",
    "# Notice the bins argument\n",
    "ax[1].hist(morgan_boys, bins=bins)\n",
    "ax[1].set_title(\"Birthday of Boys Named Morgan\")\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d352285",
   "metadata": {
    "id": "5d352285"
   },
   "source": [
    "##### Exercise 3\n",
    "\n",
    "Complete the code below to use the Freedman-Diaconis rule for the \"Taylor\" data. Use the boy data as input to `np.histogram_bin_edges()` (overall, there are less boys than girls named \"Taylor\").\n",
    "\n",
    "**Extra** This histogram looks different from the previous. What do you think is happening with the binning?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e882e2c",
   "metadata": {
    "id": "2e882e2c"
   },
   "outputs": [],
   "source": [
    "# COMPLETE the code:\n",
    "# Calculate binning with the freedman-diaconis rule\n",
    "# As data we input the taylor_boys data\n",
    "bins = np.histogram_bin_edges(taylor_boys, bins='fd')\n",
    "\n",
    "# The fundamental line and lables/titles\n",
    "fig, ax = plt.subplots(nrows=2, gridspec_kw={'hspace': .7})\n",
    "ax[0].set_title(\"Birthday of Girls Named Taylor\")\n",
    "ax[0].set_xlabel('Year')\n",
    "ax[0].set_ylabel('Count')\n",
    "ax[1].set_title(\"Birthday of Boys Named Taylor\")\n",
    "ax[1].set_xlabel('Year')\n",
    "ax[1].set_ylabel('Count')\n",
    "\n",
    "# Complete the code\n",
    "# Create an histogram for the taylor_girls data\n",
    "ax[0].hist()\n",
    "# Create an histogram for the taylor boys data\n",
    "ax[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de955a1",
   "metadata": {
    "id": "7de955a1"
   },
   "source": [
    "#### Two histograms in the same `Axes`\n",
    "\n",
    "So far, we have used identical bins for histograms in different `Axes`. What about comparing two histograms in the same `Axes`? Beyond binning concerns, we must sure the histograms are well legible. Check what happens when we simply put the histograms together. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "554d5016",
   "metadata": {
    "id": "554d5016"
   },
   "outputs": [],
   "source": [
    "# Calculate binning again\n",
    "bins = np.histogram_bin_edges(morgan_boys, bins='fd')\n",
    "\n",
    "# The fundamental line\n",
    "fig, ax = plt.subplots()\n",
    "# plot two histograms in the same Axes\n",
    "ax.hist(morgan_boys, bins=bins)\n",
    "ax.hist(morgan_girls, bins=bins)\n",
    "ax.set_title(\"Birth Year of Individuals Named Morgan\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab61ae48",
   "metadata": {
    "id": "ab61ae48"
   },
   "source": [
    "The main problem of the previous plot is that the two histograms overlaps without any transparency, so the histogram on the forefront covers the one in the background. There are different strategies to avoid this.\n",
    "\n",
    "The easiest strategy is to specify the argument `histtype='step'`, which creates non-filled histograms. See below.\n",
    "\n",
    "While we are at it, we will also create a `legend` in the usual way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f2747e6",
   "metadata": {
    "id": "0f2747e6"
   },
   "outputs": [],
   "source": [
    "# Calculate binning again\n",
    "bins = np.histogram_bin_edges(morgan_boys, bins='fd')\n",
    "\n",
    "# The fundamental line\n",
    "fig, ax = plt.subplots()\n",
    "# Notice the histtype argument\n",
    "ax.hist(morgan_boys, bins=bins, histtype='step', label='Boys')\n",
    "ax.hist(morgan_girls, bins=bins, histtype='step', label='Girls')\n",
    "ax.set_title(\"Birth Year of Individuals Named Morgan\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')\n",
    "# We add a legend\n",
    "ax.legend(loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a4674a9",
   "metadata": {
    "id": "9a4674a9"
   },
   "source": [
    "##### Exercise 4\n",
    "\n",
    "Modify the code below to reproduce the same `step`histograms with the \"Taylor\" data. \n",
    "\n",
    "**Extra** What is happening in the right part of the plot? How can you modify the code to provide a better visualization?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "610d4409",
   "metadata": {
    "id": "610d4409"
   },
   "outputs": [],
   "source": [
    "# Calculate binning again\n",
    "bins = np.histogram_bin_edges(taylor_boys, bins='fd')\n",
    "\n",
    "# The fundamental line, title and labels\n",
    "fig, ax = plt.subplots()\n",
    "ax.set_title(\"Birth Year of Individuals Named Taylor\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')\n",
    "\n",
    "# Complete the code\n",
    "ax.hist()\n",
    "ax.hist()\n",
    "\n",
    "# legend\n",
    "ax.legend(loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51af3b1d",
   "metadata": {
    "id": "51af3b1d"
   },
   "source": [
    "As an alternative to the previous strategy, we can use transparency. We will manually set the color of the two data series to be semi-transparent so that it will be clear where they overlap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ea461c8",
   "metadata": {
    "id": "1ea461c8"
   },
   "outputs": [],
   "source": [
    "# Calculate binning again\n",
    "bins = np.histogram_bin_edges(morgan_boys, bins='fd')\n",
    "\n",
    "# The fundamental line\n",
    "fig, ax = plt.subplots()\n",
    "# Notice the color argument. \n",
    "ax.hist(morgan_boys, bins=bins, color=(0,0,1,0.5),  label='Boys')\n",
    "# (1,1,0,0.5) is a semi-transparent yellow\n",
    "ax.hist(morgan_girls, bins=bins, color=(.7,.7,0,0.5), label='Girls')\n",
    "ax.set_title(\"Birth Year of Individuals Named Morgan\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')\n",
    "# We add a legend\n",
    "ax.legend(loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed746500",
   "metadata": {
    "id": "ed746500"
   },
   "source": [
    "A final way to compare histograms is to put the histograms from different data series side by side (naturally, with identical binning). This is very easy to achieve. Instead of a single `np.array`, we will pass to `ax.hist()` a list of `np.array` as data: `ax.hist` will automatically do the comparison for us. In our case, we will pass a list containing the boy and girl data for the name \"Morgan\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87f29c00",
   "metadata": {
    "id": "87f29c00"
   },
   "outputs": [],
   "source": [
    "# Calculate binning again\n",
    "bins = np.histogram_bin_edges(morgan_boys, bins='fd')\n",
    "\n",
    "# The fundamental line\n",
    "fig, ax = plt.subplots()\n",
    "# Notice: we pass a list as data, as label, as color, etc. \n",
    "ax.hist([morgan_boys, morgan_girls], bins=bins,  label=['Boys', 'Girls'], color=['blue', 'red'])\n",
    "ax.set_title(\"Birth Year of Individuals Named Morgan\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')\n",
    "ax.legend(loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8390ba30",
   "metadata": {
    "id": "8390ba30"
   },
   "source": [
    "##### Exercise 5\n",
    "\n",
    "Modify the code below to produce a side-by-side comparison of the \"Taylor\" data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "882fca90",
   "metadata": {
    "id": "882fca90"
   },
   "outputs": [],
   "source": [
    "# Modify here\n",
    "# Calculate binning\n",
    "bins = np.histogram_bin_edges(morgan_boys, bins='fd')\n",
    "\n",
    "# Plot\n",
    "fig, ax = plt.subplots()\n",
    "ax.set_title(\"Birth Year of Individuals Named Taylor\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')\n",
    "\n",
    "#Modify here\n",
    "ax.hist([morgan_boys, morgan_girls], bins=bins,  label=['Boys', 'Girls'], color=['red', 'blue'])\n",
    "\n",
    "# Legend\n",
    "ax.legend(loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00d7612e",
   "metadata": {
    "id": "00d7612e"
   },
   "source": [
    "#### Stacking histograms\n",
    "\n",
    "Finally, we may want to stack (not overlap) the two histograms. In this way, we will show the overall trend for the data, but we will still show the relative importance of the different components. In this case, we will show the overall contribution of boys and girls to the overall popularity of the name \"Morgan\".\n",
    "\n",
    "There are different ways to produce a stacked histogram in `matplotlib`. As usual, you can exercise more or less control on the plot production. Here, we will see the simplest way to produce stacked histograms: when you pass a list of data series (as we did in the plot above), it is sufficient to specify the argument `stacked=True`. For more control, you should check the argument `bottom` from the `ax.hist()` [official documentation](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.hist.html#matplotlib.axes.Axes.hist). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19f51e39",
   "metadata": {
    "id": "19f51e39"
   },
   "outputs": [],
   "source": [
    "# Calculate binning again\n",
    "bins = np.histogram_bin_edges(morgan_boys, bins='fd')\n",
    "\n",
    "# Produce the histogram\n",
    "fig, ax = plt.subplots()\n",
    "# The only difference from before: the stacked argument\n",
    "ax.hist([morgan_boys, morgan_girls], bins=bins,  label=['Boys', 'Girls'], color=['red', 'blue'], stacked=True)\n",
    "ax.set_title(\"Birth Year of Individuals Named Morgan\")\n",
    "ax.set_xlabel('Year')\n",
    "ax.set_ylabel('Count')\n",
    "ax.legend(loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05e7a06a",
   "metadata": {
    "id": "05e7a06a"
   },
   "source": [
    "### Some thoughts on publication-level plots\n",
    "\n",
    "With histograms we have covered all the ground we planned to cover at the beginning of this workshop. Before leaving, I would like to comment on how you can (read, I could) produce publication-level plots and what are the best practices when it comes to coding. \n",
    "\n",
    "In this same repository you will find a python script where I quickly go through saving a plot into a file. It is meant to be input live in an  IDE to see how an interactive backend works. In general, I would encourage you to:\n",
    "\n",
    "1. Code in a live fashion in an Integrated Development Environment (IDE). Personally, I use [PyCharm](https://www.jetbrains.com/pycharm/), but there are many valid options available.\n",
    "2. **Make your plot reproducible**. Following the spirit of open science and open data you should also share the code you used to create the plot you eventually published. As it should be clear by now, plotting may require some complex coding. At the same time, plots are powerful narrative devices: by changing your plots, you can tell different stories about the same data. Therefore, you should make your plotting (narrative) choices as explicit as possible by sharing your plotting code.\n",
    "3. However, you may not want to water down your main analysis script with over-complicated and long plotting code. I would suggest you share your plotting code in separate files or you create plotter functions to be imported. \n",
    "\n",
    "Now we will do some live-coding!"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "python_viz_4.ipynb",
   "provenance": []
  },
  "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
}