{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Post Exam Python-Matplotlib tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "matplotlib is an excellent 2D (and 3D) python library that can be used to produce publication quality output from your data. The website https://matplotlib.org/ provides a complete resource for how to use matplotlib for your work. In particular if you click on an example plot in the gallery, https://matplotlib.org/gallery/index.html, the browser will display the code required to produce the plot. It is quite difficult to ask google \"I would like my plot to look like this, and have these features, how do I do it?\", however it is easy to browse through the gallery until you see the feature that you are interested in.\n",
    "\n",
    "Unlike software like Excel in matplotlib you write code to determine the appearance of all aspects of your graph, you can recycle this code to easily create reproducable, consistent publication quality representations of your scientific data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preparing the notebook for using matplotlib and numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline \n",
    "# this line is required for the plots to appear in the Jupyter cells, rather than launching the matplotlib GUI\n",
    "\n",
    "import matplotlib\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Let printing work the same in Python 2 and 3\n",
    "from __future__ import print_function\n",
    "\n",
    "# notice two underscores _ either side of future"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create some data for plotting examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=np.linspace(0,2*np.pi, 100)\n",
    "y=np.cos(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate the basic matplotlib 2D plot, figure() creates the space into which the plot will be added."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22c5ec95668>]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3XlcVXX+x/HXh11AUQRXQARxITUXtNIy19KytLLFprJtrMyamWambJpqlvrVtGfLlO3bVI7VaGUuuZQtlrivCK4gKijiAioCn98fXGfQUMF74dx7+Twfj/vg3nPPufd9se6b71lFVTHGGGOOCnA6gDHGGO9ixWCMMeYYVgzGGGOOYcVgjDHmGFYMxhhjjmHFYIwx5hhWDMYYY45hxWCMMeYYVgzGGGOOEeR0gNMRExOjiYmJTscwxhifsnjx4l2qGnuq+XyyGBITE0lPT3c6hjHG+BQR2VKd+WxVkjHGmGNYMRhjjDmGFYMxxphjWDEYY4w5hhWDMcaYY3ikGETkTRHJE5FVJ3heRGSiiGSJyAoR6VHpuTEikum6jfFEHmOMMafPUyOGt4GhJ3l+GJDiuo0F/gkgItHAw8BZQG/gYRFp4qFMxhhjToNHjmNQ1W9FJPEks4wA3tWK64guFJHGItIS6A/MVtUCABGZTUXBfOiJXMf7dEkO2/YcJCo8mKgGwTRvFEanlo2IahBcG29njDGnraxc2Zh/gA35Rew9WMLeg0fYe/AIvz4vicbhIbX63nV1gFtrILvS4xzXtBNN/wURGUvFaIOEhITTCvHFiu3MXZf3i+kJ0eF0T2jMBakt6N8hlohQnzzuzxjjw1SVNdv3MXPVDr7L2sXa7fs5eKTsmHkCBEZ2a+03xSBVTNOTTP/lRNVJwCSAtLS0Kuc5lTdv7MXh0jL2HSxl36EjZBcUszp3H6tz9/Jd5i6mLsslNCiAgR2bcWOfRHq3jUakqojGGOMZBUUlvL9wC1MW57C1oJgAge4JTRjdO4EzWjWiQ4uGNIkIoVFYEJGhQXXynVRXxZADxFd6HAfkuqb3P276/NoMEhoUSGzDQGIbhpIcG0n/Ds2AimHbos0FzFi1g6nLtvHVqh10jYtibL8kLurckoAAKwhjjOds3V3Mq99u4JMlORw6Us55KTGM65/M4NTmxESGOppNKlb7e+CFKrYxfKGqnat47mJgPHARFRuaJ6pqb9fG58XA0b2UlgA9j25zOJG0tDStzXMlHSwp45MlObzx3SY27SqiW3xjHroklR4Jtl3cGOOeA4dLeXFuFm9+twmAy7q35tbz2pLSvGGtv7eILFbVtFPO54liEJEPqfjLPwbYScWeRsEAqvqKVIx9XqRiw3IxcJOqpruWvRn4k+ulHlXVt071frVdDEeVlyufLt3GEzPWkbf/MJd1b82Dw1OJjqjd9XvGGP+jqkxdlssjX65l14HDXN6jNfde2JEWUWF1lqFOi6Gu1VUxHFV0uJSX52cx6duNNA4P4YlRXRngWgVljDGnsqeohAf+s5LpK3fQLb4xf7n0DLrFN67zHFYMtWBN7j5++/FS1u88wPVnt+GBizsRFhxY5zmMMb5jQWY+v5+8nD3FJfxuSHtu65dMoEPbLKtbDHZKjBpIbdWIaePP5dZz2/Lewi1cPWkhO/cdcjqWMcYLqSqTvt3AmDd/plGDYD4b15dx/ds5Vgo1YcVQQ2HBgfx5eCqvXNeTzJ37ueSF71i6dY/TsYwxXuTQkTLumbyc/5u+jqGdWzBtfF86t45yOla1WTGcpqGdW/DpuD6EBgdw9aSFfLVyu9ORjDFeoLC4hNGvLeSzpdu4Z0h7Xrq2B+EhvnXQrBWDGzq2aMTUO8+lS+so7vzXEianZ596IWOM38rbd4irX13I6m37+OevenD3oBSfPEjWisFN0REhvHdLb/q2i+HeKSt4fcFGpyMZYxyQXVDMqFd+JHtPMW/f1IthXVo6Hem0WTF4QHhIEK+PSWNY5xY88uVaXp6f5XQkY0wdyi4o5spXfmTvwSN8cOtZ9GkX43Qkt1gxeEhoUCAvjO7OiG6teGJGBm9/v8npSMaYOrB970GufX0hh0rL+Gjs2XT3gzMk+NYWES8XFBjAU1eeycGSMv7y+RrCQ4K4qlf8qRc0xvik/P2H+dXrP7Gn6Aj/+vVZdGrZyOlIHmEjBg8LDgzghWu70699LPd9uoIvV9jeSsb4o32HjnDDmz+zvfAQb93Ui65xdX8kc22xYqgFoUGBvHpdT3okNOF3k5exeMtJzwlojPExR8rKufODJWTu3M+r1/ekV2K005E8yoqhljQICeS1G9JoFRXGr99dzJbdRU5HMsZ4gKry4H9WsSBzF/93eRf6tY91OpLHWTHUouiIEN66qTeqyk1vLWJPUYnTkYwxbnp5/gY+WpTN+AHtuCrNP7chWjHUsrYxEbx2Qxo5hQcZ/+ESSsvKnY5kjDlNs1bv4MmZGVx6Zit+f0F7p+PUGiuGOpCWGM2jIzvzfdZunpyZ4XQcY8xp2JB/gHsmL6drXBRPjOrqk0c0V5dHikFEhopIhohkiciEKp5/VkSWuW7rRaSw0nNllZ6b5ok83ujKtHiuP7sNr367kS9W5DodxxhTAwcOl3Lbe4sJCQrgn9f19PvT7bt9HIOIBAIvAUOouIbzIhGZpqprjs6jqr+rNP9dQPdKL3FQVbu5m8MXPDg8lbXb9/HHf6+gXbNIOrbwj32ejfFnqsofJi9n064i3rulN60bN3A6Uq3zxIihN5ClqhtVtQT4CBhxkvlHAx964H19TkhQAC//qgeRYUGM+2AJxSWlTkcyxpzCm99vZsbqHdw/rCN9kn37VBfV5YliaA1UPq1ojmvaL4hIG6AtMLfS5DARSReRhSIy0gN5vFqzRmE8f003Nu0q4uGpq52OY4w5iZU5e3n8q7UMSW3OLee2dTpOnfFEMVS1BeZE1wu9BpiiqmWVpiW4LjV3LfCciCRX+SYiY10Fkp6fn+9eYof1SY7hrgHt+PfiHP6zdJvTcYwxVdh/6AjjP1xCbGQoT/r5xubjeaIYcoDKO/PGASfaunoNx61GUtVc18+NwHyO3f5Qeb5Jqpqmqmmxsb5/QMndg1LoldiEBz5byaZddvCbMd5EVXngs1VkFxTz/OjuNA4PcTpSnfJEMSwCUkSkrYiEUPHl/4u9i0SkA9AE+LHStCYiEuq6HwP0BdYcv6w/CgoM4PlruhMUGMBvPlrKETu+wRiv8Z9l25i2PJffDm7vd6e7qA63i0FVS4HxwExgLTBZVVeLyN9E5NJKs44GPlLVyquZOgHpIrIcmAc8XnlvJn/XqnEDHru8Cyty9vLyvA1OxzHGALmFB3lo6mrS2jThzgHtnI7jCI+cdltVpwPTj5v20HGP/1LFcj8AXTyRwVdd1KUlI7u14oW5mQzoGOtXZ2g0xteUlyt/nLKcsnLl6avOJDCg/mxXqMyOfPYCf720MzGRodwzeTmHjpSdegFjTK14b+EWvs/azZ8vTqVN0win4zjGisELRIUH8+SVXcnKO2CnzDDGIRvzD/DYV2sZ0CGW0b398+R41WXF4CXOS4nl+rPb8Ob3m1iydY/TcYypV8rLlQmfrCQkMIB/XFG/dk2tihWDF7lvWEdaNgrjvikrOFxqq5SMqSsf/LyVnzcX8ODwVJo1CnM6juOsGLxIZGgQj17ehcy8A7xkeykZUye2FR7k8elrOS8lhlE945yO4xWsGLzMgA7NuLx7a16el8Xa7fucjmOMX6s4kG0lCvzfZV3q/Sqko6wYvNCDw1OJahDMhE9WUFZ+orOLGGPcNW15LvMz8vnjhR2Ijw53Oo7XsGLwQk0iQnjoklSW5+zlXz9tcTqOMX5pb/ER/v7FGs6Mi+KGcxKdjuNVrBi81KVntqJvu6Y8MSODvP2HnI5jjN95ctY6CopKePSyLvX2QLYTsWLwUiLC30d05nBpOY98sdbpOMb4lWXZhXzw01bG9Emkc+sop+N4HSsGL5YUG8nt/ZOZtjyX7zJ3OR3HGL9QWlbOA5+tpFnDUO4Z0t7pOF7JisHLjeufTJum4Tw4dZUd22CMB7y3cAurc/fx0PAzaBgW7HQcr2TF4OXCggP566VnsGlXEW9+t9npOMb4tF0HDvPM7PWclxLDRV1aOB3Ha1kx+ID+HZoxuFNzXpibyc59tiHamNP11MwMDpaU8fAlqXbMwklYMfiIB4d3orRceWy6bYg25nSsyCnk4/RsbuyTSLtmDZ2O49WsGHxEm6YRjD0vif8sy2XR5gKn4xjjU8rLlYemrqZpRCi/GZzidByv55FiEJGhIpIhIlkiMqGK528UkXwRWea63VrpuTEikum6jfFEHn81bkAyLaPCeHjqajsi2pga+HTpNpZlFzJhWEfb4FwNbheDiAQCLwHDgFRgtIikVjHrx6razXV73bVsNPAwcBbQG3hYRJq4m8lfhYcEcf9FnVizfR9TFmc7HccYn1B0uJQnZqzjzPjGXN69tdNxfIInRgy9gSxV3aiqJcBHwIhqLnshMFtVC1R1DzAbGOqBTH7rkq4t6ZHQmCdnrufA4VKn4xjj9V79ZgN5+w/z0PBOBNgRztXiiWJoDVT+8zXHNe14V4jIChGZIiJHL49U3WWNi4jw4PBUdh04zD/nZzkdxxivllt4kEkLNjK8a0t6tol2Oo7P8EQxVFXBx68A/xxIVNWuwNfAOzVYtmJGkbEiki4i6fn5+acd1h90T2jCiG6teG3BJnL2FDsdxxiv9eTMDMoVJgzr6HQUn+KJYsgBKl8gNQ7IrTyDqu5W1cOuh68BPau7bKXXmKSqaaqaFhsb64HYvu3eoR0R4B8z7BrRxlRlWXYhny3dxq3ntiWuiZ1SuyY8UQyLgBQRaSsiIcA1wLTKM4hIy0oPLwWO7ow/E7hARJq4Njpf4JpmTqF14waM7ZfE58tzWWrXiDbmGKrKo1+uISYylHED2jkdx+e4XQyqWgqMp+ILfS0wWVVXi8jfRORS12x3i8hqEVkO3A3c6Fq2APg7FeWyCPiba5qphtvOTyYmMoTHvlqHqu2+asxRs9fsZNHmPfxuSAqRoUFOx/E54otfKGlpaZqenu50DK/w3sItPPifVbx+QxqDU5s7HccYx5WWlXPBc98CMOu3/QgKtON4jxKRxaqadqr57Dfm467pFU9STASPz1hHaVm503GMcdzH6dlszC9iwtCOVgqnyX5rPi44MID7hnUkK+8A/16c43QcYxxVdLiUZ2dn0jsxmiE2gj5tVgx+4ILU5qS1acIzs9dTXGIHvZn667UFG9l14DD3X9TRzp7qBisGPyAi3H9RR/L3H+at7zc7HccYR+w6cJjXvt3IsM4t6J5gZ9ZxhxWDn+jZJprBnZrzyvwN7CkqcTqOMXXupXlZHCot5w8XdnA6is+zYvAjf7ywAwdKSnnlmw1ORzGmTmUXFPPBwq1c2TOO5NhIp+P4PCsGP9KhRUMu696at3/YzPa9B52OY0ydee7rTBDsWgseYsXgZ343uD3lqkyck+l0FGPqRMaO/Xy6NIcb+yTSMqqB03H8ghWDn4mPDudXZ7VhcnoOG/IPOB3HmFr31KwMIkOCuOP8ZKej+A0rBj80fmA7QgIDKobXxvixZdmFzF6zk1/3S6JJRIjTcfyGFYMfiokM5aa+iXy+PJe12/c5HceYWvP0rAyiI0K4+dy2TkfxK1YMfuq2fsk0DAvi6VnrnY5iTK34aeNuFmTu4o7zk+1EeR5mxeCnosKDGXteEl+v3cmy7EKn4xjjUarKU7MyaN4olOvPaeN0HL9jxeDHbjq3LdERITw9yy7mY/zLt5m7WLR5D+MHphAWHOh0HL9jxeDHIkMr9tRYkLmLhRt3Ox3HGI9QVZ6elUFckwZcnRZ/6gVMjVkx+Lnrz2lDs4ahPDN7vV3Mx/iFr9fmsSJnL3cPTCEkyL7CaoNHfqsiMlREMkQkS0QmVPH8PSKyRkRWiMgcEWlT6bkyEVnmuk07flnjnrDgQO4c0I6fNxXw4wYbNRjfVl6uPDN7PW2ahnN5j9ZOx/FbbheDiAQCLwHDgFRgtIikHjfbUiBNVbsCU4AnKj13UFW7uW6XYjzu6l7xtIwKs1GD8Xmz1uxg7fZ9/GZQil2EpxZ54jfbG8hS1Y2qWgJ8BIyoPIOqzlPVYtfDhUCcB97XVNPRUUP6lj0syNzldBxjTkt5ufLs7EySYiMY0c1GC7XJE8XQGsiu9DjHNe1EbgG+qvQ4TETSRWShiIw80UIiMtY1X3p+fr57ieuhq9Liad24AU/bqMH4qOmrtpOxcz+/HdyewAC7CE9t8kQxVPUvVOU3j4hcB6QBT1aanOC6OPW1wHMiUuUJT1R1kqqmqWpabGysu5nrnZCgAO4a2I7l2YXMy8hzOo4xNVJWrjz3dSbtm0dycZeWTsfxe54ohhyg8j5jcUDu8TOJyGDgAeBSVT18dLqq5rp+bgTmA909kMlU4YqeccRHN+C5rzNt1GB8yhcrcsnKO8Ddg1JstFAHPFEMi4AUEWkrIiHANcAxexeJSHfgVSpKIa/S9CYiEuq6HwP0BdZ4IJOpQnBgAHcNSGFFzl4bNRifUVZecRr59s0juaizjRbqgtvFoKqlwHhgJrAWmKyqq0XkbyJydC+jJ4FI4N/H7ZbaCUgXkeXAPOBxVbViqEWX9WhtowbjU75YkcuG/CJ+M6g9ATZaqBMeOfOUqk4Hph837aFK9wefYLkfgC6eyGCq5+io4d5PVjB3XR6DOjV3OpIxJ3R0tNCheUOGdW7hdJx6w3YErods1GB8xX9HC4NTbLRQh6wY6qGjo4aV2/YyZ61tazDeqaxced41Whh6ho0W6pIVQz11dNQwca6NGox3+mJFLhtttOAIK4Z6KjgwgPED2rEiZy/zM+yAQeNdysqVF+Zm0b55pI0WHGDFUI9d1j2O1o0b8NwcGzUY7zJ95Xay8g5w10AbLTjBiqEeCwkK4M4BFUdDf2vnUDJeorxceWFuJu2aRXKRHeXsCCuGem5Uz4pRw/Nf2zmUjHeYsXoH63ce4K6B7ewoZ4dYMdRzIUEB3NE/mSVbC/kuy0YNxlnlruMWkmMjGN61ldNx6i0rBsOVaXG0jApjom1rMA6btWYn63bsZ7yNFhxlxWAIDQrkjv7JLNq8h4UbC5yOY+op1YptC21jIrjERguOsmIwQMX1Gpo1DGXinEyno5h6au66PFbn7mNc/2S7OpvD7LdvgIqrvN1+fjI/btzNz5ts1GDqlmrFtoX46AaM7G5XZ3OaFYP5r9G9E4iJDOWFuTZqMHXrm/X5LM/Zy5392xFsowXH2b+A+a8GIYHc1i+JBZm7WLxlj9NxTD2hWnFOpNaNG3B5D7scvDewYjDH+NXZCURHhNiowdSZ77N2s3RrIbf3TyYkyL6SvIFH/hVEZKiIZIhIlohMqOL5UBH52PX8TyKSWOm5+13TM0TkQk/kMacvPCSIW89ry/yMfFbkFDodx9QDE+dm0qJRGFel2WjBW7hdDCISCLwEDANSgdEiknrcbLcAe1S1HfAs8A/XsqlUXAr0DGAo8LLr9YyDbjgnkagGwUyck+V0FOPnFrp2drjt/CRCg+x/fW/hiRFDbyBLVTeqagnwETDiuHlGAO+47k8BBomIuKZ/pKqHVXUTkOV6PeOgyNAgbjm3LV+v3cma3H1OxzF+7IW5mcREhjK6d4LTUUwlniiG1kB2pcc5rmlVzuO6RvReoGk1lzUOGNMnkYahQbw4z7Y1mNqxeEsB32ft5rZ+SYQF22jBm3iiGKo6bv348yqcaJ7qLFvxAiJjRSRdRNLz8+36AbUtqkEwN/VNZPrKHazfud/pOMYPTZyTRXRECL8620YL3sYTxZADxFd6HAfknmgeEQkCooCCai4LgKpOUtU0VU2LjY31QGxzKjef25aIkEBemGvbGoxnLc8u5Jv1+dx6XlvCQ4KcjmOO44liWASkiEhbEQmhYmPytOPmmQaMcd0fBczVirO1TQOuce211BZIAX72QCbjAY3DQ7ihTyJfrMglK++A03GMH3lhbiZRDYK5/uw2TkcxVXC7GFzbDMYDM4G1wGRVXS0ifxORS12zvQE0FZEs4B5ggmvZ1cBkYA0wA7hTVcvczWQ859Zz2xIWFMjL82zUYDxj1ba9fL02j1vPbUvDsGCn45gqeGQMp6rTgenHTXuo0v1DwJUnWPZR4FFP5DCe1zQylOvOTuDN7zdz96AUEmMinI5kfNyLc7NoGBbEmL6JTkcxJ2CHGZpT+nW/JIIChJfn26jBuGfdjn3MWL2Dm/q2pZGNFryWFYM5pWYNwxjdO4FPl2wju6DY6TjGh704N4vI0CButtGCV7NiMNVy+/nJBIjw8vwNTkcxPiorbz9frtzOmD5taBwe4nQccxJWDKZaWkSFcXWveKYszia38KDTcYwPenFuFg2CA7nl3CSno5hTsGIw1XZ7/2QAXvnGRg2mZjbmH2Da8lyuP6cN0RE2WvB2Vgym2lo3bsConvF89HM2O/YecjqO8SEvzssiJCiAX59nowVfYMVgamRc/2TKVW3UYKpt864ipi7L5bqz2hATGep0HFMNVgymRuKjw7m8R2s+/Hkrefts1GBO7eX5WQQFCGP72WjBV1gxmBq7c0A7SsuVV7/d6HQU4+WyC4r5dMk2RvdOoFmjMKfjmGqyYjA11qZpBCO6teKDn7aQv/+w03GMF3tpXhYBItx+frLTUUwNWDGY03LXwBRKSsuZ9K1tazBVyy4oZsriHEb3jqdFlI0WfIkVgzktbWMiGNmtNe8ttFGDqdrL812jhf42WvA1VgzmtI0f2I6S0nJeW2DbGsyxcvYU8+/0HK7uFU/LqAZOxzE1ZMVgTltSbCQjurXm3R83s+uAjRrM/7w0bwMBItxhowWfZMVg3PLfUYPtoWRccvYUM2VxNlf1iqNVYxst+CIrBuOW5P+OGrbYqMEA/PdEi3f0b+dwEnO63CoGEYkWkdkikun62aSKebqJyI8islpEVojI1ZWee1tENonIMtetmzt5jDPuGtiOw6VlTLJRQ71XsW0hm6t7xdPaRgs+y90RwwRgjqqmAHNcj49XDNygqmcAQ4HnRKRxpef/qKrdXLdlbuYxDkiKjWSka1uD7aFUv700LwtBuHOAjRZ8mbvFMAJ4x3X/HWDk8TOo6npVzXTdzwXygFg339d4mbsGpXCkTHnVzqFUb2UXVOyJdE1v2xPJ17lbDM1VdTuA62ezk80sIr2BEKDyt8ejrlVMz4qInWHLRx09ruH9n7aQt9/OoVQfvTg3i4AAYZxtW/B5pywGEflaRFZVcRtRkzcSkZbAe8BNqlrumnw/0BHoBUQD951k+bEiki4i6fn5+TV5a1NH7h7UjiNlyivzbVtDfbN1dzFTluRwbe8EO8rZD5yyGFR1sKp2ruI2Fdjp+sI/+sWfV9VriEgj4Evgz6q6sNJrb9cKh4G3gN4nyTFJVdNUNS021tZEeaM2TSO4vHvFqMGu11C/TJybSVCAMM6OW/AL7q5KmgaMcd0fA0w9fgYRCQE+A95V1X8f99zRUhEqtk+scjOPcdjdg1IoL1dempfldBRTRzbkH+DTJTlcf3YbO4Oqn3C3GB4HhohIJjDE9RgRSROR113zXAX0A26sYrfUD0RkJbASiAEecTOPcVh8dDhX9Yrno0VbydlT7HQcUwee/zqTsOBAOyeSHwlyZ2FV3Q0MqmJ6OnCr6/77wPsnWH6gO+9vvNP4Ae2Ykp7DC3Oy+Meork7HMbUoY8d+Pl+Ry+3nJ9vV2fyIHflsPK5V4wZce1YCU5bksHlXkdNxTC16dvZ6IkOCuM2uzuZXrBhMrRg3IJngQOH5OZlORzG1ZNW2vcxYvYObz21L4/AQp+MYD7JiMLWiWcMwxpyTyH+WbWP9zv1OxzG14OlZGUQ1COaW89o6HcV4mBWDqTW3nZ9MREgQz8xa73QU42GLNhcwLyOf289PplFYsNNxjIdZMZhaEx0Rwq/PS2LG6h0szy50Oo7xEFXlyRkZxDYM5cY+iU7HMbXAisHUqlvOa0t0RAhPzcpwOorxkG/W5/Pz5gLuHtiOBiGBTscxtcCKwdSqyNAgxvVPZkHmLn7YsMvpOMZN5eXKkzMziI9uwNW9EpyOY2qJFYOpdded3YaWUWE8OTMDVXU6jnHDjNU7WJ27j98Nbk9IkH19+Cv7lzW1Liw4kLsHpbB0ayGz1+x0Oo45TUfKynlqZgYpzSqu2mf8lxWDqRNX9owjKSaCJ2ZmUFpWfuoFjNeZnJ7Nxl1F3Du0I4EB4nQcU4usGEydCAoM4N6hHcjKO8AnS3KcjmNqqLiklOe+ziStTRMGdzrpZVeMH7BiMHXmwjNa0C2+Mc/OzuRgSZnTcUwNvPndJvL3H2bCsI5UnAzZ+DMrBlNnRIQJwzqyY98h3v5hs9NxTDUVFJXwyjcbGZLanLTEaKfjmDpgxWDq1NlJTRnYsRkvz8+isLjE6TimGl6cm0VxSSn3XtjB6SimjlgxmDp379AOFB0u5YW5djEfb7dldxHvLdzMlT3jSWne0Ok4po5YMZg617FFI65Ki+fdHzfbabm93BMzMggKCOD3F7R3OoqpQ24Vg4hEi8hsEcl0/WxygvnKKl29bVql6W1F5CfX8h+7LgNq6oF7hrQnKCCAJ2auczqKOYHFWwr4cuV2bjs/yS7ZWc+4O2KYAMxR1RRgjutxVQ6qajfX7dJK0/8BPOtafg9wi5t5jI9o1iiM285PYvrKHSzeUuB0HHMcVeWRL9fSrGEoY+0iPPWOu8UwAnjHdf8dYGR1F5SKfd4GAlNOZ3nj+8b2S6JZw1Ae+XKtnSrDy0xfuYOlWwv5/QXtCQ9x6wrAxge5WwzNVXU7gOvniY58CRORdBFZKCJHv/ybAoWqWup6nAPYcfb1SHhIEH+4oANLtxby+YrtTscxLoeOlPH4jLV0bNGQUT3jnY5jHHDKPwVE5GugRRVPPVCD90lQ1VwRSQLmishKYF8V853wz0YRGQuMBUhIsLM6+osresbx9g+beXz6WoZ0am6ncfYCb3y3ieyCg3xw61l26ot66pQjBlUdrKqdq7ir0QMfAAAPfUlEQVRNBXaKSEsA18+8E7xGruvnRmA+0B3YBTQWkaPlFAfkniTHJFVNU9W02NjYGnxE480CA4SHL0kld+8hXv12g9Nx6r2d+w7x0rwsLkhtTt92MU7HMQ5xd1XSNGCM6/4YYOrxM4hIExEJdd2PAfoCa7RipfI8YNTJljf+76ykplzctSWvfLOB3MKDTsep156YkUFpmfLAxZ2cjmIc5G4xPA4MEZFMYIjrMSKSJiKvu+bpBKSLyHIqiuBxVV3jeu4+4B4RyaJim8MbbuYxPur+YR1Rhce/st1XnbIsu5BPluRw87ltadM0wuk4xkFu7W6gqruBQVVMTwdudd3/AehyguU3Ar3dyWD8Q1yTcG7rl8TEuVlcf04betk5eepUebnyl2mriW0YyviB7ZyOYxxmRz4br3F7/2RaRYXx4H9W2TUb6tiUxTksyy7kvqEdiQy13VPrOysG4zXCQ4J46JJU1u3Yz3sLtzgdp94oLC7h8Rnr6JXYhCt62B7jxorBeJkLz2jBeSkxPDNrPXn7Dzkdp154alYGhcUl/PXSznatBQNYMRgvIyL89dIzOFRaxuPTbUN0bVuZs5cPftrKDeckktqqkdNxjJewYjBeJyk2krH9kvh06TZ+2rjb6Th+q6xc+fPUVTSNCOV3Q+zsqeZ/rBiMVxo/IIW4Jg3402crOVxqlwGtDR/8tIXl2YU8cHFHohoEOx3HeBErBuOVGoQE8veRndmQX8Q/59sR0Z62Y+8hnpiRwXkpMYzsZhuczbGsGIzXGtChGZec2YqX520gK++A03H8ysPTVnGkrJxHRtoGZ/NLVgzGqz00PJWw4AD+9OlKysvt1NyeMHP1Dmau3slvB7e3I5xNlawYjFeLbRjKny7qxM+bC/hoUbbTcXzevkNHeHjqajq2aMit57V1Oo7xUlYMxutdlRbPOUlN+b/pa9lmJ9lzyyNfrCFv/yEev6IrwYH2v7+pmv2XYbxeQIDwxKiulKsy4ZMVdrW30zQvI4/J6Tncdn4y3eIbOx3HeDErBuMT4qPDuX9YRxZk7rJVSqdh78Ej3P/JSlKaRfLbwSlOxzFezorB+IxfndWGc5Ka8uiXtkqppo6uQnrqyjMJDbKr5JmTs2IwPqPyKqU/TF5ueylV0+w1O/n34opVSGfaKiRTDVYMxqfER4fz8CWp/LhxN68t2Oh0HK+Xt+8Q932ygtSWjWwVkqk2t4pBRKJFZLaIZLp+NqlingEisqzS7ZCIjHQ997aIbKr0XDd38pj64aq0eIae0YKnZmWwattep+N4rfJy5Q9TVlB0uJSJo7vZKiRTbe6OGCYAc1Q1BZjjenwMVZ2nqt1UtRswECgGZlWa5Y9Hn1fVZW7mMfWAiPDY5V2IjgjhNx8t5WCJnUupKu/8uJlv1+fz5+GptGvW0Ok4xoe4WwwjgHdc998BRp5i/lHAV6pa7Ob7mnquSUQIz1zVjQ35RfztizWnXqCeWZO7j8e+Wsegjs247qwEp+MYH+NuMTRX1e0Arp/NTjH/NcCHx017VERWiMizIhJ6ogVFZKyIpItIen5+vnupjV/o2y6GO/on8+HPW/lsaY7TcbzGvkNHGPfBYpqEB/PEqK52LiRTY6csBhH5WkRWVXEbUZM3EpGWQBdgZqXJ9wMdgV5ANHDfiZZX1UmqmqaqabGxsTV5a+PHfj+kPb3bRvOnT1exfud+p+M4TlW5998ryN5zkBev7UHTyBP+rWXMCZ2yGFR1sKp2ruI2Fdjp+sI/+sWfd5KXugr4TFWPVHrt7VrhMPAW0Nu9j2Pqm6DAAF4c3Z2I0CDueH8xRYdLnY7kqDe/38yM1TuYMLQjvRKjnY5jfJS7q5KmAWNc98cAU08y72iOW41UqVSEiu0Tq9zMY+qhZo3CmDi6G5t2FXFvPT5lxs+bCnhs+louSG1uJ8gzbnG3GB4HhohIJjDE9RgRSROR14/OJCKJQDzwzXHLfyAiK4GVQAzwiJt5TD3VJzmGP17YkS9XbOfFuVlOx6lz2QXF3P7+YuKjw3nyyjNtu4JxS5A7C6vqbmBQFdPTgVsrPd4M/OIyUao60J33N6ay289PYv3O/Tw9ez0pzRsytHMLpyPViaLDpfz63XSOlJXz+pg0u0yncZsd+Wz8xtHjG86Mb8zvPl7Gmtx9TkeqdeXlym8/Xsb6nft56doeJMdGOh3J+AErBuNXwoIDee36nkQ1CObmtxf59cn2VJVHp69l9pqd/PniVPq1t731jGdYMRi/06xRGG/e2Iuiw6WMefNn9hSVOB2pVkz6diNvfLeJMee04aa+iU7HMX7EisH4pdRWjXhtTBpbC4q5+Z1FFJf4126sUxbn8NhX6xjetSUPX3KGbWw2HmXFYPzW2UlNmXhNN5ZlF3LH+0s4dMQ/zqk0a/UO7vtkBee2i+Hpq84kIMBKwXiWFYPxa0M7t+Sxy7rwzfp8bn9/sc+Xw4xVOxj3wRI6t47ilet72hlTTa2wYjB+75reCTx2eRfmZ+Qz9j3fLYevVm5n/L+W0CUuivdu6U1kqFt7mxtzQlYMpl4Y3TuBf1zRhQWZ+dz6TjoHfOzUGVOXbWP8h0vpGhfFuzf3plGYHatgao8Vg6k3ru6VwJOjzuTHjbu56pUf2bnvkNORTklV+ef8Dfzmo2X0bNOEd285i4ZWCqaWWTGYemVUzzheH5PG5t1FXP7yD159RtbSsnIenLqKf8xYxyVntrLVR6bOWDGYemdAh2ZMvu0cSsrKueLlH5ixarvTkX5h14HD3PT2It5fuJXbzk/i+avt0pym7lgxmHqpc+soPhvXh6TYCG5/fwl/+3wNJaXlTscCKs6SevHEBfy0qYB/XNGF+4d1sl1STZ2yYjD1VlyTcCbffg439knkze83ceWrP5Lp4KqlktJyJs7JZPRrC2kQHMhn4/pwdS+7LKepe1YMpl4LDQrkL5eewUvX9mDzriIumriAZ2ev53Bp3e7SunjLHoa/sIBnZq/n4i4t+fyuczmjVVSdZjDmKNuSZQxwcdeWnJUUzd8+X8PzczL5YkUuf7ywIxee0bxWTzeRW3iQiXMy+Tg9m5aNwnhjTBqDOjWvtfczpjrcGjGIyJUislpEykUk7STzDRWRDBHJEpEJlaa3FZGfRCRTRD4WkRB38hjjjpjIUCaO7s5bN/WiXOH29xdzyYvfMXfdTsrLPXtVuB17D/Hw1FX0f3I+nyzJ4aY+bZl1z/lWCsYriDuXQRSRTkA58CrwB9cFeo6fJxBYT8UV3nKARcBoVV0jIpOBT1X1IxF5BViuqv881fumpaVpevov3soYjyktK+ezpduYODeT7IKDJESHc2XPOEalxdEyqsFpveaRsnLmrstj8qJs5q/PR4Ar0+IYPzCF1o1P7zWNqQkRWayqJ/wj/r/zeeL6uCIynxMXwznAX1T1Qtfj+11PPQ7kAy1UtfT4+U7GisHUlSNl5Xy5YjsfL8rmx427EYHUlo3ok9yUc5KbktKsIS2jwggK/OXge2/xEbYUFLF4yx5+2LCbhRt3s/9QKbENQxnVM47RvRJIaBruwKcy9VV1i6EutjG0BrIrPc4BzgKaAoWqWlpp+i8u/2mMk4IDAxjZvTUju7dmy+4ipi3L5fsNu3jnhy28tmATAEEBQouoMBoEVxxnUK5K3v7D7D/0v9NuJESHM7xrSwZ1bE7/DrFVFokx3uKUxSAiXwNVXTz3AVWdWo33qGrLnZ5k+olyjAXGAiQk2C58pu61aRrBXYNSuGtQCoeOlLEsu5DNu4rI3lPMtj0HKSn733EQfdvFkBAdTlyTcM5o1Yj4aBsZGN9xymJQ1cFuvkcOEF/pcRyQC+wCGotIkGvUcHT6iXJMAiZBxaokNzMZ45aw4EDOTmrK2UlNnY5ijMfVxXh2EZDi2gMpBLgGmKYVGzfmAaNc840BqjMCMcYYU4vc3V31MhHJAc4BvhSRma7prURkOoBrNDAemAmsBSar6mrXS9wH3CMiWVRsc3jDnTzGGGPc55G9kuqa7ZVkjDE1V929kmzXCGOMMcewYjDGGHMMKwZjjDHHsGIwxhhzDCsGY4wxx/DJvZJEJB/YcpqLx1BxcJ2v8vX84Pufwdfzg+9/Bl/PD858hjaqGnuqmXyyGNwhIunV2V3LW/l6fvD9z+Dr+cH3P4Ov5wfv/gy2KskYY8wxrBiMMcYcoz4WwySnA7jJ1/OD738GX88Pvv8ZfD0/ePFnqHfbGIwxxpxcfRwxGGOMOYl6VQwiMlREMkQkS0QmOJ2nJkTkTRHJE5FVTmc5HSISLyLzRGStiKwWkd84nammRCRMRH4WkeWuz/BXpzOdDhEJFJGlIvKF01lOh4hsFpGVIrJMRHzubJoi0lhEpojIOtf/D+c4nel49WZVkogEAuuBIVRcPGgRMFpV1zgarJpEpB9wAHhXVTs7naemRKQl0FJVl4hIQ2AxMNJXfv8AIiJAhKoeEJFg4DvgN6q60OFoNSIi9wBpQCNVHe50npoSkc1Amqr65HEMIvIOsEBVX3ddoyZcVQudzlVZfRox9AayVHWjqpYAHwEjHM5Ubar6LVDgdI7TparbVXWJ6/5+Kq7N4VPX+NYKB1wPg103n/rLSkTigIuB153OUh+JSCOgH65rz6hqibeVAtSvYmgNZFd6nIOPfTH5CxFJBLoDPzmbpOZcq2GWAXnAbFX1tc/wHHAvUH6qGb2YArNEZLHrWvC+JAnIB95yrc57XUQinA51vPpUDFLFNJ/6a88fiEgk8AnwW1Xd53SemlLVMlXtRsU1ynuLiM+s1hOR4UCeqi52Ooub+qpqD2AYcKdrNauvCAJ6AP9U1e5AEeB12zvrUzHkAPGVHscBuQ5lqZdc6+U/AT5Q1U+dzuMO1/B/PjDU4Sg10Re41LWO/iNgoIi872ykmlPVXNfPPOAzKlYT+4ocIKfSSHMKFUXhVepTMSwCUkSkrWuDzzXANIcz1RuuDbdvAGtV9Rmn85wOEYkVkcau+w2AwcA6Z1NVn6rer6pxqppIxX//c1X1Oodj1YiIRLh2XsC1CuYCwGf21FPVHUC2iHRwTRoEeN0OGEFOB6grqloqIuOBmUAg8KaqrnY4VrWJyIdAfyBGRHKAh1X1DWdT1Uhf4HpgpWsdPcCfVHW6g5lqqiXwjmsPtwBgsqr65C6fPqw58FnF3xkEAf9S1RnORqqxu4APXH+gbgRucjjPL9Sb3VWNMcZUT31alWSMMaYarBiMMcYcw4rBGGPMMawYjDHGHMOKwRhjzDGsGIwxxhzDisEYY8wxrBiMMcYc4/8Bc0QUOMx+bBgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x22c5eb31908>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22c5ecf7a58>]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x22c5ec77400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(x,y,'r+') # change the line style to red plusses highlights that we are dealing with a discrete set of points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Within matplotlib.pyplot there are too many functions to describe here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Annotation', 'Arrow', 'Artist', 'AutoLocator', 'Axes', 'Button', 'Circle', 'Figure', 'FigureCanvasBase', 'FixedFormatter', 'FixedLocator', 'FormatStrFormatter', 'Formatter', 'FuncFormatter', 'GridSpec', 'IndexLocator', 'Line2D', 'LinearLocator', 'Locator', 'LogFormatter', 'LogFormatterExponent', 'LogFormatterMathtext', 'LogLocator', 'MaxNLocator', 'MultipleLocator', 'Normalize', 'NullFormatter', 'NullLocator', 'PolarAxes', 'Polygon', 'Rectangle', 'ScalarFormatter', 'Slider', 'Subplot', 'SubplotTool', 'Text', 'TickHelper', 'Widget', '_INSTALL_FIG_OBSERVER', '_IP_REGISTERED', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_auto_draw_if_interactive', '_autogen_docstring', '_backend_mod', '_backend_selection', '_hold_msg', '_imread', '_imsave', '_interactive_bk', '_pylab_helpers', '_setp', '_setup_pyplot_info_docstrings', '_show', '_string_to_bool', 'absolute_import', 'acorr', 'angle_spectrum', 'annotate', 'arrow', 'autoscale', 'autumn', 'axes', 'axhline', 'axhspan', 'axis', 'axvline', 'axvspan', 'bar', 'barbs', 'barh', 'bone', 'box', 'boxplot', 'broken_barh', 'cla', 'clabel', 'clf', 'clim', 'close', 'cm', 'cohere', 'colorbar', 'colormaps', 'colors', 'connect', 'contour', 'contourf', 'cool', 'copper', 'csd', 'cycler', 'dedent', 'delaxes', 'deprecated', 'disconnect', 'division', 'docstring', 'draw', 'draw_all', 'draw_if_interactive', 'errorbar', 'eventplot', 'figaspect', 'figimage', 'figlegend', 'fignum_exists', 'figtext', 'figure', 'fill', 'fill_between', 'fill_betweenx', 'findobj', 'flag', 'gca', 'gcf', 'gci', 'get', 'get_backend', 'get_cmap', 'get_current_fig_manager', 'get_figlabels', 'get_fignums', 'get_plot_commands', 'get_scale_docs', 'get_scale_names', 'getp', 'ginput', 'gray', 'grid', 'hexbin', 'hist', 'hist2d', 'hlines', 'hold', 'hot', 'hsv', 'imread', 'imsave', 'imshow', 'inferno', 'install_repl_displayhook', 'interactive', 'ioff', 'ion', 'is_numlike', 'ishold', 'isinteractive', 'jet', 'legend', 'locator_params', 'loglog', 'magma', 'magnitude_spectrum', 'margins', 'matplotlib', 'matshow', 'minorticks_off', 'minorticks_on', 'mlab', 'new_figure_manager', 'nipy_spectral', 'np', 'over', 'pause', 'pcolor', 'pcolormesh', 'phase_spectrum', 'pie', 'pink', 'plasma', 'plot', 'plot_date', 'plotfile', 'plotting', 'polar', 'print_function', 'prism', 'psd', 'pylab_setup', 'quiver', 'quiverkey', 'rc', 'rcParams', 'rcParamsDefault', 'rc_context', 'rcdefaults', 'register_cmap', 'rgrids', 'savefig', 'sca', 'scatter', 'sci', 'semilogx', 'semilogy', 'set_cmap', 'setp', 'show', 'silent_list', 'six', 'specgram', 'spectral', 'spring', 'spy', 'stackplot', 'stem', 'step', 'streamplot', 'style', 'subplot', 'subplot2grid', 'subplot_tool', 'subplots', 'subplots_adjust', 'summer', 'suptitle', 'switch_backend', 'sys', 'table', 'text', 'thetagrids', 'tick_params', 'ticklabel_format', 'tight_layout', 'time', 'title', 'tricontour', 'tricontourf', 'tripcolor', 'triplot', 'twinx', 'twiny', 'types', 'unicode_literals', 'uninstall_repl_displayhook', 'violinplot', 'viridis', 'vlines', 'waitforbuttonpress', 'warnings', 'winter', 'xcorr', 'xkcd', 'xlabel', 'xlim', 'xscale', 'xticks', 'ylabel', 'ylim', 'yscale', 'yticks']\n"
     ]
    }
   ],
   "source": [
    "print(dir(plt)) # matplotlib.pyplot is an extensive package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function plot in module matplotlib.pyplot:\n",
      "\n",
      "plot(*args, **kwargs)\n",
      "    Plot lines and/or markers to the\n",
      "    :class:`~matplotlib.axes.Axes`.  *args* is a variable length\n",
      "    argument, allowing for multiple *x*, *y* pairs with an\n",
      "    optional format string.  For example, each of the following is\n",
      "    legal::\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",
      "    If *x* and/or *y* is 2-dimensional, then the corresponding columns\n",
      "    will be plotted.\n",
      "    \n",
      "    If used with labeled data, make sure that the color spec is not\n",
      "    included as an element in data, as otherwise the last case\n",
      "    ``plot(\"v\",\"r\", data={\"v\":..., \"r\":...)``\n",
      "    can be interpreted as the first case which would do ``plot(v, r)``\n",
      "    using the default line style and color.\n",
      "    \n",
      "    If not used with labeled data (i.e., without a data argument),\n",
      "    an arbitrary number of *x*, *y*, *fmt* groups can be specified, as in::\n",
      "    \n",
      "        a.plot(x1, y1, 'g^', x2, y2, 'g-')\n",
      "    \n",
      "    Return value is a list of lines that were added.\n",
      "    \n",
      "    By default, each line is assigned a different style specified by a\n",
      "    'style cycle'.  To change this behavior, you can edit the\n",
      "    axes.prop_cycle rcParam.\n",
      "    \n",
      "    The following format string characters are accepted to control\n",
      "    the line style or marker:\n",
      "    \n",
      "    ================    ===============================\n",
      "    character           description\n",
      "    ================    ===============================\n",
      "    ``'-'``             solid line style\n",
      "    ``'--'``            dashed line style\n",
      "    ``'-.'``            dash-dot line style\n",
      "    ``':'``             dotted line style\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",
      "    \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",
      "    In addition, you can specify colors in many weird and\n",
      "    wonderful ways, including full names (``'green'``), hex\n",
      "    strings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or\n",
      "    grayscale intensities as a string (``'0.8'``).  Of these, the\n",
      "    string specifications can be used in place of a ``fmt`` group,\n",
      "    but the tuple forms can be used only as ``kwargs``.\n",
      "    \n",
      "    Line styles and colors are combined in a single format string, as in\n",
      "    ``'bo'`` for blue circles.\n",
      "    \n",
      "    The *kwargs* can be used to set line properties (any property that has\n",
      "    a ``set_*`` method).  You can use this to set a line label (for auto\n",
      "    legends), linewidth, anitialising, marker face color, etc.  Here is an\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",
      "        axis([0, 4, 0, 10])\n",
      "        legend()\n",
      "    \n",
      "    If you make multiple lines with one plot command, the kwargs\n",
      "    apply to all those lines, e.g.::\n",
      "    \n",
      "        plot(x1, y1, x2, y2, antialiased=False)\n",
      "    \n",
      "    Neither line will be antialiased.\n",
      "    \n",
      "    You do not need to use format strings, which are just\n",
      "    abbreviations.  All of the line properties can be controlled\n",
      "    by keyword arguments.  For example, you can set the color,\n",
      "    marker, linestyle, and markercolor with::\n",
      "    \n",
      "        plot(x, y, color='green', linestyle='dashed', marker='o',\n",
      "             markerfacecolor='blue', markersize=12).\n",
      "    \n",
      "    See :class:`~matplotlib.lines.Line2D` for details.\n",
      "    \n",
      "    The kwargs are :class:`~matplotlib.lines.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: [True | False] \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",
      "    kwargs *scalex* and *scaley*, if defined, are passed on to\n",
      "    :meth:`~matplotlib.axes.Axes.autoscale_view` to determine\n",
      "    whether the *x* and *y* axes are autoscaled; the default is\n",
      "    *True*.\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",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.plot) # the plot docstring gives a detailed set of instructions on the usasge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "plot(\\*args, \\**kwargs) refers to the functions arguments and keyword arguments. The order of the arguments in a python function determines how the argument is passed into the function i.e plot(x,y) will have x as the x-axis, plot(y,x) will have y as the x-axis. The kwargs can come in any order as they are recognised by the keyword i.e. label='my experimental data'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Returning to our plot:\n",
    "The following code begins to show how much control you can have over the appearance of the plot, in particular note that LaTex math symbols have been used to label the xticks, and the ticks have been moved to user defined positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xd4lFX2wPHvSSchQCChk0LvLaGFLiDoomAHBSkidl11ddW1rbvuqmvvjSagoNhQUUSK9BJ6J5RAQkILpEB6cn9/vAO/iAlJyEzuJO/9PM88ycy85QwETu77nnuPKKUwDMMwDHfjoTsAwzAMwyiKSVCGYRiGWzIJyjAMw3BLJkEZhmEYbskkKMMwDMMtmQRlGIZhuCWToAzDzYjIThEZoOG840VkZUWf1zCKYxKUYZRAROJEJEdEgi96fYuIKBEJv4xjTncc82yhxy0ASql2Sqlll3HMcEc8XpfY5nkRyXWcL0VEVotIr8s41zIRmVTW/QyjLEyCMozSOQSMPv9ERDoA1cp5zFeUUtULPeaWtMOlkk8ZzFVKVQdCgJXANyIiTjiuYTiVSVCGUTozgdsLPR8HfHb+iYh0E5HjhROIiNwgIlvKeiLHiG2w4/vnRWSeiMwSkTRgvIh0F5EYEUlznPN1x67LHV9THCOkS46MlFK5wAygPlCniDiiRWSDiKQ6vkY7Xn8R6Au86zjPu2X9jIZRGiZBGUbprAVqiEgbEfEEbgFmnX9TKbUBSAaGFNpnDFZiK68RwDygFjAbeAt4SylVA2gGfOnYrp/jay3HiGzNpQ4qIr7AeCBBKXXqovdqAz8Bb2Mlr9eBn0SkjlLqH8AK4H7Hee53wmc0jD8xCcowSu/8KGoIsAc4etH7M7CS0vn/4IcCn1/ieH9z3AdKEZFTl9hujVLqO6VUgVIqE8gFmotIsFLqrFJqbRk/x80ikgLEA5HAyCK2+QsQq5SaqZTKU0p9gfWZrynjuQzjspkEZRilNxO4FWvU8VkR788CrhGR6sDNwAqlVNIljveqUqqW4xF8ie3iL3p+B9AS2OO49Da81J/A8qXjnHWVUlcopTYWsU1D4PBFrx0GGpXxXIZx2UyCMoxSUkodxiqWuBr4poj3jwJrgOuAsTjn8h7AH1oOKKVilVKjgbrAy8A8EQm4eLtySgTCLnotlP8fNZo2CIbLmQRlGGVzB3CFUupcMe9/BjwOdAC+dUUAIjJGREKUUgVAiuPlfOAkUAA0dcJpFgAtReRWEfFylMC3BX50vH/cSecxjGKZBGUYZaCUOqCUirnEJt9ijTy+vUQSK69hwE4ROYtVMDFKKZWllMoAXgRWOe5r9bzcEyilkoHhwKNYxR+PA8MLFVO8BdwoImdE5O3yfBjDKI6YhoWG4VwicgC4Syn1m+5YDKMyMyMow3AiEbkB6/7MEt2xGEZl54xZ6YZhYC3/g3WfZqzj/pBhGOVgLvEZhmEYbslc4jMMwzDckq0u8QUHB6vw8HDdYRiGYdjaxo0bTymlQkrazlYJKjw8nJiYS1UIG4ZhGK4mIhevUlIkc4nPMAzDcEsmQRmGYRhuySQowzAMwy3Z6h6UYRiGq+Xm5pKQkEBWVpbuULTz8/OjcePGeHt7X9b+JkEZhmE4UUJCAoGBgYSHhyMiusPRRilFcnIyCQkJREREXNYxtF7iE5GpInJCRHYU876IyNsisl9EtolI10LvjRORWMdjXMVFbRiGUbysrCzq1Klj6+QEICLUqVOnXCNJ3fegpmOtzFycq4AWjsdk4AO40K30OaAH0B14TkSCXBqpYRhGKdk9OZ1X3j8HrZf4lFLLRST8EpuMAD5T1npMa0Wklog0AAYAi5RSpwFEZBFWovviUudLSs3incWxBAf60qFRTVrXD8TLU3eOdqHMFDi+A47tgHMnIDcL8nMgIARqNoLazaBRV/Dy1R2pYbhUTl4Bu5LS2HE0leSzOZzJyCHA15PHhrbWHZpxCe5+D6oRf2x3neB4rbjX/0REJmONvvCt35zXFu278F41b096NK3NdV0aMbRdffy8PZ0cvgYp8bDrO9j5HRwtNClZPMHbHzw8ISvl/1/3qgZhvaDtCOhwE/gEVHzMhuECZ7Pz+Hl7Et9tOUpM3Bmy8/5//d5AXy9aNwjUGJ1RGu6eoIoaH6pLvP7nF5X6GPgYICoqSq369zBOpGWzOT6FTYfPsGjXcR6as4VAXy9u6xnGXf2aEhTg47xPUFGO74IVr8HOb0AVQINOMPAf0LAr1G8P1evB+eF2XjakJ1kjq0PL4cBi+OEh+PUZ6DQK+jwCNRro/TyGcZlOpGXx/rIDzN0QT2ZuPuF1/BnbM4yuYUF0alKLuoG+eFflKydViLsnqASgSaHnjYFEx+sDLnp9WWkO6OvlSZPa/jSp7c+1nRry7PC2rD2UzOfrjvDR8gPMXnuYSX2bclf/ppVjRJV+DBY+BTu+Bp/q0Ot+iBwPdZoVv4+XLwSFW482w0EpiF8HG6ZAzDTYPAuiH4DoB8G3egV9EMMon3PZeby9JJYZq+PIzVdc16URo7s3oWtokLkndBkyMzMZNmwYS5YswdOz6P8Lc3JyGDx4MEuWLMHLy/npxN0T1HzgfhGZg1UQkaqUShKRhcB/ChVGXAk8eTkn8PAQopsFE90smAeOpfP6or288ds+ftiWyP9u7EiXUDetvSgogI3T4Ld/Ql4W9HsMet4L/rXLfiwRCO1pPQY+BYtfgN9fhs2z4boPIKKf8+M3DCdavf8Uj3+9jaMpmYzo1JC/Dm5JeLC5XF0eU6dO5frrry82OQH4+PgwaNAg5s6dy2233eb0GLT2gxKRL7BGQsHAcazKPG8ApdSHYv3a8y5WAUQGMEEpFePYdyLwlONQLyqlppV0vqioKFWaxWKX7T3Bk99s53haFvcOaM7DQ1ri6eFGv4FlnIZv74LYX63kMfzNS4+YLseRdfD9vZB8AHrdB4OeNcUUhtvJySvgxZ92MWPNYSKCA3jlxo50C7+MX9KcaPfu3bRp0waAf/6wk12JaU49ftuGNXjumnYlbpeYmMgDDzzAwYMHyczM5LPPPqNGjRpMnjyZ5ORkGjRowJw5cwgODmbGjBm8/fbb5ObmUrNmTVasWEF0dDSff/455ztADBw4kKeeeoohQ4bw9NNPk5aWxttvv83WrVt58sknWbBgQZFxFP7zOE9ENiqlokr6DLqr+EaX8L4C7ivmvanAVFfENaBVXX59uB8v/LCLd5fuZ/vRVN4e1YWa/pc3G9qpEjfD3Nute0hXvwrdJv3/vSVnCu0Bdy237kuteRfi18Ooz6F6iSvkG0aFOJGexb2zNhFz+AwTeofz+NDWVPOpBJflK0BeXh5XXXUVL774IsOHDycjI4Pc3Fyio6OZNWsWXbp04eWXX+aNN97giSee4OWXX2bLli34+PiQkpJCTk4OBw8epHB7on/+8588++yznDhxgs2bNzN//nwA2rdvz4YNG1zyOdz9Ep82gX7e/O+mTnQOrcXz83cy4r2VTB3fjaYhGu/J7PkJ5k20ysQnLoTGka49n08ADH8dIvrCt/fAJ1fArXOgXsm/vRmGK+1MTOWO6TGkZObw9uguXNupoe6QilSakY4rfPfdd7Rp04bhw4cD4O/vz9y5c+nTpw9dunQBoG3btsyfPx9PT08yMzN59NFHGTduHFFRUSQmJlKrVq0/HLNfv34opXj99ddZtmzZhUt/np6e+Pj4kJ6eTmCgcysjTSlLCW7rEcYXd/YkPSuPmz9aw+4k5w7XS23jDJg7xkoOk5e5PjkV1u46mLDAmkM1ZSgcXlNx5zaMi8TEnWbUx2vxEPj6nmi3TU46bdmyhZ49e/7htV27dtGhQ4cLz7dv307btm3x9/dnx44d9O7dm8mTJ/P+++9TrVq1P60AsX37dpKSkvD19f1TIsrOzsbPz8/pn8MkqFKICq/N3Lt64e3pwS0frWHTkTMVG8Dqd+CHB6HpQLh9PgQEV+z5wZrQe+cSCKwPs66HQysqPgbD9lbEnmTslPWEVPflq3uiadewpu6Q3FL9+vXZuXPnhecnT56kUaNG7Nq1C4CDBw8yc+ZMbr/9dmJjYwkICGDUqFEMHz6crKwsgoKCyM/Pv5CkkpKSuO222/j+++8JCAhg4cKFF46dnJxMSEjIZS8IeykmQZVS87rV+eruXgQF+DD203VsjU8peSdnWPcx/Pq0NYoZPUdv2XfNRjD+J6gVCrNvggNL9cVi2M6q/ae4Y3oM4cEBzL2rF41qVdMdktsaP348x48fp127dnTu3Jk1a9YwduxYEhMT6dChA6NGjWLq1KnUqVOHF198kVatWtG1a1cOHTrEvffeC8CVV17JypUrycjI4Prrr+e1116jTZs2PPPMMzz//PMXzrV06VKuvvpql3wOrVV8Fa20VXyXcjwtixs/XM3ZrDy+ursXzeu6cDb6ppkw/35o9Re4eQZ4ukGRBsC5UzDjWjgTB+N/gEYVeLnRsKUt8Snc+slamgT5M/euntTyd9/J9EVVrVVGmzdv5vXXX2fmzJmX3O7666/nv//9L61atSry/fJU8ZkRVBnVq+HHrDt64OXpwZhP15NwJsM1J9r9I8x/AJpdATdNc5/kBNYlxrHfWl9n3wSn9uuOyKjCYo+nM37aeoKr+zLzju5unZyqki5dujBw4EDy8/OL3SYnJ4eRI0cWm5zKyySoyxBWJ4DPJnYnIyePidM3kJ6V69wTJG6Bb+607vvcMts95x8F1rOSFMCs6yD9uN54jCrp1Nlsxk/bgLenB7Pu6EHdGs6/EW8Ub+LEiSVO1L399ttddn6ToC5TmwY1+HBMJAdOnuOvc7aQX+CkS6WpR+GLUeBfB0Z9AT7+zjmuK9RpBrd9BWdPwpe3Q16O7oiMKiQ7L597Zm3k1NlspoyLIrSOG/9bMFzCJKhyiG4ezPPXtGXxnhO8snBP+Q+YmwVzRkP2Wbh1rjVKcXeNImHkexC/Fn5+XHc0RhWhlOLpb3ewIe4Mr97UiY6Na5W8k1HlmIm65TS2Vzh7j6fz0e8H6dCoJsM7lmNOxs+PQ9JWq1qvMk2GbX8DJG2DVW9Cg44QNVF3REYlN2vtYb7amMCDVzTnGjPPybbMCMoJnrumHV1Da/HE19uJO3Xu8g6y5XPYNMNqddHqKucGWBEGPQvNB8OCx617aIZxmXYcTeVfP+5mYKsQ/jq4pe5wDI1MgnICb08P3rm1K16ewn2fbyIrt/iqlyId3wk/PgLhfa0eTpWRhydc/4m1DNO8iZCdrjsioxJKy8rlvs83Uae6D6/d3BkPd1qk2ahwJkE5SaNa1Xjtpk7sTEzjxZ92l37H3CyYdwf41YAbpoBnJb7q6l8bbvgUzhyCn/6mOxqjklFK8eQ320k4k8k7o7tQuzI2DjWcyiQoJxrUph539o1g5trDLN1zonQ7Lf4nnNwNI96vHEURJQnvDf3/DtvmwNY5uqMxKpFvNx/lp21JPDKkJVGaW2YY7sEkKCd79MpWtKoXyONfb+PMuRLKrg8shbXvQ/fJ0GJwxQRYEfo9BqHR1v2o1KO6ozEqgcSUTJ77fifdwoO4u7+Te5sZF6xevZrnnnvukttkZmbSv3//Eifo9uvXj7y8PGeH+AdaE5SIDBORvSKyX0SeKOL9N0Rki+OxT0RSCr2XX+i9+RUbefH8vD15/ZZOpGTk8PR3Oyh2KanMM/DdPRDcCgb/s2KDdDUPT6v0vCDXWg3DRstpGWVXUKB4bN5W8pXitZs6u1dz0ComOjqaf/7z0v/flLWTritpu+EhIp7Ae8AQIAHYICLzlVK7zm+jlHq40PYPAF0KHSJTKdW5ouIti3YNa/LXwS3538K9DN1Wv+h2AL8+DWdPwGg3n4x7uWo3hSEvwIK/WdWJkeN1R2S4qZlrD7NqfzL/vb5D1ZuM+/MTcGy7c49ZvwNc9VKJmxXVJfemm27ioYce4rXXXqNdu3b8/vvvxMbGMmvWLAYPtq7izJ49m88///zCcYrrpDty5EiefPJJl7R6P0/nHfnuwH6l1EEAEZkDjAB2FbP9aKyW8JXCXf2a8uuu4/xz/k76Ng8mqPAN3wNLYfMs6PMwNOxS/EEqu6g7YPd8WPgPaDYIajXRHZHhZo6mZPLyL3vo1zKEUd3Mz4ezpKen/6lLLsCOHTvo0KHDhf5PK1as4JtvvmH27NkMHjzYbTrpnqczQTUC4gs9TwB6FLWhiIQBEcCSQi/7iUgMkAe8pJT6zlWBXg4vTw9eur4D17yzkn//tJvXbu5kvZFzzurtVKc59P/TVc2qxcMDrn0X3u9pjaRGz3FNe3qjUlJK8cx3O1AKXhzZHqmKPxulGOm4QlFdcrOyssjNzcXb25vU1FQefti6QJWXl3ehe+6pU6fcopPueTrvQRX101jczYpRwDylVOG7dqGO5dpvBd4UkSLvrIrIZBGJEZGYkydPli/iMmrToAaT+zXl600JrIw9Zb245N+QcsT6j9vbBgtfBoXBwKdg3y/WaMowHH7clsSSPSd49MqWNKldxS7taVZUl9ydO3fStm1bdu7cSWRk5IVEs23bNtq3bw/gNp10z9OZoBKAwmP6xkBiMduOAr4o/IJSKtHx9SCwjD/enyq83cdKqSilVFRISEh5Yy6zBwe1ICI4gKe+3U52/GZY96F16SusV4XHok2Pe6zr5gseh6xU3dEYbiA1I5d//rCTjo1rMqF3hO5wqpyiuuRu376djh07smPHDjp3/v/b99u2baNjx44AbtNJ9zydCWoD0EJEIkTEBysJ/elXbBFpBQQBawq9FiQivo7vg4HeFH/vSis/b09evK498afPkvzlA1CtNgx6RndYFcvTC655C86dgMUv6I7GcAOv/rqX0+dy+O/1HUzVngsU1SX3fILavn37HxLUjh07LoygwD066V6glNL2AK4G9gEHgH84XnsBuLbQNs9j3WMqvF80sB3Y6vh6R2nOFxkZqXSZ9f6/lHquhjq5Yqq2GLT76TGlnqupVOIW3ZEYGm1PSFERT/yonv1uu+5QXGLXrl26QyiXTZs2qTFjxpS43XXXXaf27NlT4nZF/XkAMaoU/2drXVdHKbUAWHDRa89e9Pz5IvZbDXRwaXDOlHGa0alT2Kha88H+dnzaR3dAmgx8EnbMg5//DhN+NgUTNlRQoHj2+x0E+fvwyJWu6cJqlE/hTrrFzYVydSfd88xKEhVh6X/wyE7lQPfn+W3PSZbssWn32WpBMOg5OLIGts/THY2hwTebj7LpSAp/v6o1Nau57t6FUT66O+meZxKUq53YDTFTIWoiI4cOpWlIAC/8sIucvALdkenRZQw06AyLnrEaMxq2cTY7j5d+3kOX0Frc2LWx7nCMSsAkKFdSChY+Bb7VYcCT+Hh58Mxf2hKXnMHMtYd1R6eHhydc/T9IT4KVb+iOxqhAHy47wKmz2Tw7vG2Vb6OhzPJeQPn/HEyCcqXYRXBgiTUhN6AOAANahdC3RTBvL44lJaOExWSrqibdocNNsOZds5isTRxNyeSTFQcZ0bkhXUKDdIfjUn5+fiQnJ9s+SSmlSE5OLtc8qUrcfMjN5efCr/+wVozoNunCyyLCP/7ShqvfWsFbi2N57ppK1Nrdma54BnbNtyYuX/eB7mgMF/vfL3sAeHxYa82RuF7jxo1JSEigohcGcEd+fn40bnz5l3NNgnKVzTPh1D4Y9QV4/bHxWuv6NbilWygz1xxmbM8wmoZU1xSkRkFh0PNuWPW29bVBJ90RGS6yNT6F77Ykcv/A5jSqVU13OC7n7e1NRISZfOwM5hKfK+Scg2UvQWgvaHVVkZs8MqQlPl4evPrr3goOzo30ecSq7Pv1adOSo4pSSvHfn3cTXN2HuweYPk9G2ZgE5Qpr3oezx60+T8XM9QkJ9GVS36Ys2H6MrfEpRW5T5VWrBQOegEPL4cBi3dEYLrA89hRrD57mgStaUN3XXLAxysYkKGc7dwpWvQWth0NokYuzX3Bn3whqB/jwysI9FRScG4qcALXCrCWQCmxael9FFRQoXv55D6G1/RndPVR3OEYlZBKUsy1/FXIzrAmpJQj08+b+gc1ZtT+ZFbE2vaHq5WOtdp60FXZ/rzsaw4l+2JbIrqQ0Hr3SupxtGGVlfmqcKTUBYqZA51shpGWpdrmtZyiNg6rx8i977FuW2uEmCGljVfTl5+mOxnCC3PwCXvt1H20a1OCajkV0lDaMUjAJypmW/8/62v/vpd7F18uThwe3ZMfRNBbuPOaiwNych6e1wnvyftgyW3c0hhN8FZPAkdMZPDa0ZZWflGu4jklQznL6oNXGPXJ8mVubj+zSiKYhAbyxKJaCApuOolpdDY27we+vQF627miMcsjOy+fdJbF0Ca3FwFZ1dYdjVGImQTnL76+Ahxf0fbTMu3p6CH8d3JK9x9P5aXuSC4KrBESse1FpCdYcMqPSmrM+nsTULB4d0qpqtnE3KoxJUM5wch9smwvd74TA+pd1iOEdGtCyXnXe/G0f+XYdRTUdCE16wvLXIDer5O0Nt5OVm897S/fTPbw2vZvX0R2OUcmZBOUMy18BLz/o/dfLPoSHh/Dw4JYcOHmO77fYdH2686Oo9ETY9JnuaIzLMGvtYU6kZ/PIlS3N6MkoN60JSkSGicheEdkvIk8U8f54ETkpIlscj0mF3hsnIrGOx7iKjbyQU7Gw42trvb2A4HIdami7+rRpUIN3luy37ygqoh+E9YYVr0Fupu5ojDLIys3nw98PEt2sDj2bmtGTUX7aEpSIeALvAVcBbYHRItK2iE3nKqU6Ox6fOvatDTwH9AC6A8+JiJ4lkpe/ao2eoh8s96E8PISHBjXn0Klz/Lgt0QnBVULnR1Fnj8HGGbqjMcrgi/VHOHU2m4cGtdAdilFF6BxBdQf2K6UOKqVygDnAiFLuOxRYpJQ6rZQ6AywChrkozuIlH4DtX0LURKge4pRDXtm2Pq3qBfLOkv32regL72ONola9ZSr6Kglr9HSAHhG16WFGT4aT6ExQjYD4Qs8THK9d7AYR2SYi80TkfP12afdFRCaLSIyIxDh9+fvlr4KnL/R+yGmH9PAQ7r+iOftPnOXnHTadFwXQ72/WvSgzL6pS+GpjAsfTsnnQjJ4MJ9KZoIq6g3rxkOEHIFwp1RH4DTh/zac0+1ovKvWxUipKKRUVEuKcUQ4AZ+Ksyr2oCVDduXM9ru7QgGYhAbyzxMbzopoOhEZRVtfd/Fzd0RiXkJNXwAdL9xMZFkR0MzN6MpxHZ4JKAArPaG0M/OHGi1IqWSl1/hrPJ0Bkafd1uVVvWysgRD/g9EN7eggPXNGCPcfSWbT7uNOPXymIQL/HIOUIbPtSdzTGJXyzKYHE1CweuKK5qdwznEpngtoAtBCRCBHxAUYB8wtvICINCj29Ftjt+H4hcKWIBDmKI650vFYx0o9Zq0Z0vhVquGadseEdGxBa25/3lx2w7xp9LYdC/Q5WRV9Bvu5ojCLkFyg+/P0AHRrVpH9LJ16hMAw0JiilVB5wP1Zi2Q18qZTaKSIviMi1js0eFJGdIrIVeBAY79j3NPAvrCS3AXjB8VrFWPMuFOQ69d7Txbw8Pbirf1O2xqew+kCyy87j1kSg79/g9AHYPb/k7Y0Kt2B7EnHJGdw7oJkZPRlOJ3b67TwqKkrFxMSU7yAZp+GN9tD6L3DDJ84JrBhZufn0e2UpLepVZ/akni49l9sqyIf3uoO3P9y1vNgGkEbFU0px9dsrycnLZ9HD/c2isEapichGpVRUSduZlSTKat1HkHsO+jzs8lP5eXsyqW8Eq/Yns8WuXXc9PK2R6rFtcGCJ7miMQpbtPcnupDTu7t/MJCfDJUyCKoucc7D+I2vl7XpFzSl2vlt7hFGzmjfvLd1fIedzSx1HQWBDq6LPcBvvL9tPw5p+jOhc5AwPwyg3k6DKYtNMyDxTrjX3yqq6rxfjeoWxaNdx9p84W2HndStePhB9P8StgPgNuqMxgJi402yIO8Od/ZqabrmGy5ifrNLKz7WKI5r0hNAeFXrqcdHh+Hp58MnygxV6XrfSdRxUCzKjKDfx0fKD1PL35pZuZet9ZhhlYRJUae38FlLjoU/FjZ7Oq1Pdl5ujmvDt5qMcT7NpGwrf6tDtTti7wFqg19Bm/4mzLNp1nNt7hePv46U7HKMKMwmqNJSy1oULaQ0thmoJYVLfCPIKCpi2Kk7L+d1C98ng5Qur39Edia19svwgvl4ejOsVpjsUo4ozCao0DiyG4zusFcs99PyRhdUJ4KoODZi99jDpWTZd+qd6CHQaDVvnwNkTuqOxpeNpWXy7+Sg3RzWhTnVf3eEYVZxJUKWx+h0IbAAdbtIaxl39mpKencfn645ojUOr6AcgP8cq9zcq3LRVceQVFDCpb4TuUAwbMAmqJEnb4OAy6HGXVU2mUcfGtejZtDbTV8eRm1+gNRZt6jSzJklv+BSybVrVqMnZ7DxmrzvMsPb1CasToDscwwZMgirJmnfBpzpETtAdCQB39m1KUmoWP21L0h2KPr0fgqwU04qjgn25IZ70rDzu7NtUdyiGTZgEdSmpCVY79663Q7VauqMBYGCrujQNCeCTFQftu4hsk+7QuDusfd8sIltB8vILmLrqEFFhQXQJ1dO82rAfk6AuZd2HVgVfj7t1R3KBh4dwZ9+m7ExMY81Bmy4iC9bE3TNxsOcn3ZHYwsKdx0k4k8kkM3oyKpBJUMXJToeNM6DtCAhyr3La67o0ok6AD5+uOKQ7FH1aD4daYbDmPd2RVHlKKT5ecZCwOv4MaVtPdziGjZgEVZzNsyA7DXrdrzuSP/Hz9mRsrzCW7Dlh3+WPPDyh570QvxYSyrlCvXFJGw+fYWt8Cnf0icDTLAprVCCToIpSkA9rP4AmPaBxZMnbazCmZxg+Xh5MW2XjUVSX28C3ppm462JTVh6iZjVvboxsrDsUw2a0JigRGSYie0Vkv4g8UcT7j4jILhHZJiKLRSSs0Hv5IrLF8XBuN7u9CyDlMPS6z6mHdabg6r5c17kRX29K4My5HN3h6OEbCJHjrGaGKTaeG+ZC8aczWLjzGKO7h5pljYwKpy1BiYgn8B5wFdAWGC0iF/ew2AwYOyKvAAAgAElEQVREKaU6AvOAVwq9l6mU6ux4XIszrXkfaoVa9znc2MQ+EWTlFvD5ehv/59zjLkBg/ce6I6mSpq+Ow0OEcdHudR/WsAedI6juwH6l1EGlVA4wBxhReAOl1FKlVIbj6VrA9dcYjm6CI6uhxz3WfQ431qp+IH1bBPPZmjhy8mw6cbdmY6uQZeNnZuKuk6Vn5TJ3QzxXd2hAg5rVdIdj2JDOBNUIiC/0PMHxWnHuAH4u9NxPRGJEZK2IjCxuJxGZ7Ngu5uTJkyVHtfYD8AmELmNK3tYNTOwdwfG0bBZst/HE3Z73QnYqbPlcdyRVylcxCZzNzuOOPmZZI0MPnQmqqHKgImeeisgYIAr4X6GXQx097W8F3hSRZkXtq5T6WCkVpZSKCgkJuXREaUlWW42uY8GvRmk+g3b9W4bQLCSAKSsP2Xjibjdo3A3WfQAFNh1JOll+gWL66jgiw4Lo1MQ9Jqkb9qMzQSUAhbudNQYSL95IRAYD/wCuVUpln39dKZXo+HoQWAZ0KXdEMVOgIM9q61BJeHgIE3pHsP1oKhsPn9Edjj4974HTByF2oe5IqoTFu49z5HSGGT0ZWulMUBuAFiISISI+wCjgD9V4ItIF+AgrOZ0o9HqQiPg6vg8GegO7yhVNbhbETIVWV0PtyvWP8vqujajh52XvXlFtRkCNRtYlWqPcpq2Ko1GtalxpJuYaGmlLUEqpPOB+YCGwG/hSKbVTRF4QkfNVef8DqgNfXVRO3gaIEZGtwFLgJaVU+RLU9q8gIxl6us+yRqXl7+PF6O6h/LLzGIkpmbrD0cPTC7pNgkO/w/Hy/SjY3e4kaxmtsb3C8PI0UyUNfbT+9CmlFiilWiqlmimlXnS89qxSar7j+8FKqXoXl5MrpVYrpToopTo5vk4pZyDWb9712kN433J/Lh3G9gpDKcVnaw7rDkWfyPHgVc1aQ9G4bNNXxeHn7cGobk1K3tgwXMj8egQQtwJO7LQWhZXKuZRL4yB/hrarzxfrj5CZY9MVvv1rQ8ebYdtcyDitO5pKKflsNt9uOcr1XRtTy19v/zPDMAkKrO6s/nW0d8wtr4l9IkjNzOWbzQm6Q9Gnx12QlwUbp+uOpFKasyGenLwCJkSH6w7FMEyC4kyctbRR5Hjw9tMdTblEhQXRvlENZqyOs2/Jeb12ENHP6ribn6s7mkolN7+AmWsO07dFMC3qBeoOxzBMgmLDp4BA1B26Iyk3EWFcr3D2HT/LmgM27hXV4x5IO2p6RZXRwp3HOJaWxYTe4bpDMQzA7gkq5xxs+gzaXgs1L7WIReVxTaeG1A7wYdrqON2h6NNyqNUrat1HuiOpVKaviiOsjj8DWtbVHYphAHZPUFvnQFaqW3XMLS8/b09u7R7Kb7uPE386o+QdqiIPT+h+p7WmYtI23dFUCtsTUok5fIZxvcLxMD2fDDdh3wSllLUCdoNOVt+nKmRMzzA8RPhsTZzuUPTpMga8/WG9GUWVxrTVhwjw8eTGKNPzyXAf9k1Qh36Hk3sqdWl5cerX9OOq9vWZsyGejJw83eHoUS0IOo2CbV/BORvfjyuFU2ez+XFrEjdGNqaGn7fucAzjAvsmqHUfW6Xl7a7XHYlLjI8OJz0rj283H9Udij7d74L8bNg0XXckbu2LdUfIyS9gbK9w3aEYxh/YM0GdiYN9P1eJ0vLiRIYF0a6hzUvO67aGiP6wYQrk23QkWYLc/AJmrbNKy5vXra47HMP4A3smqCpUWl4cEWFctCk5p8ddjpLzH3VH4pYW7jzG8bRsxpuJuYYbsl+CysmATTOhzTVVprS8ONc6Ss6n27rkfBjUCjUt4YtxvrR8YCtTWm64H/slqO1fQlaK9Zt1Fefn7cmobk1MyXm3SXB4FRzboTsat7LjqFVaPrZnmCktN9yS/RLUuo+hXgcI7aU7kgoxpmcYIsKstTZe5bzLWGuVc1Ny/gczVsdRzduTm6LMquWGe7JXgso561i1fHKVKy0vTkNH07k5G+Jtvsr5TVbJuVnlHIDT53L4fmsi13dtRM1qprTccE9aE5SIDBORvSKyX0SeKOJ9XxGZ63h/nYiEF3rvScfre0VkaKlOeO6kNT+mkq9aXlbjosNJzcxl/labl5znZVpLWxnMdaxaPs4URxhuTFuCEhFP4D3gKqAtMFpE2l602R3AGaVUc+AN4GXHvm2xWsS3A4YB7zuOd2mZqdD1dvCu5rTPURn0iKhN6/qBTF992L4l5/XbQ1hviJkCBTYdSTrk5Rcwa+1hopvVoaVZtdxwYyUmKBG5X0SCXHDu7sB+pdRBpVQOMAcYcdE2I4AZju/nAYNERByvz1FKZSulDgH7HccrWRUuLS/O+ZLz3UlpbIg7ozscfbpPhpQjsO8X3ZFo9dvuExxNybT36OlMnFlhpBIozQiqPrBBRL50XJJz1s2bRkB8oecJjteK3EYplQekAnVKue+f+dWEoLDLj7gSG9G5ITX8vJhh55Lz1sOhRiPbr3I+Y3UcjWpVY1BrG5eW//o0fNjH9qNpd1diglJKPQ20AKYA44FYEfmPiDQr57mLSnQXX38qbpvS7GsdQGSyiMSISMyZPN8yhlh1+Pt4cUu3Jvyy8xhJqZm6w9HD0wuiJlrrMJ7YozsaLfYdT2fNwWTG9AzDy9NeNVIXpMRbvcI63mRNQzDcVql+QpV14+KY45EHBAHzROSVcpw7AShc39oYSCxuGxHxAmoCp0u57/nYP1ZKRSmlooLqNixHuJXf7b3CKVCK2WuP6A5Fn8jx4OkLGz7RHYkW01fH4evlwahuNi4tj5lqfe02SW8cRolKcw/qQRHZCLwCrAI6KKXuASKBG8px7g1ACxGJEBEfrKKH+RdtMx8Y5/j+RmCJI1nOB0Y5qvwisEZ468sRiy00qe3PoNZ1+WL9EbJybXppIyAY2t8AW76weoHZSGpGLt9uOsqIzg0JCvDRHY4euVmwaQa0utpaYcRwa6UZQQUD1yulhiqlvlJK5QIopQqA4Zd7Ysc9pfuBhcBu4Eul1E4ReUFErnVsNgWoIyL7gUeAJxz77gS+BHYBvwD3KaVs+j9u2YyLDif5XA4/bUvSHYo+3e+E3HOw5XPdkVSorzbGk5mbb+/iiB1fQ0ayVTBjuD2xU9lxVFSUiomJ0R2GVkopBr/+OwG+Xnx/X2+cV/NSyXw62PqP6v6N4FH178XkFygGvrqMejV8+eruaN3h6KEUfNwf8nLg3jW2mazvjkRko1IqqqTtqv6/TOMPzpecb0tIZXN8iu5w9Ol+F5w+CAcW646kQizbe4IjpzPsPXqKXw9JW60RtElOlYJJUDZ0fdfGVPe1ecl52xFQvZ5tSs6nr46jXg1fhrarrzsUfdZ/BL41oeMtuiMxSskkKBuq7uvFjZGNWbA9iRPpWbrD0cPLxyo5378Ikg/ojsalDpw8y4rYU9zWIwxvu5aWpyXBru+hyxjwNY0ZKwub/rQat/cKIzdf8fk6O5ecTwAPb1hftUvOP1sdh4+nB7f2sHHVWsxUa1Jud1NaXpmYBGVTTUOqM6BVCLPXHSEnr0B3OHoE1oN2I2HLbMhO1x2NS6Rn5TJvYwLDOzYguLpNJ6rnZcPGadByKNRuqjsaowxMgrKxcdHhnEzP5ucdNi4573E3ZKfB1jm6I3GJeRsTOJdj89Lynd9ZnQxMaXmlYxKUjfVvEUJEcADTVsXpDkWfxlHQKNIqliioWiPJggLFjNVxdAmtRacmtXSHo8+6D6FOC2g6UHckRhmZBGVjHh7CuF5hbIlPYYudS8573A3JsXBwqe5InOr32JPEJWcw3s6jp4QYSNxkjZ5sMN+tqjF/YzZ3Q6RVcj591SHdoejTdmSVLDmfviqOkEBfrmrfQHco+qz9AHxrQOfRuiMxLoNJUDYX6OfNjZGN+cnuJeeREyB2YZUpOd9/4iy/7zvJ2J5h+HjZ9J95WhLs+g66jAVf05ixMrLpT65R2LjocHLzbb7KedRER8n5x7ojcYrP1lil5aO7m9JyU1peeZkEZRARHMBAR8l5dp5N19wNrAftr4fNsyErTXc05ZKa6Sgt79SAkEAbl5bHTIWWw0xpeSVmEpQBwITeEZw6m82C7XYuOb8LctKteVGV2Fcx8WTk5DMhOkJ3KPrs+BoyTll/p0alZRKUAUDfFsE0C7FKzu20wv0fNIqExt0rdcl5foFixpo4osKC6NC4pu5w9FDKKo4IaQ1NB+iOxigHk6AMwFrlfHzvCLYlpLLpyBnd4ejT8244cwhif9UdyWVZvPs48aczGd87XHco+hxZA8e2WdMHzKrllZpJUMYF13dpRA0/L6baeeJum2shsCGs+0B3JJdl2qo4Gtb0Y5idVy1f+z5UCzKrllcBWhKUiNQWkUUiEuv4GlTENp1FZI2I7BSRbSJyS6H3povIIRHZ4nh0rthPUDUF+Hoxukcov+w4xtGUTN3h6OHpbVV9HVwGx3fpjqZMdiWmseZgMuOiw/Gy66rlZw7Dnp8gcjz4+OuOxignXT/FTwCLlVItgMWO5xfLAG5XSrUDhgFvikjh9VoeU0p1djy2uD5ke7i9VzhgrYBtW5ETwKtapRtFTVt1iGrenozqZuPS8vUfAwLd7tQdieEEuhLUCGCG4/sZwMiLN1BK7VNKxTq+TwROACEVFqFNNapVjWHt6/PF+iOcy87THY4e/rWh0yjYOhfOndIdTamcOpvN91sSuTGyMTX9vXWHo0f2Wdg002pGWbOR7mgMJ9CVoOoppZIAHF/rXmpjEekO+ACFp/m/6Lj094aIFDvZQ0Qmi0iMiMScPHnSGbFXeRN7R5CWlcc3mxJ0h6JPj7shPxtipumOpFRmrz1CTn6BvYsjtnwO2anQ817dkRhO4rIEJSK/iciOIh4jynicBsBMYIJS6nzt75NAa6AbUBv4e3H7K6U+VkpFKaWiQkLMAKw0ujpWv566Ko6CApuWnNdtDc0GwYZPrEmfbiw7L5+Zaw8zoFUIzUJs2i22IN8qjmjcDZp00x2N4SQuS1BKqcFKqfZFPL4HjjsSz/kEdKKoY4hIDeAn4Gml1NpCx05SlmxgGtDdVZ/DjkSEO/pEcOjUOZbuLfKvxh563Qtnj8OOb3RHcknztyRy6mw2k/rYeMWEfb9Y0wN63ac7EsOJdF3imw+Mc3w/Dvj+4g1ExAf4FvhMKfXVRe+dT26Cdf9qh0ujtaGr2tenYU0/Pl1h41XOmw2yJnuufc+a/OmGlFJMWXmI1vUD6d28ju5w9FnzHtQMhdbX6I7EcCJdCeolYIiIxAJDHM8RkSgR+dSxzc1AP2B8EeXks0VkO7AdCAb+XbHhV33enh6M7x3OmoPJ7DiaqjscPUSs+xnHtsOh5bqjKdKq/cnsOZbOHX0iELtOSk3cDIdXQY/J4OmlOxrDibQkKKVUslJqkFKqhePracfrMUqpSY7vZymlvAuVkl8oJ1dKXaGU6uC4ZDhGKXVWx+eo6m7pFkqAjydTV9p4FNXxFvAPtn5Dd0OfrjxIcHVfru3cUHco+qx5H3yqQ9fbdUdiOJlNZ/MZpVGzmjc3d2vC/K2JHE+zaa8obz/ofqfVK+rkXt3R/EHs8XSW7T3JuF5h+Hp56g5Hj9QE2PmN1fPJz6ZrD1ZhJkEZlzQhOoICpZhu54m73SaBp69VJeZGpqw8hK+XB7f1DNMdij7rPrTuD/a8R3ckhguYBGVcUmgdf4a1r8/stYc5a9eJuwHBjom7c+Cse8ylO5GexTebjnJjZGNqB/joDkePrDTYOAPajYQgGyfpKswkKKNEd/ZtSlpWHnM3xOsORZ9e90NeljUvyg18tvowuQUFTOpr49LyTZ9Bdpr1d2NUSSZBGSXqEhpE9/DaTF15iNz8ytknqdxCWkKrq2H9J5CToTWUc9l5zFx7mCvb1iMiOEBrLNrk51o9n8L6QKOuuqMxXMQkKKNUJvdrytGUTHt33I1+EDJPa++4+1VMPKmZuUzu10xrHFrt/A7SEiD6Ad2RGC5kEpRRKle0rkuzkAA+Xn7Qvh13Q3taS+msfgfy9dyPy8sv4NOVh4gMCyIy7E9dauxBKVj1FgS3ghZX6o7GcCGToIxS8fAQ7uzblJ2Jaazan6w7HD1EoPdDkHIYds/XEsKCHcdIOJPJnXa+93RgMRzfbv1deJj/wqoy87drlNp1XRtRN9CXD37frzsUfVpdDbWbWb/BV/BIUinFB8sO0DQkgCvb1qvQc7uVlW9aXY873KQ7EsPFTIIySs3Xy5M7+kSwan8y2xJSdIejh4cn9H4QkrZYXXcr0PLYU+xOSuPu/s3w8LDpskZHN0LcCmshXy+bltfbiElQRpnc2iOUQD8vPvz9QMkbV1WdRkP1+rDyjQo97QfL9lO/hh8jO9u4Gd/KN60VIyLH647EqAAmQRllEujnzdieYfy84xgHT9p0CUQvX6utw6Hfrd/oK8DmI2dYe/A0k/pG4ONl03+2p/bD7h+slT18A3VHY1QAm/6kG+UxoXcE3p4efLz8oO5Q9ImaYP0mX0GjqA+WHaBmNW9GdQ+tkPO5pZVvgJcf9DDLGtmFSVBGmYUE+nJzVGO+3pRAYkqm7nD08A2E7pNh949wcp9LT7X3WDq/7jrOuF5hVPe1aTuJlHjYNgcix0F10xnbLkyCMi7LXf2aoRT2HkX1uNv6jd7Fo6j3l+3H38eTCb0jXHoet7b6bUDMxFyb0ZKgRKS2iCwSkVjH1yJnHIpIfqFmhfMLvR4hIusc+891dN81KlCT2v6M7NKIL9Yf4WR6tu5w9AgIhqiJsG0unHZNz6y4U+f4YWsiY3qGEWTXRWHPnrDW3es0Cmo21h2NUYF0jaCeABYrpVoAix3Pi5JZqFnhtYVefxl4w7H/GeAO14ZrFOXeAc3IyS9gip0bGkY/AB5eLhtFfbDsAF6eHkzqa+PR05r3ID8H+jysOxKjgulKUCOAGY7vZwAjS7ujWH2trwDmXc7+hvM0DanOXzo0YOaaOFIycnSHo0eNBtB1LGz53Gqe50RHUzL5elMCo7o1oW6gn1OPXWlknIYNn0K766COjdcetCldCaqeUioJwPG1bjHb+YlIjIisFZHzSagOkKKUOr8YWgJQ7MQQEZnsOEbMyZPu0cunKrlvYHPO5eTbuy1874cAx/pwTvThMmuu2eR+Nl7WaM27kHMO+j2mOxJDA5clKBH5TUR2FPEYUYbDhCqlooBbgTdFpBlQ1BT6YtecUUp9rJSKUkpFhYSY6h9na9OgBsPa1WfaqjhSM3J1h6NHrVBr8u7GGZB+zCmHTEzJZO6GeG6KakLjIH+nHLPSyTgN6z6GtiOgbhvd0RgauCxBKaUGK6XaF/H4HjguIg0AHF9PFHOMRMfXg8AyoAtwCqglIufrbRsDia76HEbJHhzUgvTsPKassvEoqu+joPKddi/qg2UHKFCK+wba+LLW2vchJx36P647EkMTXZf45gPjHN+PA76/eAMRCRIRX8f3wUBvYJeyej0sBW681P5GxWnb0DGKWnnIvqOo2hHWKCpmGqSV7/clM3oCMs/Auo+gzbVQr53uaAxNdCWol4AhIhILDHE8R0SiRORTxzZtgBgR2YqVkF5SSu1yvPd34BER2Y91T2pKhUZv/IkZRWHdJ1H5sOL1ch3mg2UHUNh89LTmPauduxk92ZqWaelKqWRgUBGvxwCTHN+vBjoUs/9BoLsrYzTKpvAoamLvcGr523DOTlAYdBkDm2ZAn79e1pydhDMZzN0Qz42RNh49nTtltXNvdx3UL/K/AMMmzEoShtP8dUgLzubk8eHvNl5dou/frD5Ry1+9rN3fXhwLwANXNHdmVJXLyjcgNwMGPKk7EkMzk6AMp2ldvwYjOjVk+upDnEjP0h2OHrWaWK0gNs+E02VL1AdOnuXrTUe5rWcoDWtVc0187i4tyZr31PEWCGmlOxpDM5OgDKf66+CW5OYr3lti4667/f4GHt6w9D9l2u2NRfvw9fLg3gE2Hj2teA0K8sy9JwMwCcpwsvDgAG6OasLn648QfzpDdzh6BNaHnnfD9nlwbEepdtmVmMaP25KY0DuckEBfFwfopk4fgo3Trft4tW08Odm4wCQow+keHNQcEeGN31zbhsKt9X4I/GrAkn+VavNXf91LDT8vJve1ceXekn9b6xr2L25pTsNuTIIynK5BzWpMiA7n281H2ZWYpjscPaoFWUlq3y9weM0lN1194BRL9pzg3oHNqenvXUEBupnELbBjHvS611rf0DAwCcpwkXsHNKeGnzcv/bJHdyj69LgbAhvAr09blX1FKChQvPTzHhrW9GN8dHjFxudOfnsOqtV2rGtoGBaToAyXqOnvzQNXNGf5vpOsiLXpIr0+AXDF03A0BnZ+W+QmP2xLZFtCKo9e2Qo/b88KDtBNHFgCB5dZE539auqOxnAjJkEZLjO2VxiNg6rxnwV7KCgodj3fqq3TaKjXHn57HvL+2NgxOy+f/y3cS5sGNRjZpdgF+au2gnxY+LS14G4309bN+COToAyX8fXy5LGhrdidlMa8Tc7tlVRpeHjClf+ClMOw/pM/vDV9VRwJZzJ58qrWeHoUtUi/DWz6DE7shCEvgJdNqxeNYpkEZbjUtZ0a0jW0Fq/8spf0LJsuJNvsCmg+BJa/Yi3jA5xIz+KdJfsZ1Lou/VratA1MVqpVuRfaC9qanqPGn5kEZbiUiPDcNe04dTabd5faePLu0BetxnuOsvNXF+4lOy+ff/zFxn2Olr8KGckw7L8gNh1BGpdkEpThcp2a1OLGyMZMXXmIQ6fO6Q5Hj5BWVlXfxhnEblnBVxsTmNA7gqYh1XVHpkfyAVj3IXS+FRp20R2N4aZMgjIqxONDW+Hj6cGLP+0qeeOqqv/jqIBg8n98jDr+3txv1wVhlYIFj4GnLwx6Vnc0hhszCcqoEHVr+PHQ4Bb8tvsEi3Yd1x2OHn412dDsAVrn7ea9DrHU8LPppNzd8+HAYhj4lLUslGEUwyQoo8JM6B1Bq3qBPD9/Jxk5ebrDqXCnz+Vw1/ZW7PNuTfd9r0PGad0hVbzss/DLk1bpfffJuqMx3JyWBCUitUVkkYjEOr4GFbHNQBHZUuiRJSIjHe9NF5FDhd7rXPGfwigrb08PXryuPUdTMnnL0ffITv67YDfp2QX4jHwbyTxjrZ5gN8tfgbSj8JfXwVNLv1SjEtE1gnoCWKyUagEsdjz/A6XUUqVUZ6VUZ+AKIAP4tdAmj51/Xym1pUKiNsotKrw2t0Q1YcqKQ+w5Zp91+tYfOs1XGxOY1Lcp4e16QK/7rDlAh1frDq3iJG2F1e9C5zEQ2kN3NEYloCtBjQBmOL6fAZQ0CeJG4GellE37N1QtT1zVmhrVvPn719vJyy/QHY7LZeXm88TX22hUqxoPDnIURgx4wlo94YeH/rTCRJWUnwff3w/+dayJy4ZRCroSVD2lVBKA42vdErYfBXxx0Wsvisg2EXlDRIqdgi4ik0UkRkRiTp606ZpwbiYowId/XtuOrfEpfLrykO5wXO6NRfs4eOocL9/QEX8fx2UtnwDrMtepffD7y3oDrAhr3oFj2+Avr4F/bd3RGJWEyxKUiPwmIjuKeIwo43EaAB2AhYVefhJoDXQDagN/L25/pdTHSqkopVRUSIhNZ+y7oeEdGzC0XT1eX7SP/SfO6g7HZTYfOcMnKw4yunsofVoE//HNFkOg822w8g04ulFPgBXhVCws/S+0uRbaXqs7GqMScVmCUkoNVkq1L+LxPXDckXjOJ6ATlzjUzcC3SqkL6+QopZKUJRuYBnR31ecwXENE+NfI9vj7ePLYvK3kV8HFZLNy83ls3jbq1/DjqatbF73R0P9YLTm+vQdysyo2wIqQnwvf3gXe1eDqV3VHY1Qyui7xzQfGOb4fB3x/iW1Hc9HlvULJTbDuX5Wur7bhVuoG+vH8Ne3YfCSF96vgMkgv/7KH/SfO8t8bOhJY3JynarXg2rfh1F5Y+u+KDbAiLP+fNTq85i0IrKc7GqOS0ZWgXgKGiEgsMMTxHBGJEpFPz28kIuFAE+D3i/afLSLbge1AMFAF/2Xbw4jODbm2U0PeXBzLpiNndIfjNEv3nmDaqjjGR4fTv6TFYJsPhsgJVoXbgSUVE2BFiF9vJahOo6GdWQzWKDtRxXT6rIqioqJUTEyM7jCMi6Rl5XL1WysQgQUP9i1+tFFJnEzP5qq3lhNc3Zfv7utdukaEORnwyUBr8u49q6B6SXVDbi4rDT7qByof7l4FfjV0R2S4ERHZqJSKKmk7s5KEoV0NP2/eGtWZo2cyefq7HVTmX5oKChR/+2or6Vl5vDWqS+m75Pr4w41TITvNumdTUInL75WC7++DlCNw3ccmORmXzSQowy1EhtXmkSEt+X5LIjNWx+kO57K9uTiW3/ed5Nlr2tKqfmDZdq7Xzmo9cWAJrHzNNQFWhLUfWOvtDX4ewnrpjsaoxEyCMtzGvQOaM7hNXf790242xFW+deoW7z7O24tjuTGyMbd2D728g0ROgPY3wpIXYd/Ckrd3N0fWwaJnoPVwiH5AdzRGJWcSlOE2PDyE12/pTJPa/tw7exPH0ypP2fWhU+f469wttG9Ug3+PbI9cbgM+Ebj2HajfAb6eZM0hqixS4mHuGKjZBEa8Z5oQGuVmEpThVmr4efPhmEgysvOYOH0D57Ldf9Xz0+dymDBtPV4ewge3RZb+vlNxfPxh1Gzw9IY5t0JmJahuzEqDz2+xlm0aPccqnzeMcjIJynA7reoH8u5tXdlzLJ37Pt/k1uv1ZeXmM2nGBpJSs/h0XDea1PZ3zoFrhcLNn8GZOPhiNORmOue4rpCfB/Mmwsk9cPMMqFvMpGTDKCOToAy3NLBVXf49sj3L9p7kme/ds7Ivv0Dx8NwtbI5P4c1bOhMZ9qeuMeUT3geu+wiOrLUu9xXkO/f4zlBQAD88CPsXwV9ehWYDdd/V23wAAAo9SURBVEdkVCEmQRlua3T3UO4f2Jwv1sfzwo+73CpJ5TvKyX/ecYx/XN2Gqzo0cM2J2l8Pw16CPT9aK5+7U/m5UvDz47BlNvR/AqIm6o7IqGJMxzDDrT16ZUsycvKZuuoQniL84y9tLr8AwUnyCxSPz9vGt5uP8rcrWzKpb1PXnrDn3ZCRbDX7UwVWEYVHOe9zlZdSsOhZ2PCJVa034E8t3Qyj3EyCMtyaiPDM8DYUKMWnKw+RV6B4ZnhbPD30JKmcvAL+/rWVnB4e3JL7r2hRMSce+JSVlJb911qAdeQH+jrSFuTDT4/AxunQbRIM+Zep2DNcwiQow+2JCM9dYyWlKSsPcSw1izdHdS5/tVwZpWXlcs+sjazan8yjQ1rywKAKSk5gJYABT1hJasm/rcq+G6eAX82KiwGsFde/mQS7f4C+j8IVz5jkZLiMuQdlVArWSKotzwxvy8Jdx7j1k7WcqMB5UvGnM7j5wzWsO3iaV2/qVLHJqbB+j8HwN+HgUphypVXlV1FSE2DGcCs5DXsZBj1rkpPhUiZBGZXKHX0i+OC2ruxKSuOqt1awbO+lWok5x4/bErn6rRUcTclkxsTu3BjZ2OXnvKSoCTDmG0g/Bh8PgF2X6lbjJPsXw4d94cQeuHmmdV/MMFzMJCij0hnWvgE/PtCHkEBfxk/bwAs/7OKsCyb0pmTk8Pd527j/8800r1edBQ/2pXfz4JJ3rAhN+8OdSyAoHL683Wp4mJXm/PNkpcJPf4NZN0BgfZi8zHTFNSqMabdhVFpZufm8+NNuZq49TN1AX566ug0jOjcsd5VffoFizoYjvLpwL6mZudzVvxmPDGmJt6cb/j6Xnwu/vwIrXgX/OjDgSeg6rvwFFAX5sPNbWPgPOHscuk+Gwc+BT4Bz4jZsrbTtNrQkKBG5CXgeaAN0V0oVmTVEZBjwFuAJfKqUOt/YMAKYA9QGNgFjlVI5JZ33/9q72xgrrjqO49+fuyyUxQJl20JhKRRQnmq3kvBQ0aYULUqUNtGkjWlMfEFMbaJWE21MTPtOX2hS32hJ2hcmJoSkxIDQYttQpUrqNgQQurBBlsAutLAUKE9lWfj7Yka4aXZhUe6duTO/T3KTebgP/znMzp9z5sw5TlDFtO3gCZ5bt5ud3aeYOf7TfHfxVFa03cXwxhvrRHGur59XtvXw8ttddPWeZf7U23j+G3OYNaEOpovo2ZYkk4P/gJbPwMKn4N5vwfBRN/Y9/X2wey1s+TX0diZjAn79BZg4rzpxWynlPUHNAi4DLwI/GShBSWoAOklm3O0G2oEnIuI9SWuAtRGxWtLvgR0R8bvr/a4TVHFdvhz8aXsPq/62nz3vn2ZccxMPz7qDJTPvZNE94xg9cuBJEI+fucDW/cd5s+Mob3Z8wEcf93PfpNF878FpLJs7PvNnrm5IBOzZkHRF/2AXDL8VZq9IRneY8iUYNcjMvmeOJgmuYz3sWZ806905F774DMx+NPtnrqxwcp2grvy49BaDJ6hFwHMR8Ui6/my665fAMWB8RPR/8n3X4gRVfBHB3/cdZ3X7Qf7aeYzTHyf3psY1NzGlpZlb0q7pZ/v66eo9y8lzFwEYM3IYD332Dr69YDLz7h5bX4npkyKS6dbffRn2vgoXTiXbR7bA6InQfDtc6kvG9zt5CM68n+wffivMXJ5M9zH9YffQs6oZaoLK83NQE4FDFevdwAJgHHAyIvortk8c7EskrQRWAkye/D/O0WN1QxKLZ7SweEYLFy9dpv3Ah+zqOUVX71kO9J7j/MVkPLuRTQ0sv3cCU1uaaWsdw/2Tx2b28O9NJ8HkBcnrUj8c2QEHtsCJLjjVA+d6oXEENI1KalfjP5c05bXOh8bhWUdvdkXVEpSkN4DxA+z6eUQMpV/sQFeLuMb2AUXEKmAVJDWoIfyuFcSwhk/xwLQWHpiWk553WWhohEnzkpdZnalagoqIpf/nV3QDrRXrk4DDQC8wRlJjWov673YzMyuQHPabvaIdmCFpqqQm4HFgXSQ3zTYD30zf9x2gBk8qmplZLWWSoCQ9JqkbWARskLQp3X6XpI0Aae3oaWAT0AGsiYjd6Vf8FHhG0j6Se1Iv1foYzMysuvygrpmZ1dRQe/HluYnPzMxKzAnKzMxyyQnKzMxyyQnKzMxyqVSdJCSdBvZmHUfGWkieJSszl4HLAFwGWbo7IgYZHPKqPA91VA17h9JzpMgkvesycBm4DFwG9cBNfGZmlktOUGZmlktlS1Crsg4gB1wGLgNwGYDLIPdK1UnCzMzqR9lqUGZmViecoMzMLJdKkaAkLZO0V9I+ST/LOh4zM7u+wt+DktQAdAJfJpkEsR14IiLeyzQwMzO7pjLUoOYD+yJif0T0AauBFRnHlClJL0p6UNJmSR2Sdkv6QdZxVZOk6ZKOSTogabukDyX9W9KtWcd2s0gaIemfknak/6bPD/FzhT4fJLUW9diKrgwJaiJwqGK9O91WZguAfcCPI2IWsBD4vqTZ2YZVPRGxD3gbeDIi2oCdwKMR8VG2kd1UF4AlEXEf0AYsk7RwCJ8r+vnQT3GPrdDKMNSRBthW6HZNSdOBrcBZ4CQwGTgB3E+SnDsjogfoAYiI05I60n1FbvqcA+xKl2dSsHEZI2mvP5OuDktfUfbzISKOAEfS5SvHJqmPQcqlYP9xqVtlqEF1A60V65OAwxnFUhPXqS18FXit8v2SppBcrN6pbaS1I+kWYEREnJDUChxPm3wLRVKDpO3AUeD1iHjH58NVlcdWklp1XStDgmoHZkiaKqkJeBxYl3FMtTBYbeERKi5IkkYBrwA/LPgf5mygI12eVbFcKBFxKb3YTgLmS5qb7ir9+TDIsRW6Vl3vCp+gIqIfeBrYRHJRWhMRu7ONqroGqy1IGgmMiYjD6fuGkfzB/jEi1mYYci1UXojOA5+XNDPDeKoqIk4Cb5Hchyr9+TDQsZWlVl3PynAPiojYCGzMOo4aGqy28BCwGUCSgJeAjoj4Tc0jrLGI+EPF8hbgngzDqQpJtwMXI+JkevFdCvyKkp8P1zi2UtSq61nha1AlNVhtofJ+wxeAJ4Elabfr7ZK+VvtQ7SaaAGyWtJOkafv1iPgzPh8GO7ZS1arrUeEf1LWrJG0DFkTExaxjsez5fLC8c4IyM7NcchOfmZnlkhOUmZnlkhOUmZnlkhOUmZnlkhOUmZnlkhOUmZnlkhOUmZnlkhOUWZ1IRyp/IZ1071+SCjdck1klJyiz+vEssD8i5gC/BZ7KOB6zqirFYLFm9U5SM/BYRMxLN3UByzMMyazqnKDM6sNSoDWdjBDgNuCNDOMxqzo38ZnVhzbgFxHRlk5I+Bdg+3U+Y1bXnKDM6sNY4ByApEbgK8D6TCMyqzInKLP60AksTJd/BGyIiK4M4zGrOk+3YVYHJI0FXgVagK3Ayog4n21UZtXlBGVmZrnkJj4zM8slJygzM8slJygzM8slJygzM8slJygzM8slJygzM8slJygzM8ul/wD56Qs4H//GuAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x22c5ebab9e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "z=np.sin(x)\n",
    "plt.figure()\n",
    "plt.plot(x,y, label=r'$cos(x)$')\n",
    "plt.plot(x,z, label=r'$sin(x)$')# I have not specified the colour, but matplotlib will increment \n",
    "#through a range as new plots are addded.\n",
    "plt.legend(loc=1) # places the legend (created from the plot labels) in the upper-right\n",
    "plt.title('My First Plot')\n",
    "plt.xlabel(r'$\\theta$') # the r tells python to read all characters, otherwise it would not read the \\ \n",
    "plt.ylabel('y')\n",
    "xmin,xmax=plt.xlim() # returns the current limits\n",
    "plt.xlim(0,xmax*1.3) # sets new limits, makes some space on the right for the legend\n",
    "plt.xticks((0,np.pi/2,np.pi,3*np.pi/2,2*np.pi),('0','$\\pi/2$','$\\pi$','$3\\pi/2$','$2\\pi$')) # Move the tick labels and use \n",
    "#Latex commands for the labels\n",
    "plt.tight_layout() #Ensures nothing overlaps\n",
    "plt.show() # this is not needed in the notebook but is required from your code.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Loading data from a file to an array, np.loadtxt('fname',...)\n",
    "Data downloaded from https://climate.nasa.gov/system/internal_resources/details/original/647_Global_Temperature_Data_File.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "climate=np.loadtxt('https://climate.nasa.gov/system/internal_resources/details/original/647_Global_Temperature_Data_File.txt') # data downloaded from the NASA climate change website."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(138, 3)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(climate) # I want the first two columns in this array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "year,tempchange=climate.transpose()[0],climate.transpose()[1]\n",
    "# by sepearting the variables with a comma we can assign both in a single line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x22c5c4a5748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.scatter(year,tempchange, label='NASA data')\n",
    "plt.title('Nasa Climate Change data since 1880')\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('$\\delta T$ from the 1951-1980 mean [C]')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a quick look at how simple it can be to analyse your data with python the following histogram can be generated with a single additional line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([13., 25., 34., 22., 12.,  7., 10., 10.,  2.,  3.]),\n",
       " array([-0.49 , -0.342, -0.194, -0.046,  0.102,  0.25 ,  0.398,  0.546,\n",
       "         0.694,  0.842,  0.99 ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x22c5ec41f98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(tempchange)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## This notebook forms the basic introduction to plotting in python with matplotlib, next term we will expand on this with further topics:\n",
    "\n",
    "* Adding multiple plots to a figure (subplots)\n",
    "* Exploring different types of graph\n",
    "    * Imshow, Axes3D, plotting histograms\n",
    "* Animate plots"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}