Lec07_graphics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graphics examples\n",
    "# Start with simple graphics\n",
    "Look at ways of importing graphics modules and inf object oriented (OO) methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set in-line but this is default. %matplotlib is a \"magic\" command that \n",
    "# controls aspects of matplotlib such as where to render figures.\n",
    "# %config allows configuration parameters. \n",
    "# Some othee options:\n",
    "# %gui qt5     # enable PyQt5 event loop integration\n",
    "# %gui osx     # enable Cocoa event loop integration\n",
    "# inline works for this notebook with static plots \"inline\"\n",
    "%matplotlib inline\n",
    "# Re-issuing  matplotlib seems to take us out of in-line mode.\n",
    "%matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List backend (Return to this in lecture 8 for interactive plots)\n",
    "%matplotlib --list\n",
    "# Show backends being used\n",
    "#c%matplotlib\n",
    "# %lsmagic Use this to list all magic options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get versions available in current installation\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import ipywidgets as widgets\n",
    "print('Pandas version',pd.__version__)\n",
    "print('Numpy version',np.__version__)\n",
    "print('Matplotlib verion',mpl.__version__)\n",
    "print('ipywidgets verion',widgets.__version__)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Pandas version 0.25.1\n",
    "Numpy version 1.17.2\n",
    "Matplotlib verion 3.1.3\n",
    "ipywidgets verion 7.5.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Method that looks like old style program.  Importing into current name space\n",
    "# (methods are called as functions but could have issue with functions being \n",
    "# with different imports)\n",
    "# we only import specific methods here. Normally * would be used to get all \n",
    "# funtions\n",
    "from matplotlib.pyplot import plot, title, xlabel, ylabel, show\n",
    "plot([1, 2, 3, 4], [1, 4, 2, 3])\n",
    "title(\"from matplotlib.pyplot import\")\n",
    "xlabel(\"X-axis\")\n",
    "ylabel(\"Y-axis\")\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This next method is one of the more common peferred methods \n",
    "# using a separate namespace for the modules\n",
    "import matplotlib.pyplot as plt\n",
    "fig = plt.figure;\n",
    "fig(figsize=(4,4))\n",
    "plt.plot([1, 2, 3, 4], [1, 4, 2, 3])\n",
    "plt.title(\"import matplotlib.pyplot as plt\")\n",
    "plt.xlabel(\"X-axis\")\n",
    "plt.ylabel(\"Y-axis\")\n",
    "pts = plt.ginput(n=5, show_clicks=True)\n",
    "selpts = np.array(pts)\n",
    "# Now draw the points\n",
    "plt.plot(selpts[:,0],selpts[:,1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Final is object oriented approach.  We create a plot\n",
    "# object and methods are applied to the object.\n",
    "# Import is the same.  There \n",
    "import matplotlib.pyplot as plt\n",
    "# Create new Figure with black background\n",
    "# Could Add: figsize=(8, 8) in figure creation.\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "# Add a subplot (could use multiple)\n",
    "ax = plt.subplot()\n",
    "#fig, ax = plt.subplots()\n",
    "#fig.figsize=(8, 8)\n",
    "# Now plot methods are applied to the ax object\n",
    "ax.plot([1, 2, 3, 4], [1, 4, 2, 3])\n",
    "ax.set_title(\"Method applied to ax object\")\n",
    "ax.set_xlabel(\"X-axis\")\n",
    "ax.set_ylabel(\"Y-axis\");  # Adding ; stops output\n",
    "# Show is not needetd when this appoach is used.\n",
    "# In the inline, non-interactive mode, figure can't now be\n",
    "# changed (unlike to exquivalent approach in MATLAB.\n",
    "# with an interactive backend (discussed later changes are \n",
    "# possible but figure is generated in separate window)\n",
    "f = plt.gcf()\n",
    "f.get_size_inches()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With the figure created as object fig, it can now be saved\n",
    "SaveFig = False\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_fig.png')\n",
    "    fig.savefig('Lec07_fig.pdf')\n",
    "    fig.savefig('Lec07_fig.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get versions available in anaconda\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import ipywidgets as widgets\n",
    "print('Pandas version',pd.__version__)\n",
    "print('Numpy version',np.__version__)\n",
    "print('Matplotlib verions',mpl.__version__)\n",
    "print('ipywidgets verions',widgets.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Customizing only works with Mac/Unix\n",
    "import sys\n",
    "systype = sys.platform\n",
    "print('Checking System',systype)\n",
    "if (systype=='darwin' or systype == 'linux2'):\n",
    "    !echo \"axes.titlesize : 24\" > my.style\n",
    "    !echo \"axes.labelsize : 20\" >> my.style\n",
    "    !echo \"lines.linewidth : 3\" >> my.style\n",
    "    !echo \"lines.markersize : 10\" >> my.style\n",
    "    !echo \"xtick.labelsize : 16\" >> my.style\n",
    "    !echo \"ytick.labelsize : 16\" >> my.style\n",
    "    print('Created my.style')\n",
    "else:\n",
    "    print('Used text File option create file my.style')\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('my.style')\n",
    "plt.plot([1, 2, 3, 4], [1, 4, 2, 3])\n",
    "plt.title(\"New Style aplied\")\n",
    "plt.xlabel(\"X-axis\")\n",
    "plt.ylabel(\"Y-axis\")\n",
    "plt.show()\n",
    "#    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mpl.rcParams['lines.linewidth'] = 2\n",
    "mpl.rcParams['lines.linestyle'] = '--'\n",
    "mpl.rcParams['figure.figsize'] = (3, 4)\n",
    "mpl.rcParams['xtick.top'] = True\n",
    "mpl.rcParams['xtick.major.width'] = -0.8\n",
    "mpl.pyplot.plot([1, 2, 3, 4], [1, 4, 2, 3])\n",
    "plt.ylabel('Y-axis');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mpl.rcParams.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Restore defaults\n",
    "style = 1\n",
    "if style == 1:\n",
    "    mpl.style.use('default')\n",
    "else:\n",
    "    mpl.rc_file_defaults \n",
    "    \n",
    "plt.plot([1, 2, 3, 4], [1, 4, 2, 3])\n",
    "plt.ylabel('Y-axis');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Tutorial examples from Matplotlib\n",
    "https://matplotlib.org/stable/tutorials/introductory/sample_plots.html#sphx-glr-tutorials-introductory-sample-plots-py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports needed for different examples\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One approach \n",
    "x1 = np.linspace(0.0, 5.0)\n",
    "x2 = np.linspace(0.0, 2.0)\n",
    "\n",
    "y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)\n",
    "y2 = np.cos(2 * np.pi * x2)\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
    "#fig.suptitle('A tale of 2 subplots')\n",
    "\n",
    "ax1.plot(x1, y1, 'o-')\n",
    "ax1.set_ylabel('Damped oscillation')\n",
    "ax1.set_title('A tale of 2 subplots')\n",
    "ax1.tick_params(axis='both',direction='in',right=True,top=True,length=6)\n",
    "\n",
    "ax2.plot(x2, y2, '.-')\n",
    "ax2.set_xlabel('time (s)')\n",
    "ax2.set_ylabel('Undamped')\n",
    "\n",
    "plt.show()\n",
    "SaveFig = False\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor01.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?ax1.tick_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alternative appoach\n",
    "x1 = np.linspace(0.0, 5.0)\n",
    "x2 = np.linspace(0.0, 2.0)\n",
    "\n",
    "y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)\n",
    "y2 = np.cos(2 * np.pi * x2)\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(x1, y1, 'o-')\n",
    "plt.title('A tale of 2 subplots')\n",
    "plt.ylabel('Damped oscillation')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x2, y2, '.-')\n",
    "plt.xlabel('time (s)')\n",
    "plt.ylabel('Undamped')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Histograms\n",
    "np.random.seed(19680801)\n",
    "\n",
    "# example data\n",
    "mu = 100  # mean of distribution\n",
    "sigma = 15  # standard deviation of distribution\n",
    "x = mu + sigma * np.random.randn(437)\n",
    "\n",
    "num_bins = 50\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# the histogram of the data\n",
    "n, bins, patches = ax.hist(x, num_bins, density=True)\n",
    "\n",
    "# add a 'best fit' line\n",
    "y = ((1 / (np.sqrt(2 * np.pi) * sigma)) *\n",
    "     np.exp(-0.5 * (1 / sigma * (bins - mu))**2))\n",
    "ax.plot(bins, y, '--')\n",
    "ax.set_xlabel('Smarts')\n",
    "ax.set_ylabel('Probability density')\n",
    "#ax.set_title(r'Histogram of IQ: $\\mu=100$, $\\sigma=15$')\n",
    "ax.set_title('Histogram of IQ: $μ=100$, $σ=15$')\n",
    "\n",
    "# Tweak spacing to prevent clipping of ylabel\n",
    "fig.tight_layout()\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor02.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Streamplot\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "w = 3\n",
    "# Using 100j takes 100 point is the interval.\n",
    "Y, X = np.mgrid[-w:w:100j, -w:w:100j]\n",
    "U = -1 - X**2 + Y\n",
    "V = 1 + X - Y**2\n",
    "speed = np.sqrt(U**2 + V**2)\n",
    "\n",
    "fig = plt.figure(figsize=(7, 9))\n",
    "gs = gridspec.GridSpec(nrows=3, ncols=2, height_ratios=[1, 1, 2])\n",
    "\n",
    "#  Varying density along a streamline\n",
    "ax0 = fig.add_subplot(gs[0, 0])\n",
    "ax0.streamplot(X, Y, U, V, density=[0.5, 1])\n",
    "ax0.set_title('Varying Density')\n",
    "\n",
    "# Varying color along a streamline\n",
    "ax1 = fig.add_subplot(gs[0, 1])\n",
    "strm = ax1.streamplot(X, Y, U, V, color=U, linewidth=2, cmap='autumn')\n",
    "fig.colorbar(strm.lines)\n",
    "ax1.set_title('Varying Color')\n",
    "\n",
    "#  Varying line width along a streamline\n",
    "ax2 = fig.add_subplot(gs[1, 0])\n",
    "lw = 5*speed / speed.max()\n",
    "ax2.streamplot(X, Y, U, V, density=0.6, color='k', linewidth=lw)\n",
    "ax2.set_title('Varying Line Width')\n",
    "\n",
    "# Controlling the starting points of the streamlines\n",
    "seed_points = np.array([[-2, -1, 0, 1, 2, -1], [-2, -1,  0, 1, 2, 2]])\n",
    "\n",
    "ax3 = fig.add_subplot(gs[1, 1])\n",
    "strm = ax3.streamplot(X, Y, U, V, color=U, linewidth=2,\n",
    "                      cmap='autumn', start_points=seed_points.T)\n",
    "fig.colorbar(strm.lines)\n",
    "ax3.set_title('Controlling Starting Points')\n",
    "\n",
    "# Displaying the starting points with blue symbols.\n",
    "ax3.plot(seed_points[0], seed_points[1], 'bo')\n",
    "ax3.set(xlim=(-w, w), ylim=(-w, w))\n",
    "\n",
    "# Create a mask\n",
    "mask = np.zeros(U.shape, dtype=bool)\n",
    "mask[40:60, 40:60] = True\n",
    "U[:20, :20] = np.nan\n",
    "U = np.ma.array(U, mask=mask)\n",
    "\n",
    "ax4 = fig.add_subplot(gs[2:, :])\n",
    "ax4.streamplot(X, Y, U, V, color='r')\n",
    "ax4.set_title('Streamplot with Masking')\n",
    "\n",
    "ax4.imshow(~mask, extent=(-w, w, -w, w), alpha=0.5, cmap='gray', aspect='auto')\n",
    "ax4.set_aspect('equal')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor03.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiple y-axes\n",
    "from mpl_toolkits.axisartist.parasite_axes import HostAxes, ParasiteAxes\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.subplots_adjust(right=0.75)\n",
    "\n",
    "twin1 = ax.twinx()\n",
    "twin2 = ax.twinx()\n",
    "\n",
    "# Offset the right spine of twin2.  The ticks and label have already been\n",
    "# placed on the right by twinx above.\n",
    "# Line below does not work to offset axis (syntax wrong)\n",
    "#twin2.spines.right.set_position((\"axes\", 1.2))\n",
    "# spines is a dictionary and then we can set position\n",
    "twin2.spines['right'].set_position((\"axes\", 1.2))\n",
    "\n",
    "p1, = ax.plot([0, 1, 2], [0, 1, 2], \"b-\", label=\"Density\")\n",
    "p2, = twin1.plot([0, 1, 2], [0, 3, 2], \"r-\", label=\"Temperature\")\n",
    "p3, = twin2.plot([0, 1, 2], [50, 30, 15], \"g-\", label=\"Velocity\")\n",
    "\n",
    "ax.set_xlim(0, 2)\n",
    "ax.set_ylim(0, 2)\n",
    "twin1.set_ylim(0, 4)\n",
    "twin2.set_ylim(1, 65)\n",
    "\n",
    "ax.set_xlabel(\"Distance\")\n",
    "ax.set_ylabel(\"Density\")\n",
    "twin1.set_ylabel(\"Temperature\")\n",
    "twin2.set_ylabel(\"Velocity\")\n",
    "\n",
    "ax.yaxis.label.set_color(p1.get_color())\n",
    "twin1.yaxis.label.set_color(p2.get_color())\n",
    "twin2.yaxis.label.set_color(p3.get_color())\n",
    "\n",
    "tkw = dict(size=4, width=1.5)\n",
    "ax.tick_params(axis='y', colors=p1.get_color(), **tkw)\n",
    "twin1.tick_params(axis='y', colors=p2.get_color(), **tkw)\n",
    "twin2.tick_params(axis='y', colors=p3.get_color(), **tkw)\n",
    "ax.tick_params(axis='x', **tkw)\n",
    "\n",
    "ax.legend(handles=[p1, p2])\n",
    "\n",
    "plt.show()\n",
    "SaveFig = False\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor03B.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type name to see what items are in the dictionary\n",
    "twin2.spines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bar charts\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "from collections import namedtuple\n",
    "\n",
    "np.random.seed(42)\n",
    "\n",
    "Student = namedtuple('Student', ['name', 'grade', 'gender'])\n",
    "Score = namedtuple('Score', ['score', 'percentile'])\n",
    "\n",
    "# GLOBAL CONSTANTS\n",
    "test_names = ['Pacer Test', 'Flexed Arm\\n Hang', 'Mile Run', 'Agility',\n",
    "              'Push Ups']\n",
    "test_units = dict(zip(test_names, ['laps', 'sec', 'min:sec', 'sec', '']))\n",
    "\n",
    "\n",
    "def attach_ordinal(num):\n",
    "    \"\"\"Convert an integer to an ordinal string, e.g. 2 -> '2nd'.\"\"\"\n",
    "    suffixes = {str(i): v\n",
    "                for i, v in enumerate(['th', 'st', 'nd', 'rd', 'th',\n",
    "                                       'th', 'th', 'th', 'th', 'th'])}\n",
    "    v = str(num)\n",
    "    # special case early teens\n",
    "    if v in {'11', '12', '13'}:\n",
    "        return v + 'th'\n",
    "    return v + suffixes[v[-1]]\n",
    "\n",
    "\n",
    "def format_score(score, test):\n",
    "    \"\"\"\n",
    "    Create score labels for the right y-axis as the test name followed by the\n",
    "    measurement unit (if any), split over two lines.\n",
    "    \"\"\"\n",
    "    unit = test_units[test]\n",
    "    if unit:\n",
    "        return f'{score}\\n{unit}'\n",
    "    else:  # If no unit, don't include a newline, so that label stays centered.\n",
    "        return score\n",
    "\n",
    "\n",
    "def format_ycursor(y):\n",
    "    y = int(y)\n",
    "    if y < 0 or y >= len(test_names):\n",
    "        return ''\n",
    "    else:\n",
    "        return test_names[y]\n",
    "\n",
    "\n",
    "def plot_student_results(student, scores, cohort_size):\n",
    "    fig, ax1 = plt.subplots(figsize=(9, 7))  # Create the figure\n",
    "    fig.subplots_adjust(left=0.115, right=0.88)\n",
    "    fig.canvas.manager.set_window_title('Eldorado K-8 Fitness Chart')\n",
    "\n",
    "    pos = np.arange(len(test_names))\n",
    "\n",
    "    rects = ax1.barh(pos, [scores[k].percentile for k in test_names],\n",
    "                     align='center',\n",
    "                     height=0.5,\n",
    "                     tick_label=test_names)\n",
    "\n",
    "    ax1.set_title(student.name)\n",
    "\n",
    "    ax1.set_xlim([0, 100])\n",
    "    ax1.xaxis.set_major_locator(MaxNLocator(11))\n",
    "    ax1.xaxis.grid(True, linestyle='--', which='major',\n",
    "                   color='grey', alpha=.25)\n",
    "\n",
    "    # Plot a solid vertical gridline to highlight the median position\n",
    "    ax1.axvline(50, color='grey', alpha=0.25)\n",
    "\n",
    "    # Set the right-hand Y-axis ticks and labels\n",
    "    ax2 = ax1.twinx()\n",
    "\n",
    "    # Set the tick locations\n",
    "    ax2.set_yticks(pos)\n",
    "    # Set equal limits on both yaxis so that the ticks line up\n",
    "    ax2.set_ylim(ax1.get_ylim())\n",
    "\n",
    "    # Set the tick labels\n",
    "    ax2.set_yticklabels([format_score(scores[k].score, k) for k in test_names])\n",
    "\n",
    "    ax2.set_ylabel('Test Scores')\n",
    "\n",
    "    xlabel = ('Percentile Ranking Across {grade} Grade {gender}s\\n'\n",
    "              'Cohort Size: {cohort_size}')\n",
    "    ax1.set_xlabel(xlabel.format(grade=attach_ordinal(student.grade),\n",
    "                                 gender=student.gender.title(),\n",
    "                                 cohort_size=cohort_size))\n",
    "\n",
    "    rect_labels = []\n",
    "    # Lastly, write in the ranking inside each bar to aid in interpretation\n",
    "    for rect in rects:\n",
    "        # Rectangle widths are already integer-valued but are floating\n",
    "        # type, so it helps to remove the trailing decimal point and 0 by\n",
    "        # converting width to int type\n",
    "        width = int(rect.get_width())\n",
    "\n",
    "        rank_str = attach_ordinal(width)\n",
    "        # The bars aren't wide enough to print the ranking inside\n",
    "        if width < 40:\n",
    "            # Shift the text to the right side of the right edge\n",
    "            xloc = 5\n",
    "            # Black against white background\n",
    "            clr = 'black'\n",
    "            align = 'left'\n",
    "        else:\n",
    "            # Shift the text to the left side of the right edge\n",
    "            xloc = -5\n",
    "            # White on magenta\n",
    "            clr = 'white'\n",
    "            align = 'right'\n",
    "\n",
    "        # Center the text vertically in the bar\n",
    "        yloc = rect.get_y() + rect.get_height() / 2\n",
    "        label = ax1.annotate(\n",
    "            rank_str, xy=(width, yloc), xytext=(xloc, 0),\n",
    "            textcoords=\"offset points\",\n",
    "            horizontalalignment=align, verticalalignment='center',\n",
    "            color=clr, weight='bold', clip_on=True)\n",
    "        rect_labels.append(label)\n",
    "\n",
    "    # Make the interactive mouse over give the bar title\n",
    "    ax2.fmt_ydata = format_ycursor\n",
    "    # Return all of the artists created\n",
    "    return {'fig': fig,\n",
    "            'ax': ax1,\n",
    "            'ax_right': ax2,\n",
    "            'bars': rects,\n",
    "            'perc_labels': rect_labels}\n",
    "\n",
    "\n",
    "student = Student('Johnny Doe', 2, 'boy')\n",
    "scores = dict(zip(\n",
    "    test_names,\n",
    "    (Score(v, p) for v, p in\n",
    "     zip(['7', '48', '12:52', '17', '14'],\n",
    "         np.round(np.random.uniform(0, 100, len(test_names)), 0)))))\n",
    "cohort_size = 62  # The number of other 2nd grade boys\n",
    "\n",
    "arts = plot_student_results(student, scores, cohort_size)\n",
    "figa = arts['fig']\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    figa.savefig('Lec07_Tutor04.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pie Charts\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Pie chart, where the slices will be ordered and plotted counter-clockwise:\n",
    "labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'\n",
    "sizes = [15, 30, 45, 10]\n",
    "explode = (0, 0.1, 0, 0)  # only \"explode\" the 2nd slice (i.e. 'Hogs')\n",
    "\n",
    "fig1, ax1 = plt.subplots()\n",
    "ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "ax1.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    print('Saving Lec07_Tutor05.png')\n",
    "    fig1.savefig('Lec07_Tutor05.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Table Data\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "data = [[ 66386, 174296,  75131, 577908,  32015],\n",
    "        [ 58230, 381139,  78045,  99308, 160454],\n",
    "        [ 89135,  80552, 152558, 497981, 603535],\n",
    "        [ 78415,  81858, 150656, 193263,  69638],\n",
    "        [139361, 331509, 343164, 781380,  52269]]\n",
    "\n",
    "columns = ('Freeze', 'Wind', 'Flood', 'Quake', 'Hail')\n",
    "rows = ['%d year' % x for x in (100, 50, 20, 10, 5)]\n",
    "\n",
    "values = np.arange(0, 2500, 500)\n",
    "value_increment = 1000\n",
    "\n",
    "# Get some pastel shades for the colors\n",
    "colors = plt.cm.BuPu(np.linspace(0, 0.5, len(rows)))\n",
    "n_rows = len(data)\n",
    "\n",
    "index = np.arange(len(columns)) + 0.3\n",
    "bar_width = 0.4\n",
    "\n",
    "# Initialize the vertical-offset for the stacked bar chart.\n",
    "y_offset = np.zeros(len(columns))\n",
    "\n",
    "# Plot bars and create text labels for the table\n",
    "cell_text = []\n",
    "for row in range(n_rows):\n",
    "    plt.bar(index, data[row], bar_width, bottom=y_offset, color=colors[row])\n",
    "    y_offset = y_offset + data[row]\n",
    "    cell_text.append(['%1.1f' % (x / 1000.0) for x in y_offset])\n",
    "# Reverse colors and text labels to display the last value at the top.\n",
    "colors = colors[::-1]\n",
    "cell_text.reverse()\n",
    "\n",
    "# Add a table at the bottom of the axes\n",
    "the_table = plt.table(cellText=cell_text,\n",
    "                      rowLabels=rows,\n",
    "                      rowColours=colors,\n",
    "                      colLabels=columns,\n",
    "                      loc='bottom')\n",
    "\n",
    "# Adjust layout to make room for the table:\n",
    "plt.subplots_adjust(left=0.2, bottom=0.2)\n",
    "\n",
    "plt.ylabel(\"Loss in ${0}'s\".format(value_increment))\n",
    "plt.yticks(values * value_increment, ['%d' % val for val in values])\n",
    "plt.xticks([])\n",
    "plt.title('Loss by Disaster')\n",
    "\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor06.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filled polygon\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def koch_snowflake(order, scale=10):\n",
    "    \"\"\"\n",
    "    Return two lists x, y of point coordinates of the Koch snowflake.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    order : int\n",
    "        The recursion depth.\n",
    "    scale : float\n",
    "        The extent of the snowflake (edge length of the base triangle).\n",
    "    \"\"\"\n",
    "    def _koch_snowflake_complex(order):\n",
    "        if order == 0:\n",
    "            # initial triangle\n",
    "            angles = np.array([0, 120, 240]) + 90\n",
    "            return scale / np.sqrt(3) * np.exp(np.deg2rad(angles) * 1j)\n",
    "        else:\n",
    "            ZR = 0.5 - 0.5j * np.sqrt(3) / 3\n",
    "\n",
    "            p1 = _koch_snowflake_complex(order - 1)  # start points\n",
    "            p2 = np.roll(p1, shift=-1)  # end points\n",
    "            dp = p2 - p1  # connection vectors\n",
    "\n",
    "            new_points = np.empty(len(p1) * 4, dtype=np.complex128)\n",
    "            new_points[::4] = p1\n",
    "            new_points[1::4] = p1 + dp / 3\n",
    "            new_points[2::4] = p1 + dp * ZR\n",
    "            new_points[3::4] = p1 + dp / 3 * 2\n",
    "            return new_points\n",
    "\n",
    "    points = _koch_snowflake_complex(order)\n",
    "    x, y = points.real, points.imag\n",
    "    return x, y\n",
    "\n",
    "x, y = koch_snowflake(order=5)\n",
    "\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "plt.axis('equal')\n",
    "plt.fill(x, y)\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor07.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More elaboate edges\n",
    "x, y = koch_snowflake(order=2)\n",
    "\n",
    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(9, 3),\n",
    "                                    subplot_kw={'aspect': 'equal'})\n",
    "ax1.fill(x, y)\n",
    "ax2.fill(x, y, facecolor='lightsalmon', edgecolor='orangered', linewidth=3)\n",
    "ax3.fill(x, y, facecolor='none', edgecolor='purple', linewidth=3)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Log plots\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Data for plotting\n",
    "t = np.arange(0.01, 20.0, 0.01)\n",
    "\n",
    "# Create figure\n",
    "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)\n",
    "\n",
    "# log y axis\n",
    "ax1.semilogy(t, np.exp(-t / 5.0))\n",
    "ax1.set(title='semilogy')\n",
    "ax1.grid()\n",
    "\n",
    "# log x axis\n",
    "ax2.semilogx(t, np.sin(2 * np.pi * t))\n",
    "ax2.set(title='semilogx')\n",
    "ax2.grid()\n",
    "\n",
    "# log x and y axis\n",
    "ax3.loglog(t, 20 * np.exp(-t / 10.0))\n",
    "# ax3.set_xscale('log', base=2)\n",
    "# ax3.set(title='loglog base 2 on x')\n",
    "ax3.set_xscale('log')\n",
    "ax3.set(title='loglog on x')\n",
    "\n",
    "\n",
    "ax3.grid()\n",
    "\n",
    "# With errorbars: clip non-positive values\n",
    "# Use new data for plotting\n",
    "x = 10.0**np.linspace(0.0, 2.0, 20)\n",
    "y = x**2.0\n",
    "\n",
    "#ax4.set_xscale(\"log\", nonpositive='clip')\n",
    "#ax4.set_yscale(\"log\", nonpositive='clip')\n",
    "ax4.set_xscale(\"log\")\n",
    "ax4.set_yscale(\"log\")\n",
    "\n",
    "ax4.set(title='Errorbars go negative')\n",
    "ax4.errorbar(x, y, xerr=0.1 * x, yerr=5.0 + 0.75 * y)\n",
    "# ylim must be set after errorbar to allow errorbar to autoscale limits\n",
    "ax4.set_ylim(bottom=0.1)\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor09.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Polar plots\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "r = np.arange(0, 2, 0.01)\n",
    "theta = 2 * np.pi * r\n",
    "\n",
    "fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})\n",
    "ax.plot(theta, r)\n",
    "ax.set_rmax(2)\n",
    "ax.set_rticks([0.5, 1, 1.5, 2])  # Less radial ticks\n",
    "ax.set_rlabel_position(-22.5)  # Move radial labels away from plotted line\n",
    "ax.grid(True)\n",
    "\n",
    "ax.set_title(\"A line plot on a polar axis\", va='bottom')\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor10.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Legend\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Make some fake data.\n",
    "a = b = np.arange(0, 3, .02)\n",
    "c = np.exp(a)\n",
    "d = c[::-1]\n",
    "\n",
    "# Create plots with pre-defined labels.\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(a, c, 'k--', label='Model length')\n",
    "ax.plot(a, d, 'k:', label='Data length')\n",
    "ax.plot(a, c + d, 'k', label='Total message length')\n",
    "\n",
    "legend = ax.legend(loc='upper center', shadow=True, fontsize='x-large')\n",
    "\n",
    "# Put a nicer background color on the legend.\n",
    "legend.get_frame().set_facecolor('#FFFFDD')\n",
    "plt.show()\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor11.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Error bar example\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig = plt.figure()\n",
    "x1 = np.linspace(0.0, 5.0)\n",
    "y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)\n",
    "e1 = 0.5*np.exp(-np.sqrt(x1))\n",
    "\n",
    "plt.subplot()\n",
    "plt.errorbar(x1, y1, e1, marker='s', mfc='red',linestyle=' ')\n",
    "plt.title('Errorbar plot')\n",
    "# sigma added wih \\sigma<tab> ± added <shift><option>+ (on Mac)\n",
    "plt.ylabel('Damped oscillation ± 1σ')\n",
    "plt.xlabel('time (s)')\n",
    "\n",
    "plt.show()\n",
    "SaveFig = True\n",
    "if SaveFig:\n",
    "    fig.savefig('Lec07_Tutor13.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MathTex example\n",
    "import matplotlib.pyplot as plt\n",
    "import subprocess\n",
    "import sys\n",
    "import re\n",
    "\n",
    "# Selection of features following \"Writing mathematical expressions\" tutorial\n",
    "mathtext_titles = {\n",
    "    0: \"Header demo\",\n",
    "    1: \"Subscripts and superscripts\",\n",
    "    2: \"Fractions, binomials and stacked numbers\",\n",
    "    3: \"Radicals\",\n",
    "    4: \"Fonts\",\n",
    "    5: \"Accents\",\n",
    "    6: \"Greek, Hebrew\",\n",
    "    7: \"Delimiters, functions and Symbols\"}\n",
    "n_lines = len(mathtext_titles)\n",
    "\n",
    "# Randomly picked examples\n",
    "mathext_demos = {\n",
    "    0: r\"$W^{3\\beta}_{\\delta_1 \\rho_1 \\sigma_2} = \"\n",
    "    r\"U^{3\\beta}_{\\delta_1 \\rho_1} + \\frac{1}{8 \\pi 2} \"\n",
    "    r\"\\int^{\\alpha_2}_{\\alpha_2} d \\alpha^\\prime_2 \\left[\\frac{ \"\n",
    "    r\"U^{2\\beta}_{\\delta_1 \\rho_1} - \\alpha^\\prime_2U^{1\\beta}_\"\n",
    "    r\"{\\rho_1 \\sigma_2} }{U^{0\\beta}_{\\rho_1 \\sigma_2}}\\right]$\",\n",
    "\n",
    "    1: r\"$\\alpha_i > \\beta_i,\\ \"\n",
    "    r\"\\alpha_{i+1}^j = {\\rm sin}(2\\pi f_j t_i) e^{-5 t_i/\\tau},\\ \"\n",
    "    r\"\\ldots$\",\n",
    "\n",
    "    2: r\"$\\frac{3}{4},\\ \\binom{3}{4},\\ \\genfrac{}{}{0}{}{3}{4},\\ \"\n",
    "    r\"\\left(\\frac{5 - \\frac{1}{x}}{4}\\right),\\ \\ldots$\",\n",
    "\n",
    "    3: r\"$\\sqrt{2},\\ \\sqrt[3]{x},\\ \\ldots$\",\n",
    "\n",
    "    4: r\"$\\mathrm{Roman}\\ , \\ \\mathit{Italic}\\ , \\ \\mathtt{Typewriter} \\ \"\n",
    "    r\"\\mathrm{or}\\ \\mathcal{CALLIGRAPHY}$\",\n",
    "\n",
    "    5: r\"$\\acute a,\\ \\bar a,\\ \\breve a,\\ \\dot a,\\ \\ddot a, \\ \\grave a, \\ \"\n",
    "    r\"\\hat a,\\ \\tilde a,\\ \\vec a,\\ \\widehat{xyz},\\ \\widetilde{xyz},\\ \"\n",
    "    r\"\\ldots$\",\n",
    "\n",
    "    6: r\"$\\alpha,\\ \\beta,\\ \\chi,\\ \\delta,\\ \\lambda,\\ \\mu,\\ \"\n",
    "    r\"\\Delta,\\ \\Gamma,\\ \\Omega,\\ \\Phi,\\ \\Pi,\\ \\Upsilon,\\ \\nabla,\\ \"\n",
    "    r\"\\aleph,\\ \\beth,\\ \\daleth,\\ \\gimel,\\ \\ldots$\",\n",
    "\n",
    "    7: r\"$\\coprod,\\ \\int,\\ \\oint,\\ \\prod,\\ \\sum,\\ \"\n",
    "    r\"\\log,\\ \\sin,\\ \\approx,\\ \\oplus,\\ \\star,\\ \\varpropto,\\ \"\n",
    "    r\"\\infty,\\ \\partial,\\ \\Re,\\ \\leftrightsquigarrow, \\ \\ldots$\"}\n",
    "\n",
    "\n",
    "def doall():\n",
    "    # Colors used in Matplotlib online documentation.\n",
    "    mpl_blue_rvb = (191. / 255., 209. / 256., 212. / 255.)\n",
    "    mpl_orange_rvb = (202. / 255., 121. / 256., 0. / 255.)\n",
    "    mpl_grey_rvb = (51. / 255., 51. / 255., 51. / 255.)\n",
    "\n",
    "    # Creating figure and axis.\n",
    "    plt.figure(figsize=(6, 7))\n",
    "    plt.axes([0.01, 0.01, 0.98, 0.90], facecolor=\"white\", frameon=True)\n",
    "    plt.gca().set_xlim(0., 1.)\n",
    "    plt.gca().set_ylim(0., 1.)\n",
    "    plt.gca().set_title(\"Matplotlib's math rendering engine\",\n",
    "                        color=mpl_grey_rvb, fontsize=14, weight='bold')\n",
    "    plt.gca().set_xticklabels(\"\", visible=False)\n",
    "    plt.gca().set_yticklabels(\"\", visible=False)\n",
    "\n",
    "    # Gap between lines in axes coords\n",
    "    line_axesfrac = 1 / n_lines\n",
    "\n",
    "    # Plotting header demonstration formula\n",
    "    full_demo = mathext_demos[0]\n",
    "    plt.annotate(full_demo,\n",
    "                 xy=(0.5, 1. - 0.59 * line_axesfrac),\n",
    "                 color=mpl_orange_rvb, ha='center', fontsize=20)\n",
    "\n",
    "    # Plotting features demonstration formulae\n",
    "    for i_line in range(1, n_lines):\n",
    "        baseline = 1 - i_line * line_axesfrac\n",
    "        baseline_next = baseline - line_axesfrac\n",
    "        title = mathtext_titles[i_line] + \":\"\n",
    "        fill_color = ['white', mpl_blue_rvb][i_line % 2]\n",
    "        plt.fill_between([0., 1.], [baseline, baseline],\n",
    "                         [baseline_next, baseline_next],\n",
    "                         color=fill_color, alpha=0.5)\n",
    "        plt.annotate(title,\n",
    "                     xy=(0.07, baseline - 0.3 * line_axesfrac),\n",
    "                     color=mpl_grey_rvb, weight='bold')\n",
    "        demo = mathext_demos[i_line]\n",
    "        plt.annotate(demo,\n",
    "                     xy=(0.05, baseline - 0.75 * line_axesfrac),\n",
    "                     color=mpl_grey_rvb, fontsize=16)\n",
    "\n",
    "    for i in range(n_lines):\n",
    "        s = mathext_demos[i]\n",
    "        print(i, s)\n",
    "    plt.show()\n",
    "\n",
    "# sys.argv is how Jupyter was run: --latex is open option (but not\n",
    "# when lauched from anaconda)\n",
    "if '--latex' in sys.argv:\n",
    "    # Run: python mathtext_examples.py --latex\n",
    "    # Need amsmath and amssymb packages.\n",
    "    fd = open(\"mathtext_examples.ltx\", \"w\")\n",
    "    fd.write(\"\\\\documentclass{article}\\n\")\n",
    "    fd.write(\"\\\\usepackage{amsmath, amssymb}\\n\")\n",
    "    fd.write(\"\\\\begin{document}\\n\")\n",
    "    fd.write(\"\\\\begin{enumerate}\\n\")\n",
    "\n",
    "    for i in range(n_lines):\n",
    "        s = mathext_demos[i]\n",
    "        s = re.sub(r\"(?<!\\\\)\\$\", \"$$\", s)\n",
    "        fd.write(\"\\\\item %s\\n\" % s)\n",
    "\n",
    "    fd.write(\"\\\\end{enumerate}\\n\")\n",
    "    fd.write(\"\\\\end{document}\\n\")\n",
    "    fd.close()\n",
    "\n",
    "    subprocess.call([\"pdflatex\", \"mathtext_examples.ltx\"])\n",
    "else:\n",
    "    doall();\n",
    "    SaveFig = True\n",
    "    if SaveFig:\n",
    "        plt.gcf().savefig('Lec07_Tutor12.png')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Native TeX\n",
    "# This example does not work because latex can't be found.\n",
    "# Path issue \n",
    "if 1 == 1 :\n",
    "    \n",
    "    import numpy as np\n",
    "    import matplotlib\n",
    "    matplotlib.rcParams['text.usetex'] = True\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "    t = np.linspace(0.0, 1.0, 100)\n",
    "    s = np.cos(4 * np.pi * t) + 2\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(6, 4), tight_layout=True)\n",
    "    ax.plot(t, s)\n",
    "\n",
    "    ax.set_xlabel(r'\\textbf{time (s)}')\n",
    "    ax.set_ylabel('\\\\textit{Velocity (\\N{DEGREE SIGN}/sec)}', fontsize=16)\n",
    "    ax.set_title(r'\\TeX\\ is Number $\\displaystyle\\sum_{)n=1}^\\infty'\n",
    "             r'\\frac{-e^{i\\pi}}{2^n}$!', fontsize=16, color='r')\n",
    "else:\n",
    "    print('This code not selected to run')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.argv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tick direction and locations (Does not work with anaconda)\n",
    "import matplotlib.pyplot as plt\n",
    "import mpl_toolkits.axisartist.axislines as axislines\n",
    "\n",
    "\n",
    "def setup_axes(fig, pos):\n",
    "    ax = fig.add_subplot(pos, axes_class=axislines.Axes)\n",
    "    ax.set_yticks([0.2, 0.8])\n",
    "    ax.set_xticks([0.2, 0.8])\n",
    "    return ax\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(6, 3))\n",
    "fig.subplots_adjust(bottom=0.2)\n",
    "\n",
    "ax = setup_axes(fig, 131)\n",
    "for axis in ax.axis.values():\n",
    "    axis.major_ticks.set_tick_out(True)\n",
    "# or you can simply do \"ax.axis[:].major_ticks.set_tick_out(True)\"\n",
    "\n",
    "ax = setup_axes(fig, 132)\n",
    "ax.axis[\"left\"].set_axis_direction(\"right\")\n",
    "ax.axis[\"bottom\"].set_axis_direction(\"top\")\n",
    "ax.axis[\"right\"].set_axis_direction(\"left\")\n",
    "ax.axis[\"top\"].set_axis_direction(\"bottom\")\n",
    "\n",
    "ax = setup_axes(fig, 133)\n",
    "ax.axis[\"left\"].set_axis_direction(\"right\")\n",
    "ax.axis[:].major_ticks.set_tick_out(True)\n",
    "\n",
    "ax.axis[\"left\"].label.set_text(\"Long Label Left\")\n",
    "ax.axis[\"bottom\"].label.set_text(\"Label Bottom\")\n",
    "ax.axis[\"right\"].label.set_text(\"Long Label Right\")\n",
    "ax.axis[\"right\"].label.set_visible(True)\n",
    "ax.axis[\"left\"].label.set_pad(0)\n",
    "ax.axis[\"bottom\"].label.set_pad(10)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig"
   ]
  },
  {
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}