Lab 1b Arrays and Plotting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 1b: Arrays and Plotting\n",
    "### Wellesley College, Physics 202 Lab, Fall 2017\n",
    "### Lauri Wardell and Glenn Stark\n",
    "### Tutorial written by Jerome Fung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you've gotten Jupyter set up and running, and you've seen how you can use Jupyter as a calculator, we can turn our attention to some bigger tasks. In this tutorial, you will learn:\n",
    "\n",
    "* What NumPy arrays are, why they are useful, and how to use them\n",
    "* How to write *functions* and use NumPy arrays in them\n",
    "* How to make plots using `matplotlib`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data structures that consist of an ordered arrangement of numerical values can be useful in many contexts. Here are just a few examples:\n",
    "\n",
    "* You're trying to determine the spring constant of a spring by measuring the force the spring exerts as you stretch the spring different distances. (You'd like to keep your measured set of forces together, and the order of the measurements matters.)\n",
    "* You're calculating the trajectory of a particle acted upon by some complicated force and want to know the particle positions at regular time intervals.\n",
    "\n",
    "Python has a built-in `list` object, but the numpy `array` object has a number of features that make it preferable for most computational work. We'll soon see what some of those features are.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you wish to continue using the same notebook as for Lab 1a, you may use a \"Markdown\" cell to indicate that this is the beginning of Lab 1b. If you wish to start a new notebook, you need the `import` statements that allow you to use numpy, scipy, and matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "# we'll use the following parts of the scipy library for curve fitting\n",
    "# include now even though we won't use it in this tutorial\n",
    "import scipy.stats\n",
    "import scipy.optimize\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's begin by creating an array. In the next code cell, I *assign* the variable `wendy` to a *1-dimensional* array that I create \"by hand.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "wendy = np.array([1, 1, 2, 3, 5, 8, 13])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment means that I can subsequently use the variable name `wendy` to refer to or act on the entire array object I just created. For instance,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  1  2  3  5  8 13]\n"
     ]
    }
   ],
   "source": [
    "print(wendy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "prints the array. The most important feature of arrays is the ability to perform mathematical operations on the **entire array at once**. Doing so makes for code that is easier to read and usually more efficient. For example, try some of the following for yourself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4  4  5  6  8 11 16]\n",
      "[ 2  2  4  6 10 16 26]\n"
     ]
    }
   ],
   "source": [
    "print(wendy + 3)\n",
    "print(2 * wendy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If you're familiar with Python `list` objects, you probably know that doing the same thing on a list requires explicit iteration over the list elements with a `for` or `while` loop. Don't worry if you haven't worked with `list` objects before and the previous sentence was gobbledygook.)\n",
    "\n",
    "I can create other arrays in a similar fashion and perform operations with multiple arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  2,  3,  4,  6,  9, 14])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "winona = np.array([1, 1, 1, 1, 1, 1, 1])\n",
    "xena = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "# we can also use Jupyter in a calculator-like manner with arrays\n",
    "wendy + winona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, trying to perform operations on arrays that are not the same shape results in an exception (`wendy` has 7 elements whereas `xena` has 8):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (7,) (8,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-77692f4cb685>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mwendy\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mxena\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (7,) (8,) "
     ]
    }
   ],
   "source": [
    "wendy + xena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access specific elements of an array via *indexing*. Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(wendy[0]) # indices begin at 0\n",
    "print(wendy[2]) # therefore this is actually the 3rd element of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 2 3 5]\n"
     ]
    }
   ],
   "source": [
    "print(wendy[0:5]) # a range of indices, doesn't include the endpoint wendy[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "print(wendy[-1]) # last element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are lots of other indexing tricks available -- see the [official documentation on indexing here](http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html) and/or a much more extensive tutorial [here](http://www.scipy-lectures.org/intro/numpy/array_object.html) if you are interested.\n",
    "\n",
    "Arrays also have useful *methods*, which you can think of as operations that an array can perform on itself. The examples below show several possibilities as well as how to *call* a method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# add up all the elements\n",
    "wendy.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# do the same thing on a different array\n",
    "xena.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   1,   4,   9,  25,  64, 169])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#square an array\n",
    "wendy**2 #or\n",
    "np.square(wendy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 13\n"
     ]
    }
   ],
   "source": [
    "print(wendy.min(), wendy.max()) # get minimum and maximum values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a 'Markdown' cell to indicate that what you are doing next is 'Exercise 2.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 2***\n",
    "\n",
    "Using the array `wendy` defined above, calculate the following by performing mathematical operations on `wendy`:\n",
    "\n",
    "$$\\frac{\\textrm{wendy}^2 + 7}{\\textrm{sum of elements in wendy}}$$\n",
    "\n",
    "[Ans: array([ 0.24242424,  0.24242424,  0.33333333,  0.48484848,  0.96969697,\n",
    "        2.15151515,  5.33333333])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now turn to writing *functions*. You have already used a number of Python functions, like `print`, as well as functions that are part of numpy such as `np.array`. Functions provide a useful way to *encapsulate* and reuse code for calculations. Writing functions will also be necessary when you fit models to data.\n",
    "\n",
    "The writing of functions is best illustrated through an example. The next code cell contains a rather silly example, but we'll use it to point out the important features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sum_squares_of_elements(x):\n",
    "    '''\n",
    "    Add up the squares of each element of an input array x.\n",
    "    '''\n",
    "    # The next line makes x an array if it isn't one already.\n",
    "    x = np.asarray(x) \n",
    "    elements_squared = x**2\n",
    "    sum_of_elements_squared = elements_squared.sum()\n",
    "    return sum_of_elements_squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the features to notice:\n",
    "\n",
    "* Function definitions must begin with `def`. The name of the function, in this case `sum_squares_of_elements`, follows.\n",
    "* Functions may have one or more input *arguments*. A function may have no arguments, but most of the ones you'll use and write in this course will have at least one. In this example, `x` is the single argument. The argument or arguments are enclosed in parentheses.\n",
    "* The `def` statement ends with a colon. Python is sensitive to indentation. If you want subsequent lines to be part of the function, they need to be indented (by convention, 4 spaces; Jupyter will do this for you automatically).\n",
    "* A comment string (delineated by three apostrophes) called a *documentation string* or *docstring* for short follows the `def` statement. This is optional, but it can be helpful for documenting what the function does. (Choosing sensible names is also a good idea. Don't give your functions a meaningless name like `qwerty17`.)\n",
    "* The code that the function will execute on its input arguments follows.\n",
    "* Usually, the results of a function are meant to be used, and you will want a function to `return` one or more arguments. A function is not required to return anything, and you can also return multiple arguments. What you return is arbitrary: in particular, you can return numbers as well as arrays.\n",
    "\n",
    "Now that the function is defined, I can use it by *calling* it. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "273"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_squares_of_elements(wendy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Because of the np.asarray function, the function will work even if the input isn't an array\n",
    "sum_squares_of_elements(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# can call functions within other functions\n",
    "def sum_squares_of_elements_plus_n(x, n):\n",
    "    '''\n",
    "    Add a number n to the result of sum_squares_of_elements\n",
    "    '''\n",
    "    # for really simple things, calculations can happen within the return statement\n",
    "    return sum_squares_of_elements(x) + n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "276"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_squares_of_elements_plus_n(wendy, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 3***\n",
    "\n",
    "Write a function that takes as input a numpy array and a second numerical parameter, `tau`, that returns an array where each element in the output contains the calculation\n",
    "$$ e^{-x / \\tau} $$\n",
    "for the corresponding value $x$ in the input array. Hint: the exponential function is defined in Python as 'exp' and is in numpy. Therefore, your return line needs to use np.exp().\n",
    "\n",
    "Evaluate the function for x = 3, `tau` = 5.  [Ans: 0.5488....]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now turn to making basic plots. We point out a few key features here, but there is much more you can learn from reading the [matplotlib documentation](http://matplotlib.org/api/pyplot_summary.html).\n",
    "\n",
    "Let's start off with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1175c8550>]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11726c630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "foo = np.array([0, 1, 2, 3, 4, 5])\n",
    "foo_times_two = 2. * foo\n",
    "\n",
    "plt.plot(foo, foo_times_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic plotting command is `plt.plot()`. In the above example, there were two arguments to `plt.plot()`:\n",
    "\n",
    "* First argument: the variable to be plotted on the $x$ axis\n",
    "* Second argument: the variable to be plotted on the $y$ axis\n",
    "\n",
    "If no other arguments are given, the points are joined by continuous line segments. This may not always be desirable, and the behavior can be changed by an optional third argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1176a96d8>]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQQeAJAg6ACTxv/XSOESr5aNxAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1175ead30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(foo, foo_times_two, 'bo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the third argument, the format string `'bo'`, results in blue circles. The 'b' stands for blue, and the 'o' gives circles. \n",
    "\n",
    "Other colors are available, including [g]reen, [r]ed, [c]yan, [y]ellow, [m]agenta, and blac[k]. \n",
    "\n",
    "A full list of plotting markers is available [here](http://matplotlib.org/api/markers_api.html). Commonly used ones include `V`, `^`, `<`, `>` (triangles facing in different directions), `.` (small points), and `s` (squares).\n",
    "\n",
    "Try some formatting options of your own in the above plot!\n",
    "\n",
    "There are some other niceties that you might want to include. A few examples are illustrated in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x117711ac8>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfcAAAGDCAYAAAA2xlnwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x117673d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,6)) # make plots larger (nominal size in inches)\n",
    "# actual on-screen size may vary depending on your computer browser\n",
    "plt.plot(foo, foo_times_two, 'bo-') # include continuous lines between points\n",
    "plt.xlim((-1, 6)) # change x-axis limits\n",
    "plt.ylim((-2, 12)) # change y-axis limits\n",
    "plt.xlabel('String with some actual label') # label the x-axis\n",
    "plt.ylabel('Some other appropriate label', size=12) # label the y-axis\n",
    "# keyword argument above increases the font size to 12 pt\n",
    "plt.title('Give your plots better titles than this') # title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other types of plots are possible, including:\n",
    "\n",
    "* semilog plots (use `plt.semilogx` for logarithmic scaling on the $x$ axis and `plt.semilogy` for logarithmic scaling on the $y$ axis)\n",
    "* log-log plots (`plt.loglog`)\n",
    "\n",
    "Again, see the matplotlib documentation for the many other possibilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two useful commands for plotting mathematical functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Very often you'll want to plot some mathematical function (either a built-in function or one you've written) over some range of arguments. You might, for instance, want to generate an evenly spaced set of points between two values. There is a nice way to do this via the `np.linspace` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.        ,  1.44444444,  1.88888889,  2.33333333,  2.77777778,\n",
       "        3.22222222,  3.66666667,  4.11111111,  4.55555556,  5.        ])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.linspace takes 3 arguments: start, stop (inclusive), number of points\n",
    "np.linspace(1, 5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's another way to do this: the function np.arange:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1. ,  1.2,  1.4,  1.6,  1.8,  2. ,  2.2,  2.4,  2.6,  2.8,  3. ,\n",
       "        3.2,  3.4,  3.6,  3.8,  4. ,  4.2,  4.4,  4.6,  4.8])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.arange takes 3 arguments: start, stop (not inclusive)\n",
    "# and an optional 3rd argument that is the step size.\n",
    "# If step size not included, default step size is 1\n",
    "np.arange(1, 5, 0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 4***\n",
    "\n",
    "Make a graph that plots the $\\textrm{sinc}$ function, defined such that\n",
    "\n",
    "$$\\textrm{sinc}\\, x = \\frac{\\sin x}{x} \\  \\ \\ \\ \\ (x\\ne 0) $$\n",
    "\n",
    "$$\\textrm{sinc}\\, x = 1 \\ \\ \\ \\ \\  (x = 0) $$\n",
    "\n",
    "(This function arises in the formal theory of diffraction by a rectangular slit.) Plot $\\textrm{sinc}\\,x$ for $x$ between -10 and 10. \n",
    "\n",
    "Hint: the $\\textrm{sinc}$ function has already been defined in numpy as `np.sinc`.\n",
    "\n",
    "Google the sinc function if you don't know what it should look like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 5***\n",
    "\n",
    "This exercise is the culmination of the things you've learned so far.\n",
    "\n",
    "1. Take the function you wrote in Exercise 3. Plot it on a linear scale for some reasonable range of values of $x$ for $\\tau = 1$.\n",
    "2. On the same axes, plot the same function for several different values of $\\tau$. (You can issue multiple `plt.plot` commands within the same cell.)\n",
    "\n",
    "Two extensions if you have time:\n",
    "\n",
    "3. Try making the same plots on semi-log scale that's logarithmic in $y$. What do your graphs look like, and does this make sense?\n",
    "4. Look up the plt.legend function (use the built-in help or Google it) and use it to create a legend on one or both of your graphs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having learned the basics of arrays and plotting, you are now ready to proceed to the next tutorial, [Lab 1c: Introduction to Curve Fitting](Lab 1c Introduction to Curve Fitting.ipynb)."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}