03_Visualisation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.  Visualisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Introduction\n",
    "Drawing attractive figures is important. Visualisations are central to communicating quantitative insights to an audience, and in that setting it’s even more necessary to have figures that catch the attention. Besides the attractiveness, correctness is obviously even more important. Misleading data visualisations can lead to misinterpretations and false conclusions, e.g. [example 1](https://www.datapine.com/blog/misleading-data-visualization-examples/), [example 2](https://learningsolutionsmag.com/articles/misleading-data-visualizations-can-confuse-deceive-learners).  \n",
    "\n",
    "When you're new to Python, the amount of visualisation libraries can be overwhelming. As a general rule of thumb, it's often a better choice to reflect on which type of graph you want to plot and choose the corresponding and appropriate library. For this course we've chosen to dive into the Seaborn library. \n",
    "\n",
    "![Choose your library for visualisations!](img/flowchart-visualisation-python.png)\n",
    "\n",
    "Generally you could summarize that **Matplotlib (pyplot)**  has great flexibility and versatility that comes with the cost of (sometimes) complexity and low-level type of programming. **Seaborn** is a Python data visualisation library which is built on-top of Matplotlib and closely integrated with pandas data structures. It provides a higher-level wrapper on the library which makes it easier to create more aesthetically pleasing plots.  \n",
    "\n",
    "At the end of this chapter you'll find a bunch of references to blogs with comparisons of different libraries. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Seaborn logo](img/seaborn-logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.1 Introduction\n",
    "An overview of Seaborn plots is accessible on the [documentation website](https://seaborn.pydata.org/examples/index.html). Many plots can be accomplished with only seaborn functions, however for non-conventional plots, further customization is possible using Matplotlib pyplot directly. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Throughout this chapter we'll be using seaborn, pandas and some of matplotlib's features to further modify our plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some notebooks require the explicit setting of matplotlib inline to plot the graphs into the notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2 Lineplot  \n",
    "We will start exploring the Seaborn library with lineplots. \n",
    "\n",
    "The following example elaborates on lineplots with a new dataset. This dataset is retrieved from [Datahub.io](https://datahub.io/core/pharmaceutical-drug-spending) and contains the spendings of a bunch of countries in pharmaceutical as from 1971. The dataset is available in the data folder as `pharmaspending.csv`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download data from datahub.io. \n",
    "pharma = pd.read_csv('data/pharmaspending.csv')\n",
    "\n",
    "# Inspect the data\n",
    "pharma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following is defined:\n",
    "- x-axis: column name that contains the data for the x-axis = `'TIME'`\n",
    "- y-axis: column name that contains the data for the y-axis = `'PC_GDP'`\n",
    "- dataset: name of the dataset = `'pharma'`\n",
    "\n",
    "Note that the name of the x and y argument are not random. They share the identical name of the column names in the dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a lineplot of the percentage of GDP over time\n",
    "sns.lineplot(x = 'TIME', y = 'PC_GDP', data = pharma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question:\n",
    "\n",
    "Knowing that the dataset contains data for 36 countries from 1971 until 2015. What happened when Seaborn made this plot for us?  \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make a subselection of this dataframe that contains the data for Belgium and its neigbhouring countries France, Germany and the Netherlands. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make empty dataframe\n",
    "sub_pharma = pd.DataFrame()\n",
    "\n",
    "# Countries of interest\n",
    "countries = ['BEL', 'FRA', 'DEU', 'NLD']\n",
    "\n",
    "# Make subselection dataframe with the data of the countries of interest\n",
    "for country in countries:\n",
    "    sub_pharma = sub_pharma.append(pharma.loc[pharma['LOCATION'] == country], ignore_index=True)\n",
    "    \n",
    "sub_pharma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a lineplot of the percentage of GDP over time\n",
    "sns.lineplot(x = 'TIME', y = 'PC_GDP', data = sub_pharma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a lineplot of the percentage of GDP over time\n",
    "sns.lineplot(x = 'TIME', y = 'PC_GDP', data = sub_pharma, hue='LOCATION')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question:\n",
    "Why doesn't Seaborn calculate a statistical estimation around the lines in this plot? What has changed as compared to the first lineplot? \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3 Barplot\n",
    "\n",
    "Take the sum of all spendings from oldest until the most recent spendings (TOTAL_SPEND) and make a barplot. Notice that this may lead to misinterpretation and plot the spendings per capita. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the width and height of the figure\n",
    "plt.figure(figsize=(15,6))\n",
    "\n",
    "# Plot barplot with similar x, y and data definitions\n",
    "sns.barplot(x = 'LOCATION', y = 'TOTAL_SPEND', data = pharma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make sure to set the figure size again to your likings\n",
    "plt.figure(figsize=(15,6))\n",
    "\n",
    "# Plot procentual GDP as opposed to total spendings\n",
    "sns.barplot(x = 'LOCATION', y = 'PC_GDP', data = pharma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additional parameters: \n",
    "- Use median as the estimate of central tendency: `estimator=median` (from numpy import median)\n",
    "- Show the standard error of the mean with the error bars: `ci=68`\n",
    "- Show standard deviation of observations instead of a confidence interval: `ci=\"sd\"` \n",
    "- Add “caps” to the error bars: `capsize=.2`\n",
    "- Use a different color palette for the bars: `palette=\"Blues_d\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3.2.3.1 Exercise\n",
    "Plot the same barplot but only for Belgium vs the Netherlands. Find a barplot argument that selects which country is selected and hence plotted (instead of making another subselection of the pandas dataframe). \n",
    "\n",
    "\n",
    "**Extra**: Adjust the figure with error bar caps, your favourite color palette, make it a horizontal barplot, or experiment with any of the other features. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the following example, we're going to plot **horizontal** layered barplots. We will re-use the code from exercise [2.5.1 - B](02_Pandas.ipynb) with metagenic classifications. Thus, we already know that each count represents a methylated cytosine in a specific region of a gene, and we added a new column with total counts per chromosome:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import data\n",
    "metagenic = pd.read_csv('data/metagenic.csv', index_col='chr')\n",
    "\n",
    "# Add a column with total counts\n",
    "metagenic[\"total\"] = metagenic.sum(axis = 1)\n",
    "\n",
    "# Order the table per total counts\n",
    "metagenic = metagenic.sort_values(\"total\", ascending = False)\n",
    "metagenic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first create a quick and dirty plot, using a whitegrid on the background and setting the size of the plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following line will make a grid on a white background\n",
    "sns.set(style=\"whitegrid\")\n",
    "\n",
    "# Set the size of the figure plot\n",
    "plt.figure(figsize=(10,6))\n",
    "\n",
    "# Create a barplot with \n",
    "sns.barplot(x=\"total\", y=metagenic.index , data= metagenic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Althought the colors look wonderful, they are not really informative. Let's add a color palette and divide each bar in different classifications:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following line will make a grid on a white background\n",
    "sns.set(style=\"whitegrid\")\n",
    "\n",
    "# Define colorstyle\n",
    "sns.set_color_codes(\"deep\")\n",
    "\n",
    "# Define figure size\n",
    "f, ax = plt.subplots(figsize=(10,6))\n",
    "\n",
    "# First plot the total counts\n",
    "sns.barplot(x = \"total\", y = \"chr\", data = metagenic, label = \"total\", color = 'b')\n",
    "# Then plot the ones with 5'UTR counts\n",
    "sns.barplot(x = \"5utr\",y = \"chr\", data = metagenic, label = \"5utr\", color=\"y\")\n",
    "# Third bar with exons\n",
    "sns.barplot(x = \"exon\",y = \"chr\", data = metagenic, label = \"exon\", color=\"r\")\n",
    "# Fourth bar with introns \n",
    "sns.barplot(x = \"intron\",y = \"chr\", data = metagenic, label = \"intron\", color=\"g\")\n",
    "#... \n",
    "\n",
    "# Add a legend and informative axis label\n",
    "ax.set(xlabel = \"counts\", ylabel = \"chromosomes\", title=\"Metagenic classification\")\n",
    "ax.legend(loc = \"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.4 Multiplot grids\n",
    "Seaborn also allows you to visualize pairwise relationships and marginal distributions. The iris dataset is the perfect dataset for showing this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We'll be working with the famously known iris dataset to make some seaborn plots. \n",
    "iris = sns.load_dataset(\"iris\")\n",
    "iris.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set(style='white')\n",
    "# A great way of making pairwise comparisons is pairplot\n",
    "sns.pairplot(data=iris, hue=\"species\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.5 Scatter plot (Volcano plot)\n",
    "A useful plot in differential expression analysis (RNA-seq) is a volcano plot. A volcano plot visualises and identifies statistically significant gene expression changes from two different conditions. Essentially, a volcano plot is a scatter plot and can also be approached from this perspective in Seaborn logic. The data for this experiment is retrieved from the GTN tutorial \"RNA Seq Counts to Viz in R\" ([link](https://galaxyproject.github.io/training-material/topics/transcriptomics/tutorials/rna-seq-counts-to-viz-in-r/tutorial.html)).\n",
    "\n",
    "A volcano plot shows statistical significance (P-value) versus magnitude of change (fold change). The most upregulated genes are towards the right, the most downregulated genes are towards the left, and the most statistically significant genes are towards the top. With this plot, we can then quickly identify genes with large fold changes that are also statistically significant, i.e. probably the most biologically significant genes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import dataset\n",
    "volc = pd.read_csv('data/annotatedDEgenes.tabular', sep='\\t')\n",
    "volc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already have the `log2(FC)` values. The P-value needs to be log10 transformed. Notice that the datatype of the values in the DataFrame are interpreted as `numpy.float64`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the data type of a value in the P-values column\n",
    "type(volc['P-value'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following code block we will add the log10 transformed P-values using Numpy's log10 function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Log10 transform the p-values \n",
    "volc['Log10 P-value'] = -np.log10(volc['P-value'])\n",
    "volc.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Volcano plot using Seaborn's scatterplot\n",
    "sns.scatterplot(x='log2(FC)', y='Log10 P-value', data=volc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Color the scatter points according to the strandedness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3.2.5.1 Exercise\n",
    "Mimic the graph given below which is extracted from the [tutorial](https://training.galaxyproject.org/training-material/topics/transcriptomics/tutorials/rna-seq-counts-to-viz-in-r/tutorial.html#volcano-plot) and represents the final result in this tutorial. \n",
    "- Use a darkgrid background\n",
    "- Color the dots according to its strand orientations\n",
    "- Add a title, x- and y-labels \n",
    "- Save the figure  \n",
    "\n",
    "Extra: figure out how you can:\n",
    "- Move the legend outside of the plot\n",
    "- Remove the upper and right spine of the plots\n",
    "\n",
    "![Volcano plot](img/volcano-plot-gtn.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.6 Heatmap\n",
    "This exercises is the sequel of exercise 2.5.4 in the previous chapter. In this exercise, derived from the GTN, we will plot  the data that we cleaned in the previous chapter to create a heatmap of the top differentially expressed genes in an RNA-seq counts dataset.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Import data & Prepare the data (note the index)\n",
    "heatmap_df = pd.read_csv('data/heatmap_data.csv', index_col=0)\n",
    "heatmap_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important that the gene names are the row indeces and the names of the experiments are the column indeces. Besides the indeces, also a normalization will be necessary in order to allow a better interpretation. This normalization is a standard procedure in creating heatmaps and is done by using z-scores. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing statistical library from scipy for calculating z-scores\n",
    "from scipy import stats "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Preparing the data\n",
    "# Data scaling by row (scale genes) with zscores\n",
    "for row in range(len(heatmap_df)):\n",
    "    heatmap_df.iloc[row] = stats.zscore(heatmap_df.iloc[row])\n",
    "    \n",
    "heatmap_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. Set style of the plot\n",
    "sns.set_style(\"ticks\")\n",
    "sns.color_palette(\"deep\")\n",
    "\n",
    "# 3. Define/create the plot\n",
    "f = plt.figure(figsize=(10,10))\n",
    "ax = sns.heatmap(heatmap_df, cmap=\"RdBu\", annot=True)\n",
    "\n",
    "# 4. Tweak lay-out\n",
    "ax.set(xlabel='Samples', ylabel='Genes', title='Heatmap of DE genes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. Set style of the plot\n",
    "sns.set_style(\"ticks\")\n",
    "sns.color_palette(\"deep\")\n",
    "\n",
    "# 3. Define/create the plot\n",
    "f, ax = plt.subplots(figsize=(10,10))\n",
    "sns.heatmap(heatmap_df, cmap=\"RdBu\", annot=True)\n",
    "\n",
    "# 4. Tweak lay-out\n",
    "ax.set(xlabel='Samples', ylabel='Genes', title='Heatmap of DE genes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3  An overview of lay-outing options\n",
    "Finally, we will maken an overview of the different steps and lay-out options when plotting by using simple line-plots. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's difficult to find best practices regarding plotting. However, the following steps can help you with a decent order to render your plots as expected:\n",
    "\n",
    "---\n",
    "\n",
    "```python\n",
    "# 1. Import data\n",
    "...\n",
    "\n",
    "# 2. Set style of the plot\n",
    "sns.set(...)\n",
    "sns.set_style(...)\n",
    "sns.set_context(...)\n",
    "sns.color_palette(...)\n",
    "sns.axes_style(...)\n",
    "\n",
    "# 3. Initialise the plot and plot the data. \n",
    "fig = plt.figure(...)  || fig, ax = plt.subplots() \n",
    "sns.lineplot(...)\n",
    "\n",
    "# 4. Modify lay-out (title, labels, legend, etc.)\n",
    "ax.set(...)\n",
    "plt.xlabel(...)\n",
    "plt.ylabel(...)\n",
    "\n",
    "# Save the figure with:\n",
    "#ax.savefig()\n",
    "```\n",
    "---\n",
    "\n",
    "\n",
    "\n",
    "**Style of the plot**:  \n",
    "[`sns.set()`](https://seaborn.pydata.org/generated/seaborn.set.html) is the overarching method that sets aesthetic parameters in one step. Alternatively, choose one of the following methods to edit the general style of the plot:\n",
    "- [`sns.set_style()`](https://seaborn.pydata.org/generated/seaborn.set_style.html) will set the background color of the graph. Examples are: *white*, *whitegrid* or *dark*. If you choose white you will see that it loses some structure, therefore it is possible to use *ticks* on the axes. \n",
    "- [`sns.set_context()`](https://seaborn.pydata.org/generated/seaborn.set_context.html) will basically scale your figure for usage in a *paper*, *poster*, *talk* or *notebook* (default). \n",
    "- [`sns.color_palettes()`](http://seaborn.pydata.org/tutorial/color_palettes.html) choose any of the color palettes defined in the link or make your own color palette. Options are: *pastel*, *deep*, *husl*, ...\n",
    "- [`sns.axes_style()`](https://seaborn.pydata.org/generated/seaborn.axes_style.html#seaborn.axes_style) This affects things like the color of the axes, whether a grid is enabled by default, and other aesthetic elements.\n",
    "\n",
    "\n",
    "\n",
    "**Initialise the plot and plot the data**:  \n",
    "- First define the figure size and/or subplots. Note that this is done at the matplotlib level: `f = plt.figure(figsize=(10,4))` or `f, ax = plt.subplot(nrows=1, ncols=1, figsize=(10,4))` \n",
    "- Use any of [Seaborn's plots](https://seaborn.pydata.org/examples/index.html)\n",
    "\n",
    "**Modify the lay-out (title, labels, legend, etc.)**:  \n",
    "Further modifications are possible on the matplotlib level by using `ax.set()` with a list of parameters. Refer to the [official documentation](https://matplotlib.org/3.3.0/api/axes_api.html) for a list of all possibilities. However it's also possible to define them individually using [pyplots methods](https://matplotlib.org/3.1.1/api/pyplot_summary.html). Here are some that you might find interesting:\n",
    "- `plt.title`\n",
    "- `plt.xlabel` and `plt.ylabel`\n",
    "- `plt.xlim` and `plt.ylim`\n",
    "- `plt.xscale` and `plt.yscale`\n",
    "- `plt.legend`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/plotting-hierarchy.webp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3.3.1 Exercise \n",
    "Import and inspect the dataset from [datahub.io](https://datahub.io/core/genome-sequencing-costs) containing the cost of genome sequencing throughout the years (also stored as `data/sequencing_costs.csv`).\n",
    "- Set the style to a white background with ticks on the axes\n",
    "- Set the context to a paper format\n",
    "- Change the figure size\n",
    "- Rename the x- and y-label and title of the plot \n",
    "- Save the figure in your folders \n",
    "\n",
    "Tip: you can rotate the x-axis values using the following line of code: `plt.setp(ax.get_xticklabels(), rotation=90)`\n",
    "\n",
    "\n",
    "![Seq cost per Mb](img/seqcost.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3.3.2 Extra exercise\n",
    "Modify the code from the previous exercise to make two subplots underneath each other that plot the Cost per Mb over years and the Total cost. \n",
    "Find more information on subplots [here](https://matplotlib.org/3.1.0/gallery/subplots_axes_and_figures/subplots_demo.html) or [here](https://dev.to/thalesbruno/subplotting-with-matplotlib-and-seaborn-5ei8).\n",
    "\n",
    "![Subplots sequencing cost](img/subplots_seqcost.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 More exercises! \n",
    "\n",
    "\n",
    "- COVID-19: https://epistat.wiv-isp.be/covid/\n",
    "- Pokemon: \n",
    "    - https://elitedatascience.com/python-seaborn-tutorial\n",
    "    - https://medium.com/@christhai_6937/data-science-in-python-part-2-exploring-pokemon-data-using-pandas-and-seaborn-cd54d1ae5ec0\n",
    "- Titanic: https://www.kaggle.com/iyadavvaibhav/data-viz-seaborn-exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 Further reading\n",
    "The internet is full of blogs discussing visualisation libraries and best practices, here is a start for some further reading and the ones that helped me to make these materials (amongst many others):\n",
    "- https://realpython.com/python-matplotlib-guide/\n",
    "- https://mode.com/blog/python-data-visualization-libraries\n",
    "- https://pbpython.com/visualization-tools-1.html\n",
    "- https://www.dataquest.io/blog/python-data-visualization-libraries/\n",
    "- https://lisacharlotterost.de/2016/05/17/one-chart-code/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}