01_Intro_to_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python\n",
    "Python is a high level computer programming langauge that allows for complex calculations and analysis. We will be focusing mostly on functional programming, where programs are run similarly to a command line to allow for analysis. What Jupyter notebooks allow is the ability to segment out this code, fit visualizaitions inline, and work independently on different aspects of our analyses.\n",
    "\n",
    "Enough introduction, let's write.\n",
    "\n",
    "## 1) Working with the interface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows you to write information to an output, which in this case will appear directly under this box.\n",
    "\n",
    "In order to use this you must write: print('What you want to print')\n",
    "\n",
    "For example: print('Hello!')\n",
    "\n",
    "You can then run the output by either clicking 'Run' above, or by the combination Shift+Enter\n",
    "\n",
    "#### Practice\n",
    "Go ahead and write your first program. Make the output 'Hello World!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Primitive Data Types and Variables\n",
    "\n",
    "Python, unlike some other languages you might be familiar with, defines your data types from what you input. There is no need for declaring a variable. Python has a variety of basic (aka **primitive**) data types:\n",
    "* Integers\n",
    "* Floats \n",
    "* Strings\n",
    "* Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Integer (whole number) 'int'\n",
    "# For example, lets create a variable to hold the number 1.\n",
    "\n",
    "i = 1\n",
    "print(i)\n",
    "print(\"i is a\", type(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Now, lets change this up to a float (contains decimals)\n",
    "\n",
    "i = i + .5\n",
    "print(i)\n",
    "print(\"i is a\", type(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#It automatically updated!\n",
    "#Notice we can perform operations on these variables, just like in algebra.\n",
    "\n",
    "#Addition: +\n",
    "a = 5+3\n",
    "print('5 + 3 =',a)\n",
    "\n",
    "#Subtraction: -\n",
    "b = 5-3\n",
    "print('5 - 3 =',b)\n",
    "\n",
    "#Multiplication: *\n",
    "c = 2*2\n",
    "print('2 x 2 =',c)\n",
    "\n",
    "#Division: /\n",
    "d = 20/5\n",
    "print('20 / 5 =',d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "There is one more thing! \n",
    "You can separate out the quotient and remainder in division\n",
    "Integer division: how many times the dividend can be divided by the divisor\n",
    "Modulus: the function to give a remainder from division, denoted '%'\n",
    "'''\n",
    "\n",
    "# Integer Division: //\n",
    "e = 21//8\n",
    "print(\"Quotient of 21 / 8 =\", e)\n",
    "# Modulus: %\n",
    "f = 21%8\n",
    "print('Remainder of 21 / 8 =',f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some shortcuts\n",
    "\n",
    "a = a - 1 is the same as a -= 1\n",
    "\n",
    "a = a + 1 is the same as a += 1\n",
    "\n",
    "a = a * 2 is the same as a *= 2\n",
    "\n",
    "a = a / 2 is the same as a /= 2\n",
    "\n",
    "a = a % 2 is the same as a %= 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Practice\n",
    "Check if 3841 is divisble by 3 and print the result!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) Strings\n",
    "A String is what you think of as text. But these are actually just a series of characters (letters and symbols). In Python, you can create these as simply as any other data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Hello!\"\n",
    "print(a)\n",
    "\n",
    "#In fact, your very first program created a String!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can access these characters by asking for them as an index. This is as simple as string[index].\n",
    "#For example:\n",
    "a = \"Hello World!\"\n",
    "print(a[0])\n",
    "\n",
    "#There are plenty of in-built functions for working with strings such as\n",
    "a = a.lower() #Lowercase\n",
    "print(a)\n",
    "\n",
    "a = a.upper() #Uppercase\n",
    "print(a)\n",
    "\n",
    "a.strip() #Removes pre and post white space\n",
    "\n",
    "a = a.split(' ') #Breaks the string along the indicated character, we will talk about what this creates later.\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Say you want a different data type...\n",
    "\n",
    "This can be done simply by casting. Casting is asking the computer to treat a certain variable like a different type.\n",
    "\n",
    "This is done by datatype(). For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1.1\n",
    "print(type(a))\n",
    "print(type(int(a)))\n",
    "\n",
    "#The different ways (that you will likely end up encountering) are:\n",
    "int(a) #Integer\n",
    "float(a) #Decimal\n",
    "str(a) #String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4) Homage to George Boole\n",
    "Python has a way of evaluating the truth of statements. Let's see."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#True (notice the color)\n",
    "print(True)\n",
    "#False (notice the color)\n",
    "print(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Just like in base 10 algebra (what we did above), there are operators in base 2 algebra (Boolean algebra)\n",
    "#Not: not, returns the opposite of the input\n",
    "print('\\nNot True:',not True)#\\n creates a line break\n",
    "print('Not Not True:',not not True)\n",
    "print('Not False:',not False)\n",
    "\n",
    "#Or: or, returns true if either side of the sign is true.\n",
    "print('\\nTrue or True',True or True)\n",
    "print('True or False:',True or False)\n",
    "print('False or False:',False or False)\n",
    "\n",
    "#And: and, returns true if both sides are true.\n",
    "print('\\nTrue and True:',True and True)\n",
    "print('True and False:',True and False)\n",
    "print('False and False:',False and False)\n",
    "\n",
    "#Equality: ==, returns true if both sides of the sign are equivalent.\n",
    "print('\\nTrue == True:',True==True)\n",
    "print('False == True:',False==True)\n",
    "print('False == False:',False==False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#When we are working with numbers, we can create truth analyses:\n",
    "#Looking to evaluating results of equations: note >, <, >=, <=, ==, !=\n",
    "a = 1<2\n",
    "print(a)\n",
    "a = 2<1\n",
    "print(a)\n",
    "a = (2>=2)\n",
    "print(a)\n",
    "a = (2<=2)\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Now, working with these results\n",
    "print('\\nIs 5 either greater than 1 or less than -1:',5>1 or 5<-1)\n",
    "\n",
    "#Notice, the order of operations applies\n",
    "print('Is 10 not divisible 3: ',not (10%3)==0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Practice: Create a way to print true if a number is even."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5) If-Then Statements\n",
    "Python makes evaluating these truth and making decisions off of the results very easy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#For Example:\n",
    "a = True\n",
    "\n",
    "#if(condition):\n",
    "    #Command\n",
    "#Note the indents! Python requires indents, and not indenting signals the end of the post-if commands.    \n",
    "\n",
    "if(a == True):\n",
    "    print('a is True')\n",
    "\n",
    "#Or more simply:\n",
    "if(a):\n",
    "    print('\\na is True')\n",
    "    \n",
    "#If you want an alternative:\n",
    "a = False\n",
    "if(a):\n",
    "    print('\\na is True')\n",
    "else:\n",
    "    print('\\na is not True')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can also link these together to make a series of decisions and alternatives:\n",
    "a = 2\n",
    "\n",
    "#Let's check: Note, parenthesis are not required around the condition.\n",
    "if a==1:\n",
    "    print('a is 1!')\n",
    "elif a==2:\n",
    "    print('a is 2!')\n",
    "elif a==2:\n",
    "    print('a is 3!')\n",
    "else:\n",
    "    print('a is not 1, 2, or 3!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Just like before, we can link these using our base 2 (Boolean) operators:\n",
    "a = 4\n",
    "\n",
    "if((a%2)==0 or a==0):\n",
    "    print('a is even!')\n",
    "else:\n",
    "    print('a is odd!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6) Storing stuff in places\n",
    "Now that we can do base 2 and base 10 math, make decisions, and print to output, lets start working with more numbers.\n",
    "#### List\n",
    "`Lists` are **mutable** objects in `Python` that stores a series of values. This means you can change the same `list` object over and over again (this is called **mutating** it). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A List is indicated by [...] and is an ordered series of numbers. We will cover this in more detail next time.\n",
    "a = []\n",
    "print(a)\n",
    "a = ['A','Is','Filled','With','This']\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#For now we will only cover the basics\n",
    "#To access an element in a list: list[index] where the index starts from 0 and goes left to right.\n",
    "#To get a slice of the list pass in a range of index values\n",
    "#For example:\n",
    "a = [1,2,3,4,5]\n",
    "print(a[0])\n",
    "print(a[1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#If you want to check the length of a list, you can simply ask with len()\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#From before, recall: string.split(character) splits a string. What it creates is a list!\n",
    "a = \"I Am A Series Of Words\"\n",
    "a = a.split(' ')\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can also very easily check if an element exists in a list! This is indicated by 'in'\n",
    "#For example\n",
    "a = \"I Am A Series Of Words\"\n",
    "a = a.split(' ')\n",
    "print('Series' in a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also add and remove items, but we will cover lists in more detail next time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A Tuple is a like a list, but is UNCHANGEABLE, and is indicated by (...)\n",
    "#For example:\n",
    "a = ('I','Am','Eternal')\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Just like above, this can also be checked for membership\n",
    "a = ('I','Am','Eternal')\n",
    "print('I\\'m not in there' in a) #Note the \\ escape character to indicate a special character, treats like text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A set is like a list but is ordered and contains no duplicates, indicated by {...}\n",
    "#For example:\n",
    "a = {2,3,5,4,6,6,1}\n",
    "print(a)\n",
    "print('3 in a:',3 in a)\n",
    "print('a is',len(a), 'elements long')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last data type we are going to talk about in this whirlwind tour of `Python` are called dictionaries, or `dicts`. \n",
    "\n",
    "Dictionaries are `Python` objects that behave like real dictionaries:\n",
    "* dictionaries are made of key-value pairs (word and definition)\n",
    "* dictionary keys must be unique (each word is only defined once)\n",
    "* you can use the key to look up the value, but not the other way around (you can't ask a dictionary give me the word whose definition is \"furry domesticated animal that loves chase squirrels\" and get \"dog\")\n",
    "\n",
    "Dictionaries are similar to lists in that:\n",
    "* they can contain multiple data types\n",
    "* you can move through (iterate) them\n",
    "* they are mutable (meaning you can change, or mutate, them).\n",
    "\n",
    "However, dictionaries are different from lists in that they:\n",
    "* are unordered (lists are ordered on their index)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dictionaries are indicated by {...}, with elements separated by :\n",
    "#For example:\n",
    "a = {'a':1,'b':2,'c':3}\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can get items by asking for the key or index.\n",
    "print(a['a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can check for membership as well, note the behavior checking for a Value.\n",
    "print('a' in a)\n",
    "print(1 in a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#To check for values, you must:\n",
    "print(a.keys())\n",
    "print(a.values())\n",
    "print(1 in a.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can modify dictionaries in a similar way to how you can modify lists:\n",
    "a['d'] = 4                     # add a new entry\n",
    "a['a'] = 5                     # edit an existing entry\n",
    "del a['b']                     # delete an entry using its key\n",
    "a['f'] = [6,'ate',7]           # value can be a list\n",
    "\n",
    "# accessing a list element within a dictionary\n",
    "a['f'][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an incredibly brief overview of data structures in Python. You WILL need more information to complete your projects. There are tons of great resources on the internet, but I recommend  W3 schools at https://www.w3schools.com/python/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7) Loops\n",
    "Python has two main types of loops: For and While, let's examine the differences\n",
    "#### While"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Imagine in English, you say: While I am a minor, I am under 18. Once you are 18, you are an adult.\n",
    "We want to picture a person, aging, each year growing one older, until finally, adult!\n",
    "Using a while(condition): we can do that!\n",
    "A while loop will continue running the commands inside of it until the condition registers as false.\n",
    "'''\n",
    "\n",
    "a = 0 #You are born\n",
    "while(a<=18):\n",
    "    print('You are',a,' years old!')\n",
    "    a+=1 #Without this we will go on forever!\n",
    "print('You are now an adult!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can get out of a loop early with the command 'break'\n",
    "a = 0 #You are born\n",
    "while(True): #This will continue forever, no matter what!\n",
    "    print('You are',a,' years old!')\n",
    "    if(a>=18): #Note the indentation\n",
    "        break\n",
    "    a+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The opposite, you can continue a loop early by initating a quick restart\n",
    "#Imagine we only want the odd numbers, but 0, 2 and 4 are okay as well\n",
    "a = 0\n",
    "while(True): #This will continue forever, no matter what!\n",
    "    if(a==4 or a==2 or a==0):\n",
    "        print(a)\n",
    "        a+=1\n",
    "        continue\n",
    "    if(a%2)==0:\n",
    "        break\n",
    "    print(a)\n",
    "    a+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "For loops will generally be used to iterate over one of the data structures we just introduced\n",
    "What this means is that it will look at every element in a list in order (if it has an order)\n",
    "It can also be told a certain number of times. Lets jump in with an example.\n",
    "'''\n",
    "\n",
    "#Lets print each of the elements in this list\n",
    "a = [1,2,3,4,5,6,7,8,9]\n",
    "for i in a:\n",
    "    print(i)\n",
    "    \n",
    "#Or change them!\n",
    "for i in a:\n",
    "    a[i-1] *= 2 #Note, since the loop starts at one, we must subtract one\n",
    "print(a,'\\n')\n",
    "\n",
    "#Remember how Strings are a series of characters?\n",
    "for i in 'Hello World!':\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Continue and Break work as well\n",
    "a = ['a','b','c','d','e']\n",
    "for i in a:\n",
    "    if(i=='b'):\n",
    "        continue\n",
    "    if(i=='d'):\n",
    "        break\n",
    "    print(i)\n",
    "    \n",
    "#This starts the next iteration if the character is b, and ends it all if it's d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#As was mentioned earlier, we can evaluate only a certain number of times.\n",
    "#If we only want Hello from 'Hello World!' we can do the following:\n",
    "\n",
    "a = 'Hello World!'\n",
    "for i in range(5): #Hello has five letters\n",
    "    print(a[i])\n",
    "    \n",
    "#This follows the syntax, by default starting from 0:\n",
    "#range(5) = 0,1,2,3,4 = range(end)\n",
    "#range(1,5) = 1,2,3,4 = range(start, end)\n",
    "#range(1,10,2) = 1,3,5,7,9 = range(start, end, step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8) Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Functions are declared in Python by: def name(parameter):\n",
    "#For example:\n",
    "def printer():\n",
    "    print('I print!')\n",
    "printer()\n",
    "\n",
    "#You can also pass parameters, which can be any variable!\n",
    "def printer(x):\n",
    "    print(x)\n",
    "printer('I can print anything!')\n",
    "\n",
    "#With even a default if nothing is passed through:\n",
    "def printer(x='Please feed me text'):\n",
    "    print(x)\n",
    "printer()\n",
    "printer('Fine if you\\'re hungery')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Functions can also return values, this is simply defined by saying return.\n",
    "#For Example\n",
    "def squared(x):\n",
    "    return x**2\n",
    "\n",
    "print(squared(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's another function. It's a bit more complicated, and has parameters that you pass into it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc(x, y, op):         # three parameters (without any defaults)\n",
    "    if op == 'add':         # conditional statement\n",
    "        return x + y\n",
    "    elif op == 'subtract':\n",
    "        return x - y\n",
    "    else:\n",
    "        print('Valid operations: add, subtract')\n",
    "        \n",
    "calc(2,2,'+')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the function to work we must pass 3 arguments to the calc function, as all of them were required. What if you don't want to pass in all parameters each time? \n",
    "\n",
    "We can set one of the parameters to have a default value. Let's make one of the parameters optional (by adding a default value) to fix this problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_default_add(x, y, op=\"add\"): # three parameters (with addition being the default value for the 3rd parameter)\n",
    "    if op == 'add':         # conditional statement\n",
    "        return x + y\n",
    "    elif op == 'subtract':\n",
    "        return x - y\n",
    "    else:\n",
    "        print('Valid operations: add, subtract')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calc_default_add(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now it's your turn to practice and experiment!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a couple functions:\n",
    "* One called `compute_pay` that takes two parameters (`hours` and `rate`), and returns the total pay.\n",
    "* One called `get_hours_worked` that takes two parameters (`total_pay` and `rate`) and returns the total hours worked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}