Cal3-PythonGraphes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<a href=\"http://www.insa-toulouse.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/logo-insa.jpg\" style=\"float:left; max-width: 120px; display: inline\" alt=\"INSA\"/></a> \n",
    "\n",
    "<a href=\"http://wikistat.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/wikistat.jpg\" style=\"float:right; max-width: 250px; display: inline\"  alt=\"Wikistat\"/></a>\n",
    "\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a href=\"https://www.python.org/\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/390px-Python_logo_and_wordmark.svg.png\" style=\"max-width: 200px; display: inline\" alt=\"Python\"/></a> [pour Statistique et Science des Données](https://github.com/wikistat/Intro-Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graphes  2D et 3D en <a href=\"https://www.python.org/\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/390px-Python_logo_and_wordmark.svg.png\" style=\"max-width: 200px; display: inline\" alt=\"Python\"/></a> <a href=\"http://matplotlib.org/\"><img src=\"http://matplotlib.org/_static/logo2.svg\" style=\"max-width: 200px; display: inline\" alt=\"matplotlib\"/> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce calepin est une version simplifée de celui développé par J.R. Johansson. D'autres calepins du même auteur sont accessibles [ici](http://jrjohansson.github.io)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important** la commande ci-dessous provoque l'insertion des gaphiques dans le calepin plutôt que l'ouverture de nouvelles fenêtres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Introduction\n",
    "### 1.1 Principe\n",
    "\n",
    "Matplotlib est une librairie pour des graphes 2D et 3D, \n",
    "* facile à utiliser,\n",
    "* intègrant des formats $\\LaTeX$ pour les libellés,\n",
    "* contrôlant tous les éléments d'une figure, \n",
    "* supportant tous le sformats png, pdf, eps..\n",
    "Plus d'information sur la [page de Matplotlib](http://matplotlib.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour démarrer avec Matplotlib dans un programme Python, inclure les objets du module `pylab`. Plus facile:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from pylab import * "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou importer le module `matplotlib.pyplot` avec l'identifiant `plt`. Plus correct pour éviter de charger tous les objets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 MATLAB-like API\n",
    "\n",
    "La façon la plus simple d'utiliser matplotlib est de le faire par l'API de type MATLAB compatible avec les fonctions graphique de MATLAB. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from pylab import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example élémentaire d'utilisation de l'API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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('titre')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La plupart des fonctions MATLAB sont incluses dans `pylab`."
   ]
  },
  {
   "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*-');\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette API est limitée à des graphes rudimentaires. Les fonctionalités orientées objet de Matplotlib sont à privilégier pour des graphes plus élaborées. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Matplotlib orienté objet\n",
    "### 2.1 Syntaxe de base"
   ]
  },
  {
   "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');\n",
    "show()"
   ]
  },
  {
   "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');\n",
    "show;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't care about being explicit about where our plot axes are placed in the figure canvas, then we can use one of the many axis layout managers in matplotlib. My favorite is `subplots`, which can be used like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots()\n",
    "\n",
    "axes.plot(x, y, 'r')\n",
    "axes.set_xlabel('x')\n",
    "axes.set_ylabel('y')\n",
    "axes.set_title('title');\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "for ax in axes:\n",
    "    ax.plot(x, y, 'r')\n",
    "    ax.set_xlabel('x')\n",
    "    ax.set_ylabel('y')\n",
    "    ax.set_title('title')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was easy, but it isn't so pretty with overlapping figure axes and labels, right?\n",
    "\n",
    "We can deal with that by using the `fig.tight_layout` method, which automatically adjusts the positions of the axes on the figure canvas so that there is no overlapping content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "for ax in axes:\n",
    "    ax.plot(x, y, 'r')\n",
    "    ax.set_xlabel('x')\n",
    "    ax.set_ylabel('y')\n",
    "    ax.set_title('title')\n",
    "    \n",
    "fig.tight_layout()\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Tailles et proportions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib allows the aspect ratio, DPI and figure size to be specified when the `Figure` object is created, using the `figsize` and `dpi` keyword arguments. `figsize` is a tuple of the width and height of the figure in inches, and `dpi` is the dots-per-inch (pixel per inch). To create an 800x400 pixel, 100 dots-per-inch figure, we can do: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(8,4), dpi=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same arguments can also be passed to layout managers, such as the `subplots` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(figsize=(12,3))\n",
    "\n",
    "axes.plot(x, y, 'r')\n",
    "axes.set_xlabel('x')\n",
    "axes.set_ylabel('y')\n",
    "axes.set_title('title');\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Sauver les 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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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": [
    "### 2.4 Légendes, libellés et titres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have covered the basics of how to create a figure canvas and add axes instances to the canvas, let's look at how decorate a figure with titles, axis labels, and legends."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Titres**\n",
    "\n",
    "A title can be added to each axis instance in a figure. To set the title, use the `set_title` method in the axes instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ax.set_title(\"title\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Libellés des axes**\n",
    "\n",
    "Similarly, with the methods `set_xlabel` and `set_ylabel`, we can set the labels of the X and Y axes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ax.set_xlabel(\"x\")\n",
    "ax.set_ylabel(\"y\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Légendes**\n",
    "\n",
    "Legends for curves in a figure can be added in two ways. One method is to use the `legend` method of the axis object and pass a list/tuple of legend texts for the previously defined curves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ax.legend([\"curve1\", \"curve2\", \"curve3\"]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method described above follows the MATLAB API. It is somewhat prone to errors and unflexible if curves are added to or removed from the figure (resulting in a wrongly labelled curve).\n",
    "\n",
    "A better method is to use the `label=\"label text\"` keyword argument when plots or other objects are added to the figure, and then using the `legend` method without arguments to add the legend to the figure: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ax.plot(x, x**2, label=\"curve1\")\n",
    "ax.plot(x, x**3, label=\"curve2\")\n",
    "ax.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage with this method is that if curves are added or removed from the figure, the legend is automatically updated accordingly.\n",
    "\n",
    "The `legend` function takes an optional keyword argument `loc` that can be used to specify where in the figure the legend is to be drawn. The allowed values of `loc` are numerical codes for the various places the legend can be drawn. See http://matplotlib.org/users/legend_guide.html#legend-location for details. Some of the most common `loc` values are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax.legend(loc=0) # let matplotlib decide the optimal location\n",
    "ax.legend(loc=1) # upper right corner\n",
    "ax.legend(loc=2) # upper left corner\n",
    "ax.legend(loc=3) # lower left corner\n",
    "ax.legend(loc=4) # lower right corner\n",
    "# .. many more options are available"
   ]
  },
  {
   "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');\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Formattage des textes: LaTeX et fontes"
   ]
  },
  {
   "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');\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also change the global font size and font family, which applies to all text elements in a figure (tick labels, axis labels and titles, legends, etc.):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Update the matplotlib configuration parameters:\n",
    "matplotlib.rcParams.update({'font.size': 18, 'font.family': 'serif'})"
   ]
  },
  {
   "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$')\n",
    "ax.set_ylabel(r'$y$')\n",
    "ax.set_title('title');\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A good choice of global fonts are the STIX fonts: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Update the matplotlib configuration parameters:\n",
    "matplotlib.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'})"
   ]
  },
  {
   "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$')\n",
    "ax.set_ylabel(r'$y$')\n",
    "ax.set_title('title');\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, alternatively, we can request that matplotlib uses LaTeX to render the text elements in the figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "matplotlib.rcParams.update({'font.size': 18, 'text.usetex': True})"
   ]
  },
  {
   "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$')\n",
    "ax.set_ylabel(r'$y$')\n",
    "ax.set_title('title');\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# restore\n",
    "matplotlib.rcParams.update({'font.size': 12, 'font.family': 'sans', 'text.usetex': False})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Couleurs, largeur et types de lignes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With matplotlib, we can define the colors of lines and other graphical elements in a number of ways. First of all, we can use the MATLAB-like syntax where `'b'` means blue, `'g'` means green, etc. The MATLAB API for selecting line styles are also supported: where, for example, 'b.-' means a blue line with dots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MATLAB style line color and style \n",
    "ax.plot(x, x**2, 'b.-') # blue line with dots\n",
    "ax.plot(x, x**3, 'g--') # green dashed line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define colors by their names or RGB hex codes and optionally provide an alpha value using the `color` and `alpha` keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(x, x+1, color=\"red\", alpha=0.5) # half-transparant red\n",
    "ax.plot(x, x+2, color=\"#1155dd\")        # RGB hex code for a bluish color\n",
    "ax.plot(x, x+3, color=\"#15cc55\")        # RGB hex code for a greenish color\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Line and marker styles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change the line width, we can use the `linewidth` or `lw` keyword argument. The line style can be selected using the `linestyle` or `ls` keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(12,6))\n",
    "\n",
    "ax.plot(x, x+1, color=\"blue\", linewidth=0.25)\n",
    "ax.plot(x, x+2, color=\"blue\", linewidth=0.50)\n",
    "ax.plot(x, x+3, color=\"blue\", linewidth=1.00)\n",
    "ax.plot(x, x+4, color=\"blue\", linewidth=2.00)\n",
    "\n",
    "# possible linestype options ‘-‘, ‘--’, ‘-.’, ‘:’, ‘steps’\n",
    "ax.plot(x, x+5, color=\"red\", lw=2, linestyle='-')\n",
    "ax.plot(x, x+6, color=\"red\", lw=2, ls='-.')\n",
    "ax.plot(x, x+7, color=\"red\", lw=2, ls=':')\n",
    "\n",
    "# custom dash\n",
    "line, = ax.plot(x, x+8, color=\"black\", lw=1.50)\n",
    "line.set_dashes([5, 10, 15, 10]) # format: line length, space length, ...\n",
    "\n",
    "# possible marker symbols: marker = '+', 'o', '*', 's', ',', '.', '1', '2', '3', '4', ...\n",
    "ax.plot(x, x+ 9, color=\"green\", lw=2, ls='--', marker='+')\n",
    "ax.plot(x, x+10, color=\"green\", lw=2, ls='--', marker='o')\n",
    "ax.plot(x, x+11, color=\"green\", lw=2, ls='--', marker='s')\n",
    "ax.plot(x, x+12, color=\"green\", lw=2, ls='--', marker='1')\n",
    "\n",
    "# marker size and color\n",
    "ax.plot(x, x+13, color=\"purple\", lw=1, ls='-', marker='o', markersize=2)\n",
    "ax.plot(x, x+14, color=\"purple\", lw=1, ls='-', marker='o', markersize=4)\n",
    "ax.plot(x, x+15, color=\"purple\", lw=1, ls='-', marker='o', markersize=8, markerfacecolor=\"red\")\n",
    "ax.plot(x, x+16, color=\"purple\", lw=1, ls='-', marker='s', markersize=8, \n",
    "        markerfacecolor=\"yellow\", markeredgewidth=2, markeredgecolor=\"blue\");\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.7 Contrôle des axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The appearance of the axes is an important aspect of a figure that we often need to modify to make a publication quality graphics. We need to be able to control where the ticks and labels are placed, modify the font size and possibly the labels used on the axes. In this section we will look at controling those properties in a matplotlib figure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing we might want to configure is the ranges of the axes. We can do this using the `set_ylim` and `set_xlim` methods in the axis object, or `axis('tight')` for automatrically getting \"tightly fitted\" axes ranges:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 3, figsize=(12, 4))\n",
    "\n",
    "axes[0].plot(x, x**2, x, x**3)\n",
    "axes[0].set_title(\"default axes ranges\")\n",
    "\n",
    "axes[1].plot(x, x**2, x, x**3)\n",
    "axes[1].axis('tight')\n",
    "axes[1].set_title(\"tight axes\")\n",
    "\n",
    "axes[2].plot(x, x**2, x, x**3)\n",
    "axes[2].set_ylim([0, 60])\n",
    "axes[2].set_xlim([2, 5])\n",
    "axes[2].set_title(\"custom axes range\");\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logarithmic scale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to set a logarithmic scale for one or both axes. This functionality is in fact only one application of a more general transformation system in Matplotlib. Each of the axes' scales are set seperately using `set_xscale` and `set_yscale` methods which accept one parameter (with the value \"log\" in this case):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(10,4))\n",
    "      \n",
    "axes[0].plot(x, x**2, x, np.exp(x))\n",
    "axes[0].set_title(\"Normal scale\")\n",
    "\n",
    "axes[1].plot(x, x**2, x, np.exp(x))\n",
    "axes[1].set_yscale(\"log\")\n",
    "axes[1].set_title(\"Logarithmic scale (y)\");\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.8 Placement des échelles et libellés"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can explicitly determine where we want the axis ticks with `set_xticks` and `set_yticks`, which both take a list of values for where on the axis the ticks are to be placed. We can also use the `set_xticklabels` and `set_yticklabels` methods to provide a list of custom text labels for each tick location:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 4))\n",
    "\n",
    "ax.plot(x, x**2, x, x**3, lw=2)\n",
    "\n",
    "ax.set_xticks([1, 2, 3, 4, 5])\n",
    "ax.set_xticklabels([r'$\\alpha$', r'$\\beta$', r'$\\gamma$', r'$\\delta$', r'$\\epsilon$'], fontsize=18)\n",
    "\n",
    "yticks = [0, 50, 100, 150]\n",
    "ax.set_yticks(yticks)\n",
    "ax.set_yticklabels([\"$%.1f$\" % y for y in yticks], fontsize=18); # use LaTeX formatted labels\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of more advanced methods for controlling major and minor tick placement in matplotlib figures, such as automatic placement according to different policies. See http://matplotlib.org/api/ticker_api.html for details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scientific notation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With large numbers on axes, it is often better use scientific notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 1)\n",
    "      \n",
    "ax.plot(x, x**2, x, np.exp(x))\n",
    "ax.set_title(\"scientific notation\")\n",
    "\n",
    "ax.set_yticks([0, 50, 100, 150])\n",
    "\n",
    "from matplotlib import ticker\n",
    "formatter = ticker.ScalarFormatter(useMathText=True)\n",
    "formatter.set_scientific(True) \n",
    "formatter.set_powerlimits((-1,1)) \n",
    "ax.yaxis.set_major_formatter(formatter) \n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.9 Formattage des espaces sur les axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# distance between x and y axis and the numbers on the axes\n",
    "matplotlib.rcParams['xtick.major.pad'] = 5\n",
    "matplotlib.rcParams['ytick.major.pad'] = 5\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "      \n",
    "ax.plot(x, x**2, x, np.exp(x))\n",
    "ax.set_yticks([0, 50, 100, 150])\n",
    "\n",
    "ax.set_title(\"label and axis spacing\")\n",
    "\n",
    "# padding between axis label and axis numbers\n",
    "ax.xaxis.labelpad = 5\n",
    "ax.yaxis.labelpad = 5\n",
    "\n",
    "ax.set_xlabel(\"x\")\n",
    "ax.set_ylabel(\"y\");\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# restore defaults\n",
    "matplotlib.rcParams['xtick.major.pad'] = 3\n",
    "matplotlib.rcParams['ytick.major.pad'] = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Axis position adjustments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, when saving figures the labels are sometimes clipped, and it can be necessary to adjust the positions of axes a little bit. This can be done using `subplots_adjust`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 1)\n",
    "      \n",
    "ax.plot(x, x**2, x, np.exp(x))\n",
    "ax.set_yticks([0, 50, 100, 150])\n",
    "\n",
    "ax.set_title(\"title\")\n",
    "ax.set_xlabel(\"x\")\n",
    "ax.set_ylabel(\"y\")\n",
    "\n",
    "fig.subplots_adjust(left=0.15, right=.9, bottom=0.1, top=0.9);\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.10 Grille"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the `grid` method in the axis object, we can turn on and off grid lines. We can also customize the appearance of the grid lines using the same keyword arguments as the `plot` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(10,3))\n",
    "\n",
    "# default grid appearance\n",
    "axes[0].plot(x, x**2, x, x**3, lw=2)\n",
    "axes[0].grid(True)\n",
    "\n",
    "# custom grid appearance\n",
    "axes[1].plot(x, x**2, x, x**3, lw=2)\n",
    "axes[1].grid(color='b', alpha=0.5, linestyle='dashed', linewidth=0.5)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.11 Double graphique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it is useful to have dual x or y axes in a figure; for example, when plotting curves with different units together. Matplotlib supports this with the `twinx` and `twiny` functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax1 = plt.subplots()\n",
    "\n",
    "ax1.plot(x, x**2, lw=2, color=\"blue\")\n",
    "ax1.set_ylabel(r\"area $(m^2)$\", fontsize=18, color=\"blue\")\n",
    "for label in ax1.get_yticklabels():\n",
    "    label.set_color(\"blue\")\n",
    "    \n",
    "ax2 = ax1.twinx()\n",
    "ax2.plot(x, x**3, lw=2, color=\"red\")\n",
    "ax2.set_ylabel(r\"volume $(m^3)$\", fontsize=18, color=\"red\")\n",
    "for label in ax2.get_yticklabels():\n",
    "    label.set_color(\"red\")\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.12 Axes centrés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.spines['right'].set_color('none')\n",
    "ax.spines['top'].set_color('none')\n",
    "\n",
    "ax.xaxis.set_ticks_position('bottom')\n",
    "ax.spines['bottom'].set_position(('data',0)) # set position of x spine to x=0\n",
    "\n",
    "ax.yaxis.set_ticks_position('left')\n",
    "ax.spines['left'].set_position(('data',0))   # set position of y spine to y=0\n",
    "\n",
    "xx = np.linspace(-0.75, 1., 100)\n",
    "ax.plot(xx, xx**3);\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.13 Autres graphes 2D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the regular `plot` method, there are a number of other functions for generating different kind of plots. See the matplotlib plot gallery for a complete list of available plot types: http://matplotlib.org/gallery.html. Some of the more useful ones are show below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = np.array([0,1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 4, figsize=(12,3))\n",
    "\n",
    "axes[0].scatter(xx, xx + 0.25*np.random.randn(len(xx)))\n",
    "axes[0].set_title(\"scatter\")\n",
    "\n",
    "axes[1].step(n, n**2, lw=2)\n",
    "axes[1].set_title(\"step\")\n",
    "\n",
    "axes[2].bar(n, n**2, align=\"center\", width=0.5, alpha=0.5)\n",
    "axes[2].set_title(\"bar\")\n",
    "\n",
    "axes[3].fill_between(x, x**2, x**3, color=\"green\", alpha=0.5);\n",
    "axes[3].set_title(\"fill_between\");\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# polar plot using add_axes and polar projection\n",
    "fig = plt.figure()\n",
    "ax = fig.add_axes([0.0, 0.0, .6, .6], polar=True)\n",
    "t = np.linspace(0, 2 * np.pi, 100)\n",
    "ax.plot(t, t, color='blue', lw=3);\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A histogram\n",
    "n = np.random.randn(100000)\n",
    "fig, axes = plt.subplots(1, 2, figsize=(12,4))\n",
    "\n",
    "axes[0].hist(n)\n",
    "axes[0].set_title(\"Default histogram\")\n",
    "axes[0].set_xlim((min(n), max(n)))\n",
    "\n",
    "axes[1].hist(n, cumulative=True, bins=50)\n",
    "axes[1].set_title(\"Cumulative detailed histogram\")\n",
    "axes[1].set_xlim((min(n), max(n)));\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.14 Textes d'annotation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Annotating text in matplotlib figures can be done using the `text` function. It supports LaTeX formatting just like axis label texts and titles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(xx, xx**2, xx, xx**3)\n",
    "\n",
    "ax.text(0.15, 0.2, r\"$y=x^2$\", fontsize=20, color=\"blue\")\n",
    "ax.text(0.65, 0.1, r\"$y=x^3$\", fontsize=20, color=\"green\");\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.15 Figures avec sous graphes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Axes can be added to a matplotlib Figure canvas manually using `fig.add_axes` or using a sub-figure layout manager such as `subplots`, `subplot2grid`, or `gridspec`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(2, 3)\n",
    "fig.tight_layout()\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### subplot2grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = plt.subplot2grid((3,3), (0,0), colspan=3)\n",
    "ax2 = plt.subplot2grid((3,3), (1,0), colspan=2)\n",
    "ax3 = plt.subplot2grid((3,3), (1,2), rowspan=2)\n",
    "ax4 = plt.subplot2grid((3,3), (2,0))\n",
    "ax5 = plt.subplot2grid((3,3), (2,1))\n",
    "fig.tight_layout()\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### gridspec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "\n",
    "gs = gridspec.GridSpec(2, 3, height_ratios=[2,1], width_ratios=[1,2,1])\n",
    "for g in gs:\n",
    "    ax = fig.add_subplot(g)\n",
    "    \n",
    "fig.tight_layout()\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### add_axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Manually adding axes with `add_axes` is useful for adding insets to figures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(xx, xx**2, xx, xx**3)\n",
    "fig.tight_layout()\n",
    "\n",
    "# inset\n",
    "inset_ax = fig.add_axes([0.2, 0.55, 0.35, 0.35]) # X, Y, width, height\n",
    "\n",
    "inset_ax.plot(xx, xx**2, xx, xx**3)\n",
    "inset_ax.set_title('zoom near origin')\n",
    "\n",
    "# set axis range\n",
    "inset_ax.set_xlim(-.2, .2)\n",
    "inset_ax.set_ylim(-.005, .01)\n",
    "\n",
    "# set axis tick locations\n",
    "inset_ax.set_yticks([0, 0.005, 0.01])\n",
    "inset_ax.set_xticks([-0.1,0,.1]);\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.16 Graphes de contour"
   ]
  },
  {
   "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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)\n",
    "show()"
   ]
  },
  {
   "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)\n",
    "show()"
   ]
  },
  {
   "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])\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 graphes 3D "
   ]
  },
  {
   "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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mpl_toolkits.mplot3d.axes3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1  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)\n",
    "show()"
   ]
  },
  {
   "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)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 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);\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Change the view angle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the perspective of a 3D plot using the `view_init` method, which takes two arguments: `elevation` and `azimuth` angle (in degrees):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12,6))\n",
    "\n",
    "ax = fig.add_subplot(1,2,1, projection='3d')\n",
    "ax.plot_surface(X, Y, Z, rstride=4, cstride=4, alpha=0.25)\n",
    "ax.view_init(30, 45)\n",
    "\n",
    "ax = fig.add_subplot(1,2,2, projection='3d')\n",
    "ax.plot_surface(X, Y, Z, rstride=4, cstride=4, alpha=0.25)\n",
    "ax.view_init(70, 30)\n",
    "\n",
    "fig.tight_layout()\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Compléments"
   ]
  },
  {
   "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": {
  "hide_input": false,
  "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.6"
  },
  "toc": {
   "nav_menu": {
    "height": "512px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}