03_python_vis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Introduction\" data-toc-modified-id=\"Introduction-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction</a></span><ul class=\"toc-item\"><li><span><a href=\"#An-example-gallery\" data-toc-modified-id=\"An-example-gallery-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>An example gallery</a></span></li><li><span><a href=\"#Why-visualize-data?\" data-toc-modified-id=\"Why-visualize-data?-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Why visualize data?</a></span></li><li><span><a href=\"#Conceptual-ideas\" data-toc-modified-id=\"Conceptual-ideas-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Conceptual ideas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Begin-with-the-consumer-in-mind\" data-toc-modified-id=\"Begin-with-the-consumer-in-mind-1.3.1\"><span class=\"toc-item-num\">1.3.1&nbsp;&nbsp;</span>Begin with the consumer in mind</a></span></li><li><span><a href=\"#Tell-a-story\" data-toc-modified-id=\"Tell-a-story-1.3.2\"><span class=\"toc-item-num\">1.3.2&nbsp;&nbsp;</span>Tell a story</a></span></li><li><span><a href=\"#A-matter-of-perception\" data-toc-modified-id=\"A-matter-of-perception-1.3.3\"><span class=\"toc-item-num\">1.3.3&nbsp;&nbsp;</span>A matter of perception</a></span></li><li><span><a href=\"#Some-principles\" data-toc-modified-id=\"Some-principles-1.3.4\"><span class=\"toc-item-num\">1.3.4&nbsp;&nbsp;</span>Some principles</a></span></li></ul></li></ul></li><li><span><a href=\"#Plotting-in-Python\" data-toc-modified-id=\"Plotting-in-Python-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Plotting in Python</a></span><ul class=\"toc-item\"><li><span><a href=\"#Static-plots\" data-toc-modified-id=\"Static-plots-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Static plots</a></span></li><li><span><a href=\"#Dynamic-or-interactive-plots\" data-toc-modified-id=\"Dynamic-or-interactive-plots-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Dynamic or interactive plots</a></span></li></ul></li><li><span><a href=\"#Univariate-plots\" data-toc-modified-id=\"Univariate-plots-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Univariate plots</a></span><ul class=\"toc-item\"><li><span><a href=\"#pandas\" data-toc-modified-id=\"pandas-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>pandas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Histogram\" data-toc-modified-id=\"Histogram-3.1.1\"><span class=\"toc-item-num\">3.1.1&nbsp;&nbsp;</span>Histogram</a></span></li><li><span><a href=\"#Bar-plot\" data-toc-modified-id=\"Bar-plot-3.1.2\"><span class=\"toc-item-num\">3.1.2&nbsp;&nbsp;</span>Bar plot</a></span></li><li><span><a href=\"#Density-plot\" data-toc-modified-id=\"Density-plot-3.1.3\"><span class=\"toc-item-num\">3.1.3&nbsp;&nbsp;</span>Density plot</a></span></li></ul></li><li><span><a href=\"#seaborn\" data-toc-modified-id=\"seaborn-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>seaborn</a></span><ul class=\"toc-item\"><li><span><a href=\"#Histogram\" data-toc-modified-id=\"Histogram-3.2.1\"><span class=\"toc-item-num\">3.2.1&nbsp;&nbsp;</span>Histogram</a></span></li><li><span><a href=\"#Bar-plot\" data-toc-modified-id=\"Bar-plot-3.2.2\"><span class=\"toc-item-num\">3.2.2&nbsp;&nbsp;</span>Bar plot</a></span></li><li><span><a href=\"#Density-plot\" data-toc-modified-id=\"Density-plot-3.2.3\"><span class=\"toc-item-num\">3.2.3&nbsp;&nbsp;</span>Density plot</a></span></li></ul></li></ul></li><li><span><a href=\"#Bivariate-plots\" data-toc-modified-id=\"Bivariate-plots-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Bivariate plots</a></span><ul class=\"toc-item\"><li><span><a href=\"#pandas\" data-toc-modified-id=\"pandas-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>pandas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Scatter-plot\" data-toc-modified-id=\"Scatter-plot-4.1.1\"><span class=\"toc-item-num\">4.1.1&nbsp;&nbsp;</span>Scatter plot</a></span></li><li><span><a href=\"#Box-plot\" data-toc-modified-id=\"Box-plot-4.1.2\"><span class=\"toc-item-num\">4.1.2&nbsp;&nbsp;</span>Box plot</a></span></li></ul></li><li><span><a href=\"#seaborn\" data-toc-modified-id=\"seaborn-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>seaborn</a></span><ul class=\"toc-item\"><li><span><a href=\"#Scatter-plot\" data-toc-modified-id=\"Scatter-plot-4.2.1\"><span class=\"toc-item-num\">4.2.1&nbsp;&nbsp;</span>Scatter plot</a></span></li><li><span><a href=\"#Box-plot\" data-toc-modified-id=\"Box-plot-4.2.2\"><span class=\"toc-item-num\">4.2.2&nbsp;&nbsp;</span>Box plot</a></span></li><li><span><a href=\"#Violin-plot\" data-toc-modified-id=\"Violin-plot-4.2.3\"><span class=\"toc-item-num\">4.2.3&nbsp;&nbsp;</span>Violin plot</a></span></li><li><span><a href=\"#Barplot-(categorical-vs-continuous)\" data-toc-modified-id=\"Barplot-(categorical-vs-continuous)-4.2.4\"><span class=\"toc-item-num\">4.2.4&nbsp;&nbsp;</span>Barplot (categorical vs continuous)</a></span></li><li><span><a href=\"#Joint-plot\" data-toc-modified-id=\"Joint-plot-4.2.5\"><span class=\"toc-item-num\">4.2.5&nbsp;&nbsp;</span>Joint plot</a></span></li></ul></li></ul></li><li><span><a href=\"#Facets-and-multivariate-data\" data-toc-modified-id=\"Facets-and-multivariate-data-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Facets and multivariate data</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#Scatter-plots-by-group\" data-toc-modified-id=\"Scatter-plots-by-group-5.0.1\"><span class=\"toc-item-num\">5.0.1&nbsp;&nbsp;</span>Scatter plots by group</a></span></li></ul></li><li><span><a href=\"#Facets\" data-toc-modified-id=\"Facets-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Facets</a></span></li><li><span><a href=\"#Pairs-plots\" data-toc-modified-id=\"Pairs-plots-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Pairs plots</a></span></li></ul></li><li><span><a href=\"#Customizing-the-look\" data-toc-modified-id=\"Customizing-the-look-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Customizing the look</a></span><ul class=\"toc-item\"><li><span><a href=\"#Themes\" data-toc-modified-id=\"Themes-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span>Themes</a></span></li></ul></li><li><span><a href=\"#Finer-control-with-matplotlib\" data-toc-modified-id=\"Finer-control-with-matplotlib-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Finer control with matplotlib</a></span><ul class=\"toc-item\"><li><span><a href=\"#Matlab-like-plotting\" data-toc-modified-id=\"Matlab-like-plotting-7.1\"><span class=\"toc-item-num\">7.1&nbsp;&nbsp;</span>Matlab-like plotting</a></span></li></ul></li><li><span><a href=\"#Resources\" data-toc-modified-id=\"Resources-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Resources</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data visualization using Python\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Data visualization is a basic task in data exploration and understanding. Humans are mainly visual creatures, and data visualization provides an opportunity to enhance communication of the story within the data. Often we find that data and the data-generating process is complex, and a visual representation of the data and our innate ability at pattern recognition can help reveal the complexities in a cognitively accessible way.\n",
    "\n",
    "### An example gallery\n",
    "\n",
    "Data visualization has a long and storied history, from Florence Nightangle onwards. Dr. Nightangle was a pioneer in data visualization and developed the *rose plot* to represent causes of death in hospitals during the Crimean War.\n",
    "\n",
    "![](graphs/rose.jpg)\n",
    "\n",
    " John Snow, in 1854, famously visualized the cholera outbreak in London, which showed the geographic proximity of cholera prevalence with particular water wells.\n",
    "\n",
    "![](graphs/snow_map.png)\n",
    "\n",
    "In one of the more famous visualizations, considered by many to be an optimal use of display ink and space, Minard visualized Napoleon's disastrous campaign to Russia\n",
    "\n",
    "![](graphs/map-full-size1.png)\n",
    "\n",
    "In more recent times, an employee at Facebook visualized all connections between users across the world, which clearly showed geographical associations with particular countries and regions.\n",
    "\n",
    "![](graphs/facebook-high-res-friendship-world-map-paul-butler.png)\n",
    "\n",
    "### Why visualize data?\n",
    "\n",
    "We often rely on numerical summaries to help understand and distinguish datasets. In 1973, Anscombe published an influential set of 4 datasets, each with two variables and with the means, variances and correlations being identical. When you graphed these data, the differences in the datasets were clearly visible. This set is popularly known as Anscombe's quartet.\n",
    "\n",
    "![](graphs/anscombe.png)\n",
    "\n",
    "A more recent experiment in data construction by Matejka and Fitzmaurice (2017) started with a representation of a dinosaur and created 10 more bivariate datasets which all shared the same univariate means and variances and the same pairwise correlations.\n",
    "\n",
    "![](graphs/datasaurus.png)\n",
    "\n",
    "These examples clarify the need for visualization to better understand relationships between variables. \n",
    "\n",
    "Even when using statistical visualization techniques, one has to be careful. Not all visualizations can discriminate between statistical characteristics. This was also explored by Matejka and Fitzmaurice. \n",
    "\n",
    "|      Strip plot      |       Boxplot        |     Violin plot      |\n",
    "| :------------------: | :------------------: | :------------------: |\n",
    "| ![](graphs/box1.png) | ![](graphs/box2.png) | ![](graphs/box3.png) |\n",
    "\n",
    "### Conceptual ideas\n",
    "\n",
    "#### Begin with the consumer in mind\n",
    "\n",
    "+ You have a deep understanding of the data you're presenting\n",
    "+ The person seeing the visualization **doesn't**\n",
    "+ Develop simpler visualizations first that are easier to explain\n",
    "\n",
    "#### Tell a story\n",
    "\n",
    "+ Make sure the graphic is clear\n",
    "+ Make sure the main point you want to make \"pops\"\n",
    "\n",
    "#### A matter of perception\n",
    "\n",
    "+ Color (including awareness of color deficiencies)\n",
    "+ Shape\n",
    "+ Fonts\n",
    "\n",
    "#### Some principles\n",
    "\n",
    "1. Data-ink ratio\n",
    "2. No mental gymnastics\n",
    "    1. The graphic should be self-evident\n",
    "    2. Context should be clear\n",
    "3. Is a graph the wrong choice?\n",
    "4. Focus on the consumer\n",
    "\n",
    "> See [my slides](http://araastat.com/BIOF439/slides/lectures/01-DataViz.pdf) for some more opinionated ideas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting in Python\n",
    "\n",
    "Let's take a very quick tour before we get into the weeds. We'll use the mtcars dataset as an exemplar dataset that we can import using `pandas`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "fig.show": true,
    "lines_to_next_cell": 0,
    "name": "03-python-vis-0"
   },
   "outputs": [],
   "source": [
    "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": {
    "eval": "#R_CODE#knitr::is_html_output()",
    "name": "03-python-vis-style1"
   },
   "outputs": [],
   "source": [
    "sns.set_context('paper')\n",
    "sns.set_style('white', {'font.family':'Futura', 'text.color':'1'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "eval": "#R_CODE#knitr::is_latex_output()",
    "lines_to_next_cell": 0,
    "name": "03-python-vis-style2"
   },
   "outputs": [],
   "source": [
    "sns.set_context('paper')\n",
    "sns.set_style('white', {'font.family':'Futura Medium'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "fig.show": true,
    "lines_to_next_cell": 0,
    "name": "03-python-vis-1"
   },
   "outputs": [],
   "source": [
    "mtcars = pd.read_csv('data/mtcars.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Static plots\n",
    "\n",
    "We will demonstrate plotting in what I'll call the `matplotlib` ecosystem. `matplotlib` is the venerable and powerful visualization package that was originally designed to emulate the Matlab plotting paradigm. It has since evolved and as become a bit more user-friendly. It is still quite granular and can facilitate a lot of custom plots once you become familiar with it. However, as a starting point, I think it's a bit much. We'll see a bit of what it can offer later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will consider two other options which are built on top of `matplotlib`, but are much more accessible. These are `pandas` and `seaborn`. The two packages have some different approaches, but both wrap `matplotlib` in higher-level code and decent choices so we don't need to get into the `matplotlib` trenches quite so much. We'll still call `matplotlib` in our code, since both these packages need it for some fine tuning. Both packages are also very much aligned to the `DataFrame` construct in `pandas`, so makes plotting a much more seamless experience. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-2"
   },
   "outputs": [],
   "source": [
    "mtcars.plot.scatter(x = 'hp', y = 'mpg');\n",
    "plt.show()\n",
    "# mtcars.plot(x = 'hp', y = 'mpg', kind = 'scatter');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-3"
   },
   "outputs": [],
   "source": [
    "sns.scatterplot(data = mtcars, x = 'hp', y = 'mpg');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are of course some other choices based on your background and preferences. For static plots, there are a couple of emulators of the popular R package `ggplot2`. These are `plotnine` and `ggplot`. `plotnine` seems a bit more developed and uses the `ggplot2` semantics of aesthetics and layers, with almost identical code syntax. \n",
    "\n",
    "> You can install `plotnine` using `conda`: \n",
    ">\n",
    "> ```shell\n",
    "> conda install -c conda-forge plotnine\n",
    "> ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-4"
   },
   "outputs": [],
   "source": [
    "from plotnine import *\n",
    "\n",
    "(ggplot(mtcars) + \n",
    "  aes(x = 'hp', y = 'mpg') +\n",
    "  geom_point())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dynamic or interactive plots\n",
    "\n",
    "There are several Python packages that wrap around Javascript plotting libraries that are so popular in web-based graphics like D3 and Vega. Three that deserve mention are `plotly`, `bokeh`, and `altair`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> If you actually want to experience the interactivity of the plots, please use the \"Live notebooks\" link in Canvas to run these notebooks. Otherwise, you can download the notebooks from the GitHub site and run them on your own computer. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`plotly` is a Python package developed by the company [Plot.ly](https://www.plotly.com) to interface with their interactive Javascript library either locally or via their web service. Plot.ly also develops an R package to interface with their products as well. It provides an intuitive syntax and ease of use, and is probably the more popular package for interactive graphics from both R and Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "eval": false,
    "name": "03-python-vis-5",
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "\n",
    "fig = px.scatter(mtcars, x = 'hp', y = 'mpg')\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`bokeh` is an interactive visualization package developed by Anaconda. It is quite powerful, but its code can be rather verbose and granular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "error": true,
    "eval": false,
    "lines_to_next_cell": 2,
    "name": "03-python-vis-6",
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [],
   "source": [
    "from bokeh.plotting import figure, output_file\n",
    "from bokeh.io import output_notebook, show\n",
    "output_notebook()\n",
    "p = figure()\n",
    "p.xaxis.axis_label = 'Horsepower'\n",
    "p.yaxis.axis_label = 'Miles per gallon'\n",
    "\n",
    "p.circle(mtcars['hp'], mtcars['mpg'], size=10);\n",
    "\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`altair` that leverages ideas from Javascript plotting libraries and a distinctive code syntax that may appeal to some"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "eval": false,
    "name": "03-python-vis-7",
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [],
   "source": [
    "import altair as alt\n",
    "\n",
    "alt.Chart(mtcars).mark_point().encode(\n",
    "    x='hp',\n",
    "    y='mpg'\n",
    ").interactive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We won't focus on these dynamic packages in this workshop in the interests of time, but you can avail of several online resources for these.\n",
    "\n",
    "| Package | Resources                                                    |\n",
    "| ------- | ------------------------------------------------------------ |\n",
    "| plotly  | [Fundamentals](https://plotly.com/python/)                   |\n",
    "| bokeh   | [Tutorial](https://mybinder.org/v2/gh/bokeh/bokeh-notebooks/master?filepath=tutorial%2F00%20-%20Introduction%20and%20Setup.ipynb) |\n",
    "| altair  | [Overview](https://altair-viz.github.io/getting_started/overview.html) |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Univariate plots\n",
    "\n",
    "We will be introducing plotting and code from 3 modules: `matplotlib`, `seaborn` and `pandas`. As we go forth, you may ask the question, which one should I learn? Chris Moffitt has the following advice.\n",
    "\n",
    "A pathway to learning ([Chris Moffit](https://pbpython.com/effective-matplotlib.html))\n",
    "\n",
    "1. Learn the basic matplotlib terminology, specifically what is a `Figure` and an `Axes` .\n",
    "2. Always use the object-oriented interface. Get in the habit of using it from the start of your analysis. (*not really getting into this, but basically don't use the Matlab form I'll show at the end, if you don't have to*)\n",
    "3. Start your visualizations with basic pandas plotting.\n",
    "4. Use seaborn for the more complex statistical visualizations.\n",
    "5. Use matplotlib to customize the pandas or seaborn visualization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pandas\n",
    "\n",
    "#### Histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-8"
   },
   "outputs": [],
   "source": [
    "mtcars.plot.hist(y = 'mpg');\n",
    "plt.show()\n",
    "# mtcars.plot(y = 'mpg', kind = 'hist')\n",
    "#mtcars['mpg'].plot(kind = 'hist')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bar plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-9"
   },
   "outputs": [],
   "source": [
    "mtcars['cyl'].value_counts().plot.bar();\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Density plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-10"
   },
   "outputs": [],
   "source": [
    "mtcars['mpg'].plot( kind = 'density');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### seaborn\n",
    "\n",
    "#### Histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-11"
   },
   "outputs": [],
   "source": [
    "ax = sns.distplot(mtcars['mpg'], kde=False);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bar plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-12"
   },
   "outputs": [],
   "source": [
    "sns.countplot(data = mtcars, x = 'cyl');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-13"
   },
   "outputs": [],
   "source": [
    "diamonds = pd.read_csv('data/diamonds.csv.gz')\n",
    "ordered_colors = ['E','F','G','H','I','J']\n",
    "sns.catplot(data = diamonds, x = 'color', kind = 'count', color = 'blue');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Density plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-14"
   },
   "outputs": [],
   "source": [
    "sns.distplot(mtcars['mpg'], hist=False);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bivariate plots\n",
    "\n",
    "### pandas\n",
    "\n",
    "#### Scatter plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-15"
   },
   "outputs": [],
   "source": [
    "diamonds = pd.read_csv('data/diamonds.csv.gz')\n",
    "diamonds.plot(x = 'carat', y = 'price', kind = 'scatter');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Box plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-16"
   },
   "outputs": [],
   "source": [
    "diamonds.boxplot(column = 'price', by = 'color');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### seaborn\n",
    "\n",
    "#### Scatter plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-17"
   },
   "outputs": [],
   "source": [
    "sns.regplot(data = diamonds, x = 'carat', y = 'price', fit_reg=False);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.scatterplot(data=diamonds, x = 'carat', y = 'price', linewidth=0); \n",
    "# We set the linewidth to 0, otherwise the lines around the circles\n",
    "# appear white and wash out the figure. Try with any positive \n",
    "# value of linewidth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Box plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-18"
   },
   "outputs": [],
   "source": [
    "ordered_color = ['E','F','G','H','I','J']\n",
    "sns.catplot(data = diamonds, x = 'color', y = 'price', \n",
    "            order = ordered_color, color = 'blue', kind = 'box');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Violin plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-19"
   },
   "outputs": [],
   "source": [
    "g = sns.catplot(data = diamonds, x = 'color', y = 'price', \n",
    "                kind = 'violin', order = ordered_color);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Barplot (categorical vs continuous)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-20"
   },
   "outputs": [],
   "source": [
    "ordered_colors = ['D','E','F','G','H','I','J']\n",
    "sns.barplot(data = diamonds, x = 'color', y = 'price', order = ordered_colors);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-21"
   },
   "outputs": [],
   "source": [
    "sns.barplot(data = diamonds, x = 'cut', y = 'price');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Joint plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-22"
   },
   "outputs": [],
   "source": [
    "sns.jointplot(data = diamonds, x = 'carat', y = 'price');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-23"
   },
   "outputs": [],
   "source": [
    "sns.jointplot(data = diamonds, x = 'carat', y = 'price', kind = 'reg');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 0,
    "name": "03-python-vis-24"
   },
   "outputs": [],
   "source": [
    "sns.jointplot(data = diamonds, x = 'carat', y = 'price', kind = 'hex');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Facets and multivariate data\n",
    "\n",
    "The basic idea in this section is to see how we can visualize more than two variables at a time. We will see two strategies:\n",
    "\n",
    "1. Put multiple graphs on the same frame, with each graph referring to a level of a 3rd variable\n",
    "1. Create a grid of separate graphs, with each graph referring to a level of a 3rd variable\n",
    "\n",
    "This strategy also can work any time we need to visualize the data corresponding to different levels of a variable, say by gender or race or country. \n",
    "\n",
    "In this example we're going to start with 4 time series, labelled A, B, C, D. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-25"
   },
   "outputs": [],
   "source": [
    "ts = pd.read_csv('data/ts.csv')\n",
    "ts.dt = pd.to_datetime(ts.dt) # convert this column to a datetime object\n",
    "ts.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For one strategy we will employ, it is actually a bit easier to change this to a wide data form, using `pivot`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-26"
   },
   "outputs": [],
   "source": [
    "dfp = ts.pivot(index = 'dt', columns = 'kind', values = 'value')\n",
    "dfp.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-27"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "dfp.plot(ax=ax);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This creates 4 separate time series plots, one for each of the columns labeled A, B, C and D. The x-axis is determined by `dfp.index`, which during the pivoting operation, we deemed was the values of `dt` in the original data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `seaborn`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-28"
   },
   "outputs": [],
   "source": [
    "sns.lineplot(data = dfp);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we can achieve this same plot using the original data, and `seaborn`, in rather short order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-29"
   },
   "outputs": [],
   "source": [
    "sns.lineplot(data = ts, x = 'dt', y = 'value', hue = 'kind');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this plot, assigning a variable to `hue` tells seaborn to draw lines (in this case) of different hues based on values of that variable. \n",
    "\n",
    "We can use a bit more granular and explicit code for this as well. This allows us a bit more control of the plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 2,
    "name": "03-python-vis-30"
   },
   "outputs": [],
   "source": [
    "g = sns.FacetGrid(ts, hue = 'kind', height = 5, aspect = 1.5)\n",
    "g.map(plt.plot, 'dt', 'value').add_legend()\n",
    "g.ax.set(xlabel = 'Date',\n",
    "        ylabel = 'Value',\n",
    "        title = 'Time series');\n",
    "plt.show()\n",
    "\n",
    "## All of this code chunk needs to be run at one time, otherwise you get weird errors. This\n",
    "## is true for many plotting commands which are composed of multiple commands. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `FacetGrid` tells `seaborn` that we're going to layer graphs, with layers based on `hue` and the hues being determined by values of `kind`. Notice that we can add a few more details like the aspect ratio of the plot and so on. The documentation for [FacetGrid](https://seaborn.pydata.org/generated/seaborn.FacetGrid.html), which we will also use for facets below, may be helpful in finding all the options you can control."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also show more than one kind of layer on a single graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 2,
    "name": "03-python-vis-31"
   },
   "outputs": [],
   "source": [
    "bm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-32"
   },
   "outputs": [],
   "source": [
    "plt.style.use('seaborn-notebook')\n",
    "sns.relplot(x = 'timepoint', y = 'signal', data = fmri);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-33"
   },
   "outputs": [],
   "source": [
    "sns.relplot(x = 'timepoint', y = 'signal', data = fmri, kind = 'line');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-34"
   },
   "outputs": [],
   "source": [
    "sns.relplot(x = 'timepoint', y = 'signal', data = fmri, kind = 'line', hue ='event');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 2,
    "name": "03-python-vis-35"
   },
   "outputs": [],
   "source": [
    "sns.relplot(x = 'timepoint', y = 'signal', data = fmri, hue = 'region', \n",
    "            style = 'event', kind = 'line');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use color to show the region, and line style (solid vs dashed) to show the event."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scatter plots by group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-36"
   },
   "outputs": [],
   "source": [
    "g = sns.FacetGrid(diamonds, hue = 'color', height = 7.5)\n",
    "g.map(plt.scatter, 'carat', 'price').add_legend();\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that this arranges the colors and values for the `color` variable in random order. If we have a preferred order we can impose that using the option `hue_order`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 2,
    "name": "03-python-vis-37"
   },
   "outputs": [],
   "source": [
    "clarity_ranking = [\"I1\", \"SI2\", \"SI1\", \"VS2\", \"VS1\", \"VVS2\", \"VVS1\", \"IF\"]\n",
    "sns.scatterplot(x=\"carat\", y=\"price\",\n",
    "                hue=\"clarity\", size=\"depth\",\n",
    "                hue_order=clarity_ranking,\n",
    "                sizes=(1, 8), linewidth=0,\n",
    "                data=diamonds);\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Facets\n",
    "\n",
    "Facets or trellis graphics is a visualization method where we draw multiple plots in a grid, with each plot corresponding to unique values of a particular variable or combinations of variables. This has also been called *small multiples*. \n",
    "\n",
    "We'll proceed with an example using the `iris` dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-38"
   },
   "outputs": [],
   "source": [
    "iris = pd.read_csv('data/iris.csv')\n",
    "iris.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-39"
   },
   "outputs": [],
   "source": [
    "g = sns.FacetGrid(iris, col = 'species', hue = 'species', height = 5)\n",
    "g.map(plt.scatter, 'sepal_width', 'sepal_length').add_legend();\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use `FacetGrid` to indicate that we're creating multiple subplots by specifying the option `col` (for column). So this code says we are going to create one plot per level of species, arranged as separate columns (or in effect along one row). You could also specify `row` which would arrange the plots one to a row, or, in effect, in one column. \n",
    "\n",
    "The `map` function says, take the facets I've defined and stored in `g`, and in each one, plot a scatter plot with `sepal_width` on the x-axis and `sepal_length` on the y-axis. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also use `relplot` for a more compact solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-40"
   },
   "outputs": [],
   "source": [
    "sns.relplot(x = 'sepal_width', y = 'sepal_length', data = iris, \n",
    "            col = 'species', hue = 'species');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A bit more of a complicated example, using the `fmri` data, where we're coloring lines based on the subject, and creating a 2-d grid, where region of the brain in along columns and event type is along rows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-41"
   },
   "outputs": [],
   "source": [
    "sns.relplot(x=\"timepoint\", y=\"signal\", hue=\"subject\",\n",
    "            col=\"region\", row=\"event\", height=3,\n",
    "            kind=\"line\", estimator=None, data=fmri);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, we want to show how each subject fares for each of the two events, just within the frontal region. We let `seaborn` figure out the layout, only specifying that we'll be going along rows (\"by column\") and also saying we'll wrap around to the beginning once we've got to 5 columns. Note we use the `query` function to filter the dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-42"
   },
   "outputs": [],
   "source": [
    "sns.relplot(x=\"timepoint\", y=\"signal\", hue=\"event\", style=\"event\",\n",
    "            col=\"subject\", col_wrap=5,\n",
    "            height=3, aspect=.75, linewidth=2.5,\n",
    "            kind=\"line\", data=fmri.query(\"region == 'frontal'\"));\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example we want to compare the distribution of price from the diamonds dataset by color, and so it makes sense to create density plots of the price distribution and stack them one below the next so we can visually compare them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-43"
   },
   "outputs": [],
   "source": [
    "ordered_colors = ['E','F','G','H','I','J']\n",
    "g = sns.FacetGrid(data = diamonds, row = 'color', height = 1.7, \n",
    "                  aspect = 4, row_order = ordered_colors)\n",
    "g.map(sns.kdeplot, 'price');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You need to use `FacetGrid` to create sets of univariate plots since there is no particular method that allows univariate plots over a grid like `relplot` for bivariate plots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pairs plots\n",
    "\n",
    "The pairs plot is a quick way to compare every pair of variables in a dataset (or at least, every pair of continuous variables) in a grid. You can specify what kind of univariate plot will be displayed on the diagonal locations on the grid, and which bivariate plots will be displayed on the off-diagonal locations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-44"
   },
   "outputs": [],
   "source": [
    "sns.pairplot(data=iris);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can achieve more customization using `PairGrid`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 2,
    "name": "03-python-vis-45"
   },
   "outputs": [],
   "source": [
    "g = sns.PairGrid(iris, diag_sharey=False);\n",
    "g.map_upper(sns.scatterplot);\n",
    "g.map_lower(sns.kdeplot, colors=\"C0\");\n",
    "g.map_diag(sns.kdeplot, lw=2);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customizing the look "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Themes\n",
    "\n",
    "There are several [themes](https://matplotlib.org/3.2.1/gallery/style_sheets/style_sheets_reference.html) available in the modern `matplotlib`, some of which borrow from `seaborn`. You can see the available themes and play around. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-46"
   },
   "outputs": [],
   "source": [
    "plt.style.available"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See some examples below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-47"
   },
   "outputs": [],
   "source": [
    "plt.style.use('fivethirtyeight')\n",
    "sns.scatterplot(data = iris, x = 'sepal_width', y = 'sepal_length');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-48"
   },
   "outputs": [],
   "source": [
    "plt.style.use('bmh')\n",
    "sns.scatterplot(data = iris, x = 'sepal_width', y = 'sepal_length');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-49"
   },
   "outputs": [],
   "source": [
    "plt.style.use('classic')\n",
    "sns.scatterplot(data = iris, x = 'sepal_width', y = 'sepal_length');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-50"
   },
   "outputs": [],
   "source": [
    "plt.style.use('ggplot')\n",
    "sns.scatterplot(data = iris, x = 'sepal_width', y = 'sepal_length');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-51"
   },
   "outputs": [],
   "source": [
    "plt.style.use('Solarize_Light2')\n",
    "sns.scatterplot(data = iris, x = 'sepal_width', y = 'sepal_length');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> One small syntax point. You may have noticed in your own work that you get a little annoying line in the output when you plot. You can prevent that from happening by putting a semi-colon (`;`) after the last plotting command\n",
    "\n",
    "## Finer control with matplotlib\n",
    "\n",
    "![https://matplotlib.org/tutorials/introductory/usage.html#sphx-glr-tutorials-introductory-usage-py](graphs/matplotlib-anatomy.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see from the figure, you can control each aspect of the plot displayed above using `matplotlib`. I won't go into the details, and will leave it to you to look at the `matplotlib` [documentation](https://matplotlib.org/contents.html) and [examples](https://matplotlib.org/gallery/index.html) if you need to customize at this level of granularity. \n",
    "\n",
    "The following is an example using pure `matplotlib`. You can see how you can build up a plot. The crucial part here is that you need to run the code from each chunk together.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-52"
   },
   "outputs": [],
   "source": [
    "from matplotlib.ticker import FuncFormatter\n",
    "\n",
    "data = {'Barton LLC': 109438.50,\n",
    "        'Frami, Hills and Schmidt': 103569.59,\n",
    "        'Fritsch, Russel and Anderson': 112214.71,\n",
    "        'Jerde-Hilpert': 112591.43,\n",
    "        'Keeling LLC': 100934.30,\n",
    "        'Koepp Ltd': 103660.54,\n",
    "        'Kulas Inc': 137351.96,\n",
    "        'Trantow-Barrows': 123381.38,\n",
    "        'White-Trantow': 135841.99,\n",
    "        'Will LLC': 104437.60}\n",
    "group_data = list(data.values())\n",
    "group_names = list(data.keys())\n",
    "group_mean = np.mean(group_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 0,
    "name": "03-python-vis-53"
   },
   "outputs": [],
   "source": [
    "plt.style.use('default')\n",
    "fig, ax = plt.subplots()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-54"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.barh(group_names, group_data);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-55"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.barh(group_names, group_data)\n",
    "ax.set(xlim = [-10000, 140000], xlabel = 'Total Revenue', ylabel = 'Company', \n",
    "       title = 'Company Revenue');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-56"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 4))\n",
    "ax.barh(group_names, group_data)\n",
    "labels = ax.get_xticklabels()\n",
    "plt.setp(labels, rotation=45, horizontalalignment='right')\n",
    "ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company',\n",
    "       title='Company Revenue');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you have created your figure, you do need to save it to disk so that you can use it in your Word or Markdown or PowerPoint document. You can see the formats available. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-57"
   },
   "outputs": [],
   "source": [
    "fig.canvas.get_supported_filetypes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type will be determined by the ending of the file name. You can add some options depending on the type. I'm showing an example of saving the figure to a PNG file. Typically I'll save figures to a vector graphics format like PDF, and then convert into other formats, since that results in minimal resolution loss. You of course have the option to save to your favorite format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-58"
   },
   "outputs": [],
   "source": [
    "# fig.savefig('sales.png', dpi = 300, bbox_inches = 'tight') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matlab-like plotting\n",
    "\n",
    "`matplotlib` was originally developed to emulate Matlab. Though this kind of syntax is no longer recommended, it is still available and may be of use to those coming to Python from Matlab or Octave. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-59"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot([1, 2, 3, 4]);\n",
    "plt.ylabel('some numbers');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-60"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# evenly sampled time at 200ms intervals\n",
    "t = np.arange(0., 5., 0.2)\n",
    "\n",
    "# red dashes, blue squares and green triangles\n",
    "plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "name": "03-python-vis-61"
   },
   "outputs": [],
   "source": [
    "def f(t):\n",
    "    return np.exp(-t) * np.cos(2*np.pi*t)\n",
    "\n",
    "t1 = np.arange(0.0, 5.0, 0.1)\n",
    "t2 = np.arange(0.0, 5.0, 0.02)\n",
    "\n",
    "plt.figure();\n",
    "plt.subplot(211);\n",
    "plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k');\n",
    "\n",
    "plt.subplot(212);\n",
    "plt.plot(t2, np.cos(2*np.pi*t2), 'r--');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A really nice online resource for learning data visualization in Python is the [Python Graph Gallery](https://python-graph-gallery.com/). This site has many examples of different kinds of plots using `pandas`, `seaborn` and `matplotlib`"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,Rmd"
  },
  "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.8.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}