Workshop-Intro-To-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## Part I: Basics of Python Programming\n",
    "\n",
    "This document is heavily based on the Python-Novice-Gapminder lesson developed by Software Carpentry, and the original lesson can be found online at http://swcarpentry.github.io/python-novice-gapminder/\n",
    "\n",
    "Throughout this Jupyter Notebook file, code and comments going through the lesson are already written. You should follow along and run code block by block; this is so that you have a version of the code that won't fail because of simple things like spelling mistakes or missing characters (which happens when you feverishly try to type what's happening up front). Don't worry; there will be opportunities to practice as we move along. If at any point when following along some pre-provided code fails, please don't hesitate to ask one of the instructors for help.\n",
    "\n",
    "A few more notes - unlike R, which we also have workshops in, Python is a general purpose programming language and has less conveniences than R does in terms of data analysis. This means that programming concepts such as loops and if-statements which we've usually not covered in R are far more important in Python. Still, in the interest of time, we're going to prioritize data analysis (specifically working with the `pandas` and `matplotlib` packages) before we move onto these other topics.\n",
    "\n",
    "Given that you are reading this in Jupyter notebook, the cell containing this text is called a Markdown cell; in contrast to a Code cell which will contain, you guessed it, our code. You can create a cell by clicking an existing cell above or below you want a cell, and then clicking on 'Insert' (near the top of this website), and then one of the corresponding options. Most people use Jupyter notebook and these cells to write a kind of interactive report that contains the code to perform the analysis of the report inside it; we'll be using it for some comments.\n",
    "\n",
    "You'll also need to know to click 'Run' to run the code in a cell. There are some useful keyboard shortcuts you can also use - Shift-Enter runs a cell, while Alt-Enter creates a new cell (shortcut may differ on Mac)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are other types of comments; this cell is a Code block and everything in here will be executed when you \n",
    "# run this cell. However, it's common in programming languages to write helpful messages to yourself and other\n",
    "# readers throughout the code that isn't meant to be executed. In Python we can create a comment by typing '#';\n",
    "# afterward everything on that line after the '#' will be ignored and not executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's start with some very simple math\n",
    "2 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you ran the cell above you should now see `4` as the output. One thing to note about Jupyter notebook cells is that it only displays the output of the last line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 3 # you never see the answer as there is code beneath this\n",
    "5 + 5 # last line; so you'll see 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you run the previous cell you'll see that we never get the answer for `3 + 3`; that's because it wasn't the output line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This isn't to say that the first lines don't get run; you just don't see the output\n",
    "x = 5\n",
    "x + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we ran two lines of code and both were run; we assigned `5` to the variable (think label) of 'x', and then we added 'x' (which is `5`) with `2` to get 7. `x = 5` was still run despite not being the last line.\n",
    "\n",
    "### Mathematical operations\n",
    "\n",
    "* Addition: use `+`\n",
    "* Subtraction: use `-`\n",
    "* Multiplication: use `*`\n",
    "* Division: use `/`\n",
    "* Power: use `**`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 2 # addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 - 2 # subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 * 2 # multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 / 2 # division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3**2 # 3 to the power of 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Order of operations in Python follow the same order of operations in algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Is this 3 + (2*3) = 9 or (3+2) * 3 = 15? \n",
    "3 + 2 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use parentheses to explicitly set the order\n",
    "(3 + 2) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables\n",
    "Just above we performed a variable assignment of `x = 5`; we can assign different types of values to different labels. The label name (or variable name) has a few rules though - it can only contain letters, digits, and the underscore; and it can't start with a digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "instructor_age = 25\n",
    "instructor_first_name = 'Joel'\n",
    "instructor_email = 'joelt@sfu.ca' # feel free to email any questions you might have later on"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we defined text using `'`; this is because if we just typed `instructor_first_name = Joel` then Python would look for a variable called `Joel` which we didn't define (and might store something unrelated like a number); so the quotes tell Python that we mean text. You can also define text using `\"`; Python treats it the same as `'` as long as the opening and closing quotes match.\n",
    "\n",
    "We can use the `print` function to display things on the screen (instead of just typing the variable name). `print` can also be used to overcome Jupyter's limitation with only displaying the last line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(instructor_age)\n",
    "print(instructor_email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here print takes several arguments to print all the things on the screen in the same line\n",
    "print(instructor_first_name, 'is', instructor_age, 'years old')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There were 4 'things' that we printed on the screen in the previous print statement; `instructor_first_name`, the text \"is\", `instructor_age`, and the text \"years old\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what happens if we try to use a variable that hasn't been defined. Pay attention to the error message; in the future you might misspell a variable name and seeing this error will be very informative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(instructor_last_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`name 'instructor_last_name' is not defined`; which makes sense as we never defined as last name variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice\n",
    "Define two variables called `my_age` and `my_first_name` with your age and first name. Use `print` to print a similar message I did above using your information.\n",
    "\n",
    "Remember that there are two instructors available to help if you need it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables have Types\n",
    "So far we've worked with just strings (text) and numbers, but there are many, many, other types of variables in Python. In this workshop today we're also going to work with datasets as variables and lists, but in general know that basically everything is a variable. Technically even functions are variables that we use. We can see the type of a variable by calling the `type` function on it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(instructor_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(instructor_first_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(print) # yes; print is technically a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously some operations between variables have different meaning depending on the types involved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "instructor_first_name - instructor_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I can't subtract a number from a string! Also pay attention to the error message as it describes exactly what we did wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some cases this is inconvenient, because a variable could be converted into another type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "other_age = '23' # note here I'm storing a number as text so we can't do math with it yet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can convert the types (if possible) using the `int`, `float`, or `str` functions. `float` turns something into a decimal number, while `int` only turns something into a whole number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "instructor_age - int(other_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "instructor_age - float(other_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(instructor_age) + other_age # just to show that adding strings together does"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "Strings (text) are common enough that they have special features. Here is some information about them.\n",
    "\n",
    "We can get the length of a string by using the `len` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "helper_first_name = 'Daniel'\n",
    "len(helper_first_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a 'slice' to get a part of the string. Here we use square brackets and say we want the zeroth up to (but not including) the 3rd character. This is a bit confusing; in Python when you have a numbered collection, such as a list or a string, the first element is element 0, the next one is element 1, and so on. \n",
    "\n",
    "D  A  N  I  E  L\n",
    "\n",
    "0  1  2  3  4  5\n",
    "\n",
    "`0:3` corresponds to asking for elements 0, 1, and 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "helper_first_name[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the first letter\n",
    "helper_first_name[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the last letter\n",
    "helper_first_name[len(helper_first_name) - 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "Why did we have to subtract 1 from the length to get the last letter? What would have happened if we didn't subtract 1?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Answer: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It turns out that Python has a shortcut with slices to go from some index to the end (or from the beginning to some index) by leaving one side of `:` blank. This way we could avoid typing something long like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "helper_first_name[3:len(helper_first_name)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With something short like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "helper_first_name[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or to get the beginning of the word\n",
    "helper_first_name[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods\n",
    "Most variables also have something called methods that are special functions that apply to that variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# upper turns it upper case\n",
    "helper_first_name.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lower case\n",
    "helper_first_name.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# swap case\n",
    "helper_first_name.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replace wherever 'iel' appears with 'ny'\n",
    "helper_first_name.replace('iel', 'ny')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "helper_first_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that these methods didn't actually modify `helper_first_name` but instead created a new string that we could have assigned to a new variable. Sometimes methods will modify their variable; other times they won't. It depends on the method and the object. For strings they won't modify it.\n",
    "\n",
    "We can look at the help function for a method by appending `?` (or using the `help` function) on a method, function, or variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Will bring up in Jupyter a help file\n",
    "?helper_first_name.replace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Will print the help file below the cell\n",
    "help(helper_first_name.replace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can look at the methods and sub-objects (attributes) available on a variable by using the `dir` command; ignore everything that starts with `_`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(helper_first_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's a lot of output here but if you look you can see the same functions we just used like `lower` and `upper`. We can then check the help files for whatever method looks useful, like we did for `replace`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice\n",
    "Using the `my_name` variable from the previous practice, experiment with:\n",
    "* Making your name upper case\n",
    "* Making your name lower case\n",
    "* Get just the first 2 letters of your name\n",
    "* Read the help page for the `count` method on strings and describe what it does. Try experimenting with it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "A function is a block of code which only runs when it is called.\n",
    "\n",
    "You can pass data, known as parameters, into a function.\n",
    "\n",
    "A function can return data as a result.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(instructor_first_name, 'is', instructor_age, 'years old')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(info)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some other helpful functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`max`, `min`, and `round`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can take a number of numbers directly\n",
    "print(max(5,3,8,2))\n",
    "print(min(5,3,8,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or can take a list of numbers\n",
    "some_numbers = [5.24,3.12,8.92,2.42]\n",
    "print(max(some_numbers))\n",
    "print(min(some_numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(round(6.7357))\n",
    "print(round(6.7357, 2))\n",
    "print(round(6.7357, -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Worth noting that round(some_numbers) won't work\n",
    "round(some_numbers) # will give error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For-loops can be helpful to apply a function to every item in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For-Loops\n",
    "Now that we have lists, we might want to do something to every item inside. As we saw with `round` it's not always easy. There we might want to round all the numbers and get a new list back. In other cases we might just want to *do* something with the items inside, say for example saying \"Hello\" to all the names in a list. Writing code to the same thing for element 0, element 1, ... manually is not feasible.\n",
    "\n",
    "There are two variants for for-loops; the simpler version is shown first.\n",
    "### Variant 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "instructors_friends = ['Daniel', 'Neil', 'Shaun']\n",
    "for friend in instructors_friends:\n",
    "    print(\"Hello\", friend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few things to note - \n",
    "1. We start a for loop with the `for` keyword\n",
    "2. We define a temporary variable (in this case `friend`) which will be each element from the list\n",
    "3. We use the `in` keyword to specify which list we're going to use\n",
    "4. We end that line with a `:`; this tells Python we're now going to start our code\n",
    "5. On the next line(s) we **indent** the code (either using a tab or spaces); this tells Python we're still in the for-loop. Once the indentation ends the for-loop ends. The length of the indentation doesn't matter; as long as its consistent in the entire loop.\n",
    "\n",
    "Here's an example of a for-loop with multiple lines to show the indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for friend in instructors_friends:\n",
    "    friend_upper_case = friend.upper()\n",
    "    print(\"Hello\", friend_upper_case)\n",
    "    print(\"Goodbye\", friend_upper_case)\n",
    "    print() # print blank line\n",
    "print(\"For-loop completed; this line is run after the for-loop finishes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many cases we might want to loop over a range of numbers, say from 1 to 100. We can use the `range` function to help with this instead of creating a long list. Note that `range(a, b)` runs from `a, a+1, a+2, ...., b-2, b-1`; `b` doesn't get included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_hundred = 0\n",
    "for i in range(1, 101):\n",
    "    sum_hundred = sum_hundred + i\n",
    "\n",
    "print(sum_hundred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember when we were working with `some_numbers` and we wanted to `round` each of them? We can use a for-loop to solve it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounded_some_numbers = []\n",
    "for number in some_numbers:\n",
    "    rounded_number = round(number)\n",
    "    rounded_some_numbers.append(rounded_number)\n",
    "    \n",
    "rounded_some_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variant 2\n",
    "\n",
    "It turns out that using for-loops to do something to everything in a list and then making a new list with that is so common that Python provides a special shortcut way of doing it. We use the list notation of square brackets to create a new list, but inside the list we instead have our command, followed by `for <variable> in <previous_list>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounded_some_numbers = [round(number) for number in some_numbers]\n",
    "rounded_some_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much easier than the previous method for this common case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice\n",
    "\n",
    "* Write a for-loop to loop through `some_numbers` and print the number on the screen. You'll have to use **Variant 1**.\n",
    "* Use a for-loop to create a new list containing each element of `some_numbers` divided by 5. Try to use **Variant 2**.\n",
    "* Let `x = [1, 2, 5, 8]` and `y = [2, 5, 9, 0]`. Write a for-loop that creates a new list that is the sum of each element of `x` and `y` (so your new list should show `[3, 7, 14, 8]`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries\n",
    "In Python there are libraries to provide extra functionality. You might have noticed that those built-in functions of `max`, `min`, and `round` are pretty basic; what about getting `sin` or `cos` to do some trigonometry? We can get these functions by importing the `math` library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First to show that sin won't work without math\n",
    "math.sin(3.14/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.pi)\n",
    "print(math.sin(math.pi/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once `import math` was called, every time we now call `math` it will work. Sometimes library names can get really long; we can use something called *aliasing* to replace the name with a shorter version. This is also convenient if two libraries share the same name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aliasing\n",
    "import math as m\n",
    "print(m.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you're getting tired of writing `m.` all the time; say we are going to use `sin` all throughout our calculations, then we can import specific items from a library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sin, pi\n",
    "sin(pi/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I know that I showed you 3 ways to import libraries and that it can be hard to remember all of them, so if you want permission to forget to one or two of them just remember the first way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***After*** importing a library we can use `dir` to see what methods it has available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also look at the help page for a library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice\n",
    "\n",
    "There's a library called `random` that can be used to generate random numbers. Import this package, look at its help file to find a function called `randint`, and use that function to generate a random number between 0 to 10. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User-Defined Functions\n",
    "\n",
    "Throughout this workshop there have been a few times where we've had to write our own code over and over again to do the same thing with only minor changes, like on a different dataset. For example, we converted the columns of a dataset to years by taking the last 4 characters and then converting it to an integer, and we did that again in the practice. \n",
    "\n",
    "Wouldn't it be nice if we could write it once then easily use it moving forward? That's what defining our own functions will help us do.\n",
    "\n",
    "First let's start with something simple, a function that takes a name as an argument and prints a greeting to that person.\n",
    "We start a function by writing `def`, the name of the function, and then parenthesis with the labels of all the parameters that are needed. We then have a `:`, and then the code we want to run is on later lines, indented like we did with for-loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Joel\n"
     ]
    }
   ],
   "source": [
    "def say_hello(name):\n",
    "    print('Hello', name)\n",
    "say_hello(\"Joel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes a function returns something back, like when we called math.sin we expected a number back.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5050"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count_up_to(n):\n",
    "    summation = 0\n",
    "    for i in range(0, n+1):\n",
    "        summation = summation + i\n",
    "    return summation\n",
    "count_up_to(10)\n",
    "count_up_to(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this function isn't calling print; we can save the output here for later use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2525.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_hundred = count_up_to(100)\n",
    "sum_hundred/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If-statements\n",
    "When we define our own functions we often want them to be flexible enough to handle different scenarios. We can use if-statements to define different 'paths' our code takes given different scenarios.\n",
    "\n",
    "We start with if, then some condition that returns either True or False (below we use the > symbol to do a comparison). A : then denotes when the code starts, and we then have those lines of code indented like we did with for-loops and custom functions.\n",
    "\n",
    "Below here I use a for-loop as an illustration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.54 is large\n",
      "9.22 is large\n"
     ]
    }
   ],
   "source": [
    "masses = [3.54, 2.07, 9.22, 1.86, 1.71]\n",
    "for m in masses:\n",
    "    if m > 3.0:\n",
    "        print(m, 'is large')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case we only do something when m is larger than 3.0; we can use `else` to specify what happens when the condition is not met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.54 is large\n",
      "2.07 is small\n",
      "9.22 is large\n",
      "1.86 is small\n",
      "1.71 is small\n"
     ]
    }
   ],
   "source": [
    "for m in masses:\n",
    "    if m > 3.0:\n",
    "        print(m, 'is large')\n",
    "    else:\n",
    "        print(m, 'is small')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use `elif` to specify additional conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.54 is large\n",
      "2.07 is small\n",
      "9.22 is HUGE\n",
      "1.86 is small\n",
      "1.71 is small\n"
     ]
    }
   ],
   "source": [
    "for m in masses:\n",
    "    if m > 9.0:\n",
    "        print(m, 'is HUGE')\n",
    "    elif m > 3.0:\n",
    "        print(m, 'is large')\n",
    "    else:\n",
    "        print(m, 'is small')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an if statement integrated in a custom function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sell_beer(true_customer_age):\n",
    "    if true_customer_age >= 19:\n",
    "        print('Would you like a receipt with that?')\n",
    "    elif true_customer_age >= 13:\n",
    "        print(\"That's clearly a fake ID\")\n",
    "    else:\n",
    "        print('Where are your parents?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Would you like a receipt with that?\n"
     ]
    }
   ],
   "source": [
    "sell_beer(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "That's clearly a fake ID\n"
     ]
    }
   ],
   "source": [
    "sell_beer(17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Where are your parents?\n"
     ]
    }
   ],
   "source": [
    "sell_beer(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice\n",
    "\n",
    "Define a function that takes a grade from 0 to 100 and returns a letter grade.\n",
    "* If the grade is less than 50, return an 'F'\n",
    "* If the grade is between 50 and 70, return a 'C'\n",
    "* If the grade is between 71 and 85, return a 'B'\n",
    "* If the grade is greater than 85, return an 'A'."
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}