solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To make your code appear cleaner, use PEP 8 style guide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.python.org/dev/peps/pep-0008/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Class names: \n",
    "\n",
    "\n",
    "| Type | Convention |\n",
    "|---|---|\n",
    "| Variable | lowercase_separated_by_underscores  | \n",
    "| Function | lowercase_separated_by_underscores  | \n",
    "| Class | UpperCamelCase  |\n",
    "| Constant | CAPITALIZED_WITH_UNDERSCORES   |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Effective Python](https://images-na.ssl-images-amazon.com/images/I/518KlDL92eL._SX380_BO1,204,203,200_.jpg)\n",
    "![Clean Code](https://images-na.ssl-images-amazon.com/images/I/515iEcDr1GL._SX385_BO1,204,203,200_.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Code refactoring** is the process of restructuring existing computer code—changing the factoring—without changing its external behavior. Refactoring improves nonfunctional attributes of the software. Advantages include improved code readability and reduced complexity; these can improve source-code maintainability and create a more expressive internal architecture or object model to improve extensibility.\n",
    "\n",
    "-- Wikipedia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zen of Python: There should be one-- and preferably only one --obvious way to do it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Meaningful Variable Names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Variable names should improve readibility\n",
    "- Avoid vague names like flag, x, y, etc.\n",
    "- Avoid bad comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Bad example\n",
    "\n",
    "# This is Jake's income\n",
    "x = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Good Example\n",
    "\n",
    "jakes_income = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Bad example\n",
    "\n",
    "# This function tells if employee is eligible or not\n",
    "flag()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Good example\n",
    "\n",
    "is_employee_eligible()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions and loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If you're copying and pasting code, you might want to use a loop and/or function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task: Create a list of squares of the first 9 non-negative numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "squares.append(0**2)\n",
    "squares.append(1**2)\n",
    "squares.append(2**2)\n",
    "squares.append(3**2)\n",
    "squares.append(4**2)\n",
    "squares.append(5**2)\n",
    "squares.append(6**2)\n",
    "squares.append(7**2)\n",
    "squares.append(8**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for number in range(9):\n",
    "    squares.append(number**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [number**2 for number in range(9)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for number in range(9):\n",
    "    if number%2==0:\n",
    "        squares.append(number**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [number**2 for number in range(9) if number%2==0]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using functions for generality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_squares(n):\n",
    "    return [number**2 for number in range(n)]\n",
    "\n",
    "get_squares(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Functions should do one thing. They should do it well. They should do it only.\n",
    "- Use descriptive names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Task: Derive a function that returns a list of n prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 7, 11, 13]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "    if num in [0,1]:\n",
    "        return False\n",
    "    if num==2:\n",
    "        return True\n",
    "    for x in range(2,num):\n",
    "        if num%x == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def prime_list(n):\n",
    "    prime_list = []\n",
    "    number = 1\n",
    "    while len(prime_list) <= n:\n",
    "        if is_prime(number):\n",
    "            prime_list.append(number)\n",
    "        number += 1\n",
    "    return prime_list\n",
    "\n",
    "prime_list(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider using docstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function is_palindrome in module __main__:\n",
      "\n",
      "is_palindrome(a_string)\n",
      "    Takes string as input, and evaluates whether that string is a palindrome.\n",
      "    \n",
      "    Arg: string\n",
      "    Returns: boolean\n",
      "    \n",
      "    Example:\n",
      "    is_palindrome('racecar') = True\n",
      "    is_palindrome('bus') = False\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def is_palindrome(a_string):\n",
    "    \"\"\"\n",
    "    Takes string as input, and evaluates whether that string is a palindrome.\n",
    "    \n",
    "    Arg: string\n",
    "    Returns: boolean\n",
    "    \n",
    "    Example:\n",
    "    is_palindrome('racecar') = True\n",
    "    is_palindrome('bus') = False\n",
    "    \"\"\"\n",
    "    return a_string.lower() == a_string.lower()[::-1]\n",
    "\n",
    "help(is_palindrome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def simple_generator_function():\n",
    "    yield 1\n",
    "    yield 76\n",
    "    yield 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "generator_instance = simple_generator_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(generator_instance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "76\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "for num in simple_generator_function():\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def squared_gen(num):\n",
    "    for num in range(num):\n",
    "        yield num**2\n",
    "        \n",
    "list(squared_gen(9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def squared_gen(num):\n",
    "    return (num**2 for num in range(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More Iterations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use zip to process iterators in parallel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joe received a 66 out of 100.\n",
      "Dan received a 45 out of 100.\n",
      "Michael received a 23 out of 100.\n",
      "Devin received a 76 out of 100.\n",
      "Jerry received a 81 out of 100.\n"
     ]
    }
   ],
   "source": [
    "names = [\"Joe\", \"Dan\", \"Michael\", \"Devin\", \"Jerry\"]\n",
    "scores = [66, 45, 23, 76, 81]\n",
    "\n",
    "for name, score in zip(names, scores):\n",
    "    print(f'{name} received a {score} out of 100.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Dan': 45, 'Devin': 76, 'Jerry': 81, 'Joe': 66, 'Michael': 23}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{name: score for name, score in zip(names, scores)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use enumerate instead of range\n",
    "\n",
    "Task: List out numbers and candies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "candy_list = ['reeses', 'almond joy', 'butterfinger']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: reeses\n",
      "2: almond joy\n",
      "3: butterfinger\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(candy_list)):\n",
    "    print(str(i+1) + ': ' + candy_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: reeses\n",
      "2: almond joy\n",
      "3: butterfinger\n"
     ]
    }
   ],
   "source": [
    "for i, candy in enumerate(candy_list, 1):\n",
    "    print(str(i) + ': ' + candy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[num for num in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "generator comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x000001A435D28F10>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(num for num in range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dictionary comprenhension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{num:num**2 for num in range(10)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using exisiting modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B'),\n",
       " ('A', 'C'),\n",
       " ('A', 'D'),\n",
       " ('B', 'A'),\n",
       " ('B', 'C'),\n",
       " ('B', 'D'),\n",
       " ('C', 'A'),\n",
       " ('C', 'B'),\n",
       " ('C', 'D'),\n",
       " ('D', 'A'),\n",
       " ('D', 'B'),\n",
       " ('D', 'C')]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools\n",
    "\n",
    "list(itertools.permutations('ABCD',2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(itertools.combinations('ABCD',2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AB', 'AC', 'AD', 'BC', 'BD', 'CD']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[''.join(pair) for pair in itertools.combinations('ABCD',2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'A'),\n",
       " ('A', 'B'),\n",
       " ('A', 'C'),\n",
       " ('B', 'A'),\n",
       " ('B', 'B'),\n",
       " ('B', 'C'),\n",
       " ('C', 'A'),\n",
       " ('C', 'B'),\n",
       " ('C', 'C')]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(itertools.product('ABC', repeat=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "list_1 = ['dog', 'cat', 'monkey']\n",
    "list_2 = ['pizza', 'spaghetti']\n",
    "list_3 = [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('dog', 'pizza', 1),\n",
       " ('dog', 'pizza', 2),\n",
       " ('dog', 'pizza', 3),\n",
       " ('dog', 'pizza', 4),\n",
       " ('dog', 'spaghetti', 1),\n",
       " ('dog', 'spaghetti', 2),\n",
       " ('dog', 'spaghetti', 3),\n",
       " ('dog', 'spaghetti', 4),\n",
       " ('cat', 'pizza', 1),\n",
       " ('cat', 'pizza', 2),\n",
       " ('cat', 'pizza', 3),\n",
       " ('cat', 'pizza', 4),\n",
       " ('cat', 'spaghetti', 1),\n",
       " ('cat', 'spaghetti', 2),\n",
       " ('cat', 'spaghetti', 3),\n",
       " ('cat', 'spaghetti', 4),\n",
       " ('monkey', 'pizza', 1),\n",
       " ('monkey', 'pizza', 2),\n",
       " ('monkey', 'pizza', 3),\n",
       " ('monkey', 'pizza', 4),\n",
       " ('monkey', 'spaghetti', 1),\n",
       " ('monkey', 'spaghetti', 2),\n",
       " ('monkey', 'spaghetti', 3),\n",
       " ('monkey', 'spaghetti', 4)]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(i,j,k) for i in list_1 for j in list_2 for k in list_3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('dog', 'pizza', 1),\n",
       " ('dog', 'pizza', 2),\n",
       " ('dog', 'pizza', 3),\n",
       " ('dog', 'pizza', 4),\n",
       " ('dog', 'spaghetti', 1),\n",
       " ('dog', 'spaghetti', 2),\n",
       " ('dog', 'spaghetti', 3),\n",
       " ('dog', 'spaghetti', 4),\n",
       " ('cat', 'pizza', 1),\n",
       " ('cat', 'pizza', 2),\n",
       " ('cat', 'pizza', 3),\n",
       " ('cat', 'pizza', 4),\n",
       " ('cat', 'spaghetti', 1),\n",
       " ('cat', 'spaghetti', 2),\n",
       " ('cat', 'spaghetti', 3),\n",
       " ('cat', 'spaghetti', 4),\n",
       " ('monkey', 'pizza', 1),\n",
       " ('monkey', 'pizza', 2),\n",
       " ('monkey', 'pizza', 3),\n",
       " ('monkey', 'pizza', 4),\n",
       " ('monkey', 'spaghetti', 1),\n",
       " ('monkey', 'spaghetti', 2),\n",
       " ('monkey', 'spaghetti', 3),\n",
       " ('monkey', 'spaghetti', 4)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(itertools.product(list_1, list_2, list_3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(itertools.chain(range(9),range(20,30)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas Iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Never, I repeat NEVER loop through a numpy array or pandas dataframe/series. It is highly inefficient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Error Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid maximum element\n"
     ]
    }
   ],
   "source": [
    "def normalize(numbers):\n",
    "    max_number = max(numbers)\n",
    "    for i in range(len(numbers)):\n",
    "        numbers[i] /= float(max_number)\n",
    "    return numbers  \n",
    "\n",
    "try:\n",
    "    normalize([0, 0, 0])\n",
    "except ZeroDivisionError:\n",
    "    print('Invalid maximum element')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "inf\n"
     ]
    }
   ],
   "source": [
    "def safe_division(number, divisor, ignore_overflow=False, ignore_zero_division=False):\n",
    "    try:\n",
    "        return number/divisor\n",
    "    except OverflowError:\n",
    "        if ignore_overflow:\n",
    "            return 0\n",
    "        else: \n",
    "            raise\n",
    "    except ZeroDivisionError:\n",
    "        if ignore_zero_division:\n",
    "            return float('inf')\n",
    "        else:\n",
    "            raise\n",
    "            \n",
    "print(safe_division(1.0, 10**500, ignore_overflow=True))\n",
    "print(safe_division(1.0, 0, ignore_zero_division=True))"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}