C2_Week2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Plotting with matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can show matplotlib figures directly in the notebook by using the `%matplotlib notebook` and `%matplotlib inline` magic commands. \n",
    "\n",
    "`%matplotlib notebook` provides an interactive environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#下一行：如果用这行，下面会提示 Javascript Error: IPython is not defined\n",
    "#%matplotlib notebook \n",
    "%matplotlib inline\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'module://ipykernel.pylab.backend_inline'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "mpl.get_backend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Plot y versus x as lines and/or markers.\n",
       "\n",
       "Call signatures::\n",
       "\n",
       "    plot([x], y, [fmt], data=None, **kwargs)\n",
       "    plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
       "\n",
       "The coordinates of the points or line nodes are given by *x*, *y*.\n",
       "\n",
       "The optional parameter *fmt* is a convenient way for defining basic\n",
       "formatting like color, marker and linestyle. It's a shortcut string\n",
       "notation described in the *Notes* section below.\n",
       "\n",
       ">>> plot(x, y)        # plot x and y using default line style and color\n",
       ">>> plot(x, y, 'bo')  # plot x and y using blue circle markers\n",
       ">>> plot(y)           # plot y using x as index array 0..N-1\n",
       ">>> plot(y, 'r+')     # ditto, but with red plusses\n",
       "\n",
       "You can use `.Line2D` properties as keyword arguments for more\n",
       "control on the  appearance. Line properties and *fmt* can be mixed.\n",
       "The following two calls yield identical results:\n",
       "\n",
       ">>> plot(x, y, 'go--', linewidth=2, markersize=12)\n",
       ">>> plot(x, y, color='green', marker='o', linestyle='dashed',\n",
       "        linewidth=2, markersize=12)\n",
       "\n",
       "When conflicting with *fmt*, keyword arguments take precedence.\n",
       "\n",
       "**Plotting labelled data**\n",
       "\n",
       "There's a convenient way for plotting objects with labelled data (i.e.\n",
       "data that can be accessed by index ``obj['y']``). Instead of giving\n",
       "the data in *x* and *y*, you can provide the object in the *data*\n",
       "parameter and just give the labels for *x* and *y*::\n",
       "\n",
       ">>> plot('xlabel', 'ylabel', data=obj)\n",
       "\n",
       "All indexable objects are supported. This could e.g. be a `dict`, a\n",
       "`pandas.DataFame` or a structured numpy array.\n",
       "\n",
       "\n",
       "**Plotting multiple sets of data**\n",
       "\n",
       "There are various ways to plot multiple sets of data.\n",
       "\n",
       "- The most straight forward way is just to call `plot` multiple times.\n",
       "  Example:\n",
       "\n",
       "  >>> plot(x1, y1, 'bo')\n",
       "  >>> plot(x2, y2, 'go')\n",
       "\n",
       "- Alternatively, if your data is already a 2d array, you can pass it\n",
       "  directly to *x*, *y*. A separate data set will be drawn for every\n",
       "  column.\n",
       "\n",
       "  Example: an array ``a`` where the first column represents the *x*\n",
       "  values and the other columns are the *y* columns::\n",
       "\n",
       "  >>> plot(a[0], a[1:])\n",
       "\n",
       "- The third way is to specify multiple sets of *[x]*, *y*, *[fmt]*\n",
       "  groups::\n",
       "\n",
       "  >>> plot(x1, y1, 'g^', x2, y2, 'g-')\n",
       "\n",
       "  In this case, any additional keyword argument applies to all\n",
       "  datasets. Also this syntax cannot be combined with the *data*\n",
       "  parameter.\n",
       "\n",
       "By default, each line is assigned a different style specified by a\n",
       "'style cycle'. The *fmt* and line property parameters are only\n",
       "necessary if you want explicit deviations from these defaults.\n",
       "Alternatively, you can also change the style cycle using the\n",
       "'axes.prop_cycle' rcParam.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "x, y : array-like or scalar\n",
       "    The horizontal / vertical coordinates of the data points.\n",
       "    *x* values are optional. If not given, they default to\n",
       "    ``[0, ..., N-1]``.\n",
       "\n",
       "    Commonly, these parameters are arrays of length N. However,\n",
       "    scalars are supported as well (equivalent to an array with\n",
       "    constant value).\n",
       "\n",
       "    The parameters can also be 2-dimensional. Then, the columns\n",
       "    represent separate data sets.\n",
       "\n",
       "fmt : str, optional\n",
       "    A format string, e.g. 'ro' for red circles. See the *Notes*\n",
       "    section for a full description of the format strings.\n",
       "\n",
       "    Format strings are just an abbreviation for quickly setting\n",
       "    basic line properties. All of these and more can also be\n",
       "    controlled by keyword arguments.\n",
       "\n",
       "data : indexable object, optional\n",
       "    An object with labelled data. If given, provide the label names to\n",
       "    plot in *x* and *y*.\n",
       "\n",
       "    .. note::\n",
       "        Technically there's a slight ambiguity in calls where the\n",
       "        second label is a valid *fmt*. `plot('n', 'o', data=obj)`\n",
       "        could be `plt(x, y)` or `plt(y, fmt)`. In such cases,\n",
       "        the former interpretation is chosen, but a warning is issued.\n",
       "        You may suppress the warning by adding an empty format string\n",
       "        `plot('n', 'o', '', data=obj)`.\n",
       "\n",
       "\n",
       "Other Parameters\n",
       "----------------\n",
       "scalex, scaley : bool, optional, default: True\n",
       "    These parameters determined if the view limits are adapted to\n",
       "    the data limits. The values are passed on to `autoscale_view`.\n",
       "\n",
       "**kwargs : `.Line2D` properties, optional\n",
       "    *kwargs* are used to specify properties like a line label (for\n",
       "    auto legends), linewidth, antialiasing, marker face color.\n",
       "    Example::\n",
       "\n",
       "    >>> plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)\n",
       "    >>> plot([1,2,3], [1,4,9], 'rs',  label='line 2')\n",
       "\n",
       "    If you make multiple lines with one plot command, the kwargs\n",
       "    apply to all those lines.\n",
       "\n",
       "    Here is a list of available `.Line2D` properties:\n",
       "\n",
       "      agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
       "  alpha: float (0.0 transparent through 1.0 opaque) \n",
       "  animated: bool \n",
       "  antialiased or aa: bool \n",
       "  clip_box: a `.Bbox` instance \n",
       "  clip_on: bool \n",
       "  clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
       "  color or c: any matplotlib color \n",
       "  contains: a callable function \n",
       "  dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
       "  dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
       "  dashes: sequence of on/off ink in points \n",
       "  drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
       "  figure: a `.Figure` instance \n",
       "  fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
       "  gid: an id string \n",
       "  label: object \n",
       "  linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
       "  linewidth or lw: float value in points \n",
       "  marker: :mod:`A valid marker style <matplotlib.markers>`\n",
       "  markeredgecolor or mec: any matplotlib color \n",
       "  markeredgewidth or mew: float value in points \n",
       "  markerfacecolor or mfc: any matplotlib color \n",
       "  markerfacecoloralt or mfcalt: any matplotlib color \n",
       "  markersize or ms: float \n",
       "  markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
       "  path_effects: `.AbstractPathEffect` \n",
       "  picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
       "  pickradius: float distance in points\n",
       "  rasterized: bool or None \n",
       "  sketch_params: (scale: float, length: float, randomness: float) \n",
       "  snap: bool or None \n",
       "  solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
       "  solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
       "  transform: a :class:`matplotlib.transforms.Transform` instance \n",
       "  url: a url string \n",
       "  visible: bool \n",
       "  xdata: 1D array \n",
       "  ydata: 1D array \n",
       "  zorder: float \n",
       "\n",
       "Returns\n",
       "-------\n",
       "lines\n",
       "    A list of `.Line2D` objects representing the plotted data.\n",
       "\n",
       "\n",
       "See Also\n",
       "--------\n",
       "scatter : XY scatter plot with markers of variing size and/or color (\n",
       "    sometimes also called bubble chart).\n",
       "\n",
       "\n",
       "Notes\n",
       "-----\n",
       "**Format Strings**\n",
       "\n",
       "A format string consists of a part for color, marker and line::\n",
       "\n",
       "    fmt = '[color][marker][line]'\n",
       "\n",
       "Each of them is optional. If not provided, the value from the style\n",
       "cycle is used. Exception: If ``line`` is given, but no ``marker``,\n",
       "the data will be a line without markers.\n",
       "\n",
       "**Colors**\n",
       "\n",
       "The following color abbreviations are supported:\n",
       "\n",
       "=============    ===============================\n",
       "character        color\n",
       "=============    ===============================\n",
       "``'b'``          blue\n",
       "``'g'``          green\n",
       "``'r'``          red\n",
       "``'c'``          cyan\n",
       "``'m'``          magenta\n",
       "``'y'``          yellow\n",
       "``'k'``          black\n",
       "``'w'``          white\n",
       "=============    ===============================\n",
       "\n",
       "If the color is the only part of the format string, you can\n",
       "additionally use any  `matplotlib.colors` spec, e.g. full names\n",
       "(``'green'``) or hex strings (``'#008000'``).\n",
       "\n",
       "**Markers**\n",
       "\n",
       "=============    ===============================\n",
       "character        description\n",
       "=============    ===============================\n",
       "``'.'``          point marker\n",
       "``','``          pixel marker\n",
       "``'o'``          circle marker\n",
       "``'v'``          triangle_down marker\n",
       "``'^'``          triangle_up marker\n",
       "``'<'``          triangle_left marker\n",
       "``'>'``          triangle_right marker\n",
       "``'1'``          tri_down marker\n",
       "``'2'``          tri_up marker\n",
       "``'3'``          tri_left marker\n",
       "``'4'``          tri_right marker\n",
       "``'s'``          square marker\n",
       "``'p'``          pentagon marker\n",
       "``'*'``          star marker\n",
       "``'h'``          hexagon1 marker\n",
       "``'H'``          hexagon2 marker\n",
       "``'+'``          plus marker\n",
       "``'x'``          x marker\n",
       "``'D'``          diamond marker\n",
       "``'d'``          thin_diamond marker\n",
       "``'|'``          vline marker\n",
       "``'_'``          hline marker\n",
       "=============    ===============================\n",
       "\n",
       "**Line Styles**\n",
       "\n",
       "=============    ===============================\n",
       "character        description\n",
       "=============    ===============================\n",
       "``'-'``          solid line style\n",
       "``'--'``         dashed line style\n",
       "``'-.'``         dash-dot line style\n",
       "``':'``          dotted line style\n",
       "=============    ===============================\n",
       "\n",
       "Example format strings::\n",
       "\n",
       "    'b'    # blue markers with default shape\n",
       "    'ro'   # red circles\n",
       "    'g-'   # green solid line\n",
       "    '--'   # dashed line with default color\n",
       "    'k^:'  # black triangle_up markers connected by a dotted line\n",
       "\n",
       ".. note::\n",
       "    In addition to the above described arguments, this function can take a\n",
       "    **data** keyword argument. If such a **data** argument is given, the\n",
       "    following arguments are replaced by **data[<arg>]**:\n",
       "\n",
       "    * All arguments with the following names: 'x', 'y'.\n",
       "\u001b[0;31mFile:\u001b[0m      ~/anaconda3/lib/python3.6/site-packages/matplotlib/pyplot.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt #这个是所谓的 scripting layer\n",
    "plt.plot?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1195aab70>]"
      ]
     },
     "execution_count": 34,
     "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": [
    "# because the default is the line style '-', \n",
    "# nothing will be shown if we only pass in one point (3,2)\n",
    "plt.plot(3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1192e0b70>]"
      ]
     },
     "execution_count": 35,
     "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": [
    "# we can pass in '.' to plt.plot to indicate that we want\n",
    "# the point (3,2) to be indicated with a marker '.'\n",
    "plt.plot(3, 2, '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how to make a plot without using the scripting layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# First let's set the backend without using mpl.use() from the scripting layer\n",
    "from matplotlib.backends.backend_agg import FigureCanvasAgg\n",
    "from matplotlib.figure import Figure\n",
    "\n",
    "# create a new figure\n",
    "fig = Figure()\n",
    "\n",
    "# associate fig with the backend\n",
    "canvas = FigureCanvasAgg(fig)\n",
    "\n",
    "# add a subplot to the fig\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "# plot the point (3,2)\n",
    "ax.plot(3, 2, '.')\n",
    "\n",
    "# save the figure to test.png\n",
    "# you can see this figure in your Jupyter workspace afterwards by going to\n",
    "# https://hub.coursera-notebooks.org/\n",
    "canvas.print_png('test.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use html cell magic to display the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src='test.png' />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src='test.png' />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 6, 0, 10]"
      ]
     },
     "execution_count": 45,
     "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": [
    "# create a new figure\n",
    "plt.figure()\n",
    "\n",
    "# plot the point (3,2) using the circle marker\n",
    "plt.plot(3, 2, 'o') #有几种不同的图形表现方式，目前测试 . o p _ x 都对应不同形状\n",
    "\n",
    "# get the current axes\n",
    "ax = plt.gca()\n",
    "\n",
    "# Set axis properties [xmin, xmax, ymin, ymax]\n",
    "ax.axis([0,6,0,10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11a051be0>]"
      ]
     },
     "execution_count": 46,
     "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": [
    "# create a new figure\n",
    "plt.figure()\n",
    "\n",
    "# plot the point (1.5, 1.5) using the circle marker\n",
    "plt.plot(1.5, 1.5, 'o')\n",
    "# plot the point (2, 2) using the circle marker\n",
    "plt.plot(2, 2, 'o')\n",
    "# plot the point (2.5, 2.5) using the circle marker\n",
    "plt.plot(2.5, 2.5, 'o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.spines.Spine at 0x119e5bef0>,\n",
       " <matplotlib.spines.Spine at 0x119d05c18>,\n",
       " <matplotlib.spines.Spine at 0x119d05b38>,\n",
       " <matplotlib.spines.Spine at 0x119d05780>,\n",
       " <matplotlib.axis.XAxis at 0x119d05518>,\n",
       " <matplotlib.axis.YAxis at 0x119d05208>,\n",
       " Text(0.5,1,''),\n",
       " Text(0,1,''),\n",
       " Text(1,1,''),\n",
       " <matplotlib.patches.Rectangle at 0x119e452e8>]"
      ]
     },
     "execution_count": 48,
     "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": [
    "# get current axes\n",
    "ax = plt.gca()\n",
    "# get all the child objects the axes contains\n",
    "ax.get_children()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scatterplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x1197b3cc0>"
      ]
     },
     "execution_count": 49,
     "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": [
    "import numpy as np\n",
    "\n",
    "x = np.array([1,2,3,4,5,6,7,8])\n",
    "y = x\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter(x, y) # similar to plt.plot(x, y, '.'), but the underlying child objects in the axes are not Line2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x1197ce390>"
      ]
     },
     "execution_count": 53,
     "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": [
    "import numpy as np\n",
    "\n",
    "x = np.array([1,2,3,4,5,6,7,8])\n",
    "y = x\n",
    "\n",
    "# create a list of colors for each point to have\n",
    "# ['green', 'green', 'green', 'green', 'green', 'green', 'green', 'red']\n",
    "colors = ['green']*(len(x)-1)\n",
    "colors.append('red')\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "# plot the point with size 100 and chosen colors\n",
    "plt.scatter(x, y, s=100, c=colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]\n",
      "(1, 6) (2, 7) (3, 8) (4, 9) (5, 10)\n"
     ]
    }
   ],
   "source": [
    "# convert the two lists into a list of pairwise tuples\n",
    "zip_generator = zip([1,2,3,4,5], [6,7,8,9,10])\n",
    "\n",
    "print(list(zip_generator))\n",
    "# the above prints:\n",
    "# [(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]\n",
    "\n",
    "zip_generator = zip([1,2,3,4,5], [6,7,8,9,10])\n",
    "# The single star * unpacks a collection into positional arguments\n",
    "print(*zip_generator)\n",
    "# the above prints:\n",
    "# (1, 6) (2, 7) (3, 8) (4, 9) (5, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2, 3, 4, 5), (6, 7, 8, 9, 10)]\n",
      "(1, 2, 3, 4, 5)\n",
      "(6, 7, 8, 9, 10)\n"
     ]
    }
   ],
   "source": [
    "# use zip to convert 5 tuples with 2 elements each to 2 tuples with 5 elements each\n",
    "print(list(zip((1, 6), (2, 7), (3, 8), (4, 9), (5, 10))))\n",
    "# the above prints:\n",
    "# [(1, 2, 3, 4, 5), (6, 7, 8, 9, 10)]\n",
    "\n",
    "\n",
    "zip_generator = zip([1,2,3,4,5], [6,7,8,9,10])\n",
    "# let's turn the data back into 2 lists\n",
    "x, y = zip(*zip_generator) # This is like calling zip((1, 6), (2, 7), (3, 8), (4, 9), (5, 10))\n",
    "print(x)\n",
    "print(y)\n",
    "# the above prints:\n",
    "# (1, 2, 3, 4, 5)\n",
    "# (6, 7, 8, 9, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x119761588>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFb9JREFUeJzt3X+Q3HV9x/HnK2T9EWIEk1NiEoimDLUwAeNODDplmCLWo0xS9f6IMwngqNdwjEjMTIf2D5zSmU6dMU2LzJCJhxYSpdQTaLQ5Kmqr/lHSbmKIwWjJqZBAlJNgSAwjm/bdP77f4GVvL3fZ797u3n1ej5md/e7n+979vOebudd98/1+976KCMzMLA0z2t2AmZm1jkPfzCwhDn0zs4Q49M3MEuLQNzNLiEPfzCwhDn0zs4Q49M3MEuLQNzNLyMx2N1Br3rx5sXjx4na3YWY2pezatetXEdE1Xl3Hhf7ixYupVCrtbsPMbEqR9PRE6nx4x8wsIQ59M7OEOPTNzBLi0DczS4hD38wsIQ59M7M2GRqCvj6YMwdmzMie+/qy8ckybuhL+qKk5yXtGzH2JkmPSXoqfz5/jPfemNc8JenGZjZuZjaVDQ7C0qXQ3w/HjkFE9tzfn40PDk7OvBPZ0/9H4AM1Y7cD346Ii4Fv569PI+lNwGeAdwPLgc+M9cvBzCwlQ0PQ0wMnTkC1evq6ajUb7+mZnD3+cUM/Ir4HHKkZXgXcly/fB/xpnbf+MfBYRByJiBeBxxj9y8PMLDkbN44O+1rVKmza1Py5Gz2m/5aIOAyQP7+5Ts0C4OCI14fyMTOzpG3bNrHQ37q1+XNP5olc1RmLuoVSr6SKpMrw8PAktmRm1n7Hjze37mw0Gvq/lDQfIH9+vk7NIWDRiNcLgefqfVhEbImIckSUu7rG/XtBZmZT2uzZza07G42G/nbg1NU4NwL/Uqfm34D3Szo/P4H7/nzMzCxpa9ZAqXTmmlIJ1q5t/twTuWTzAeA/gUskHZL0MeBvgWslPQVcm79GUllSP0BEHAH+Gvjv/HFnPmZmlrQNGyYW+uvXN39uRdQ9zN425XI5/KeVzWy6GxzMLsusVk8/qVsqZY+BAejunvjnSdoVEeXx6vyNXDOzNujuhr17obf39G/k9vZm42cT+GfDe/pmZtOA9/TNzGwUh76ZWUIc+mZmCXHom5klxKFvZpYQh76ZWUIc+mZmCXHom5klxKFvZpYQh76ZWUIc+mZmCXHom5klxKFvZpaQQqEv6VOS9kl6UtJtddZfLemopD35444i85mZWTEzG32jpMuATwDLgVeARyX9a0Q8VVP6/Yi4vkCPZmbWJEX29N8BPB4RJyLiJPBd4IPNacvMzCZDkdDfB1wlaa6kWcB1wKI6dVdKekLSoKRLC8xnZmYFNXx4JyL2S/os8BhwHHgCOFlTthu4KCKOS7oOeAS4uPazJPUCvQAXXnhhoy2Zmdk4Cp3IjYh7I2JZRFwFHAGeqln/UkQcz5d3ACVJ8+p8zpaIKEdEuaurq0hLZmZ2BkWv3nlz/nwh8CHggZr1F0hSvrw8n++FInOamVnjGj68k/uapLlAFbglIl6UtA4gIjYDPcDNkk4CLwOro9PuxG5mlpBCoR8Rf1hnbPOI5buBu4vMYWZmzeNv5JqZJcShb2aWEIe+mVlCHPpmZglx6JuZJcShb2aWEIe+mVlCHPpmZglx6JuZJcShb2aWEIe+mVlCHPpmZglx6JuZJcShb2aWEIe+mTXN0BD09cGcOTBjRvbc15eNW2dw6JtZUwwOwtKl0N8Px45BRPbc35+NDw62u0OD4rdL/JSkfZKelHRbnfWSdJekA5L2SlpWZD4z60xDQ9DTAydOQLV6+rpqNRvv6fEefydoOPQlXQZ8AlgOXA5cL+nimrJu4OL80Qvc0+h8Zta5Nm4cHfa1qlXYtKk1/djYiuzpvwN4PCJORMRJ4LvAB2tqVgH3R+Zx4DxJ8wvMaWYdaNu2iYX+1q2t6cfGViT09wFXSZoraRZwHbCopmYBcHDE60P52Gkk9UqqSKoMDw8XaMnM2uH48ebW2eRpOPQjYj/wWeAx4FHgCeBkTZnqvbXOZ22JiHJElLu6uhptyczaZPbs5tbZ5Cl0Ijci7o2IZRFxFXAEeKqm5BCn7/0vBJ4rMqeZdZ41a6BUOnNNqQRr17amHxtb0at33pw/Xwh8CHigpmQ7cEN+Fc8K4GhEHC4yp5l1ng0bJhb669e3ph8b28yC7/+apLlAFbglIl6UtA4gIjYDO8iO9R8ATgAfLTifmXWgJUtgYCC7LLNaPf2kbqmUPQYGsjprL0WMOsTeVuVyOSqVSrvbMLMGDA1ll2Vu3ZqdtJ09Ozuks369A3+ySdoVEeVx6xz6ZmZT30RD33+GwcwsIQ59M7OEOPTNzBLi0DczS4hD38wsIQ59M7OEOPTNzBLi0DczS4hD38wsIQ59M7OEOPTNzBLi0DczS4hD38wsIQ59M7OEFL1z1npJT0raJ+kBSa+rWX+TpGFJe/LHx4u1a2ZmRTQc+pIWALcC5Yi4DDgHWF2n9MGIuCJ/9Dc6n5mZFVf08M5M4PWSZgKz8E3Pzcw6WsOhHxHPAp8DngEOk930/Jt1Sj8saa+kAUmLGp3PzMyKK3J453xgFfA24K3AuZLW1JR9HVgcEUuBbwH3jfFZvZIqkirDw8ONtmRmZuMocnjnfcDPImI4IqrAQ8B7RhZExAsR8dv85ReAd9X7oIjYEhHliCh3dXUVaMnMzM6kSOg/A6yQNEuSgGuA/SMLJM0f8XJl7XozM2utmY2+MSJ2ShoAdgMngR8AWyTdCVQiYjtwq6SV+fojwE3FWzYzs0YpItrdw2nK5XJUKpV2t2FmNqVI2hUR5fHq/I1cM7OEOPTNzBLi0DczS4hD38wsIQ59M7OEOPTNzBLi0DczS4hD38wsIQ59M7OEOPTNzBLi0DczS4hD38wsIQ59M7OEOPTNzBLi0Dcbx9AQ9PXBnDkwY0b23NeXjZtNNQ59szMYHISlS6G/H44dg4jsub8/Gx8cbHeHZmenUOhLWi/pSUn7JD0g6XU1618r6UFJByTtlLS4yHxmrTQ0BD09cOIEVKunr6tWs/GeHu/x29TScOhLWgDcCpQj4jLgHGB1TdnHgBcj4veATcBnG53PrNU2bhwd9rWqVdi0qTX9mDVD0cM7M4HXS5oJzAKeq1m/CrgvXx4Arslvom7W8bZtm1job93amn7MmqHh0I+IZ4HPAc8Ah4GjEfHNmrIFwMG8/iRwFJhb+1mSeiVVJFWGh4cbbcmsqY4fb26dWScocnjnfLI9+bcBbwXOlbSmtqzOW0fdiT0itkREOSLKXV1djbZk1lSzZze3zqwTFDm88z7gZxExHBFV4CHgPTU1h4BFAPkhoDcCRwrMadYya9ZAqXTmmlIJ1q5tTT9mzVAk9J8BVkialR+nvwbYX1OzHbgxX+4BvhMRo/b0zTrRhg0TC/3161vTj1kzFDmmv5Ps5Oxu4If5Z22RdKeklXnZvcBcSQeATwO3F+zXrGWWLIGBAZg1a3T4l0rZ+MBAVmc2VajTdrzL5XJUKpV2t2H2qqGh7LLMrVuzk7azZ2eHdNavd+Bb55C0KyLK49Y59M3Mpr6Jhr7/DIOZWUIc+mZmCXHom5klxKFvZpYQh76ZWUIc+mZmCXHom5klxKFvZpYQh76ZWUIc+mZmCXHom5klxKFvZpYQh76ZWUIc+mZmCSlyj9xLJO0Z8XhJ0m01NVdLOjqi5o7iLZuZWaNmNvrGiPgJcAWApHOAZ4GH65R+PyKub3QeMzNrnmYd3rkGGIqIp5v0eWZmNgmaFfqrgQfGWHelpCckDUq6tEnzmZlZAwqHvqTXACuBr9ZZvRu4KCIuBz4PPDLGZ/RKqkiqDA8PF23JzMzG0Iw9/W5gd0T8snZFRLwUEcfz5R1ASdK8OnVbIqIcEeWurq4mtGRmZvU0I/Q/whiHdiRdIEn58vJ8vheaMKeZmTWg4at3ACTNAq4F/mzE2DqAiNgM9AA3SzoJvAysjogoMqeZmTWuUOhHxAlgbs3Y5hHLdwN3F5nDzMyax9/INTNLiEPfzCwhDn0zs4Q49M3MEuLQNzNLiEPfzCwhDn0zs4Q49M3MEuLQNzNLiEPfzCwhDn0zs4Q49M3MEuLQNzNLiEPfzCwhDv0UDQ1BXx/MmQMzZmTPfX3ZuJlNaw2HvqRLJO0Z8XhJ0m01NZJ0l6QDkvZKWla8ZStkcBCWLoX+fjh2DCKy5/7+bHxwsN0dmtkkavgmKhHxE+AKAEnnAM8CD9eUdQMX5493A/fkz9YOQ0PQ0wMnToxeV61mj54e2LsXlixpfX9mNumadXjnGmAoIp6uGV8F3B+Zx4HzJM1v0px2tjZuzIL9TKpV2LSpNf2YWcs1K/RXU//m6AuAgyNeH8rHrB22bZtY6G/d2pp+zKzlCoe+pNcAK4Gv1ltdZ2zUjdEl9UqqSKoMDw8XbcnGcvx4c+vMbMppxp5+N7A7In5ZZ90hYNGI1wuB52qLImJLRJQjotzV1dWElqyu2bObW2dmU04zQv8j1D+0A7AduCG/imcFcDQiDjdhTmvEmjVQKp25plSCtWtb04+ZtVyh0Jc0C7gWeGjE2DpJ6/KXO4CfAgeALwB9ReazgjZsmFjor1/fmn7MrOUavmQTICJOAHNrxjaPWA7gliJzWBMtWQIDA9llmacu0TylVMoeAwO+XNNsGvM3clPT3Z1dh9/be/o3cnt7s/Hu7nZ3aGaTSNnOeOcol8tRqVTa3YaZ2ZQiaVdElMer856+mVlCHPpmZglx6JuZJcShb2aWEIe+mVlCHPpmZglx6JuZJcShb2aWEIe+mVlCHPpmZglx6JuZJcShb2aWEIe+mVlCHPpmZgkpeues8yQNSPqxpP2SrqxZf7Wko5L25I87irVrZmZFFLpzFvAPwKMR0SPpNcCsOjXfj4jrC85jZmZN0HDoS5oDXAXcBBARrwCvNKctMzObDEUO77wdGAa+JOkHkvolnVun7kpJT0galHRpvQ+S1CupIqkyPDxcoCUzMzuTIqE/E1gG3BMR7wR+A9xeU7MbuCgiLgc+DzxS74MiYktElCOi3NXVVaAlMzM7kyKhfwg4FBE789cDZL8EXhURL0XE8Xx5B1CSNK/AnGZmVkDDoR8RvwAOSrokH7oG+NHIGkkXSFK+vDyf74VG5zQzs2KKXr3zSeDL+ZU7PwU+KmkdQERsBnqAmyWdBF4GVkdEFJzTzMwapE7L4HK5HJVKpd1tmJlNKZJ2RUR5vDp/I9fMLCEOfTOzhDj0zcwS4tA3M0uIQ9/MLCEOfTOzhDj0zcwS4tA3M0uIQ9/MLCEOfTOzhDj0zcwS4tA3M0uIQ9/MLCEOfTOzhEyf0B8agr4+mDMHZszInvv6snEzMwMKhr6k8yQNSPqxpP2SrqxZL0l3STogaa+kZWN9ViGDg7B0KfT3w7FjEJE99/dn44ODkzKtmdlUU3RP/x+ARyPi94HLgf0167uBi/NHL3BPwflGGxqCnh44cQKq1dPXVavZeE+P9/jNzCgQ+pLmAFcB9wJExCsR8euaslXA/ZF5HDhP0vyGu61n48bRYV+rWoVNm5o6rZnZVFRkT//twDDwJUk/kNQv6dyamgXAwRGvD+VjzbNt28RCf+vWpk5rZjYVFQn9mcAy4J6IeCfwG+D2mhrVed+om/JK6pVUkVQZHh4+uy6OH29unZnZNFYk9A8BhyJiZ/56gOyXQG3NohGvFwLP1X5QRGyJiHJElLu6us6ui9mzm1tnZjaNNRz6EfEL4KCkS/Kha4Af1ZRtB27Ir+JZARyNiMONzlnXmjVQKp25plSCtWubOq2Z2VRU9OqdTwJflrQXuAL4G0nrJK3L1+8AfgocAL4A9BWcb7QNGyYW+uvXN31qM7OpZmaRN0fEHqBcM7x5xPoAbikyx7iWLIGBgeyyzGr19JO6pVL2GBjI6szMEjc9vpHb3Q1790Jv7+nfyO3tzca7u9vdoZlZR1C2M945yuVyVCqVdrdhZjalSNoVEbVHXkaZHnv6ZmY2IQ59M7OEOPTNzBLi0DczS0jHnciVNAw8XfBj5gG/akI7zdSJPYH7Olud2Fcn9gTu62wV7euiiBj3Txp0XOg3g6TKRM5it1In9gTu62x1Yl+d2BO4r7PVqr58eMfMLCEOfTOzhEzX0N/S7gbq6MSewH2drU7sqxN7Avd1tlrS17Q8pm9mZvVN1z19MzOrY8qGvqQvSnpe0r4x1kvSXZIOSNorqfYGL+3q62pJRyXtyR93tKCnRZL+XdJ+SU9K+lSdmpZvrwn21Y7t9TpJ/yXpibyvv6pT81pJD+bba6ekxR3Q002Shkdsq49PZk81c5+T3zb1G3XWtXRbTbCndm6rn0v6YT7vqD80Nuk/ixExJR9kN2VfBuwbY/11wCDZLRtXADs7pK+rgW+0eFvNB5bly28A/gf4g3Zvrwn21Y7tJWB2vlwCdgIramr6gM358mrgwQ7o6Sbg7lZuqxFzfxr4Sr1/q1Zvqwn21M5t9XNg3hnWT+rP4pTd04+I7wFHzlCyCrg/Mo8D50ma3wF9tVxEHI6I3fnyMWA/o29Q3/LtNcG+Wi7fBqduqlzKH7Unv1YB9+XLA8A1kurdE7qVPbWFpIXAnwD9Y5S0dFtNsKdONqk/i1M29CdgAXBwxOtDdECg5K7M/5s+KOnSVk6c/9f6nWR7iiO1dXudoS9ow/bKDw3sAZ4HHovf3Qv6lFe3V0ScBI4Cc9vcE8CH80MCA5IW1Vk/Gf4e+HPg/8ZY3/JtNYGeoD3bCrJf1t+UtEtSb531k/qzOJ1Dv96eRCfsGe0m+7r05cDngUdaNbGk2cDXgNsi4qXa1XXe0pLtNU5fbdleEfG/EXEFsBBYLumympKWb68J9PR1YHFELAW+xe/2rieNpOuB5yNi15nK6oxN2raaYE8t31YjvDcilgHdwC2SrqpZP6nbazqH/iFg5G/vhcBzberlVRHx0qn/pkfEDqAkad5kzyupRBasX46Ih+qUtGV7jddXu7bXiPl/DfwH8IGaVa9uL0kzgTfSosN6Y/UUES9ExG/zl18A3tWCdt4LrJT0c+CfgD+StK2mptXbatye2rStTs39XP78PPAwsLymZFJ/Fqdz6G8HbsjPhK8AjkbE4XY3JemCU8czJS0n+zd4YZLnFHAvsD8i/m6MspZvr4n01abt1SXpvHz59cD7gB/XlG0HbsyXe4DvRH4Wrl091Rz3XUl2jmRSRcRfRMTCiFhMdpL2OxGxpqaspdtqIj21Y1vl854r6Q2nloH3A7VX+k3qz2KhG6O3k6QHyK7smCfpEPAZspNbRMRmYAfZWfADwAngox3SVw9ws6STwMvA6sn8Aci9F1gL/DA/Jgzwl8CFI/pqx/aaSF/t2F7zgfsknUP2S+afI+Ibku4EKhGxneyX1VZJB8j2Wld3QE+3SloJnMx7ummSexpTm7fVRHpq17Z6C/Bwvh8zE/hKRDwqaR205mfR38g1M0vIdD68Y2ZmNRz6ZmYJceibmSXEoW9mlhCHvplZQhz6ZmYJceibmSXEoW9mlpD/B2y28cl/fxUCAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "# plot a data series 'Tall students' in red using the first two elements of x and y\n",
    "plt.scatter(x[:2], y[:2], s=100, c='red', label='Tall students')\n",
    "# plot a second data series 'Short students' in blue using the last three elements of x and y \n",
    "plt.scatter(x[2:], y[2:], s=100, c='blue', label='Short students')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Relationship between ball kicking and grades')"
      ]
     },
     "execution_count": 57,
     "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": [
    "# add a label to the x axis\n",
    "plt.xlabel('The number of times the child kicked a ball')\n",
    "# add a label to the y axis\n",
    "plt.ylabel('The grade of the student')\n",
    "# add a title\n",
    "plt.title('Relationship between ball kicking and grades')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11a277320>"
      ]
     },
     "execution_count": 58,
     "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": [
    "# add a legend (uses the labels from plt.scatter)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11a2c86d8>"
      ]
     },
     "execution_count": 59,
     "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": [
    "# add the legend to loc=4 (the lower right hand corner), also gets rid of the frame and adds a title\n",
    "plt.legend(loc=4, frameon=False, title='Legend')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.spines.Spine at 0x11a34b710>,\n",
       " <matplotlib.spines.Spine at 0x11a34b9b0>,\n",
       " <matplotlib.spines.Spine at 0x11a34b390>,\n",
       " <matplotlib.spines.Spine at 0x11a34b5f8>,\n",
       " <matplotlib.axis.XAxis at 0x11a34b7f0>,\n",
       " <matplotlib.axis.YAxis at 0x10cac74e0>,\n",
       " Text(0.5,1,''),\n",
       " Text(0,1,''),\n",
       " Text(1,1,''),\n",
       " <matplotlib.patches.Rectangle at 0x11a35a2b0>]"
      ]
     },
     "execution_count": 60,
     "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": [
    "# get children from current axes (the legend is the second to last item in this list)\n",
    "plt.gca().get_children()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the legend from the current axes\n",
    "legend = plt.gca().get_children()[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-62-06380a03f01e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# you can use get_children to navigate through the child artists\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlegend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_children\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_children\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_children\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_children\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# you can use get_children to navigate through the child artists\n",
    "legend.get_children()[0].get_children()[1].get_children()[0].get_children()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Legend\n",
      "    <matplotlib.offsetbox.VPacker object at 0x11a08e5c0>\n",
      "        <matplotlib.offsetbox.TextArea object at 0x11a08e2b0>\n",
      "            Text(0,0,'None')\n",
      "        <matplotlib.offsetbox.HPacker object at 0x11a08e208>\n",
      "    FancyBboxPatch(0,0;1x1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import the artist class from matplotlib\n",
    "from matplotlib.artist import Artist\n",
    "\n",
    "def rec_gc(art, depth=0):\n",
    "    if isinstance(art, Artist):\n",
    "        # increase the depth for pretty printing\n",
    "        print(\"  \" * depth + str(art))\n",
    "        for child in art.get_children():\n",
    "            rec_gc(child, depth+2)\n",
    "\n",
    "# Call this function on the legend artist to see what the legend is made up of\n",
    "rec_gc(plt.legend())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Line Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11a6f34e0>,\n",
       " <matplotlib.lines.Line2D at 0x11a6f39e8>]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8VPW9//HXJxskBAjIIltEhQIuIJiiQhVxQawoblBEEdQWb1utvfb+FPtrb+9te622v7r0alUqKorIpghFi1UU1KqUVUChShAxsi8JSwJZ5vv745xAglkmyUzOzOT9fDzymJkzE84HlHe+fM73fL/mnENEROJfUtAFiIhIZCjQRUQShAJdRCRBKNBFRBKEAl1EJEEo0EVEEoQCXUQkQSjQRUQShAJdRCRBpDTmydq1a+e6d+/emKcUEYl7K1as2O2ca1/b5xo10Lt3787y5csb85QiInHPzL4M53NquYiIJAgFuohIglCgi4gkCAW6iEiCUKCLiCQIBbqISLSEyuAff4IHT4YP/td7HUUKdBGRaNiTC5OHwOLfQdFeeOd+mHyhdzxKFOgiItEwZRjs+ARKCr3XJYWwY513PEoU6CIi0dChN7hQ5WMuBB36RO2UCnQRkWjoOwYsufKxtEzoPy5qp1Sgi4hEWlkpfDoP3HEXQZOSodfwqJ22UddyERFJeKEQzL8TNr4Jl/8BzpnYaKfWCF1EJFKcgzd/CR9Phwvva9QwBwW6iEjkvP8QfPgYDLwdhtzb6KdXoIuIRMLyZ2DRr+HM0TD8ATBr9BIU6CIiDfXJXFhwN/S8DK7+MyQFE60KdBGRhti4CF7+AWSfC6Oeg+TUwEoJK9DNLMvM5pjZBjNbb2bnmVlbM3vTzD73H9tEu1gRkZjy1TKYeRO07wU3zIC0jEDLCXeE/iiw0DnXG+gHrAcmAYuccz2BRf5rEZGmYed6ePF6yOwIN70C6VlBV1R7oJtZK+ACYAqAc67YOZcPjASm+h+bClwdrSJFRGLKvi/hhWsgpTnc/Cq07Bh0RUB4I/RTgF3As2a2ysyeNrMWQEfn3DYA/7FDFOsUEYkNB3fCC1d7i22NewXadA+6oqPCCfQUYADwhHOuP3CIOrRXzGyimS03s+W7du2qZ5kiIjHgcAFMuxYObIcb50DH04OuqJJwAj0PyHPOLfVfz8EL+B1m1gnAf9xZ1Tc75yY753Kccznt27ePRM0iIo2vpAimj4GdG2D0C9BtYNAVfUOtge6c2w58ZWa9/EMXA58C84Hx/rHxwLyoVCgiErSyEph9C2z5EK55EnpeEnRFVQp3ca47gRfNLA3YBNyC98NglpndBmwBRkWnRBGRAIVCMO8O+OxvcMUf4czrg66oWmEFunNuNZBTxVsXR7YcEZEY4hy88XNYMwOG/gK+/f2gK6qR7hQVEanOu/8Plj4B5/wQLviPoKuplQJdRKQqy56Gd37r7Tx02f2BLLZVVwp0EZHjrZ0Dr/0HfOtyGPlYYItt1VV8VCki0lg+fwvm3g7Z58GoZwNdbKuuFOgiIuW2LIVZ46BDHxg7A1LTg66oThToIiIAOz6B6aOg5YneYlvNWwddUZ0p0EVE9n4BL1wLqRkw7lXIjM+lqcK9sUhEJDEd2OGtnFh6GG5dCG1OCrqielOgi0jTVZQP067zVlC8eZ7XO49jCnQRaZqKC+GlMbBrA4ydCd2+HXRFDaZAF5Gmp6wEZk+ALR/B9c9Aj8RYxUSBLiJNSygEr/4IPn8DRjwMZ1wbdEURo1kuItJ0OAcLJ8HaWXDRLyHn1qAriigFuog0HUt+D/98Cs67A87/WdDVRJwCXUSahn/+BRbfD/3GwqW/iYvFtupKgS4iiW/tHHj9/0Cv78JV/xs3i23VVWL+rkREyn3+prfY1kmD4fpnITlx54Io0EUkcW35CGaOg46nww0vQWrzoCuKKgW6iCSm7etg+mho3QVufBmatwq6oqhToItI4tm7CaZdC6ktYNxcyGwfdEWNInGbSSLSNB3Y7i22VVYMtyyErOygK2o0CnQRSRxF+7xlcA/ugvF/hQ69g66oUSnQRSQxFBfC9O/Bns9h7CzoenbQFTW6sALdzDYDB4AyoNQ5l2NmbYGZQHdgMzDaObcvOmWKiNSgtBhm3Qx5y2DUc3Dq0KArCkRdLooOdc6d5ZzL8V9PAhY553oCi/zXIiKNKxSCV38IG9/0Fts6bWTQFQWmIbNcRgJT/edTgasbXo6ISB04B3+7B9bNgUv+C86eEHBBwQq3h+6Av5uZA55yzk0GOjrntgE457aZWZWb8JnZRGAiQHZ207naLCJREiqDDx+H9x+GTv1g0zsw6E4Y/NOgKwtcuIE+2Dm31Q/tN81sQ7gn8MN/MkBOTo6rR40iIp49uTB7vPdYUuiFeXobGDAhIRfbqquwWi7Oua3+405gLjAQ2GFmnQD8x53RKlJEBIApw2DHJ16YlztcAM9cFlxNMaTWQDezFmbWsvw5MAxYB8wHxvsfGw/Mi1aRIiKAN6/chSofc6G439w5UsJpuXQE5pr3z5kUYLpzbqGZLQNmmdltwBZgVPTKFBEBMjt981haJvQf1/i1xKBaA905twnoV8XxPUBi7KwqIrHNOXjnflg3G5JSIVRy7L2kZOg1PLjaYojuFBWR2BYKefuA/vMpbyR+5aNeiMs3KNBFJHaVlcL8O+Djl7x9QIf9VrNZaqBAF5HYVHoE5twKGxbA0F/ABf+hMK+FAl1EYk/xIZhxozfP/PLfwzm3B11RXFCgi0hsKdoHL46Gr5fD1U/AWWODrihuKNBFJHYc3OltTrH7Mxg1FU67KuiK4ooCXURiQ/4WeP5qOLANxs6EUy8KuqK4o0AXkeDt/twL8+IDMO5VyD4n6IrikgJdRIK17WNv2zgzmPAanHhm0BXFrYashy4i0jBbPoLnroSU5t6GzgrzBlGgi0gwNr7ltVky28OtC6Fdj6ArinsKdBFpfJ/Og+ljvBC/ZSFkdQu6ooSgQBeRxrVqGsyeAF0GwPgF3ghdIkKBLiKN56MnYN6P4ZQLYdxcSM8KuqKEolkuIhJ9zsGSB2Hx76DPVXDd05DSLOiqEo4CXUSiKxSCv/9f+OjPcNaNcOWfIFnREw36UxWR6Ckrhb/eBaunwTk/hMvuhyR1eqNFgS4i0VF6BF7+PqyfDxfeB0Pu1fK3UaZAF5HIKz4EM2+C3Lfhst/BeT8KuqImQYEuIpFVlA/TR0PeMrjqMRigDZwbiwJdRCLn4C6Ydg3s3ADXPwunXx10RU2KAl1EIqMgD54fCQVfw9gZ0OOSoCtqcsK+3GxmyWa2yswW+K9PNrOlZva5mc00s7TolSkiMW33RnhmuLdBxbi5CvOA1GX+0F3A+gqvHwQeds71BPYBt0WyMBGJE9vXwrPDoaQIJiyAk84LuqImK6xAN7OuwBXA0/5rAy4C5vgfmQqoWSbS1GxZCs9dAclp3oqJnfoFXVGTFu4I/RHgHiDkvz4ByHfOlfqv84AuEa5NRGJZ7tvwwtWQ0c5f/rZn0BU1ebUGupmNAHY651ZUPFzFR1013z/RzJab2fJdu3bVs0wRiSnr/wrTvwdtT/HCPCs76IqE8Ebog4GrzGwzMAOv1fIIkGVm5bNkugJbq/pm59xk51yOcy6nfXstkykS91ZPh1k3e+2VCQsgs0PQFYmv1kB3zt3nnOvqnOsOjAHeds7dCLwDXO9/bDwwL2pVikhsWPoUvPpD6H6+t5lzepugK5IKGrJKzr3A3Wa2Ea+nPiUyJYlIzHEOlvwB/nYP9B4BY2dBs8ygq5Lj1OnGIufcYmCx/3wTMDDyJYlITHEO/v4L+PAx6HeDdzu/lr+NSfqvIiLVC5V5y9+uegEG3g7DH9DytzFMgS4iVSsthld+AJ++ChfcA0N/ruVvY5wCXUS+qbgQZo2DjW/BsN/CoDuDrkjCoEAXkcoOF3hzzLd85G0Xd/b4oCuSMCnQRZq6UBl8+Di8/zCcczusXwC71sP1z8AZ1wZdndSBAl2kKduTC7PHe48lhbD4Ae/4iEcV5nFIl6tFmrIpw2DHJ16YA+C8C59v/zrQsqR+FOgiTVmH3uBClY+5EHToE0w90iAKdJGmKlQGaVXc7ZmWCf21D2g8UqCLNEWFe+HFUfDZQkhOrfxeUjL0Gh5MXdIguigq0tRsXwszboQD2+DKR+HsCUFXJBGiQBdpStbMhvl3eqskTngdun076IokghToIk1BWSm8+Z/w0eOQPQhGT9U65glIgS6S6A7ugjm3wOb3vAW2Lvufb/bNJSEo0EUS2dcrYObNULgbrnkK+o0JuiKJIgW6SKJaNQ0W3A2ZHeHWN6DzWUFXJFGmQBdJNKXFsHASLJ8Cp1wI1z0DLU4IuippBAp0kURyYLu3gfNXS2HwXXDRf2p3oSZE/6VFEsWWpV6YHzkA1z+rxbWaIAW6SLxzzmuv/G0StO4K4+ZCx9OCrkoCoEAXiWclh+G1n8HqadBzGFz7F0jPCroqCYgCXSReFeTBzJtg6yoYci8MmaQNnJu4WgPdzJoD7wLN/M/Pcc79ysxOBmYAbYGVwDjnXHE0ixUR3xfvwewJUHoExkyH3lcEXZHEgHB+nB8BLnLO9QPOAoab2bnAg8DDzrmewD7gtuiVKSKA1y//8HF4fiRktIWJ7yjM5ahaA915DvovU/0vB1wEzPGPTwWujkqFIuIpLoRXfgBv/Bx6fxd+8Da06xl0VRJDwuqhm1kysALoATwO5AL5zrlS/yN5QJeoVCgisPcLr1++4xO4+D/hO3d7W8WJVBBWoDvnyoCzzCwLmAtUtT+Vq+p7zWwiMBEgOzu7nmWKNGEb34I5fkfzxjnQ85Jg65GYVadL4s65fGAxcC6QZWblPxC6Alur+Z7Jzrkc51xO+/btG1KrSNPiHLz3R5h2vTe/fOJihbnUqNZAN7P2/sgcM0sHLgHWA+8A1/sfGw/Mi1aRIk3OkQMwaxws+jWccR3c9ndoe3LQVUmMC6fl0gmY6vfRk4BZzrkFZvYpMMPMfgusAqZEsU6RpmP3594WcXs2wmX3w7k/Ur9cwlJroDvn1gD9qzi+CRgYjaJEmqwNr8Pc270NKG5+FU6+IOiKJI7oTlGRWBAKwZIHYMmD0Lk/jH4BsroFXZXEGQW6SNCK8uGVifD5G3DWTXDFHyG1edBVSRxSoIsEacenMPNGyP/KC/Kc29Qvl3pToIsE5ZO58OqPoVkmTFgA2ecGXZHEOQW6SGMrK4W3fw3/eBS6nQOjpkKrTkFXJQlAgS7SmAr3wpxbYNNir70y/AFISQu6KkkQCnSRxrLtY5hxExzcASMfh/43BV2RJBgFukhj+HgG/PUuyGgHt/4NupwddEWSgBToItEQKvPWLX//IWjXC776CLqf723enKk1jSQ6FOgikbYnF2aPh90bobTIC/OMdvDdPyrMJaq0AaFIpE0ZBtvXeWFermgvPPfd4GqSJkGBLhJJB7bjbQ1w3PYALgQdqtpGQCRyFOgikeAcrHwBHhsIh/dD8nFTEdMyof+4YGqTJkOBLtJQe7/wNm2efweceAZ8/y1ITa/8maRk6DU8mPqkydBFUZH6CpXB0qfg7d+AJcMVD8HZt0BSEkzaEnR10gQp0EXqY+cGb0Setwx6DoMRD3vbxIkESIEuUhelxfCPR+DdP3h98Wv/AmeO0gqJEhMU6CLh+nolzL8Tdqzz9vkc/qDmlUtMUaCL1Ka4EBb/Dj58DDI7wpiXoLfmlEvsUaCL1GTz+96ofO8mGDAeLv01pGcFXZVIlRToIlU5vB/e+hUsfwbadIeb58MpQ4KuSqRGCnSR4332Biz4dziwDc67A4b+X0jLCLoqkVop0EXKHdoNCyfB2tnQvg+Mfh665gRdlUjYag10M+sGPA+cCISAyc65R82sLTAT6A5sBkY75/ZFr1SRKHEO1r0Mf7vHa7UMmQTn/0w7CUncCefW/1LgZ865PsC5wI/N7DRgErDIOdcTWOS/Fokv+7fCSzfAy7dB1klw+xIYep/CXOJSrSN059w2YJv//ICZrQe6ACOBC/2PTQUWA/dGpUqRSHMOVk6Fv/8Sykpg2P/AuT/01lwRiVN16qGbWXegP7AU6OiHPc65bWbWoZrvmQhMBMjOzm5IrSKRsSfX2w5u83veLkJX/QnanhJ0VSINFnagm1km8DLwU+fcfgvzVmfn3GRgMkBOTo6r5eMi0RMqg4/+DG//DySnwpWPenPLddu+JIiwAt3MUvHC/EXn3Cv+4R1m1skfnXcCdkarSJEG2/EpzPsxbF0J37ocRjwErToHXZVIRNV6UdS8ofgUYL1z7qEKb80HxvvPxwPzIl+eSAOVFsM7v4OnLoD8L+G6KXDDSwpzSUjhjNAHA+OAtWa22j/2c+ABYJaZ3QZsAUZFp0SRespb4Y3Kd62HM0fD8AegxQlBVyUSNeHMcnkfqK7JeHFkyxGJgOJD8M79Xr+8ZScYOwu+dVnQVYlEne4UlcSyaQn89SewbzPk3AqX/Dc0bxV0VSKNQoEuiaEoH978Jax83puCOOE16P6doKsSaVQKdIl/G16H1+6Ggztg0E/gwvu0mJY0SQp0iV8Hd3nrr3zyCnQ4HcZMhy4Dgq5KJDAKdIkPoTL48HF4/2H4zr9Di/bwxn3eBdChv4DBd2n9FWnyFOgS+/bkwuzx3mNJIbz1X+DKoOOZcN3T0KF30BWKxAQFusS+KcOgaC+4kPfalQHmbUChMBc5Kpzlc0WCc3i/d4GzPMyPctChTyAlicQqjdAlNh05AEufgg8fg6J9YMn+yNyXlgn9xwVXn0gM0ghdYsuRg/DeQ/BIX3j7N9B1IIz/KzTLrPy5pGToNTyYGkVilEboEhuKD8Gyp+Efj0LhHuhxqTefvOvZ3vuTtgRbn0gcUKBLsIoLYfkz8I9H4NAuOPUiL8i7DQy6MpG4o0CXYJQUwYrnvHnlB3fAyUNg6M8h+9ygKxOJWwp0aVwlh729PN97CA5u97aAG/UcnDQo6MpE4p4CXRpH6RFv4az3HoIDW+Gkwd5NQSefH3RlIglDgS7RVVoMq6fBu3+E/XnQ7Vy45gmvxaK9PEUiSoEu0VFWAqtf9IK8YIs3/XDk/8IpQxXkIlGiQJfIKiuBj2fAu7+H/C3Q5WwY8TD0uFhBLhJlCnSJjLJSWDsLljzo7RbU6Sz47h+h56UKcpFGokCXhgmVwdrZsOT3sDcXTuwLN8yAbw1XkIs0MgW61E+oDNa9AksegD0bvaVsv/ci9L5CQS4SEAW61E0o5O0QtOT3sPtf3k5Bo1+A3iMgSUsDiQSp1kA3s2eAEcBO59wZ/rG2wEygO7AZGO2c2xe9MiVwoRCsnweLH4Rd66F9b++GoD4jFeQiMSKcv4nPAccvazcJWOSc6wks8l9LIgqF4NP58OR3YPYEbwnb66bADz+A069RmIvEkFpH6M65d82s+3GHRwIX+s+nAouBeyNYlwTNOdjwGix+AHashRN6wLVPwxnXekvXikjMqW8PvaNzbhuAc26bmXWIYE0SJOfgs4Ww+Hew7WNoewpc8xSccT0k65KLSCyL+t9QM5sITATIzs6O9umkLkJl8OHj3oqH3/l3OKEnvPsgbF0FbbrD1U/AmaMV5CJxor5/U3eYWSd/dN4J2FndB51zk4HJADk5Oa6e55NI25MLs8d7jyWF8NavvH07W3aCqx6DfmMgOTXoKkWkDup7RWs+MN5/Ph6YF5lypNE8fQlsX+eFOfibMJt36/6AcQpzkThUa6Cb2UvAh0AvM8szs9uAB4BLzexz4FL/tcS6Iwfh45nwwjVQtBc4/h9MDjr0CaIykYTz5JJcPsjdXenYB7m7eXJJbtTOGc4slxuqeeviCNci0VBWCl8s9oJ8wwJvRJ6VDb2+C5sWHxuhA6RlQv9xQVUqklD6dm3NHdNX8djY/gw6tR0f5O4++jpadLUrETnnzVBZMwvWzfG2eGueBX2/5311OweKD8AjZ0JJhe9LSoZex99yICJVKS0LkV9UQn5hCfmFxeQXlrCvsJiCIu8xv7CEnh0yuXnKP8nKSKW0zPHnmwYw6NR2UatJgZ5I8rd4C2V9PNO7LT85Db51mRfiPYdBSrNjn23eGiZtCa5WkXp4ckkufbu2rhSKH+TuZk1eAf825NR6/ZplIcf+8hAuqhjOJRQUFrOvsOS448UUFJZw4Ehptb9mcpKRlZ5K64xU2rdsxraCw0wYdFJUwxwU6PGvKB8+neeNxr983zuWPQhGPAKnjYSMtsHWJxJBNbUxQiHHgcOl5Bf5IewHcL4fyhVHzhUDev/hElw18+/MoHV6Km0y0midnkq7zDR6dMgkKyOVrPQ02rRIpXV6KlkZabTxj2W1SKVlsxTM7Gh9P7moB9OWbmHY6SdGNdTNVfc7iYKcnBy3fPnyRjtfwiotho1vehtJfPYGlB3x5pD3+x6cOcqbQy4Sp5xzHDxS6ofxsZFz+Wh5/db9LPrXTjq3bk7eviLaZzbjcGkZBUUlhGqIs1bNU44Gb+uMNLLSU48+b5OR6oX00eNpZGWk0qp5KklJ9Vs9tOIPm+N/+NQ11M1shXMup7bPaYQeL5yDr/4Ja2Z6qx0W7YMW7SHnVug7Gjr317K1UmfRaGGUc85RWFxGflEJ+w55veVKfeZDx7c4jn2mtIZkzmyWQrPkJDbvKaRbm3T6dcsiK+PYKLo8jLP8xzYZabRqnkJKcuOuO7Qmr6BSeA86tR2Pje3PmryCqI3SFeixbk+uF+JrZno7AaWkQ58RXl/8lKG6i1MaJNyZGIdLyo61K8rbGUXH+smV3vNbHgWFJRSXhao9d3pqcqURcq8TW1YaIbfOOBbObTJSaZ3uPV+2ea/XxhjstTHGnpMd9d50fVT1A3HQqe3UcmlyDu32No9YMxO+Xg6WBCcP8UK8zwho1jLoCiVOHSkto8DvIZePkFds3ssLH23htE6tWLe1gL5dW5OcZJVaHkdKqw/mtJQk2tQ4QvbCuE2FY63TU2meWvdF3iLZxognarnEm5Ii+Nfr3sXNjW9BqNTbBWjYb72FsVp1CrpCCVM02xjlSspCfnvi2IyMoxcBK4yQ91W4MJhfVEJhcVm1v+aKLfvISEsmv7CENhlpdGubQd+ux0I4K708qI9dEMxKTyM9rfFW3wyijRFPFOhBCpXB5ve9EP90njc3vFUXOO8Ory/e8fSgK5R6qMsNJWUhdzSYvZkYxew7VMU0uaLKbY2DYUyZKx8ld85qTp9OrY5e+GtdcUZGRiqbdh3kV/M/4aZzT+LFpVv475Gnx2w4BtHGiCdquQRhxyd+X3w2HNgKaS29KYb9vgcnfUebRsSh8ilz5TMyPsjdzePvbOTs7DYs27yP83u2Iz0t+ejc5vKWx/7D1Qdzkj9l7tgI+VhvueKUuTYVLv61zjg2ZS4cTbWFEW/Cbbko0BvL/q2wdo43Gt+xFpJSoMel3ki81+WQmh50hYI3M+PAkdJK7YpjszK8dkbFFkb583CmzLVpkeaPnI8FdNZxYdymwkXBls1T6j1lLlyN0R6ShlOgB6XiGuPn/RhanujdvblpCeCg67e9i5unXwMtNAIKR31Cp3zKXNWzL8pvPPFbHJX6zyWU1ZDMLZuleCPk6i4CpqfSpkUqW/YW8fCbnzE6pysvr/iax27UiFfqTxdFg7AnF2be5D2WHYG3f+Mdb9UVhtzrjcZP0Kinrnp3bMmPpq3k3uG9OaldBks37eUv723iyn6duf/19cf6z5VuQql5ylxGWnKlEXLvE1v5I+SKF/8q33DSOj2V1DDmMn+Qu5s/LfqcJ/x1O4b27qA2hjQKjdAbIlQGO9d7UwvzlsHql7xNlCuyJEhvC/dEb8nMeFE+Za58RLyv0gi5+ouANU2Za5aSVGGEXLG3XMXdf37Lo3VGKs1SojczQ20MiTSN0KPhwHbI88P76xXeVm3FB7330ttAs1ZweF/l73GhmFxjvCGhE40pc6nJVmk9jOy2GfTt2rpSb/m9z3bx+rrt3DCwGz+5uCdtMtLqNZc52jQTQ4KiQK9OSZG3BG3FAC/4ynsvKQVOPBPOGgtdcqBrjreZ8ppZ8Nrdx0IeYnaN8b5dW3PHi6t44Loz6dEhk/c27uYPC//FuPNOYsr7XzR4lbnqpsxVughYYdSckZZc48yMD3J384cv9h5d5OjKfp3pdKouJItUpJYLeOuk7Mk91jrJWw471nk39wC0zvZCu2uOF+Cd+lY9K+VwgbfG+OGCY8eat4afrvUeo6ROq8yFOWXu+FXmKt7lF6kpc+HS1Dpp6tRyqUnhXvh6pT/yXu6Nvov8VklaJnQZAIN+cizAW3YM65d9culu+o5a+c02xtLd/NuQ2gO9ulXmjh8hV7zwty/MKXMVV5nr3q6F30tOY/WWfbz7+W6u6teZWwZ3j8gqc5GmuwNFwpP4gV5W4o2285Z7X18vhz0b/TfN62/3udJvnXwb2vfydu6ph6N3CN7Qn37dsli0YSe/mLuWOy7qwYI1W4+78Fd5yly4q8xlVZgy1yUr/WgA12eVuQ9ydzPtoy+PtjHGDOxG/3Yt6vV7jyb1pEXCk1gtF+egIM9vnfhf21ZD6WHv/RYdvNDuerb32Ll/rQtdVVxl7tgI2bv4V9Uqczv2H6GgqKTGX/P4KXPHr8Nc3Spz4UyZC5faGCLxIyFuLHpySS59O2cyaOdM70ad8+/mg/ajWbP1oDdqO3LQm2lSftEybzkc3O59c3Iz6HzW0YuWR04cQEFqR/YVlVa4y++40XKlOwHrv8rcZzsOsHJLPhf37sConG5H+89tMlJpVc9V5iJNU+tE4kdCBPrKVcvImPd9eqbsILm0iLLk5uwsy4SuObQt+pK0vf/CnBe4BenZ5LU4jdxmfVif1It1ZV3ZU0SdpsxVHiEfdxEwI/W4kXPVU+bKR7o3nZPNtKVbNOIVkQZrlIuiZjYceBRIBp52zj3QkF/veAPeHEPI9pLkj5KTyw7TicOEvlrIe6G+rHZXsyrUg9WhU8k/3JLkgopT5pLpnJVa45S58ue1TZkL1/Fti3NPPUFtDBFpNPUOdDNLBh4HLgXygGVmNt8592mkiqNDb5JttsM8AAAEpElEQVQ2v/+Nwzva5pA/5Hn6Z6QxNMpT5upCszFEJEgNGaEPBDY65zYBmNkMYCQQuUDvfzOleatIKT109FBpSgs6XTiRkf26ROw0kaLZGCISpIZMm+gCfFXhdZ5/LGKWpg2ksLRyj7+w1LE0bWAkTyMikhAaMkKvqrfxjSusZjYRmAiQnZ1dpxOs2hmibNzaSiPcdf5MjHNib3kUEZFANSTQ84BuFV53BbYe/yHn3GRgMnizXOpyArUwRETC15CWyzKgp5mdbGZpwBhgfmTKEhGRuqr3CN05V2pmdwBv4E1bfMY590nEKhMRkTpp0Dx059zrwOsRqkVERBpA28uLiCQIBbqISIJo1LVczGwX8GU9v70dsDuC5URbPNWrWqMnnuqNp1ohvuptaK0nOefa1/ahRg30hjCz5eEsThMr4qle1Ro98VRvPNUK8VVvY9WqlouISIJQoIuIJIh4CvTJQRdQR/FUr2qNnniqN55qhfiqt1FqjZseuoiI1CyeRugiIlKDuAh0MxtuZv8ys41mNinoeqpjZs+Y2U4zWxd0LeEws25m9o6ZrTezT8zsrqBrqo6ZNTezf5rZx36t/x10TbUxs2QzW2VmC4KupTZmttnM1prZajOL4k7uDWdmWWY2x8w2+P/vnhd0TdUxs17+n2n5134z+2nUzhfrLRd/Z6TPqLAzEnBDRHdGihAzuwA4CDzvnDsj6HpqY2adgE7OuZVm1hJYAVwdo3+2BrRwzh00s1TgfeAu59xHAZdWLTO7G8gBWjnnRgRdT03MbDOQ45yL+XndZjYVeM8597S/MGCGcy4/6Lpq42fZ18A5zrn63o9To3gYoR/dGck5VwyU74wUc5xz7wJ7g64jXM65bc65lf7zA8B6IrxJSaQ4z0H/Zar/FbOjETPrClwBPB10LYnEzFoBFwBTAJxzxfEQ5r6LgdxohTnER6BHfWckATPrDvQHlgZbSfX8FsZqYCfwpnMuZmsFHgHuAUJBFxImB/zdzFb4m9LEqlOAXcCzfjvraTNrEXRRYRoDvBTNE8RDoIe1M5LUn5llAi8DP3XO7Q+6nuo458qcc2fhbaYy0Mxisq1lZiOAnc65FUHXUgeDnXMDgMuBH/vtw1iUAgwAnnDO9QcOATF7Xa2c3xq6CpgdzfPEQ6CHtTOS1I/fj34ZeNE590rQ9YTD/yf2YmB4wKVUZzBwld+XngFcZGbTgi2pZs65rf7jTmAuXqszFuUBeRX+dTYHL+Bj3eXASufcjmieJB4CXTsjRYl/oXEKsN4591DQ9dTEzNqbWZb/PB24BNgQbFVVc87d55zr6pzrjvf/69vOuZsCLqtaZtbCvyiO374YBsTkTC3n3HbgKzPr5R+6GIi5i/hVuIEot1uggRtcNIZ42hnJzF4CLgTamVke8Cvn3JRgq6rRYGAcsNbvTQP83N+4JNZ0Aqb6MwWSgFnOuZifDhgnOgJzvZ/vpADTnXMLgy2pRncCL/oDvE3ALQHXUyMzy8CbpXd71M8V69MWRUQkPPHQchERkTAo0EVEEoQCXUQkQSjQRUQShAJdRCRBKNBFRBKEAl1EJEEo0EVEEsT/B8yDQ9hzSYSMAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "linear_data = np.array([1,2,3,4,5,6,7,8])\n",
    "exponential_data = linear_data**2\n",
    "\n",
    "plt.figure()\n",
    "# plot the linear data and the exponential data\n",
    "plt.plot(linear_data, '-x', exponential_data, '-p') #图形使用点线的设置方法很有趣"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11a65a390>]"
      ]
     },
     "execution_count": 67,
     "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": [
    "# plot another series with a dashed red line\n",
    "plt.plot([22,44,55], '--r') # -- 表示虚线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11a76b940>"
      ]
     },
     "execution_count": 68,
     "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": [
    "plt.xlabel('Some data')\n",
    "plt.ylabel('Some other data')\n",
    "plt.title('A title')\n",
    "# add a legend with legend entries (because we didn't have labels when we plotted the data series)\n",
    "plt.legend(['Baseline', 'Competition', 'Us'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PolyCollection at 0x11a7ff438>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFfFJREFUeJzt3VuMXWd5xvHnsZ0ICESBZhJZhNQgRbRVJQgapaBIiJK2SgsiuYAK1FZWFcm9oAhEJQjcIKRewA2HiwrJSmhdlVMaQIkQoo0CEeUiKePEIY4d27GT2OMZz8HxeA6e87y9+NbUjjOHvWf22t9aa/9/0mjP3rNG+5HlPF759rfe5YgQAKD+duQOAADoDAodABqCQgeAhqDQAaAhKHQAaAgKHQAagkIHgIag0AGgISh0AGiIXd18sxtvvDH27NnTzbcEgNo7ePDgeET0bXZcVwt9z549GhgY6OZbAkDt2X6lleNYcgGAhqDQAaAhKHQAaAgKHQAagkIHgIag0AGgISh0AGgICh0AGoJCB4ASLS9Lk5PdeS8KHQBKsrIiHT4sTU935/0odAAoQYR09Kh04UL33pNCB4ASHD8ujY119z0pdADosFOnpOHh7r8vhQ4AHXTmjHT6dJ73ptABoEPOnZNOnsz3/hQ6AHTA+Lh07FjeDBQ6AGzTxIR05Eja2ZJTS4Vu+wbbD9t+wfZR2x+w/Tbbj9k+UTy+teywAFA1U1PSc8+lPee5tXqG/m1Jv4iIP5D0HklHJd0v6fGIuE3S48VzAOgZly5Jv/tduhq0CjYtdNvXS/qgpAclKSIWImJC0j2SDhSHHZB0b1khAaBq5uelZ5+VFhdzJ7mslTP0d0kak/Svtp+x/YDt6yTdHBHDklQ83lRiTgCojMXFVObz87mTvFYrhb5L0vskfScibpc0ozaWV2zvsz1ge2Cs25dNAUCHLS+nZZZLl3Ineb1WCn1Q0mBEPFU8f1ip4Eds75ak4nF0rV+OiP0R0R8R/X19fZ3IDABZrA7bmprKnWRtmxZ6RJyTdMb2u4uX7pJ0RNKjkvYWr+2V9EgpCQGgAiLS1sRuDttq164Wj/uMpO/ZvlbSKUl/r/SPwUO275N0WtInyokIAPkdP54uHqqylgo9Ig5J6l/jR3d1Ng4AVM/Jk3mGbbWLK0UBYAOnT6eBW3VAoQPAOoaH0yjcuqDQAWANY2Np3bxOKHQAuMqFC+n2cbmHbbWLQgeAK0xNpb3mVRi21S4KHQAKVRu21S4KHQAkzc1Vb9hWuyh0AD1vcTGdmVdt2Fa7KHQAPa3Kw7baRaED6FkrK+luQ1UdttUuCh1AT1odtjUxkTtJ51DoAHrSsWPVH7bVLgodQM85eVI6dy53is6j0AH0lDoN22oXhQ6gZwwN1WvYVrsodAA9YWxMOnEid4pyUegAGq+uw7baRaEDaLTJyfoO22oXhQ6gsWZm0oVDdR221S4KHUAjzc2lS/rrPGyrXRQ6gMZZWEiTE+s+bKtdFDqARllaSmfms7O5k3QfhQ6gMVZW0geg09O5k+Sxq5WDbL8saUrSsqSliOi3/TZJP5K0R9LLkv46Ii6UExMANhYhPf98s4ZttaudM/Q/jYj3RkR/8fx+SY9HxG2SHi+eA0AWx45J58/nTpHXdpZc7pF0oPj+gKR7tx8HANr34ovNHLbVrlYLPST9t+2DtvcVr90cEcOSVDzetNYv2t5ne8D2wNjY2PYTA8AVXnlFGhzMnaIaWlpDl3RnRAzZvknSY7ZfaPUNImK/pP2S1N/f3/ALbwF009CQ9NJLuVNUR0tn6BExVDyOSvqppDskjdjeLUnF42hZIQHgaqOjzR+21a5NC932dbbfsvq9pL+QdFjSo5L2FoftlfRIWSEB4Erj49ILLzR/2Fa7WllyuVnST22vHv/9iPiF7d9Kesj2fZJOS/pEeTEBIBkZoczXs2mhR8QpSe9Z4/Xzku4qIxQArOXsWZZZNtLqh6IAkNUrr/AB6GYodACVd/Jkc+8D2kkUOoDKipCOH5eGh3MnqQcKHUAlRaTbxo2yIbplFDqAyllZSYO2en02S7sodACVsrycbhvXy1MTt4pCB1AZi4vp5hRTU7mT1BOFDqAS5udTmc/M5E5SXxQ6gOxmZ9M9QOfmciepNwodQFYzM6nMFxZyJ6k/Ch1ANpOT6QPQxcXcSZqBQgeQxcREKvPl5dxJmoNCB9B14+PSkSNpvzk6h0IH0FWMvy0PhQ6ga4aG0vhbyrwcFDqArjh9Wjp1KneKZqPQAZTu1KlU6CgXhQ6gNBFpiWVoKHeS3kChAyhFRPrwc2Qkd5LeQaED6DjG3+ZBoQPoKMbf5kOhA+gYxt/mtaPVA23vtP2M7Z8Vz99p+ynbJ2z/yPa15cUEUHULC9KhQ5R5Ti0XuqTPSjp6xfOvS/pmRNwm6YKk+zoZDEB9zM1JzzzDLPPcWip027dI+oikB4rnlvRhSQ8XhxyQdG8ZAQFU28xMKvPZ2dxJ0OoZ+rckfUHS6iid35M0ERFLxfNBSW/vcDYAFTc1lZZZ5udzJ4HUQqHb/qik0Yg4eOXLaxy65nQG2/tsD9geGBsb22JMAFUzMZHKnFnm1dHKLpc7JX3M9l9JeoOk65XO2G+wvas4S79F0prXgkXEfkn7Jam/v5+RPEADnD+f9pkz/rZaNj1Dj4gvRcQtEbFH0icl/TIi/kbSryR9vDhsr6RHSksJoDJGR6XDhynzKmpnl8vVvijp87ZfVFpTf7AzkQBU1dCQdPQo42+rqq0LiyLiCUlPFN+fknRH5yMBqCLG31YfV4oC2BTjb+uBQgewoRMnpLNnc6dAKyh0AGti/G39UOgAXmdlRTpyRBofz50E7aDQAbzG8nLalnjhQu4kaBeFDuD/LS2l8beTk7mTYCsodACS0vjbZ59lYmKdUegAND2dllnm5nInwXZQ6ECPGxmRjh3jUv4moNCBHhUhnTwpDQ7mToJOodCBHrSwkLYlciPnZqHQgR4zOZlG33JTiuah0IEeMjycLuVnvbyZKHSgB6ysSC++mMbforkodKDh5ufTEgsXCzUfhQ402MWLqcwXFnInQTdQ6EBDnT2bllm4u1DvoNCBhllZkY4fl86dy50E3UahAw0yN5eWWKamcidBDhQ60BAXLqSLhRYXcydBLhQ60ABnzqT7frJe3tsodKDGlpfTYK3R0dxJUAU7NjvA9hts/6/tZ20/b/urxevvtP2U7RO2f2T72vLjAlg1Oys9/TRljss2LXRJ85I+HBHvkfReSXfbfr+kr0v6ZkTcJumCpPvKiwngSq++Kh08yM0o8FqbFnok08XTa4qvkPRhSQ8Xrx+QdG8pCQG8xiuvSM89l24XB1yplTN02d5p+5CkUUmPSTopaSIiVv9KDUp6ezkRAUiXb9780kt8+Im1tVToEbEcEe+VdIukOyT94VqHrfW7tvfZHrA9MDY2tvWkQA+7dCktsYyP506CKmup0FdFxISkJyS9X9INtld3ydwiac05bhGxPyL6I6K/r69vO1mBnjQ+nsr80qXcSVB1rexy6bN9Q/H9GyX9maSjkn4l6ePFYXslPVJWSKAXRaTllcOH03ILsJlW9qHvlnTA9k6lfwAeioif2T4i6Ye2/1nSM5IeLDEn0FOWltJVn6++mjsJ6mTTQo+I30m6fY3XTymtpwPooJmZdFY+O5s7CeqGK0WBChkdTVd+ssSCraDQgQqISLNYzpzJnQR1RqEDmS0upvXyCxdyJ0HdUehARlNTaX753FzuJGgCCh3I5Ny5dGehlZXcSdAUFDrQZRHpXp9nz+ZOgqah0IEuWlhISywXL+ZOgiai0IEumZxMZT4/nzsJmopCB7pgaCgts7BejjJR6ECJVlakEyek4eHcSdALKHSgJHNzaX/55GTuJOgVFDrQYRFpB8tLL3EJP7qLQgc6aGYmzWLhrBw5UOhAB0RIp0+n+33ywSdyodCBbZqaSmfl09ObHwuUiUIHtmhlJa2TDw5y02ZUA4UObMHERDor5yYUqBIKHWjD0lKaWz605i3RgbwodKBF58+n6Yhcuo+qotCBTSwupsv2R0ZyJwE2RqEDGxgdTZfuLy7mTgJsjkIH1jA/n5ZXzp/PnQRoHYUOXGVoKH3wubSUOwnQnh2bHWD7HbZ/Zfuo7edtf7Z4/W22H7N9onh8a/lxgfLMzkqHDqUzc8ocdbRpoUtakvRPEfGHkt4v6dO2/0jS/ZIej4jbJD1ePAdqJ0I6c0YaGEj7y4G62nTJJSKGJQ0X30/ZPirp7ZLukfSh4rADkp6Q9MVSUgIlYZgWmqStNXTbeyTdLukpSTcXZa+IGLZ90zq/s0/SPkm69dZbt5MV6JiVlcvDtLhsH03RypKLJMn2myX9WNLnIqLl85mI2B8R/RHR39fXt5WMQEdNTkoHD0ovv0yZo1laOkO3fY1SmX8vIn5SvDxie3dxdr5b0mhZIYFOWF5OJc4wLTRVK7tcLOlBSUcj4htX/OhRSXuL7/dKeqTz8YDOmJhIH3qeOUOZo7laOUO/U9LfSXrO9qHitS9L+pqkh2zfJ+m0pE+UExHYuqUl6eRJbtKM3tDKLpffSPI6P76rs3GAzhkfT5ftM0wLvYIrRdE4i4upyEf5VAc9hkJHo4yMpMmIDNNCL6LQ0QgM0wIodDQAw7SAhEJHbc3Opsv2mb8CJBQ6amd1mNbLL6dL+AEkFDpqZXo6nZVPTeVOAlQPhY5auHQpnZGPjXGlJ7AeCh2VdulSmog4OkqRA5uh0FFJs7PpjJwiB1pHoaNSZmfTGfnICEUOtItCRyXMzaUiP3eOIge2ikJHVhQ50DkUOrKYn79c5OwlBzqDQkdXzc+ne3kOD1PkQKdR6OiKhYV0Rk6RA+Wh0FGqhYV0Rj40RJEDZaPQUYqFhTRv5exZihzoFgodHbW4ePmMfHk5dxqgt1Do6IjFxctn5BQ5kAeFjm1ZWkpFPjhIkQO5UejYktUiP3uWOwUBVbFjswNsf9f2qO3DV7z2NtuP2T5RPL613JioiqWlNDTrySfTNkTKHKiOTQtd0r9Juvuq1+6X9HhE3Cbp8eI5GmxpKRX4k0+mQqfIgerZdMklIn5te89VL98j6UPF9wckPSHpix3MhYpYXk7r44OD6YNPANW11TX0myNiWJIiYtj2TR3MhApYXk7r42fOUORAXZT+oajtfZL2SdKtt95a9tthm5aX0x7y06cpcqButlroI7Z3F2fnuyWNrndgROyXtF+S+vv7GZBaUSsrl8/IFxZypwGwFVst9Ecl7ZX0teLxkY4lQlctL6eBWadPU+RA3W1a6LZ/oPQB6I22ByV9RanIH7J9n6TTkj5RZkh0VoR04UK6zdv4OBcEAU3Ryi6XT63zo7s6nAUlm5pKJT46ytk40ERcKdpwc3OpxEdGpEuXcqcBepPdnfeh0BtoaUkaG0u3d7t4MXcaoDl27pR27ZKuuSZ9rfX9Wq9R6GjLyor06qvpTPz8eWaQAxvZsWP98t2onHe0cm19RhR6zV28mEp8bIx94+g9O3ZsfGa8XjlXvZi3ikKvoUuXLn+4OTubOw2wffbmyxZrvbZzZ+7k1UKh18TiYirwc+fSbhWgiuzXF3Ar5byLJuoI/hgrbGUl7RMfGUnr48F1tuiiVs+Sr34N+fDHXzER0sTE5XVxLvrBdq2eAbezzrxrV/d2ZqBzKPSKmJlJyymjo9L8fO40qKKdO7e2zkwx9w4KPaP5+cvr4jMzudOgW5q6ZQ75UehdtrycllJGRtLSCuvi9bXZlrn1CptiRlko9C6IuHzRz/g4F/1UzZU7M9gyhzqj0Es0OXl5vzgX/ZRvtZjbLWd2ZqAp+KvcQUtLqcQvXkzLKgzD2rqtLGVQzOh1/CewRRHpg8zJyctfFPjrbbZlbr3X2JkBtI9Cb9H8/GvLe3q6t/aIs2UOqD4KfQ3Ly+ny+snJy49N2Ru+umWu3XJmZwZQfRS60tLJanFPTqbnVd9OyJQ5AFfruUJfXHzt0snUVPowM5dWpsyt9XO2zAG4WqMLfWUlrXVfuXRS1rjZVqfMXf1zdmYA6JRG1cns7GuXTqant3YRz1aWMihmALnVtoaWll5b3lNTr7+T/a5d0rXXMmUOQG/YVqHbvlvStyXtlPRARHytI6nWsLSU9nnPzqavxcXLSxZ9fdLu3WyZA9DbtlzotndK+hdJfy5pUNJvbT8aEUc6Fe5Ku3ZJ11+fvgAAr7edTWx3SHoxIk5FxIKkH0q6pzOxAADt2k6hv13SmSueDxavAQAy2E6hr7VC/brLcWzvsz1ge2BsbGwbbwcA2Mh2Cn1Q0juueH6LpKGrD4qI/RHRHxH9fX1923g7AMBGtlPov5V0m+132r5W0iclPdqZWACAdm15l0tELNn+R0n/pbRt8bsR8XzHkgEA2rKtfegR8XNJP+9QFgDANjB7DwAagkIHgIZwdHHwt+0xSa9s8ddvlDTewThlq1NespanTnnrlFWqV97tZv39iNh0m2BXC307bA9ERH/uHK2qU16ylqdOeeuUVapX3m5lZckFABqCQgeAhqhToe/PHaBNdcpL1vLUKW+dskr1ytuVrLVZQwcAbKxOZ+gAgA3UotBt3237mO0Xbd+fO896bH/X9qjtw7mztML2O2z/yvZR28/b/mzuTOux/Qbb/2v72SLrV3Nn2oztnbafsf2z3Fk2Y/tl28/ZPmR7IHeejdi+wfbDtl8o/u5+IHem9dh+d/Fnuvo1aftzpb1f1ZdcijsjHdcVd0aS9Kmy7oy0HbY/KGla0r9HxB/nzrMZ27sl7Y6Ip22/RdJBSfdW9M/Wkq6LiGnb10j6jaTPRsSTmaOty/bnJfVLuj4iPpo7z0ZsvyypPyIqv6/b9gFJ/xMRDxSDAd8UERO5c22m6LKzkv4kIrZ6Pc6G6nCGXps7I0XEryW9mjtHqyJiOCKeLr6fknRUFb1JSSTTxdNriq/Kno3YvkXSRyQ9kDtLk9i+XtIHJT0oSRGxUIcyL9wl6WRZZS7Vo9C5M1IX2N4j6XZJT+VNsr5iCeOQpFFJj0VEZbNK+pakL0hayR2kRSHpv20ftL0vd5gNvEvSmKR/LZazHrB9Xe5QLfqkpB+U+QZ1KPSW7oyErbP9Zkk/lvS5iJjMnWc9EbEcEe9VupnKHbYruaxl+6OSRiPiYO4sbbgzIt4n6S8lfbpYPqyiXZLeJ+k7EXG7pBlJlf1cbVWxNPQxSf9Z5vvUodBbujMStqZYj/6xpO9FxE9y52lF8b/YT0i6O3OU9dwp6WPFuvQPJX3Y9n/kjbSxiBgqHkcl/VRpqbOKBiUNXvF/Zw8rFXzV/aWkpyNipMw3qUOhc2ekkhQfND4o6WhEfCN3no3Y7rN9Q/H9GyX9maQX8qZaW0R8KSJuiYg9Sn9ffxkRf5s51rpsX1d8KK5i+eIvJFVyp1ZEnJN0xva7i5fuklS5D/HX8CmVvNwibfMGF91Qpzsj2f6BpA9JutH2oKSvRMSDeVNt6E5JfyfpuWJtWpK+XNy4pGp2SzpQ7BTYIemhiKj8dsCauFnST9O/79ol6fsR8Yu8kTb0GUnfK07wTkn6+8x5NmT7TUq79P6h9Peq+rZFAEBr6rDkAgBoAYUOAA1BoQNAQ1DoANAQFDoANASFDgANQaEDQENQ6ADQEP8HCX4nMhyFXcAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fill the area between the linear data and exponential data\n",
    "plt.gca().fill_between(range(len(linear_data)), \n",
    "                       linear_data, exponential_data, \n",
    "                       facecolor='blue', \n",
    "                       alpha=0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try working with dates!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11aa46748>,\n",
       " <matplotlib.lines.Line2D at 0x11aa6e198>]"
      ]
     },
     "execution_count": 70,
     "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": [
    "plt.figure()\n",
    "\n",
    "observation_dates = np.arange('2017-01-01', '2017-01-09', dtype='datetime64[D]')\n",
    "\n",
    "plt.plot(observation_dates, linear_data, '-o',  observation_dates, exponential_data, '-o')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try using pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "matplotlib does not support generators as input",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/units.py\u001b[0m in \u001b[0;36mget_converter\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    168\u001b[0m                 \u001b[0;31m# get_converter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 169\u001b[0;31m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxravel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmask\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    170\u001b[0m                     \u001b[0;31m# some elements are not masked\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'mask'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-71-d8577b79c140>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mobservation_dates\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'2017-01-01'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'2017-01-09'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'datetime64[D]'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mobservation_dates\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_datetime\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobservation_dates\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# trying to plot a map will result in an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobservation_dates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlinear_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'-o'\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0mobservation_dates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexponential_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'-o'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   3356\u001b[0m                       mplDeprecation)\n\u001b[1;32m   3357\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3358\u001b[0;31m         \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3359\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3360\u001b[0m         \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_hold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwashold\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1853\u001b[0m                         \u001b[0;34m\"the Matplotlib list!)\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlabel_namer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1854\u001b[0m                         RuntimeWarning, stacklevel=2)\n\u001b[0;32m-> 1855\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1856\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1857\u001b[0m         inner.__doc__ = _add_data_doc(inner.__doc__,\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1525\u001b[0m         \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormalize_kwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_alias_map\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1526\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1527\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_lines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1528\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1529\u001b[0m             \u001b[0mlines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_grab_next_args\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    404\u001b[0m                 \u001b[0mthis\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    405\u001b[0m                 \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 406\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mseg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_plot_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    407\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mseg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    408\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_plot_args\u001b[0;34m(self, tup, kwargs)\u001b[0m\n\u001b[1;32m    381\u001b[0m             \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mindex_of\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    382\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 383\u001b[0;31m         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_xy_from_xy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    384\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    385\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcommand\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'plot'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_xy_from_xy\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m    213\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_xy_from_xy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    214\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxaxis\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0myaxis\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 215\u001b[0;31m             \u001b[0mbx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_units\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    216\u001b[0m             \u001b[0mby\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0myaxis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_units\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    217\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mupdate_units\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m   1461\u001b[0m         \"\"\"\n\u001b[1;32m   1462\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1463\u001b[0;31m         \u001b[0mconverter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmunits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mregistry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_converter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1464\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mconverter\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1465\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/units.py\u001b[0m in \u001b[0;36mget_converter\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    180\u001b[0m                 if (not isinstance(next_item, np.ndarray) or\n\u001b[1;32m    181\u001b[0m                         next_item.shape != x.shape):\n\u001b[0;32m--> 182\u001b[0;31m                     \u001b[0mconverter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_converter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext_item\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    183\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mconverter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    184\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/units.py\u001b[0m in \u001b[0;36mget_converter\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    186\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mconverter\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    187\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 188\u001b[0;31m                 \u001b[0mthisx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msafe_first_element\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    189\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    190\u001b[0m                 \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/matplotlib/cbook/__init__.py\u001b[0m in \u001b[0;36msafe_first_element\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m   2355\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2356\u001b[0m             \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2357\u001b[0;31m         raise RuntimeError(\"matplotlib does not support generators \"\n\u001b[0m\u001b[1;32m   2358\u001b[0m                            \"as input\")\n\u001b[1;32m   2359\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: matplotlib does not support generators as input"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "plt.figure()\n",
    "observation_dates = np.arange('2017-01-01', '2017-01-09', dtype='datetime64[D]')\n",
    "observation_dates = map(pd.to_datetime, observation_dates) # trying to plot a map will result in an error\n",
    "plt.plot(observation_dates, linear_data, '-o',  observation_dates, exponential_data, '-o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11c38e400>,\n",
       " <matplotlib.lines.Line2D at 0x11c3a5b38>]"
      ]
     },
     "execution_count": 72,
     "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": [
    "plt.figure()\n",
    "observation_dates = np.arange('2017-01-01', '2017-01-09', dtype='datetime64[D]')\n",
    "observation_dates = list(map(pd.to_datetime, observation_dates)) #此处解决上面的error：convert the map to a list to get rid of the error\n",
    "plt.plot(observation_dates, linear_data, '-o',  observation_dates, exponential_data, '-o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = plt.gca().xaxis\n",
    "\n",
    "# rotate the tick labels for the x axis\n",
    "for item in x.get_ticklabels():\n",
    "    item.set_rotation(45) #解决坐标轴数值太长彼此重叠的问题！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# adjust the subplot so the text doesn't run off the image\n",
    "plt.subplots_adjust(bottom=0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Exponential vs. Linear performance')"
      ]
     },
     "execution_count": 75,
     "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": [
    "ax = plt.gca()\n",
    "ax.set_xlabel('Date')\n",
    "ax.set_ylabel('Units')\n",
    "ax.set_title('Exponential vs. Linear performance')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Exponential ($x^2$) vs. Linear ($x$) performance')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can add mathematical expressions in any text element\n",
    "ax.set_title(\"Exponential ($x^2$) vs. Linear ($x$) performance\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bar Charts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 77,
     "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": [
    "plt.figure()\n",
    "xvals = range(len(linear_data))\n",
    "plt.bar(xvals, linear_data, width = 0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 78,
     "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": [
    "new_xvals = []\n",
    "\n",
    "# plot another set of bars, adjusting the new xvals to make up for the first set of bars plotted\n",
    "for item in xvals:\n",
    "    new_xvals.append(item+0.3)\n",
    "\n",
    "plt.bar(new_xvals, exponential_data, width = 0.3 ,color='red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 79,
     "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": [
    "from random import randint\n",
    "linear_err = [randint(0,15) for x in range(len(linear_data))] \n",
    "\n",
    "# This will plot a new set of bars with errorbars using the list of random error values\n",
    "plt.bar(xvals, linear_data, width = 0.3, yerr=linear_err) #加入了线性误差\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 80,
     "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": [
    "# stacked bar charts are also possible\n",
    "plt.figure()\n",
    "xvals = range(len(linear_data))\n",
    "plt.bar(xvals, linear_data, width = 0.3, color='b')\n",
    "plt.bar(xvals, exponential_data, width = 0.3, bottom=linear_data, color='r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 81,
     "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": [
    "# or use barh for horizontal bar charts\n",
    "plt.figure()\n",
    "xvals = range(len(linear_data))\n",
    "plt.barh(xvals, linear_data, height = 0.3, color='b')\n",
    "plt.barh(xvals, exponential_data, height = 0.3, left=linear_data, color='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dejunkifying a Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/xiucat/anaconda3/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Passing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.\n",
      "  warnings.warn(message, mplDeprecation, stacklevel=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "languages =['Python', 'SQL', 'Java', 'C++', 'JavaScript']\n",
    "pos = np.arange(len(languages))\n",
    "popularity = [56, 39, 34, 34, 29]\n",
    "\n",
    "plt.bar(pos, popularity, align='center')\n",
    "plt.xticks(pos, languages)\n",
    "plt.ylabel('% Popularity')\n",
    "plt.title('Top 5 Languages for Math & Data \\nby % popularity on Stack Overflow', alpha=0.8)\n",
    "\n",
    "#TODO: remove all the ticks (both axes), and tick labels on the Y axis\n",
    "#去掉图例上的横杠，以及横轴或者纵轴的标签，使用tick_params完成\n",
    "plt.tick_params(top='off', bottom='off', left='off', right='off', labelleft='off', labelbottom='on')\n",
    "# remove the frame of the chart\n",
    "# 去掉图中的边框\n",
    "for spine in plt.gca().spines.values():\n",
    "    spine.set_visible(False)\n",
    "\n",
    "    \n",
    "# 根据需要改变bar的颜色change the bar colors to be less bright blue\n",
    "bars = plt.bar(pos, popularity, align='center', linewidth=0, color='lightslategrey')\n",
    "# make one bar, the python bar, a contrasting color\n",
    "#对特定bar（使用[0]定位）改变颜色\n",
    "bars[0].set_color('#1F77B4')\n",
    "\n",
    "# soften all labels by turning grey\n",
    "#更改label标签的颜色（这里实际改的是透明度 alpha）\n",
    "plt.xticks(pos, languages, alpha=0.5)\n",
    "plt.ylabel('% Popularity', alpha=0.5)\n",
    "plt.title('Top 5 Languages for Math & Data \\nby % popularity on Stack Overflow', alpha=0.8)\n",
    "  \n",
    "\n",
    "# direct label each bar with Y axis values\n",
    "for bar in bars:#下一行：在bar的柱体内加入text\n",
    "    plt.gca().text(bar.get_x() + bar.get_width()/2, bar.get_height() - bar.get_height()*0.15, str(int(bar.get_height())) + '%', \n",
    "                 ha='center', color='w', fontsize=11)\n",
    "    \n",
    "    \n",
    "plt.show()\n",
    "\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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}