{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "***********\n",
    "Usage Guide\n",
    "***********\n",
    "\n",
    "This tutorial covers some basic usage patterns and best-practices to\n",
    "help you get started with Matplotlib.\n",
    "\n",
    "\n",
    "General Concepts\n",
    "================\n",
    "\n",
    ":mod:`matplotlib` has an extensive codebase that can be daunting to many\n",
    "new users. However, most of matplotlib can be understood with a fairly\n",
    "simple conceptual framework and knowledge of a few important points.\n",
    "\n",
    "Plotting requires action on a range of levels, from the most general\n",
    "(e.g., 'contour this 2-D array') to the most specific (e.g., 'color\n",
    "this screen pixel red'). The purpose of a plotting package is to assist\n",
    "you in visualizing your data as easily as possible, with all the necessary\n",
    "control -- that is, by using relatively high-level commands most of\n",
    "the time, and still have the ability to use the low-level commands when\n",
    "needed.\n",
    "\n",
    "Therefore, everything in matplotlib is organized in a hierarchy. At the top\n",
    "of the hierarchy is the matplotlib \"state-machine environment\" which is\n",
    "provided by the :mod:`matplotlib.pyplot` module. At this level, simple\n",
    "functions are used to add plot elements (lines, images, text, etc.) to\n",
    "the current axes in the current figure.\n",
    "\n",
    "<div class=\"alert alert-info\"><h4>Note</h4><p>Pyplot's state-machine environment behaves similarly to MATLAB and\n",
    "   should be most familiar to users with MATLAB experience.</p></div>\n",
    "\n",
    "The next level down in the hierarchy is the first level of the object-oriented\n",
    "interface, in which pyplot is used only for a few functions such as figure\n",
    "creation, and the user explicitly creates and keeps track of the figure\n",
    "and axes objects. At this level, the user uses pyplot to create figures,\n",
    "and through those figures, one or more axes objects can be created. These\n",
    "axes objects are then used for most plotting actions.\n",
    "\n",
    "For even more control -- which is essential for things like embedding\n",
    "matplotlib plots in GUI applications -- the pyplot level may be dropped\n",
    "completely, leaving a purely object-oriented approach.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sphinx_gallery_thumbnail_number = 3\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Parts of a Figure\n",
    "=================\n",
    "\n",
    "![](../../_static/anatomy.png)\n",
    "\n",
    "\n",
    "\n",
    ":class:`~matplotlib.figure.Figure`\n",
    "----------------------------------\n",
    "\n",
    "The **whole** figure.  The figure keeps\n",
    "track of all the child :class:`~matplotlib.axes.Axes`, a smattering of\n",
    "'special' artists (titles, figure legends, etc), and the **canvas**.\n",
    "(Don't worry too much about the canvas, it is crucial as it is the\n",
    "object that actually does the drawing to get you your plot, but as the\n",
    "user it is more-or-less invisible to you).  A figure can have any\n",
    "number of :class:`~matplotlib.axes.Axes`, but to be useful should have\n",
    "at least one.\n",
    "\n",
    "The easiest way to create a new figure is with pyplot:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()  # an empty figure with no axes\n",
    "fig.suptitle('No axes on this figure')  # Add a title so we know which it is\n",
    "\n",
    "fig, ax_lst = plt.subplots(2, 2)  # a figure with a 2x2 grid of Axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":class:`~matplotlib.axes.Axes`\n",
    "------------------------------\n",
    "\n",
    "This is what you think of as 'a plot', it is the region of the image\n",
    "with the data space. A given figure\n",
    "can contain many Axes, but a given :class:`~matplotlib.axes.Axes`\n",
    "object can only be in one :class:`~matplotlib.figure.Figure`.  The\n",
    "Axes contains two (or three in the case of 3D)\n",
    ":class:`~matplotlib.axis.Axis` objects (be aware of the difference\n",
    "between **Axes** and **Axis**) which take care of the data limits (the\n",
    "data limits can also be controlled via set via the\n",
    ":meth:`~matplotlib.axes.Axes.set_xlim` and\n",
    ":meth:`~matplotlib.axes.Axes.set_ylim` :class:`Axes` methods).  Each\n",
    ":class:`Axes` has a title (set via\n",
    ":meth:`~matplotlib.axes.Axes.set_title`), an x-label (set via\n",
    ":meth:`~matplotlib.axes.Axes.set_xlabel`), and a y-label set via\n",
    ":meth:`~matplotlib.axes.Axes.set_ylabel`).\n",
    "\n",
    "The :class:`Axes` class and it's member functions are the primary entry\n",
    "point to working with the OO interface.\n",
    "\n",
    ":class:`~matplotlib.axis.Axis`\n",
    "------------------------------\n",
    "\n",
    "These are the number-line-like objects. They take\n",
    "care of setting the graph limits and generating the ticks (the marks\n",
    "on the axis) and ticklabels (strings labeling the ticks).  The\n",
    "location of the ticks is determined by a\n",
    ":class:`~matplotlib.ticker.Locator` object and the ticklabel strings\n",
    "are formatted by a :class:`~matplotlib.ticker.Formatter`.  The\n",
    "combination of the correct :class:`Locator` and :class:`Formatter` gives\n",
    "very fine control over the tick locations and labels.\n",
    "\n",
    ":class:`~matplotlib.artist.Artist`\n",
    "----------------------------------\n",
    "\n",
    "Basically everything you can see on the figure is an artist (even the\n",
    ":class:`Figure`, :class:`Axes`, and :class:`Axis` objects).  This\n",
    "includes :class:`Text` objects, :class:`Line2D` objects,\n",
    ":class:`collection` objects, :class:`Patch` objects ... (you get the\n",
    "idea).  When the figure is rendered, all of the artists are drawn to\n",
    "the **canvas**.  Most Artists are tied to an Axes; such an Artist\n",
    "cannot be shared by multiple Axes, or moved from one to another.\n",
    "\n",
    "\n",
    "Types of inputs to plotting functions\n",
    "=====================================\n",
    "\n",
    "All of plotting functions expect `np.array` or `np.ma.masked_array` as\n",
    "input.  Classes that are 'array-like' such as `pandas` data objects\n",
    "and `np.matrix` may or may not work as intended.  It is best to\n",
    "convert these to `np.array` objects prior to plotting.\n",
    "\n",
    "For example, to convert a `pandas.DataFrame` ::\n",
    "\n",
    "  a = pandas.DataFrame(np.random.rand(4,5), columns = list('abcde'))\n",
    "  a_asarray = a.values\n",
    "\n",
    "and to convert a `np.matrix` ::\n",
    "\n",
    "  b = np.matrix([[1,2],[3,4]])\n",
    "  b_asarray = np.asarray(b)\n",
    "\n",
    "\n",
    "Matplotlib, pyplot and pylab: how are they related?\n",
    "====================================================\n",
    "\n",
    "Matplotlib is the whole package and :mod:`matplotlib.pyplot` is a module in\n",
    "Matplotlib.\n",
    "\n",
    "For functions in the pyplot module, there is always a \"current\" figure and\n",
    "axes (which is created automatically on request).  For example, in the\n",
    "following example, the first call to ``plt.plot`` creates the axes, then\n",
    "subsequent calls to ``plt.plot`` add additional lines on the same axes, and\n",
    "``plt.xlabel``, ``plt.ylabel``, ``plt.title`` and ``plt.legend`` set the\n",
    "axes labels and title and add a legend.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 2, 100)\n",
    "\n",
    "plt.plot(x, x, label='linear')\n",
    "plt.plot(x, x**2, label='quadratic')\n",
    "plt.plot(x, x**3, label='cubic')\n",
    "\n",
    "plt.xlabel('x label')\n",
    "plt.ylabel('y label')\n",
    "\n",
    "plt.title(\"Simple Plot\")\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":mod:`pylab` is a convenience module that bulk imports\n",
    ":mod:`matplotlib.pyplot` (for plotting) and :mod:`numpy`\n",
    "(for mathematics and working with arrays) in a single namespace.\n",
    "pylab is deprecated and its use is strongly discouraged because\n",
    "of namespace pollution. Use pyplot instead.\n",
    "\n",
    "For non-interactive plotting it is suggested\n",
    "to use pyplot to create the figures and then the OO interface for\n",
    "plotting.\n",
    "\n",
    "\n",
    "Coding Styles\n",
    "==================\n",
    "\n",
    "When viewing this documentation and examples, you will find different\n",
    "coding styles and usage patterns. These styles are perfectly valid\n",
    "and have their pros and cons. Just about all of the examples can be\n",
    "converted into another style and achieve the same results.\n",
    "The only caveat is to avoid mixing the coding styles for your own code.\n",
    "\n",
    "<div class=\"alert alert-info\"><h4>Note</h4><p>Developers for matplotlib have to follow a specific style and guidelines.\n",
    "   See `developers-guide-index`.</p></div>\n",
    "\n",
    "Of the different styles, there are two that are officially supported.\n",
    "Therefore, these are the preferred ways to use matplotlib.\n",
    "\n",
    "For the pyplot style, the imports at the top of your\n",
    "scripts will typically be::\n",
    "\n",
    "    import matplotlib.pyplot as plt\n",
    "    import numpy as np\n",
    "\n",
    "Then one calls, for example, np.arange, np.zeros, np.pi, plt.figure,\n",
    "plt.plot, plt.show, etc.  Use the pyplot interface\n",
    "for creating figures, and then use the object methods for the rest:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(0, 10, 0.2)\n",
    "y = np.sin(x)\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, why all the extra typing instead of the MATLAB-style (which relies\n",
    "on global state and a flat namespace)?  For very simple things like\n",
    "this example, the only advantage is academic: the wordier styles are\n",
    "more explicit, more clear as to where things come from and what is\n",
    "going on.  For more complicated applications, this explicitness and\n",
    "clarity becomes increasingly valuable, and the richer and more\n",
    "complete object-oriented interface will likely make the program easier\n",
    "to write and maintain.\n",
    "\n",
    "\n",
    "Typically one finds oneself making the same plots over and over\n",
    "again, but with different data sets, which leads to needing to write\n",
    "specialized functions to do the plotting.  The recommended function\n",
    "signature is something like:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f22f4154ba8>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def my_plotter(ax, data1, data2, param_dict):\n",
    "    \"\"\"\n",
    "    A helper function to make a graph\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ax : Axes\n",
    "        The axes to draw to\n",
    "\n",
    "    data1 : array\n",
    "       The x data\n",
    "\n",
    "    data2 : array\n",
    "       The y data\n",
    "\n",
    "    param_dict : dict\n",
    "       Dictionary of kwargs to pass to ax.plot\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    out : list\n",
    "        list of artists added\n",
    "    \"\"\"\n",
    "    out = ax.plot(data1, data2, **param_dict)\n",
    "    return out\n",
    "\n",
    "# which you would then use as:\n",
    "\n",
    "data1, data2, data3, data4 = np.random.randn(4, 100)\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "my_plotter(ax, data1, data2, {'marker': 'x'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or if you wanted to have 2 sub-plots:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f22f4094160>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "my_plotter(ax1, data1, data2, {'marker': 'x'})\n",
    "my_plotter(ax2, data3, data4, {'marker': 'o'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, for these simple examples this style seems like overkill, however\n",
    "once the graphs get slightly more complex it pays off.\n",
    "\n",
    "\n",
    "\n",
    "Backends\n",
    "========\n",
    "\n",
    "\n",
    "What is a backend?\n",
    "------------------\n",
    "\n",
    "A lot of documentation on the website and in the mailing lists refers\n",
    "to the \"backend\" and many new users are confused by this term.\n",
    "matplotlib targets many different use cases and output formats.  Some\n",
    "people use matplotlib interactively from the python shell and have\n",
    "plotting windows pop up when they type commands.  Some people run\n",
    "`Jupyter <https://jupyter.org>`_ notebooks and draw inline plots for\n",
    "quick data analysis. Others embed matplotlib into graphical user\n",
    "interfaces like wxpython or pygtk to build rich applications.  Some\n",
    "people use matplotlib in batch scripts to generate postscript images\n",
    "from numerical simulations, and still others run web application\n",
    "servers to dynamically serve up graphs.\n",
    "\n",
    "To support all of these use cases, matplotlib can target different\n",
    "outputs, and each of these capabilities is called a backend; the\n",
    "\"frontend\" is the user facing code, i.e., the plotting code, whereas the\n",
    "\"backend\" does all the hard work behind-the-scenes to make the figure.\n",
    "There are two types of backends: user interface backends (for use in\n",
    "pygtk, wxpython, tkinter, qt4, or macosx; also referred to as\n",
    "\"interactive backends\") and hardcopy backends to make image files\n",
    "(PNG, SVG, PDF, PS; also referred to as \"non-interactive backends\").\n",
    "\n",
    "There are four ways to configure your backend. If they conflict each other,\n",
    "the method mentioned last in the following list will be used, e.g. calling\n",
    ":func:`~matplotlib.use()` will override the setting in your ``matplotlibrc``.\n",
    "\n",
    "\n",
    "#. The ``backend`` parameter in your ``matplotlibrc`` file (see\n",
    "   :doc:`/tutorials/introductory/customizing`)::\n",
    "\n",
    "       backend : WXAgg   # use wxpython with antigrain (agg) rendering\n",
    "\n",
    "#. Setting the :envvar:`MPLBACKEND` environment variable, either for your\n",
    "   current shell or for a single script.  On Unix::\n",
    "\n",
    "        > export MPLBACKEND=module://my_backend\n",
    "        > python simple_plot.py\n",
    "\n",
    "        > MPLBACKEND=\"module://my_backend\" python simple_plot.py\n",
    "\n",
    "   On Windows, only the former is possible::\n",
    "\n",
    "        > set MPLBACKEND=module://my_backend\n",
    "        > python simple_plot.py\n",
    "\n",
    "   Setting this environment variable will override the ``backend`` parameter\n",
    "   in *any* ``matplotlibrc``, even if there is a ``matplotlibrc`` in your\n",
    "   current working directory. Therefore setting :envvar:`MPLBACKEND`\n",
    "   globally, e.g. in your ``.bashrc`` or ``.profile``, is discouraged as it\n",
    "   might lead to counter-intuitive behavior.\n",
    "\n",
    "#. If your script depends on a specific backend you can use the\n",
    "   :func:`~matplotlib.use` function::\n",
    "\n",
    "      import matplotlib\n",
    "      matplotlib.use('PS')   # generate postscript output by default\n",
    "\n",
    "   If you use the :func:`~matplotlib.use` function, this must be done before\n",
    "   importing :mod:`matplotlib.pyplot`. Calling :func:`~matplotlib.use` after\n",
    "   pyplot has been imported will have no effect.  Using\n",
    "   :func:`~matplotlib.use` will require changes in your code if users want to\n",
    "   use a different backend.  Therefore, you should avoid explicitly calling\n",
    "   :func:`~matplotlib.use` unless absolutely necessary.\n",
    "\n",
    "<div class=\"alert alert-info\"><h4>Note</h4><p>Backend name specifications are not case-sensitive; e.g., 'GTK3Agg'\n",
    "   and 'gtk3agg' are equivalent.</p></div>\n",
    "\n",
    "With a typical installation of matplotlib, such as from a\n",
    "binary installer or a linux distribution package, a good default\n",
    "backend will already be set, allowing both interactive work and\n",
    "plotting from scripts, with output to the screen and/or to\n",
    "a file, so at least initially you will not need to use any of the\n",
    "methods given above.\n",
    "\n",
    "If, however, you want to write graphical user interfaces, or a web\n",
    "application server (`howto-webapp`), or need a better\n",
    "understanding of what is going on, read on. To make things a little\n",
    "more customizable for graphical user interfaces, matplotlib separates\n",
    "the concept of the renderer (the thing that actually does the drawing)\n",
    "from the canvas (the place where the drawing goes).  The canonical\n",
    "renderer for user interfaces is ``Agg`` which uses the `Anti-Grain\n",
    "Geometry`_ C++ library to make a raster (pixel) image of the figure.\n",
    "All of the user interfaces except ``macosx`` can be used with\n",
    "agg rendering, e.g., ``WXAgg``, ``GTK3Agg``, ``QT4Agg``, ``QT5Agg``,\n",
    "``TkAgg``.  In addition, some of the user interfaces support other rendering\n",
    "engines.  For example, with GTK+ 3, you can also select Cairo rendering\n",
    "(backend ``GTK3Cairo``).\n",
    "\n",
    "For the rendering engines, one can also distinguish between `vector\n",
    "<https://en.wikipedia.org/wiki/Vector_graphics>`_ or `raster\n",
    "<https://en.wikipedia.org/wiki/Raster_graphics>`_ renderers.  Vector\n",
    "graphics languages issue drawing commands like \"draw a line from this\n",
    "point to this point\" and hence are scale free, and raster backends\n",
    "generate a pixel representation of the line whose accuracy depends on a\n",
    "DPI setting.\n",
    "\n",
    "Here is a summary of the matplotlib renderers (there is an eponymous\n",
    "backend for each; these are *non-interactive backends*, capable of\n",
    "writing to a file):\n",
    "\n",
    "=============   ============   ================================================\n",
    "Renderer        Filetypes      Description\n",
    "=============   ============   ================================================\n",
    ":term:`AGG`     :term:`png`    :term:`raster graphics` -- high quality images\n",
    "                               using the `Anti-Grain Geometry`_ engine\n",
    "PS              :term:`ps`     :term:`vector graphics` -- Postscript_ output\n",
    "                :term:`eps`\n",
    "PDF             :term:`pdf`    :term:`vector graphics` --\n",
    "                               `Portable Document Format`_\n",
    "SVG             :term:`svg`    :term:`vector graphics` --\n",
    "                               `Scalable Vector Graphics`_\n",
    ":term:`Cairo`   :term:`png`    :term:`raster graphics` and\n",
    "                :term:`ps`     :term:`vector graphics` -- using the\n",
    "                :term:`pdf`    `Cairo graphics`_ library\n",
    "                :term:`svg`\n",
    "=============   ============   ================================================\n",
    "\n",
    "And here are the user interfaces and renderer combinations supported;\n",
    "these are *interactive backends*, capable of displaying to the screen\n",
    "and of using appropriate renderers from the table above to write to\n",
    "a file:\n",
    "\n",
    "========= ================================================================\n",
    "Backend   Description\n",
    "========= ================================================================\n",
    "Qt5Agg    Agg rendering in a :term:`Qt5` canvas (requires PyQt5_).  This\n",
    "          backend can be activated in IPython with ``%matplotlib qt5``.\n",
    "ipympl    Agg rendering embedded in a Jupyter widget.  (requires ipympl).\n",
    "          This backend can be enabled in a Jupyter notebook with\n",
    "          ``%matplotlib ipympl``.\n",
    "GTK3Agg   Agg rendering to a :term:`GTK` 3.x canvas (requires PyGObject_,\n",
    "          and pycairo_ or cairocffi_).  This backend can be activated in\n",
    "          IPython with ``%matplotlib gtk3``.\n",
    "macosx    Agg rendering into a Cocoa canvas in OSX.  This backend can be\n",
    "          activated in IPython with ``%matplotlib osx``.\n",
    "TkAgg     Agg rendering to a :term:`Tk` canvas (requires TkInter_). This\n",
    "          backend can be activated in IPython with ``%matplotlib tk``.\n",
    "nbAgg     Embed an interactive figure in a Jupyter classic notebook.  This\n",
    "          backend can be enabled in Jupyter notebooks via\n",
    "          ``%matplotlib notebook``.\n",
    "WebAgg    On ``show()`` will start a tornado server with an interactive\n",
    "          figure.\n",
    "GTK3Cairo Cairo rendering to a :term:`GTK` 3.x canvas (requires PyGObject_,\n",
    "          and pycairo_ or cairocffi_).\n",
    "Qt4Agg    Agg rendering to a :term:`Qt4` canvas (requires PyQt4_ or\n",
    "          ``pyside``).  This backend can be activated in IPython with\n",
    "          ``%matplotlib qt4``.\n",
    "WXAgg     Agg rendering to a :term:`wxWidgets` canvas (requires wxPython_ 4).\n",
    "          This backend can be activated in IPython with ``%matplotlib wx``.\n",
    "========= ================================================================\n",
    "\n",
    "\n",
    "ipympl\n",
    "------\n",
    "\n",
    "The Jupyter widget ecosystem is moving too fast to support directly in\n",
    "Matplotlib.  To install ipympl\n",
    "\n",
    ".. code-block:: bash\n",
    "\n",
    "   pip install ipympl\n",
    "   jupyter nbextension enable --py --sys-prefix ipympl\n",
    "\n",
    "or\n",
    "\n",
    ".. code-block:: bash\n",
    "\n",
    "   conda install ipympl -c conda-forge\n",
    "\n",
    "See `jupyter-matplotlib <https://github.com/matplotlib/jupyter-matplotlib>`__\n",
    "for more details.\n",
    "\n",
    "GTK and Cairo\n",
    "-------------\n",
    "\n",
    "`GTK3` backends (*both* `GTK3Agg` and `GTK3Cairo`) depend on Cairo\n",
    "(pycairo>=1.11.0 or cairocffi).\n",
    "\n",
    "How do I select PyQt4 or PySide?\n",
    "--------------------------------\n",
    "\n",
    "The `QT_API` environment variable can be set to either `pyqt` or `pyside`\n",
    "to use `PyQt4` or `PySide`, respectively.\n",
    "\n",
    "Since the default value for the bindings to be used is `PyQt4`,\n",
    ":mod:`matplotlib` first tries to import it, if the import fails, it tries to\n",
    "import `PySide`.\n",
    "\n",
    "\n",
    "What is interactive mode?\n",
    "===================================\n",
    "\n",
    "Use of an interactive backend (see `what-is-a-backend`)\n",
    "permits--but does not by itself require or ensure--plotting\n",
    "to the screen.  Whether and when plotting to the screen occurs,\n",
    "and whether a script or shell session continues after a plot\n",
    "is drawn on the screen, depends on the functions and methods\n",
    "that are called, and on a state variable that determines whether\n",
    "matplotlib is in \"interactive mode\".  The default Boolean value is set\n",
    "by the :file:`matplotlibrc` file, and may be customized like any other\n",
    "configuration parameter (see :doc:`/tutorials/introductory/customizing`).  It\n",
    "may also be set via :func:`matplotlib.interactive`, and its\n",
    "value may be queried via :func:`matplotlib.is_interactive`.  Turning\n",
    "interactive mode on and off in the middle of a stream of plotting\n",
    "commands, whether in a script or in a shell, is rarely needed\n",
    "and potentially confusing, so in the following we will assume all\n",
    "plotting is done with interactive mode either on or off.\n",
    "\n",
    "<div class=\"alert alert-info\"><h4>Note</h4><p>Major changes related to interactivity, and in particular the\n",
    "   role and behavior of :func:`~matplotlib.pyplot.show`, were made in the\n",
    "   transition to matplotlib version 1.0, and bugs were fixed in\n",
    "   1.0.1.  Here we describe the version 1.0.1 behavior for the\n",
    "   primary interactive backends, with the partial exception of\n",
    "   *macosx*.</p></div>\n",
    "\n",
    "Interactive mode may also be turned on via :func:`matplotlib.pyplot.ion`,\n",
    "and turned off via :func:`matplotlib.pyplot.ioff`.\n",
    "\n",
    "<div class=\"alert alert-info\"><h4>Note</h4><p>Interactive mode works with suitable backends in ipython and in\n",
    "   the ordinary python shell, but it does *not* work in the IDLE IDE.\n",
    "   If the default backend does not support interactivity, an interactive\n",
    "   backend can be explicitly activated using any of the methods discussed in `What is a backend?`_.</p></div>\n",
    "\n",
    "\n",
    "Interactive example\n",
    "--------------------\n",
    "\n",
    "From an ordinary python prompt, or after invoking ipython with no options,\n",
    "try this::\n",
    "\n",
    "    import matplotlib.pyplot as plt\n",
    "    plt.ion()\n",
    "    plt.plot([1.6, 2.7])\n",
    "\n",
    "Assuming you are running version 1.0.1 or higher, and you have\n",
    "an interactive backend installed and selected by default, you should\n",
    "see a plot, and your terminal prompt should also be active; you\n",
    "can type additional commands such as::\n",
    "\n",
    "    plt.title(\"interactive test\")\n",
    "    plt.xlabel(\"index\")\n",
    "\n",
    "and you will see the plot being updated after each line.  Since version 1.5,\n",
    "modifying the plot by other means *should* also automatically\n",
    "update the display on most backends. Get a reference to the :class:`~matplotlib.axes.Axes` instance,\n",
    "and call a method of that instance::\n",
    "\n",
    "    ax = plt.gca()\n",
    "    ax.plot([3.1, 2.2])\n",
    "\n",
    "If you are using certain backends (like `macosx`), or an older version\n",
    "of matplotlib, you may not see the new line added to the plot immediately.\n",
    "In this case, you need to explicitly call :func:`~matplotlib.pyplot.draw`\n",
    "in order to update the plot::\n",
    "\n",
    "    plt.draw()\n",
    "\n",
    "\n",
    "Non-interactive example\n",
    "-----------------------\n",
    "\n",
    "Start a fresh session as in the previous example, but now\n",
    "turn interactive mode off::\n",
    "\n",
    "    import matplotlib.pyplot as plt\n",
    "    plt.ioff()\n",
    "    plt.plot([1.6, 2.7])\n",
    "\n",
    "Nothing happened--or at least nothing has shown up on the\n",
    "screen (unless you are using *macosx* backend, which is\n",
    "anomalous).  To make the plot appear, you need to do this::\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "Now you see the plot, but your terminal command line is\n",
    "unresponsive; the :func:`show()` command *blocks* the input\n",
    "of additional commands until you manually kill the plot\n",
    "window.\n",
    "\n",
    "What good is this--being forced to use a blocking function?\n",
    "Suppose you need a script that plots the contents of a file\n",
    "to the screen.  You want to look at that plot, and then end\n",
    "the script.  Without some blocking command such as show(), the\n",
    "script would flash up the plot and then end immediately,\n",
    "leaving nothing on the screen.\n",
    "\n",
    "In addition, non-interactive mode delays all drawing until\n",
    "show() is called; this is more efficient than redrawing\n",
    "the plot each time a line in the script adds a new feature.\n",
    "\n",
    "Prior to version 1.0, show() generally could not be called\n",
    "more than once in a single script (although sometimes one\n",
    "could get away with it); for version 1.0.1 and above, this\n",
    "restriction is lifted, so one can write a script like this::\n",
    "\n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "    plt.ioff()\n",
    "    for i in range(3):\n",
    "        plt.plot(np.random.rand(10))\n",
    "        plt.show()\n",
    "\n",
    "which makes three plots, one at a time. I.e. the second plot will show up,\n",
    "once the first plot is closed.\n",
    "\n",
    "Summary\n",
    "-------\n",
    "\n",
    "In interactive mode, pyplot functions automatically draw\n",
    "to the screen.\n",
    "\n",
    "When plotting interactively, if using\n",
    "object method calls in addition to pyplot functions, then\n",
    "call :func:`~matplotlib.pyplot.draw` whenever you want to\n",
    "refresh the plot.\n",
    "\n",
    "Use non-interactive mode in scripts in which you want to\n",
    "generate one or more figures and display them before ending\n",
    "or generating a new set of figures.  In that case, use\n",
    ":func:`~matplotlib.pyplot.show` to display the figure(s) and\n",
    "to block execution until you have manually destroyed them.\n",
    "\n",
    "\n",
    "Performance\n",
    "===========\n",
    "\n",
    "Whether exploring data in interactive mode or programmatically\n",
    "saving lots of plots, rendering performance can be a painful\n",
    "bottleneck in your pipeline. Matplotlib provides a couple\n",
    "ways to greatly reduce rendering time at the cost of a slight\n",
    "change (to a settable tolerance) in your plot's appearance.\n",
    "The methods available to reduce rendering time depend on the\n",
    "type of plot that is being created.\n",
    "\n",
    "Line segment simplification\n",
    "---------------------------\n",
    "\n",
    "For plots that have line segments (e.g. typical line plots,\n",
    "outlines of polygons, etc.), rendering performance can be\n",
    "controlled by the ``path.simplify`` and\n",
    "``path.simplify_threshold`` parameters in your\n",
    "``matplotlibrc`` file (see\n",
    ":doc:`/tutorials/introductory/customizing` for\n",
    "more information about the ``matplotlibrc`` file).\n",
    "The ``path.simplify`` parameter is a boolean indicating whether\n",
    "or not line segments are simplified at all. The\n",
    "``path.simplify_threshold`` parameter controls how much line\n",
    "segments are simplified; higher thresholds result in quicker\n",
    "rendering.\n",
    "\n",
    "The following script will first display the data without any\n",
    "simplification, and then display the same data with simplification.\n",
    "Try interacting with both of them::\n",
    "\n",
    "  import numpy as np\n",
    "  import matplotlib.pyplot as plt\n",
    "  import matplotlib as mpl\n",
    "\n",
    "  # Setup, and create the data to plot\n",
    "  y = np.random.rand(100000)\n",
    "  y[50000:] *= 2\n",
    "  y[np.logspace(1, np.log10(50000), 400).astype(int)] = -1\n",
    "  mpl.rcParams['path.simplify'] = True\n",
    "\n",
    "  mpl.rcParams['path.simplify_threshold'] = 0.0\n",
    "  plt.plot(y)\n",
    "  plt.show()\n",
    "\n",
    "  mpl.rcParams['path.simplify_threshold'] = 1.0\n",
    "  plt.plot(y)\n",
    "  plt.show()\n",
    "\n",
    "Matplotlib currently defaults to a conservative simplification\n",
    "threshold of ``1/9``. If you want to change your default settings\n",
    "to use a different value, you can change your ``matplotlibrc``\n",
    "file.  Alternatively, you could create a new style for\n",
    "interactive plotting (with maximal simplification) and another\n",
    "style for publication quality plotting (with minimal\n",
    "simplification) and activate them as necessary. See\n",
    ":doc:`/tutorials/introductory/customizing` for\n",
    "instructions on how to perform these actions.\n",
    "\n",
    "The simplification works by iteratively merging line segments\n",
    "into a single vector until the next line segment's perpendicular\n",
    "distance to the vector (measured in display-coordinate space)\n",
    "is greater than the ``path.simplify_threshold`` parameter.\n",
    "\n",
    "<div class=\"alert alert-info\"><h4>Note</h4><p>Changes related to how line segments are simplified were made\n",
    "  in version 2.1. Rendering time will still be improved by these\n",
    "  parameters prior to 2.1, but rendering time for some kinds of\n",
    "  data will be vastly improved in versions 2.1 and greater.</p></div>\n",
    "\n",
    "Marker simplification\n",
    "---------------------\n",
    "\n",
    "Markers can also be simplified, albeit less robustly than\n",
    "line segments. Marker simplification is only available\n",
    "to :class:`~matplotlib.lines.Line2D` objects (through the\n",
    "``markevery`` property). Wherever\n",
    ":class:`~matplotlib.lines.Line2D` construction parameter\n",
    "are passed through, such as\n",
    ":func:`matplotlib.pyplot.plot` and\n",
    ":meth:`matplotlib.axes.Axes.plot`, the ``markevery``\n",
    "parameter can be used::\n",
    "\n",
    "  plt.plot(x, y, markevery=10)\n",
    "\n",
    "The markevery argument allows for naive subsampling, or an\n",
    "attempt at evenly spaced (along the *x* axis) sampling. See the\n",
    ":doc:`/gallery/lines_bars_and_markers/markevery_demo`\n",
    "for more information.\n",
    "\n",
    "Splitting lines into smaller chunks\n",
    "-----------------------------------\n",
    "\n",
    "If you are using the Agg backend (see `what-is-a-backend`),\n",
    "then you can make use of the ``agg.path.chunksize`` rc parameter.\n",
    "This allows you to specify a chunk size, and any lines with\n",
    "greater than that many vertices will be split into multiple\n",
    "lines, each of which have no more than ``agg.path.chunksize``\n",
    "many vertices. (Unless ``agg.path.chunksize`` is zero, in\n",
    "which case there is no chunking.) For some kind of data,\n",
    "chunking the line up into reasonable sizes can greatly\n",
    "decrease rendering time.\n",
    "\n",
    "The following script will first display the data without any\n",
    "chunk size restriction, and then display the same data with\n",
    "a chunk size of 10,000. The difference can best be seen when\n",
    "the figures are large, try maximizing the GUI and then\n",
    "interacting with them::\n",
    "\n",
    "  import numpy as np\n",
    "  import matplotlib.pyplot as plt\n",
    "  import matplotlib as mpl\n",
    "  mpl.rcParams['path.simplify_threshold'] = 1.0\n",
    "\n",
    "  # Setup, and create the data to plot\n",
    "  y = np.random.rand(100000)\n",
    "  y[50000:] *= 2\n",
    "  y[np.logspace(1,np.log10(50000), 400).astype(int)] = -1\n",
    "  mpl.rcParams['path.simplify'] = True\n",
    "\n",
    "  mpl.rcParams['agg.path.chunksize'] = 0\n",
    "  plt.plot(y)\n",
    "  plt.show()\n",
    "\n",
    "  mpl.rcParams['agg.path.chunksize'] = 10000\n",
    "  plt.plot(y)\n",
    "  plt.show()\n",
    "\n",
    "Legends\n",
    "-------\n",
    "\n",
    "The default legend behavior for axes attempts to find the location\n",
    "that covers the fewest data points (`loc='best'`). This can be a\n",
    "very expensive computation if there are lots of data points. In\n",
    "this case, you may want to provide a specific location.\n",
    "\n",
    "Using the *fast* style\n",
    "----------------------\n",
    "\n",
    "The *fast* style can be used to automatically set\n",
    "simplification and chunking parameters to reasonable\n",
    "settings to speed up plotting large amounts of data.\n",
    "It can be used simply by running::\n",
    "\n",
    "  import matplotlib.style as mplstyle\n",
    "  mplstyle.use('fast')\n",
    "\n",
    "It is very light weight, so it plays nicely with other\n",
    "styles, just make sure the fast style is applied last\n",
    "so that other styles do not overwrite the settings::\n",
    "\n",
    "  mplstyle.use(['dark_background', 'ggplot', 'fast'])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}