Basics_2-Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 id=\"tocheading\">Table of Contents and Notebook Setup</h1>\n",
    "<div id=\"toc\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are used for code organization and code reuse. They also make code more readable by giving a name to a block of code. They are defined with the \"def\" keyword and returned with the \"return\" keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sum_square(x, y, z=2):\n",
    "    return (x+y)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_square(4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions have <b> positional </b> arguments and <b> keyword </b> arguments. In the preceding example, x and y are positional arguments and z is a keyword argument. Python's rule is that <i> positional arguments must come before keyword arguments. </i> Typically keyword arguments are used for default values or optional arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function above can be called in the following three ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_square(x=4, y=5, z=3)\n",
    "sum_square(4, 5, 3)\n",
    "sum_square(4, y=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last line above, we make \"y\" a keyword argument since we use an equal sign to specify it. Sometimes, for clarity, it is nice to specify everything as a keyword argument like we did in the first line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Namespaces, Scope, and Local Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can access both <b> global </b> variables and <b> local </b> variables. These two terms refer to the <b> namespace </b> of a python variable. The local namespace is created when the function is called and immediately populated by the functions arguments. Afterwards, the local namespace is destroyed and only the return value survives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def func(x,y):\n",
    "    a=[]\n",
    "    a.append(x)\n",
    "    a.append(y)\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a pointless function, but it is used to clarify things above. When the function is created, x and y are put in the local namespace. Then a is put in the local namespace (when the second line is executed). When the function is finished, x, y, and a are all deleted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If need be, we can <i> assign </i> variables outside the functions scope (global variables) using the global keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "def func(x,y):\n",
    "    global a\n",
    "    a=[]\n",
    "    a.append(x)\n",
    "    a.append(y)\n",
    "    return None\n",
    "\n",
    "func(3,4)\n",
    "print(a)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use of the global keyword is generally discouraged."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Returning Multiple Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a python function, you can return multiple values in the form of a tuple. This application alone makes Python superior to Java and C++, where you would have to return an array and the code would look messy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func(x,y,z):\n",
    "    return x-y, z-y\n",
    "\n",
    "a, b = func(2, 3, 4)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the values get unpacked into the variables a and b. We could have also just done:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1, 1)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_val = func(2, 3, 4)\n",
    "return_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but here return_val itself is a tuple (we didn't take advantage of the unpacking feature)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Anonymous (Lambda) Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda functions are easy ways to express functions in one line of code. This serves multiple purposes. For starters, we can define very simple functions in one line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def long(x):\n",
    "    return x**2\n",
    "\n",
    "short = lambda x: x**2\n",
    "\n",
    "long(2)\n",
    "short(2) #equivalent ^^"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also serves an extreme important second purpose; sometimes the arguments to functions <i> are functions themselves. </i> This is very prevalent in data analysis and it will show up frequently in these notes. Take the following two snippets of code as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0009999999996975"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def derivative(f, x, delta=0.001): #returns derivative of f at value x\n",
    "    return (f(x+delta)-f(x))/delta\n",
    "\n",
    "def x_square(x):\n",
    "    return x**2\n",
    "\n",
    "derivative(x_square, 1)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not bad. But we can cut down on the code significantly since x_square can be represented using a lambda function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0009999999996975"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def derivative(f, x, delta=0.001): #returns derivative of f at value x\n",
    "    return (f(x+delta)-f(x))/delta\n",
    "\n",
    "derivative(lambda x: x**2, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much more concise, and now we don't have to waste space in our program defining an x squared function. Note specifically how the lambda function takes the place of x_square in the first sample of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda functions can take in multiple variables and return multiple variables as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value = lambda x, y, z: (x-y, y-z)\n",
    "a, b = value(2,3,4)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go crazy. There's quite literally endless possibilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Currying: Partial Argument Application"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Currying</b> is jargon for defining new functions based on old ones. This type of coding may help with lambda functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(x, y):\n",
    "    return x+y\n",
    "\n",
    "add_five = lambda x: add(x,5)\n",
    "add_five(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first element to the add function is said to be <b>curried</b>. This will be used later in data analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Python has a <i> consistent </i> way to iterate over sequences by means of <b> iterator protocol </b>. This protocol is a generic way to make objects iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "some_dict={'a':1, 'b':2, 'c':3}\n",
    "for item in some_dict:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When writing \"for item in some_dict\" the python interpretor first creates an iterator out of some_dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<dict_keyiterator at 0x1055a2e58>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_iterator = iter(some_dict)\n",
    "dict_iterator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An <b>iterator</b> is an object that will <i> yield objects </i> when used in a context like a for loop. Most methods that accept a list or list-like-obejct will also accept iterators. This includes methods like min, max, sum, tuple, and list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(dict_iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A <b> generator </b> is a concise way to contruct an iterable object. Normal functions execute and return a single object (this can be a list or tuple that contains multiple things). Generators return a sequence of values, but lazily; they pause at each one untill the next one is requested. This can save computation space. To create a generator, use the \"yield\" keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object squares at 0x105564938>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def squares(n=10):\n",
    "    for i in range(1, n+1):\n",
    "        yield i**2\n",
    "\n",
    "gen1 = squares()\n",
    "gen1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is not until we start requesting the values of gen that it returns the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 9 16 25 36 49 64 81 100 "
     ]
    }
   ],
   "source": [
    "for x in gen1:\n",
    "    print(x, end= ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cats in the cradle and the silver spoon. Little boy blue and the man in the moon."
     ]
    }
   ],
   "source": [
    "def sentence_gen():\n",
    "    yield 'Cats in the cradle '\n",
    "    yield 'and the silver spoon. '\n",
    "    yield 'Little boy blue '\n",
    "    yield 'and the man in the moon.'\n",
    "\n",
    "gen2 = sentence_gen()\n",
    "for x in gen2:\n",
    "    print(x, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generator Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like lambda functions for functions, there are more concise way to make generators as well. This involves using a generator expression like such:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x1055ae620>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen = (x**3 for x in range(10))\n",
    "gen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These generator expressions are often easier to use than lists when using functions like \"sum.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "249500250000"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(x**3 for x in range(1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## itertools module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a standard library called \"itertools\" that has a collection of generators for many common data algorithms. The method \"groupby\" takes a sequence and a function and groups <i> consecutive </i> elements in the sequence by their return values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A ['Adam', 'Axtor']\n",
      "J ['Jim', 'James']\n",
      "A ['Asshole']\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "first_letter = lambda x: x[0]\n",
    "male_names=['Adam', 'Axtor', 'Jim', 'James', 'Asshole']\n",
    "\n",
    "for letter, names in itertools.groupby(male_names, first_letter):\n",
    "    print(letter, list(names))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many other useful tools which you can find by googling \"itertools.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Errors and Exception Handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to write elegant code, one needs to be able to handle errors or <i> exceptions </i> gracefully. In data analysis, many functions only work on certain kinds of data input. Take, for example, the float function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.234"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('1.234')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'something'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-439904410854>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'something'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'something'"
     ]
    }
   ],
   "source": [
    "float('something')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want a float method that fails gracefully, we can use a <b> try </b> and <b> except </b> block as such."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'something'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def attempt_float(x):\n",
    "    try:\n",
    "        return float(x)\n",
    "    except:\n",
    "        return x\n",
    "    \n",
    "attempt_float('something')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code in the except block is only executed if the code in the try block raises an exception."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have freedom to decide <i> what type of exceptions </i> we want to permit. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "float() argument must be a string or a number, not 'tuple'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-a7437c28cf3f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: float() argument must be a string or a number, not 'tuple'"
     ]
    }
   ],
   "source": [
    "float((1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "institues a type error and not a value error like before. Maybe we only want the code in the except block to be completed if the try block raises a \"value exception.\" We can accomplish that as such"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'something'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def attempt_float(x):\n",
    "    try:\n",
    "        return float(x)\n",
    "    except(ValueError):\n",
    "        return x\n",
    "    \n",
    "attempt_float('something')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "attempt_float() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-4ec920c0d268>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mattempt_float\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: attempt_float() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "attempt_float(1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exactly what we wanted. In general, we specify what types of exceptions we will permit inside the brackets of except(). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following most general sequence of \"try\" block code. We wil analyze it afterwards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Failed\n",
      "The value of a was 4 and the value of b was 0\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "b = 0\n",
    "\n",
    "try:\n",
    "    print(a/b)\n",
    "except:\n",
    "    print(\"Failed\")\n",
    "else:\n",
    "    print(\"Succeeded\")\n",
    "finally:\n",
    "    print(\"The value of a was {0} and the value of b was {1}\".format(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly the <b>try</b> block is attempted. If it doesn't succeed then the <b>except</b> block is executed. If is does succeed then the <b>else</b> block is executed. Regardless of whether or not the try block succeeds, the <b>finally</b> block is then executed. This becomes a nice way to organize code."
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}