notebooks/Python_02_Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Immersion Course\n",
    "\n",
    "### An Introduction to Python - Part 2\n",
    "\n",
    "### Joe Blankenship - Just some dude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## The Basics\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic math operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition\n",
    "\n",
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subtraction\n",
    "\n",
    "2 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplication\n",
    "\n",
    "2 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Division\n",
    "\n",
    "3 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer Division\n",
    "\n",
    "3 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modulus/Remainder\n",
    "\n",
    "5 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exponents\n",
    "\n",
    "3 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python also has a math library built in for more advanced operations\n",
    "\n",
    "from math import sqrt\n",
    "\n",
    "sqrt(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integers\n",
    "\n",
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Floats\n",
    "\n",
    "type(1.5003)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also convert between types\n",
    "\n",
    "# from float to integer\n",
    "int(10.3454)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from integer to float\n",
    "float(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# strings\n",
    "\n",
    "type('Hello UK!')\n",
    "\n",
    "# Python doesn't discriminate between '' and \"\" for most simple cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concatenation\n",
    "\n",
    "'Matt' + ' and other Matt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also use multiplication, but only with integers\n",
    "\n",
    "hexa_tad = 'Tad ' * 6\n",
    "print(hexa_tad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Once again, we can convert between types\n",
    "\n",
    "# from float to string\n",
    "str(10.2345234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from string to integer\n",
    "int('10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from string to float\n",
    "float('12.345436')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Literals and Quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# strings can use single or double quotes\n",
    "# use the `\\` escape character to place single in single or double in double\n",
    "\n",
    "'this is joe\\'s ' + \" & 'that' is not\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also add tabs, new lines, and blackslashed using excape character\n",
    "\n",
    "print(\"\\tThis is a tab, \\nthis is a new line,\\nand this is a backslash \\\\\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also declare the above a raw string with `r`\n",
    "\n",
    "print(r\"\\tThis is a tab, \\nthis is a new line,\\nand this is a backslash \\\\\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can use multiline strings like this\n",
    "\n",
    "'''\n",
    "This is an example\n",
    "\n",
    "of a multiline string\n",
    "\n",
    "using triple quotes\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Slicing and Indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when Python counts or indexes, it does so from zero\n",
    "# for strings, we can index characters in the string\n",
    "\n",
    "a_string = 'This is a test string for showing string stuff'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can access letters using index notation\n",
    "\n",
    "a_string[5:14:1] # index from left to right starting at 0 to the end, grabbing every 2nd character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to reverse a string do this\n",
    "\n",
    "a_string[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can search for characters inside of a string with `in` and `not in`\n",
    "\n",
    "'test' in a_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# UPPER and lower case\n",
    "\n",
    "a_string.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# there are also several `is` functions for strings to test certain cases\n",
    "# use tab to explore other `is` string functions\n",
    "\n",
    "a_string.islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can check the start and end of a string\n",
    "\n",
    "a_string.startswith(\"This\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can join and split strings\n",
    "\n",
    "a_split = a_string.split(' ')\n",
    "a_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a string join\n",
    "\n",
    "a_join = ' '.join(a_split)\n",
    "a_join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can strip out whitespaces with strip, lstrip, or rstrip\n",
    "\n",
    "another_string = '                 hey              '\n",
    "another_string.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Python Style Guide](https://www.python.org/dev/peps/pep-0008/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assigning a variable to an object\n",
    "\n",
    "michael = 45\n",
    "\n",
    "# outside of Jupyter, use the built_in print() command\n",
    "# print(michael)\n",
    "\n",
    "# inside of Jupyter, just type the variable name\n",
    "michael"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# variable names should be simple\n",
    "# use underscores, letters, and numbers only\n",
    "\n",
    "a_random_integer = 99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also be as descriptive as possible\n",
    "\n",
    "a_descriptive_var = 'a descriptive var'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Don't start with a number\n",
    "\n",
    "4you = 'for you'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the length of a variable\n",
    "\n",
    "random_string = 'a;sjdf;lahoiehfadhgaidg;oiu3urweuroiodsifaklsdknfakent.ane.,maner.qjenr.qn,m f,ma sdf,man'\n",
    "\n",
    "len(random_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Docstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# comments... This is a comment :)\n",
    "\n",
    "\"\"\"\n",
    "This is another way to place information about your code in your functions and classes\n",
    "\n",
    "This is a multiline comment\n",
    "\n",
    "When you use dir() and help(), this type of docstring is what you're seeing\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can search **[PyPI](https://pypi.org/)** for packages and their source code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also do a `pip search` inside your active virtual environment\n",
    "\n",
    "For example\n",
    "`pip search pandas`\n",
    "\n",
    "You can then install your packages\n",
    "`pipenv install pandas`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can render datetime like this in Python\n",
    "import datetime\n",
    "\n",
    "datetime.datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# libraries can import other libraries\n",
    "from pandas import datetime\n",
    "\n",
    "datetime.today()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create your own modules\n",
    "# See module_test.py for content\n",
    "\n",
    "import module_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "module_test.hello_world()\n",
    "\n",
    "# we'll do more on modules, libraries, and packaging in a later module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dir() and help()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Examine library modules\n",
    "\n",
    "import math\n",
    "\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# examine help from a library\n",
    "\n",
    "from math import sqrt\n",
    "\n",
    "help(sqrt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time for Exercise 1!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Flow Control\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are only 2 Boolean values: True and False\n",
    "\n",
    "a = 1\n",
    "b = 2\n",
    "c = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# equal to\n",
    "a == a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not equal\n",
    "a != b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# less than\n",
    "a < b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# greater than\n",
    "a > b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Less than or equal to\n",
    "a <= c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# greater than or equal to\n",
    "a >= c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remember:** `==` is for comparison, `=` is for variable assignment "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are also 3 Boolean operators: and, or, not\n",
    "\n",
    "# and\n",
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or\n",
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not\n",
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use it to negate a Boolean value\n",
    "True and not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine Boolean and comparison\n",
    "True and (5 < 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We'll use the above operators and comparison to establish condition for running blocks of code\n",
    "\n",
    "website = input(' type a website... ') # Set an input\n",
    "\n",
    "if website == 'google': # set the condition for the underlying code\n",
    "    print('True')\n",
    "else: # if the above condition is not True, then do this\n",
    "    print('False')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If, Elif, Else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if statments begin a flow \n",
    "if 'candy' == 'corn':\n",
    "    print('That\\'s amazing!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# else statements don't have conditions\n",
    "# else comes after if and elif\n",
    "if 'candy' == 'corn':\n",
    "    print('That\\'s amazing!')\n",
    "else:\n",
    "    print('Nope!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# elif statements create branches in flow\n",
    "# order of elif statements does matter\n",
    "if 'candy' == 'corn':\n",
    "    print('That\\'s amazing!')\n",
    "elif 'candy' == 'candy':\n",
    "    print('Sweet!')\n",
    "else:\n",
    "    print('Nope!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Python indexes from zero.\n",
    "\n",
    "**Also Note:** To break out of an _infinite_ loop, hit **Ctrl-C**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For loop\n",
    "# We'll be using the built-in range() method for demonstration\n",
    "\n",
    "for i in range(4): # establish a numeric range for # of times to loop\n",
    "    print('Yay for four for loops this many times: %s' % str(i))\n",
    "\n",
    "# Instead of adding strings '... times: ' + str(i)\n",
    "# I used string formatting to substitute %s with a value after % "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can increment a variable outside of the for loop\n",
    "\n",
    "loop_sum = 0 # set the initial sum to zero\n",
    "\n",
    "for number in range(101): # for each number in range 0 to 100\n",
    "    loop_sum = loop_sum + number # add the number to loop_sum\n",
    "print(loop_sum) # print the final sum for this addition loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also set the start, stop, and step value of our range method\n",
    "\n",
    "help(range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# after reviewing the docs, we can set our values\n",
    "# start at 10 and stop at 20, in steps of 2\n",
    "for i in range (10, 21, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also reverse the count order\n",
    "for i in range (10, -1, -2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# While loop\n",
    "\n",
    "pancakes = 1 # set an initial counter value\n",
    "\n",
    "while pancakes < 3: # establish a while loop and set condition\n",
    "    print('Put a pancake on my plate.') # output a response based on condition\n",
    "    pancakes = pancakes + 1 # increase the counter value which affects the loop condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# break gets you out of a loop\n",
    "# continue goes back to the beginning to evaluate condition\n",
    "\n",
    "pancakes = 0\n",
    "\n",
    "while pancakes < 3: # establish a while loop and set condition\n",
    "    print('Would you like a pancake on your plate?') # output a response based on condition\n",
    "    response = input() # wait for an input as condition for the following decision\n",
    "    if response == 'yes': # if condition met, await a second response for following decision\n",
    "        print('Or would you like French Toast?')\n",
    "        response_2 = input()\n",
    "        if response_2 == 'yes': # if condition met, continue back to beginning of loop \n",
    "            print('I didn\\'t even know that was an option!')\n",
    "            continue\n",
    "        else:  # if condition not met, update pancake count and go to beginning of loop\n",
    "            print('Well then here is your pancake')\n",
    "            pancakes = pancakes + 1 # increase the counter value which affects the loop condition\n",
    "    else: # if condition not met, break out of loop\n",
    "        print('Sounds good.')\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Membership test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can add exceptions to your loops to check for values\n",
    "# use raise `errorMsg`\n",
    "breakfast = [\"french toast\", \"eggs\", \"hash browns\"]\n",
    "\n",
    "for item in breakfast:\n",
    "    if \"pancakes\" not in breakfast:\n",
    "        raise ValueError('No Pancakes!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Terminate a program\n",
    "\n",
    "You can terminate a program anywhere in the flow control with `sys.exit()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time for Exercise 2!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Functions\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you define functions with def\n",
    "\n",
    "def hello(name):\n",
    "    print('Hello ' + str(name) + '!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# as before, we have to call the function with argument to run it\n",
    "hello('Lori')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the output of a function is the return value\n",
    "\n",
    "def greetings(name):\n",
    "    if name == 'Joe':\n",
    "        return 'What\\'s up ' + name + '?' # this will be the output from the function if conditions are met\n",
    "    elif name == 'Jack':\n",
    "        return \"How's it going\" + name + '?'\n",
    "    elif name == 'Jeremy':\n",
    "        return 'Just why ' + name + '?'\n",
    "    else:\n",
    "        return None # None is a value for an absence of a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# call our greeting function\n",
    "\n",
    "greetings('Joe')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# keyword arguments are often optional parameters in a function\n",
    "# here we'll use the sep keyword for the print function\n",
    "\n",
    "print('Nick', 'Matt', 'Other Matt', sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global Scope\n",
    "# Variable outside of the function are in the global scope for that function\n",
    "\n",
    "tacos = 'yum'\n",
    "\n",
    "def taco_function():\n",
    "    print(tacos)\n",
    "\n",
    "# the taco_function can see tacos as can any other fucntion outside of taco_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Local Scope\n",
    "# Variables inside the function are in the local scope for that function\n",
    "\n",
    "def rock_function():\n",
    "    rocks = 'rocks'\n",
    "    return rocks\n",
    "\n",
    "# print(rocks) will throw an errot because it cannot see inside of the rock_function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Local scope variable cannot see other Local scope variables (e.g., taco_function cannot see rocks)<br>\n",
    "**Best Practice:** Don't use Local scope variable names that are the same as Global scope or other Local scope variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global Statement\n",
    "# placing global statement in fucntion says 'overwrite global tacos with 'not yum' once the function runs\n",
    "\n",
    "tacos = 'yum'\n",
    "\n",
    "def taco_function():\n",
    "    global tacos\n",
    "    tacos = 'not yum'\n",
    "\n",
    "taco_function()\n",
    "print(tacos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exception Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# When a function encounters an unexpected input, it will throw an error\n",
    "\n",
    "def name_input(first_name, last_name):\n",
    "    print(first_name + last_name)\n",
    "\n",
    "name_input('Bob', 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can implement try and except statements to handle this error\n",
    "\n",
    "def name_input(first_name, last_name):\n",
    "    try:\n",
    "        print(first_name + last_name)\n",
    "    except TypeError:\n",
    "        print('Something was wrong with your name. Use only letters.')\n",
    "\n",
    "name_input('Bob', 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time for Exercise 3!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Data Structures\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists are defined by square brackets, comma delimiters, and heterogenous data types\n",
    "\n",
    "test_list = ['Rich', 77, True, 3.14, None]\n",
    "test_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to access an item inside a list, use indexing\n",
    "# remember, Python indexes from zero\n",
    "# indexing outside of the number of items will throw an error\n",
    "\n",
    "test_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lists can also contain other lists\n",
    "\n",
    "test_list_2 = ['Monty', ['Python', 'Flying', 'Circus'], 1969, 1974]\n",
    "\n",
    "test_list_2[0] + ' ' + test_list_2[1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can use negative indexes\n",
    "\n",
    "test_list[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the process of getting several items from a list is called slicing\n",
    "# use a colon to delimit start and stop index positions in the list\n",
    "\n",
    "test_list[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can replace values in a list\n",
    "\n",
    "test_list[0] = 'Joe'\n",
    "test_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can add (concatenate) and multiply (replicate) lists\n",
    "\n",
    "test_list * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove values from a list with del\n",
    "\n",
    "del test_list[4]\n",
    "\n",
    "test_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can check if a value is in a list\n",
    "\n",
    "'Joe' in test_list or 'Bob' not in test_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For more advanced use, you can use lists for multiple assignment\n",
    "\n",
    "name, age, dude, pi_guess = test_list\n",
    "\n",
    "dude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Augmented Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# there are several operators that act as shortcuts for standard math operations\n",
    "\n",
    "meaning = 42\n",
    "\n",
    "# add to for numbers and strings\n",
    "\n",
    "meaning += 1\n",
    "meaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subtract from\n",
    "\n",
    "meaning = 42\n",
    "\n",
    "meaning -= 1\n",
    "meaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replicate values\n",
    "\n",
    "meaning = 42\n",
    "\n",
    "meaning *= 2\n",
    "meaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# divide values\n",
    "\n",
    "meaning = 42\n",
    "\n",
    "meaning /= 2\n",
    "meaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remainder value\n",
    "\n",
    "meaning = 42\n",
    "\n",
    "meaning %= 2\n",
    "meaning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists and Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can use for loops to iterate over lists\n",
    "\n",
    "for i in range(len(test_list)):\n",
    "    print(str(test_list[i]) + ' is index position ' + str(i) + ' in test_list.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are several method in Python for list manipulation\n",
    "\n",
    "test_list_3 = ['Billy', 'Jean', 'Jenny', 'Aaron', 'Zane', 'Jean', 'Larry']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# index will identify a list items first position in a list\n",
    "\n",
    "test_list_3.index('Jean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# append can add an item to the end of a list\n",
    "\n",
    "test_list_3.append('Jerry')\n",
    "test_list_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert adds a new list item in a designated index position\n",
    "\n",
    "test_list_3.insert(1, 'Patricia')\n",
    "test_list_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove does just what it sound like\n",
    "# if you have multiple items with same value, it removes only the first matching item\n",
    "\n",
    "test_list_3.remove('Jean')\n",
    "test_list_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sort will arrange items from lowest to highest or alphbetically (upper to lower)\n",
    "# sort only works on homogeneous data\n",
    "# kwargs are optional\n",
    "\n",
    "test_list_3.sort(reverse=False, key=str.upper)\n",
    "test_list_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Thanks to Dan Bader for this example\n",
    "\n",
    "A list comprehension is structured like this:\n",
    "\n",
    "vals = [expression \n",
    "        for value in collection \n",
    "        if condition]\n",
    "\n",
    "This is equivalent to:\n",
    "\n",
    "vals = []\n",
    "for value in collection:\n",
    "    if condition:\n",
    "        vals.append(expression)\n",
    "'''\n",
    "# Example:\n",
    "\n",
    "even_squares = [x * x for x in range(10) if not x % 2]\n",
    "even_squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuples are like lists except for 1) they use () and 2) they are immutable\n",
    "\n",
    "test_tuple_1 = ('Hello', 'Tuples', 1, 1.5)\n",
    "test_tuple_1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is very much like our string variables\n",
    "# difference being tuples are comma delimited\n",
    "\n",
    "a_string = 'a test string'\n",
    "a_string[2:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can convert from a list to a tuple\n",
    "\n",
    "tuple(test_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can convert from a tuple to a list\n",
    "\n",
    "list(test_tuple_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can convert a string into a list or tuple\n",
    "\n",
    "list(a_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can also create dictionary-like structures with names tuples\n",
    "# these are immutable and faster in some cases than dictionaries\n",
    "\n",
    "from collections import namedtuple\n",
    "\n",
    "Map = namedtuple('Map', 'lat lon name')\n",
    "my_map = Map(lat=38.038683, lon=-84.504279, name='Patterson Office Tower')\n",
    "\n",
    "my_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### References in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# When assigning a list to a variable, you are assigning a reference for the list to a variable\n",
    "\n",
    "test_list_4 = [1, 2, 3, 4, 5, 6]\n",
    "ref_list_a = test_list_4\n",
    "test_list_4[3] = 42\n",
    "print(test_list_4, ref_list_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets try this with simple immutable values (e.g., a string)\n",
    "\n",
    "test_a = 77\n",
    "test_b = test_a\n",
    "test_a = 45\n",
    "print(\"test_a is \" + str(test_a) + \" and test_b is \" + str(test_b) + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Keep this in mind when passing arguments into functions and the resultant effect of that data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to avoid this issue with mutable data structures, use the copy or deepcopy built-in module\n",
    "\n",
    "import copy # import deepcopy if your list contains list(s)\n",
    "\n",
    "test_list_4 = [1, 2, 3, 4, 5, 6]\n",
    "ref_list_a = copy.copy(test_list_4)\n",
    "test_list_4[3] = 42\n",
    "print(test_list_4, ref_list_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries are key/value combination where the index can be anything\n",
    "# Dictionaries are created with curly brackets\n",
    "# Key/Value Pairs are separated with a colon\n",
    "\n",
    "test_dict_1 = {'name': 'Joe', 'height': ['6', '4'], 'town': 'Lexington', 'current_year': 2018}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access a dictionary value via its key\n",
    "\n",
    "test_dict_1['height']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in Python versions  older than 3.6, dictionaries are unordered and require `OrderedDict`\n",
    "\n",
    "from collections import OrderedDict\n",
    "\n",
    "OrderedDict(test_dict_1)\n",
    "\n",
    "# if you want your code to work with other version of Python you have to do it like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# However, as of Python 3.6, ordered dictionaries is a language feature\n",
    "\n",
    "test_dict_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use keys() to obtain a list of keys from the dictionary\n",
    "\n",
    "test_dict_1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use values() to obtain a dictionaries values\n",
    "\n",
    "test_dict_1.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use items() to output the key/value pairs\n",
    "\n",
    "test_dict_1.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# notice that each of the outputs is a list\n",
    "# to obtain a pure list, use the list function on the output\n",
    "list(test_dict_1.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to search through dictionaries, use `in` and `not in`\n",
    "\n",
    "'name' in test_dict_1 # this is the same as test_dict_1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can search through a dictionary using get(key, return_value)\n",
    "\n",
    "test_dict_2 = {'Joe': ['UK', 'Student'], 'Michael': ['UK', 'Faculty'], 'Jack': ['UK', 'Faculty']}\n",
    "\n",
    "dict_search = input('Who are you looking for?')\n",
    "\n",
    "'Here is the information for ' + dict_search + ': ' + str(test_dict_2.get(dict_search, 'No one by that name is in the database.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to add a new key to a dictionary with a default value, use setdefault()\n",
    "\n",
    "test_dict_2.setdefault('Jeremy', 1)\n",
    "\n",
    "test_dict_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pretty Print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pprint will help make a dictionary and other outputs readable\n",
    "\n",
    "import pprint\n",
    "\n",
    "pprint.pprint(test_dict_2) # use pformat to output as string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nesting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionaries and lists can have other dictionaries and lists inside\n",
    "\n",
    "test_dict_3 = {'Matt': {'place': 'here', 'time': 1200},\n",
    "               'Rich': {'place': 'there', 'time': 600},\n",
    "               'Stan': {'place': 'out there', 'time': 1800}\n",
    "              }\n",
    "\n",
    "for k, v in test_dict_3.items(): # for each key, values in the dictionary's items\n",
    "    location = v.get('place', 'somewhere') # declare a location that contains an item's place, if no place return 'somewhere'\n",
    "    print(location)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time for Exercise 4!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<hr>\n",
    "\n",
    "## Additional Materials (for future versions)\n",
    "\n",
    "<hr>\n",
    "\n",
    "* [Python 2 to 3](https://medium.com/@boxed/moving-a-large-and-old-codebase-to-python3-33a5a13f8c99)\n",
    "* [Metaclasses](https://stackabuse.com/python-metaclasses-and-metaprogramming/)\n",
    "* [Python Async](https://www.aeracode.org/2018/02/19/python-async-simplified/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<hr>\n",
    "\n",
    "## Resources\n",
    "\n",
    "<hr>\n",
    "\n",
    "**Note:** A lot of the open-source materials are provided by people who develop those materials for a living. So please consider sending them a thank you and if you can, a few buck to support their efforts. Thanks! :)    \n",
    "\n",
    "* [Automate the Boring Stuff](https://automatetheboringstuff.com/)\n",
    "* [PSF Python Tutorial](https://docs.python.org/3/tutorial/index.html)\n",
    "* [Python Cheatsheet](https://www.pythoncheatsheet.org/)\n",
    "* [Python Patterns](https://github.com/faif/python-patterns)\n",
    "* [Jake VdP Python Class](https://github.com/jakevdp/WhirlwindTourOfPython)\n",
    "* [Oleksii's Learn Python](https://github.com/trekhleb/learn-python)\n",
    "* [Jerry's Learn Python3](https://github.com/jerry-git/learn-python3)\n",
    "* [Python for Social Scientists](https://nealcaren.github.io/python-tutorials/)\n",
    "* [Mode Analytics Python Tutorials](https://community.modeanalytics.com/python/)\n",
    "* [A to Z of Useful Python Tricks](https://medium.freecodecamp.org/an-a-z-of-useful-python-tricks-b467524ee747)\n",
    "* [Python and Async](https://www.aeracode.org/2018/02/19/python-async-simplified/)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}