small_matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# matplotlib - 2D and 3D plotting in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "J.R. Johansson (jrjohansson at gmail.com)\n",
    "\n",
    "The latest version of this [IPython notebook](http://ipython.org/notebook.html) lecture is available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
    "\n",
    "The other notebooks in this lecture series are indexed at [http://jrjohansson.github.io](http://jrjohansson.github.io)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This line configures matplotlib to show figures embedded in the notebook, \n",
    "# instead of opening a new window for each figure. More about that later. \n",
    "# If you are using an old version of IPython, try using '%pylab inline' instead.\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib is an excellent 2D and 3D graphics library for generating scientific figures. Some of the many advantages of this library include:\n",
    "\n",
    "* Easy to get started\n",
    "* Support for $\\LaTeX$ formatted labels and texts\n",
    "* Great control of every element in a figure, including figure size and DPI. \n",
    "* High-quality output in many formats, including PNG, PDF, SVG, EPS, and PGF.\n",
    "* GUI for interactively exploring figures *and* support for headless generation of figure files (useful for batch jobs).\n",
    "\n",
    "One of the key features of matplotlib that I would like to emphasize, and that I think makes matplotlib highly suitable for generating figures for scientific publications is that all aspects of the figure can be controlled *programmatically*. This is important for reproducibility and convenient when one needs to regenerate the figure with updated data or change its appearance. \n",
    "\n",
    "More information at the Matplotlib web page: http://matplotlib.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get started using Matplotlib in a Python program, either include the symbols from the `pylab` module (the easy way):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pylab import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or import the `matplotlib.pyplot` module under the name `plt` (the tidy way):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MATLAB-like API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The easiest way to get started with plotting using matplotlib is often to use the MATLAB-like API provided by matplotlib. \n",
    "\n",
    "It is designed to be compatible with MATLAB's plotting functions, so it is easy to get started with if you are familiar with MATLAB.\n",
    "\n",
    "To use this API from matplotlib, we need to include the symbols in the `pylab` module: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pylab import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple figure with MATLAB-like plotting API:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 5, 10)\n",
    "y = x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "figure()\n",
    "plot(x, y, 'r')\n",
    "xlabel('x')\n",
    "ylabel('y')\n",
    "title('title')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the plotting related functions in MATLAB are covered by the `pylab` module. For example, subplot and color/symbol selection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "subplot(1,2,1)\n",
    "plot(x, y, 'r--')\n",
    "subplot(1,2,2)\n",
    "plot(y, x, 'g*-');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The good thing about the pylab MATLAB-style API is that it is easy to get started with if you are familiar with MATLAB, and it has a minumum of coding overhead for simple plots. \n",
    "\n",
    "However, I'd encourrage not using the MATLAB compatible API for anything but the simplest figures.\n",
    "\n",
    "Instead, I recommend learning and using matplotlib's object-oriented plotting API. It is remarkably powerful. For advanced figures with subplots, insets and other components it is very nice to work with. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The matplotlib object-oriented API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main idea with object-oriented programming is to have objects that one can apply functions and actions on, and no object or program states should be global (such as the MATLAB-like API). The real advantage of this approach becomes apparent when more than one figure is created, or when a figure contains more than one subplot. \n",
    "\n",
    "To use the object-oriented API we start out very much like in the previous example, but instead of creating a new global figure instance we store a reference to the newly created figure instance in the `fig` variable, and from it we create a new axis instance `axes` using the `add_axes` method in the `Figure` class instance `fig`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "\n",
    "axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # left, bottom, width, height (range 0 to 1)\n",
    "\n",
    "axes.plot(x, y, 'r')\n",
    "\n",
    "axes.set_xlabel('x')\n",
    "axes.set_ylabel('y')\n",
    "axes.set_title('title');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although a little bit more code is involved, the advantage is that we now have full control of where the plot axes are placed, and we can easily add more than one axis to the figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "\n",
    "axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes\n",
    "axes2 = fig.add_axes([0.2, 0.5, 0.4, 0.3]) # inset axes\n",
    "\n",
    "# main figure\n",
    "axes1.plot(x, y, 'r')\n",
    "axes1.set_xlabel('x')\n",
    "axes1.set_ylabel('y')\n",
    "axes1.set_title('title')\n",
    "\n",
    "# insert\n",
    "axes2.plot(y, x, 'g')\n",
    "axes2.set_xlabel('y')\n",
    "axes2.set_ylabel('x')\n",
    "axes2.set_title('insert title');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving figures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To save a figure to a file we can use the `savefig` method in the `Figure` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(\"filename.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can also optionally specify the DPI and choose between different output formats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(\"filename.png\", dpi=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What formats are available and which ones should be used for best quality?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib can generate high-quality output in a number formats, including PNG, JPG, EPS, SVG, PGF and PDF. For scientific papers, I recommend using PDF whenever possible. (LaTeX documents compiled with `pdflatex` can include PDFs using the `includegraphics` command). In some cases, PGF can also be good alternative."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following figure shows how to use the figure title, axis labels and legends described above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(x, x**2, label=\"y = x**2\")\n",
    "ax.plot(x, x**3, label=\"y = x**3\")\n",
    "ax.legend(loc=2); # upper left corner\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('title');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatting text: LaTeX, fontsize, font family"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The figure above is functional, but it does not (yet) satisfy the criteria for a figure used in a publication. First and foremost, we need to have LaTeX formatted text, and second, we need to be able to adjust the font size to appear right in a publication.\n",
    "\n",
    "Matplotlib has great support for LaTeX. All we need to do is to use dollar signs encapsulate LaTeX in any text (legend, title, label, etc.). For example, `\"$y=x^3$\"`.\n",
    "\n",
    "But here we can run into a slightly subtle problem with LaTeX code and Python text strings. In LaTeX, we frequently use the backslash in commands, for example `\\alpha` to produce the symbol $\\alpha$. But the backslash already has a meaning in Python strings (the escape code character). To avoid Python messing up our latex code, we need to use \"raw\" text strings. Raw text strings are prepended with an '`r`', like `r\"\\alpha\"` or `r'\\alpha'` instead of `\"\\alpha\"` or `'\\alpha'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(x, x**2, label=r\"$y = \\alpha^2$\")\n",
    "ax.plot(x, x**3, label=r\"$y = \\alpha^3$\")\n",
    "ax.legend(loc=2) # upper left corner\n",
    "ax.set_xlabel(r'$\\alpha$', fontsize=18)\n",
    "ax.set_ylabel(r'$y$', fontsize=18)\n",
    "ax.set_title('title');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colormap and contour figures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Colormaps and contour figures are useful for plotting functions of two variables. In most of these functions we will use a colormap to encode one dimension of the data. There are a number of predefined colormaps. It is relatively straightforward to define custom colormaps. For a list of pre-defined colormaps, see: http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = 0.7\n",
    "phi_ext = 2 * np.pi * 0.5\n",
    "\n",
    "def flux_qubit_potential(phi_m, phi_p):\n",
    "    return 2 + alpha - 2 * np.cos(phi_p) * np.cos(phi_m) - alpha * np.cos(phi_ext - 2*phi_p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi_m = np.linspace(0, 2*np.pi, 100)\n",
    "phi_p = np.linspace(0, 2*np.pi, 100)\n",
    "X,Y = np.meshgrid(phi_p, phi_m)\n",
    "Z = flux_qubit_potential(X, Y).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### pcolor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "p = ax.pcolor(X/(2*np.pi), Y/(2*np.pi), Z, cmap=matplotlib.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max())\n",
    "cb = fig.colorbar(p, ax=ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### imshow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "im = ax.imshow(Z, cmap=matplotlib.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max(), extent=[0, 1, 0, 1])\n",
    "im.set_interpolation('bilinear')\n",
    "\n",
    "cb = fig.colorbar(im, ax=ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### contour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "cnt = ax.contour(Z, cmap=matplotlib.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max(), extent=[0, 1, 0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3D figures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use 3D graphics in matplotlib, we first need to create an instance of the `Axes3D` class. 3D axes can be added to a matplotlib figure canvas in exactly the same way as 2D axes; or, more conveniently, by passing a `projection='3d'` keyword argument to the `add_axes` or `add_subplot` methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.mplot3d.axes3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Surface plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(14,6))\n",
    "\n",
    "# `ax` is a 3D-aware axis instance because of the projection='3d' keyword argument to add_subplot\n",
    "ax = fig.add_subplot(1, 2, 1, projection='3d')\n",
    "\n",
    "p = ax.plot_surface(X, Y, Z, rstride=4, cstride=4, linewidth=0)\n",
    "\n",
    "# surface_plot with color grading and color bar\n",
    "ax = fig.add_subplot(1, 2, 2, projection='3d')\n",
    "p = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=matplotlib.cm.coolwarm, linewidth=0, antialiased=False)\n",
    "cb = fig.colorbar(p, shrink=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wire-frame plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(8,6))\n",
    "\n",
    "ax = fig.add_subplot(1, 1, 1, projection='3d')\n",
    "\n",
    "p = ax.plot_wireframe(X, Y, Z, rstride=4, cstride=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Coutour plots with projections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(8,6))\n",
    "\n",
    "ax = fig.add_subplot(1,1,1, projection='3d')\n",
    "\n",
    "ax.plot_surface(X, Y, Z, rstride=4, cstride=4, alpha=0.25)\n",
    "cset = ax.contour(X, Y, Z, zdir='z', offset=-np.pi, cmap=matplotlib.cm.coolwarm)\n",
    "cset = ax.contour(X, Y, Z, zdir='x', offset=-np.pi, cmap=matplotlib.cm.coolwarm)\n",
    "cset = ax.contour(X, Y, Z, zdir='y', offset=3*np.pi, cmap=matplotlib.cm.coolwarm)\n",
    "\n",
    "ax.set_xlim3d(-np.pi, 2*np.pi);\n",
    "ax.set_ylim3d(0, 3*np.pi);\n",
    "ax.set_zlim3d(-np.pi, 2*np.pi);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Backends"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib has a number of \"backends\" which are responsible for rendering graphs. The different backends are able to generate graphics with different formats and display/event loops. There is a distinction between noninteractive backends (such as 'agg', 'svg', 'pdf', etc.) that are only used to generate image files (e.g. with the `savefig` function), and interactive backends (such as Qt4Agg, GTK, MaxOSX) that can display a GUI window for interactively exploring figures. \n",
    "\n",
    "A list of available backends are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(matplotlib.rcsetup.all_backends)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default backend, called `agg`, is based on a library for raster graphics which is great for generating raster formats like PNG.\n",
    "\n",
    "Normally we don't need to bother with changing the default backend; but sometimes it can be useful to switch to, for example, PDF or GTKCairo (if you are using Linux) to produce high-quality vector graphics instead of raster based graphics. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generating SVG with the svg backend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #\n",
    "# # RESTART THE NOTEBOOK: the matplotlib backend can only be selected before pylab is imported!\n",
    "# # (e.g. Kernel > Restart)\n",
    "# # \n",
    "# import matplotlib\n",
    "# matplotlib.use('svg')\n",
    "# import matplotlib.pylab as plt\n",
    "# import numpy\n",
    "# from IPython.display import Image, SVG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #\n",
    "# # Now we are using the svg backend to produce SVG vector graphics\n",
    "# #\n",
    "# fig, ax = plt.subplots()\n",
    "# t = numpy.linspace(0, 10, 100)\n",
    "# ax.plot(t, numpy.cos(t)*numpy.sin(t))\n",
    "# plt.savefig(\"test.svg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #\n",
    "# # Show the produced SVG file. \n",
    "# #\n",
    "# SVG(filename=\"test.svg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The IPython notebook inline backend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we use IPython notebook it is convenient to use a matplotlib backend that outputs the graphics embedded in the notebook file. To activate this backend, somewhere in the beginning on the notebook, we add:\n",
    "\n",
    "    %matplotlib inline\n",
    "\n",
    "It is also possible to activate inline matplotlib plotting with:\n",
    "\n",
    "    %pylab inline\n",
    "\n",
    "The difference is that `%pylab inline` imports a number of packages into the global address space (scipy, numpy), while `%matplotlib inline` only sets up inline plotting. In new notebooks created for IPython 1.0+, I would recommend using `%matplotlib inline`, since it is tidier and you have more control over which packages are imported and how. Commonly, scipy and numpy are imported separately with:\n",
    "\n",
    "    import numpy as np\n",
    "    import scipy as sp\n",
    "    import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inline backend has a number of configuration options that can be set by using the IPython magic command `%config` to update settings in `InlineBackend`. For example, we can switch to SVG figures or higher resolution figures with either:\n",
    "\n",
    "    %config InlineBackend.figure_format='svg'\n",
    "     \n",
    "or:\n",
    "\n",
    "    %config InlineBackend.figure_format='retina'\n",
    "    \n",
    "For more information, type:\n",
    "\n",
    "    %config InlineBackend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format='svg'\n",
    "\n",
    "# import matplotlib.pylab as plt\n",
    "# import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #\n",
    "# # Now we are using the SVG vector graphics displaced inline in the notebook\n",
    "# #\n",
    "# fig, ax = plt.subplots()\n",
    "# t = numpy.linspace(0, 10, 100)\n",
    "# ax.plot(t, numpy.cos(t)*numpy.sin(t))\n",
    "# plt.savefig(\"test.svg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interactive backend (this makes more sense in a python script file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #\n",
    "# # RESTART THE NOTEBOOK: the matplotlib backend can only be selected before pylab is imported!\n",
    "# # (e.g. Kernel > Restart)\n",
    "# # \n",
    "# import matplotlib\n",
    "# matplotlib.use('Qt4Agg') # or for example MacOSX\n",
    "# import matplotlib.pylab as plt\n",
    "# import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Now, open an interactive plot window with the Qt4Agg backend\n",
    "# fig, ax = plt.subplots()\n",
    "# t = np.linspace(0, 10, 100)\n",
    "# ax.plot(t, np.cos(t) * np.sin(t))\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that when we use an interactive backend, we must call `plt.show()` to make the figure appear on the screen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://www.matplotlib.org - The project web page for matplotlib.\n",
    "* https://github.com/matplotlib/matplotlib - The source code for matplotlib.\n",
    "* http://matplotlib.org/gallery.html - A large gallery showcaseing various types of plots matplotlib can create. Highly recommended! \n",
    "* http://www.loria.fr/~rougier/teaching/matplotlib - A good matplotlib tutorial.\n",
    "* http://scipy-lectures.github.io/matplotlib/matplotlib.html - Another good matplotlib reference.\n"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}