lecture_07_branching_userinput.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Today:  Branching and User Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Branching (If/Else blocks) -- Section 3.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"The flow of computer programs often needs to branch. \n",
    "That is, if a condition is met, we do one thing, and if not, we do another thing.\" -p.104 of your book\n",
    "\n",
    "This is referred to as branching into a block of statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "====  Basic if  ====\n",
    "```python\n",
    "if <condition>:\n",
    "    <do something>\n",
    "```\n",
    "====  Add an else  ====\n",
    "```python\n",
    "if <condition>:\n",
    "    <do something>\n",
    "else:\n",
    "    <do something else>\n",
    "```    \n",
    "==== Add an elif  ====\n",
    "```python\n",
    "if <condition>:\n",
    "    <do something>\n",
    "elif <a different condition>:\n",
    "    <do something else>\n",
    "else:\n",
    "    <do something else>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2*PI. Mmmm, lots of PI.\n"
     ]
    }
   ],
   "source": [
    "x = 6.28  # set the variable x equal to tau, the real circular constant\n",
    "\n",
    "# Note this is the only correct way to check equality on floats.\n",
    "# Subtract the expected value and compare to your allowed error:\n",
    "\n",
    "eps = 1e-10  # my deviation I allow until I call them 'equal'\n",
    "if((x - 6.28) < eps):      # if x is equal to tau\n",
    "    print(\"2*PI. Mmmm, lots of PI.\")  # print something\n",
    "else:                      # else\n",
    "    print(\"No PI. Alas.\")  # print something else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from math import exp\n",
    "\n",
    "def func1(value):\n",
    "    if(0 <= value <= 1):     # note the math-like syntax here!\n",
    "        result = exp(value)  # executed if value is between 0 and 1\n",
    "    else:\n",
    "        result = -10         # executed otherwise (if is false)\n",
    "    \n",
    "    return result            # Return the result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What should this yield?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = func1(1)  \n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. And this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1(1.5)  "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can have multiple branching with \"else if\" statements,\n",
    "which are shortened to \"elif\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def func2(value):\n",
    "    if 0 <= value < 1:\n",
    "        result = exp(value)  # executed if value is between 0 (inclusive) and 1 (exclusive) \n",
    "    elif 1 <= value <= 2:\n",
    "        result = -100        # executed if value is between 1 and 2 (inclusive)\n",
    "    else:\n",
    "        result = 0\n",
    "        print('value is not between 0 and 2')\n",
    "    \n",
    "    return value, result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. So, what will this print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\t1.6487212707001282\n",
      "1\t-100\n",
      "1.5\t-100\n",
      "value is not between 0 and 2\n",
      "20\t0\n"
     ]
    }
   ],
   "source": [
    "print(\"{}\\t{}\".format(*func2(0.5)))\n",
    "print(\"{}\\t{}\".format(*func2(1)))\n",
    "print(\"{}\\t{}\".format(*func2(1.5)))\n",
    "print(\"{}\\t{}\".format(*func2(20)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'm smelling a violation of the DRY principle!\n",
    "How can we improve? Another function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calc_and_print(value):\n",
    "    print(\"{}\\t{}\".format(*func2(value)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\t1.6487212707001282\n",
      "1\t-100\n",
      "1.5\t-100\n",
      "value is not between 0 and 2\n",
      "20\t0\n"
     ]
    }
   ],
   "source": [
    "for val in [0.5, 1, 1.5, 20]:\n",
    "    calc_and_print(val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahh, better. ;)\n",
    "\n",
    "#### The ternary operator for if-else branching\n",
    "\n",
    "Ternary operators are statements with 3 arguments, but usually this is the only one per language, so it's often called **THE** ternary operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'x does not equal 2'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "'x equals 2' if x == 2 else 'x does not equal 2'"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "How handy!  Consider this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def squareRoot(value):\n",
    "    return math.sqrt(value) if value >= 0 else\\\n",
    "        'Imaginary numbers not supported!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n",
      "Imaginary numbers not supported!\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "math domain error",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-b0fd35cf23cc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msquareRoot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msquareRoot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# my function protects against error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m     \u001b[0;31m# the original not\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: math domain error"
     ]
    }
   ],
   "source": [
    "print(squareRoot(2.0))\n",
    "print(squareRoot(-2.0))  # my function protects against error\n",
    "print(math.sqrt(-2))     # the original not"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using break to end a `while` loop\n",
    "\n",
    "a while loop with a limit on the maximum number of allowed iterations.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = 0\n",
    "while count < 100:\n",
    "    count += 1\n",
    "    \n",
    "count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = 0\n",
    "while True:  # obviously always True. So the while block needs to interrupt\n",
    "    if count == 100:\n",
    "        break           # Immediately jump out of the while loop\n",
    "    else:\n",
    "        pass           # this doesn't do anyting, maybe reminder to have an else case?\n",
    "    count += 1\n",
    "    \n",
    "count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the new reserved words: \"break\" and \"pass\"\n",
    "\n",
    "In this example, the else statement is optional, i.e. we could just do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = 0\n",
    "while True:\n",
    "    if i == 100:\n",
    "        break\n",
    "    i += 1\n",
    "\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Gold case for `while` loop\n",
    "The previous code cell is not terribly useful, but consider an approximation of the sine curve.\n",
    "To make this more interesting, let's calculate sine to a particular accuracy (AKA tolerance)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\sin(x) \\approx \\sum_{n=0}^N \\frac{(-1)^n}{(2n + 1)!} x^{2n + 1}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count        approx   math.sin(x)\n",
      "    0     2.0943951     0.8660254\n",
      "    1    0.56322095     0.8660254\n",
      "    2    0.89904502     0.8660254\n",
      "    3    0.86397146     0.8660254\n",
      "    4    0.86610827     0.8660254\n"
     ]
    }
   ],
   "source": [
    "from math import pi, factorial, sin\n",
    "tau = 2*pi   # read http://tauday.com ! ;)\n",
    "\n",
    "x = tau / 3          # Evaluate at x = pi / 5 (just a number I chose) \n",
    "mathSin = sin(x)     # Use math.sin to calculate sin(x)\n",
    "prevTotal = 1e5      # The previous value of the sine series.\n",
    "                     # Just something big to start with; will be overwritten first \n",
    "                     # time through loop.\n",
    "tolerance = 0.01\n",
    "total     = 0.0      # The summation's running total\n",
    "n         = 0        # The current summation term number\n",
    "\n",
    "print(\"%5s  %12s  %12s\" % (\"count\", \"approx\", \"math.sin(x)\"))\n",
    "\n",
    "while True:\n",
    "    term = (-1)**n * x**(2*n + 1) / factorial(2*n + 1)  # Calculate the current term\n",
    "    \n",
    "    total += term    # Add the term to the running total\n",
    "    \n",
    "    #  Print the current term number, running total, and math.sin value\n",
    "    print('%5i  %12.8g  %12.8g' % (n, total, mathSin))\n",
    "    \n",
    "    # If the diff between prevTotal and total is less than the tolerance, stop the loop\n",
    "    if abs(prevTotal - total) < tolerance:\n",
    "        break\n",
    "    \n",
    "    prevTotal = total    # Update the previous total value\n",
    "    \n",
    "    n += 1               # Increment the summation count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By adding the \"if\" statement, we can compare the previous total with the current total.  When the difference between the previous and current totals is less than the tolerance, the code \"breaks\" and the while loop is stopped."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if statements in list comprehensions\n",
    "\n",
    "We can add an if condition to a list comprehension.  We would do this when we wanted to limit or filter the values that are put into the resulting list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 26, 39, 52, 65, 78, 91]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divisor = 3.25   # Number to divide by\n",
    "\n",
    "# Create a list of numbers between 1 and 100 that are divisible by \"divisor\"\n",
    "numList = [num for num in range(1, 101) if num % divisor == 0]\n",
    "numList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Charlie', 'Zarah', 'Gerardo', 'Parker', 'Tarek']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nameList = ['Samual', 'Charlie', 'Zarah', 'Robert', 'Liangyu', 'Jeffery', 'Brian', 'Aidan', 'Melissa', 'Gerardo', \\\n",
    "            'Emily', 'Parker', 'Amanda', 'Kristine', 'Tarek', 'Christian', 'Ian', 'Alex', 'Nathaniel', \\\n",
    "            'Samantha', 'Pengqi']\n",
    "\n",
    "searchstr = 'ar'\n",
    "\n",
    "# when reading list comprehensions, always make a mental break\n",
    "# in front of the `for` keyword\n",
    "filterList = [name for name in nameList if searchstr in name]\n",
    "\n",
    "print(\"Zarah\".find(text))\n",
    "\n",
    "filterList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### User Input\n",
    "\n",
    "Until now, we have provided the information necessary for a program to run \n",
    "by typing it into our notebook cells.\n",
    "\n",
    "This can be inconvenient, especially if we want to:\n",
    "\n",
    "1. Write an interactive program, or \n",
    "2. If the amount of information the program requires is huge.\n",
    "(e.g., 10-body system vs. 3-body system)\n",
    "\n",
    "Today, we'll cover the first case: writing an interactive program.\n",
    "\n",
    "Later, we'll discuss #2, where we must supply a lot of information \n",
    "to a program, and it's best to read that information from a file rather than \n",
    "supplying it \"by hand.\"\n",
    "\n",
    "### input\n",
    "\n",
    "The \"input\" function allows you (a user) to supply new information to \n",
    "Python code as it runs. \n",
    "\n",
    "This can be useful for:\n",
    "* Supplying parameters (e.g., a blackbody temperature).\n",
    "* Changing how the code branches (e.g., what if user supplies\n",
    "bogus input? More discussion about this coming up.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a float: 4.2\n"
     ]
    }
   ],
   "source": [
    "x = input('Enter a float: ')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "(Might not work in older ipython notebooks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4.2'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(x))\n",
    "x = float(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Why bother?\n",
    "\n",
    "Anytime we supply input, whether it be in an iPython session (via `input`), the Linux terminal, or from a file (later this semester), that input will be interpreted *as a string.*\n",
    "\n",
    "Let's try inputting some values for the escape velocity equation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$v=\\sqrt{\\frac{2GM}{r}}$$\n",
    "Equation for escape velocity in $\\frac{meters}{second}$ where $G$ is the gravitational constant, $M$ is the mass of the planet, and $r$ is the radius of the planet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def escapeVel(mass, radius):                 # Define the function with 2 input variables\n",
    "    G = 6.67e-11                             # Gravitational constant\n",
    "    velocity = sqrt(2*G*mass / radius)       # Escape velocity equation\n",
    "    \n",
    "    return velocity                          # Return the escape velocity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What will this do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter the planet's mass in kg:  \n",
      "Please enter the planet's radius in m: \n",
      "Ending program!\n"
     ]
    }
   ],
   "source": [
    "maxCount = 100\n",
    "count = 0\n",
    "\n",
    "while True and count < maxCount:\n",
    "    mass   = input(\"Please enter the planet's mass in kg:  \")\n",
    "    radius = input(\"Please enter the planet's radius in m: \")\n",
    "    \n",
    "    if mass != \"\" and radius != \"\":\n",
    "        print(\"The escape velocity is: %.1f m/s\" % escapeVel(float(mass), float(radius)))\n",
    "    else:\n",
    "        print(\"Ending program!\")\n",
    "        break\n",
    "    \n",
    "    print()\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now something complete different: Version control with git\n",
    "\n",
    "Ever had something like `xxx_v0.txt`, `xxx_v1.txt`, `xxx_v2.txt` etc.? \n",
    "\n",
    "Did you always remember what's the best version? \n",
    "\n",
    "How did you compare the files? Manually, possibly?\n",
    "\n",
    "Version control enables you:\n",
    "* Keep track on your changes over time\n",
    "* Compare your most recent changes with the currently `committed` (=stored) version\n",
    " * With some more effort (=command-line-fu) compare with any version at any time\n",
    "* Work on a different idea while not disturbing your main codes (=`branching out`)\n",
    "* Collaborate more easily with others\n",
    "* show you logs of your changes, for everything, or per file\n",
    "* enable you to `blame` who did certain changes while collaborating\n",
    "     * that git function is indeed called `git blame`\n",
    "* bake a bread, make a coffee...\n",
    "\n",
    "#### git <-> GitHub\n",
    "* `git` is the version control software we will be using.\n",
    "* `GitHub` is a web service for collaborating on software (and documentation), and it runs on `git`, but it **IS NOT** git.\n",
    "* `GitHub` offers a lot on top of your programs:\n",
    " * Issue tracker\n",
    " * Wiki\n",
    " * Graphical browsing of differences\n",
    " * Pull requests (more on that later)\n",
    " * Offers a graphical desktop client program to interact with `git` and `GitHub`.\n",
    "* `git` has a steep learning curve, but it's absolutely worth it.\n",
    " * Best strategy is to only use small set of commands at beginning, and then learn more when you want to solve a new issue.\n",
    "\n",
    "We will run through a setup here and you will practice it in the tutorial, but please go through the 15 minutes of time of a beautifully made intro on https://try.github.io by the GitHub team.\n",
    "\n",
    "#### First time\n",
    "* git init\n",
    "* < create a textfile.txt>\n",
    "* git add textfile.txt\n",
    "    * < now in staging phase, can add more files if required>\n",
    "* git commit\n",
    " * will pop up editor, type in commit message:\n",
    "* \"First commit\"\n",
    "    * then <Ctrl-X>, <Y>, <Return> to leave editor with saving that message\n",
    "* git log\n",
    "  * Will show you name, time and commit message\n",
    "  * Also shows a very long hex-code. That's the unmistake-able identifier for this commit.\n",
    "  \n",
    "#### Usually\n",
    "* You have changed a file, let's look what's different\n",
    "* git diff\n",
    "  * shows all changes made to folder\n",
    "* If you are happy to commit this, you can omit staging phase and store everything:\n",
    "* git commit --all -m 'change this to that'\n",
    "* Done. Even didn't use nasty editor.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [stable]",
   "language": "python",
   "name": "Python [stable]"
  },
  "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.5.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}