03_probability_distributions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome to the Dark Art of Coding:\n",
    "## Introduction to Data Science Fundamentals\n",
    "Probability distributions and Combinations, Permutations, Factorials\n",
    "\n",
    "\n",
    "<img src='images/logos.3.600.wide.png' height='250' width='300' style=\"float:right\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main objectives\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will be able to:\n",
    "\n",
    "* Understand discrete probability distributions\n",
    "* Understand permutations and combinations, including:\n",
    "    * factorials\n",
    "    * calculating the number of arrangements of items\n",
    "    * examining permutations\n",
    "    * examining combinations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discrete Probability Distributions\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often, it is useful to simply understand the probability of an event. But sometimes it just isn't enough.\n",
    "\n",
    "For example, sometimes we need to know the consequences of a fairly likely event OR the results if an unlikely event occurs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start this conversation, let's consider a classic example: the three wheel slot machine that costs $0.20 to play:\n",
    "\n",
    "* A = Apple\n",
    "* O = Orange\n",
    "* Q = Quarter\n",
    "\n",
    "|Combination|Payout|Gain/Loss|\n",
    "|:---|:---||\n",
    "|A . A . A|\\$4|\\$3.80|\n",
    "|(in any order) > A . A . O|\\$3|\\$2.80|\n",
    "|O . O . O|\\$2|\\$1.80|\n",
    "|Q . Q . Q|\\$1|\\$0.80|\n",
    "|All other combinations|\\$0|-\\$0.20|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The probability to get any single symbol is as follows:\n",
    "\n",
    "* A = 0.1\n",
    "* O = 0.2\n",
    "* Q = 0.2\n",
    "* all other symbols = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Combination|Payout|Gain/Loss|Probability|\n",
    "|:---|:---|:---||\n",
    "|A . A . A|\\$4|\\$3.80|$0.1 \\times 0.1 \\times 0.1 = $|0.001|\n",
    "|A . A . O|\\$3|\\$2.80|$(0.1 \\times 0.1 \\times 0.2) + (0.1 \\times 0.2 \\times 0.1) + (0.2 \\times 0.1 \\times 0.1) = $|0.006|\n",
    "|O . O . O|\\$2|\\$1.80|$0.2 \\times 0.2 \\times 0.2 =$| 0.008|\n",
    "|Q . Q . Q|\\$1|\\$0.80|$0.2 \\times 0.2 \\times 0.2 =$| 0.008|\n",
    "|All other combinations|\\$0|-\\$0.20|$1 - 0.001 - 0.006 - 0.008 - 0.008 =$| 0.977|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we translate the gain/loss, to a result (labeled x), we can assign the probability of getting any specific result.\n",
    "\n",
    "|Combination|P(X = x)|x|\n",
    "|:---|:---|:---||\n",
    "|A . A . A|0.001|\\$3.80|\n",
    "|A . A . O|0.006|\\$2.80|\n",
    "|O . O . O|0.008|\\$1.80|\n",
    "|Q . Q . Q|0.008|\\$0.80|\n",
    "|All other combinations|0.977|-\\$0.20|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we mentioned... What this means is that the probability of earning \\$3.80 is one in a thousand.\n",
    "The probability of losing \\$0.20 is 977 in a thousand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expectation:\n",
    "\n",
    "The question that often comes to mind is... sure, I get that on any given trial, I might lose, I might win, but is there a way to average out my wins/losses? Well, yes, there is a way to calculate your expected wins and losses over time OR a large number of trials."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called **Expectation**. Expectation of a random variable **X** is much like the mean we explored earlier AND you use a similar process to calculate it:\n",
    "\n",
    "Multiply the value **x** by the **probability of x** and sum the results:\n",
    "\n",
    "$E(X) = \\sum \\ x \\ P(X = x)$\n",
    "\n",
    "**Note**: random variables (this collection of values), such as **X** are often identified with capital letters. Generally the individual values that the variable can take are denoted with a lower case **x**\n",
    "\n",
    "**Note**: in later cells, we will refer to $E(X)$ as $\\mu$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Combination|P(X = x)|x|Result|\n",
    "|:---|:---|:---|||\n",
    "|A . A . A|0.001|\\$3.80|0.0038|\n",
    "|A . A . O|0.006|\\$2.80|0.0168|\n",
    "|O . O . O|0.008|\\$1.80|0.0144|\n",
    "|Q . Q . Q|0.008|\\$0.80|0.0064|\n",
    "|All other combinations|0.977|-\\$0.20|-0.1954|\n",
    "|||**$\\mu$**|**-0.1604**|\n",
    "\n",
    "Which means that overall, everytime you play, you can expect to **lose an average of $0.16** for every game you play."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we discussed means, earlier, we also noted that often it is useful to understand how widely the results might deviate from the expected values. Two measures that we looked at for typical dataset were the variance and the standard deviation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variance of a probability distribution (X) is the expectation of $(X - \\mu)^2$\n",
    "\n",
    "$Var(X) = E(X - \\mu)^2 = \\sum (x - \\mu)^2 P(X \\ = \\ x)$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Combination|P(X = x)|x|Result|x - $\\mu$|\n",
    "|:---|:---|:---||||\n",
    "|A . A . A|0.001|\\$3.80|0.0038|3.8 - (-0.1604) = 3.9604|\n",
    "|A . A . O|0.006|\\$2.80|0.0168|2.8 - (-0.1604) = 2.9604|\n",
    "|O . O . O|0.008|\\$1.80|0.0144|1.8 - (-0.1604) = 1.9604|\n",
    "|Q . Q . Q|0.008|\\$0.80|0.0064|0.8 - (-0.1604) = 0.9604|\n",
    "|All other combinations|0.977|-\\$0.20|-0.1954|-0.2 - (-0.1604) = -0.0396|\n",
    "|||**$\\mu$**|**-0.1604**||\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking the results of $ x - \\mu$ and squaring them... yada\n",
    "\n",
    "|Combination|P(X = x)|x - $\\mu$|(x - $\\mu$)$^2$|Result|\n",
    "|:---|:---|:---||||\n",
    "|A . A . A|0.001|3.9604|15.6848|0.001 * 15.6848 = 0.0157|\n",
    "|A . A . O|0.006|2.9604|8.7640|0.006 * 8.7640 = 0.0526|\n",
    "|O . O . O|0.008|1.9604|3.8432|0.008 * 3.8432 = 0.0307|\n",
    "|Q . Q . Q|0.008|0.9604|0.9224|0.008 * 0.9224 = 0.0074|\n",
    "|All other combinations|0.977|-0.0396|0.00157|0.977 * 0.00157 = 0.0015|\n",
    "||||**Variance:**|0.1079|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Standard Deviation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard deviation is simply the square root of the variance:\n",
    "    \n",
    "$\\sigma = \\sqrt {Var(X)}$   \n",
    "\n",
    "The standard deviation is: 0.328"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wait... how do we code all that...\n",
    "\n",
    "There is a lot going on in this example. We leave it to you to create a snippet of code to calculate the Expectation, the Variance and Standard Deviation for a small number of input values.\n",
    "\n",
    "## scipy.stats field trip\n",
    "\n",
    "Instead, let's take a quick look at a source of professionally developed tools that can help you... let's go on a field trip:\n",
    "\n",
    "A useful resource to turn to are the statistical methods found in the [scipy.stats library](https://docs.scipy.org/doc/scipy-0.19.1/reference/stats.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More to study!\n",
    "\n",
    "As you grow more familiar with the idea of discrete probability distributions, a concept you will want to follow-up on is the idea of linear transforms...\n",
    "\n",
    "What does that mean?\n",
    "\n",
    "Say the expected gains and losses change? We double or trip the costs. We multiply the payouts by 3, 4 or 5. That will change our formula outputs and affect the mean or Expectation and thus the Variance and Standard Deviation. Understanding linear transforms will help you to deal with this simply and easily without having to recalculate all the values.\n",
    "\n",
    "Now... let's change topics for a bit..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combinations & Permutations with a sprinkling of Factorials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In looking at the sample space... a primary concern is being able to accurately identify or calculate the number of arrangements of items. In the previous example, we glossed over this when we mentioned that all arrangements of Apple, Apple, Orange impacted the probability of that event.\n",
    "\n",
    "In the case of the Apple, Apple, Orange slot machine result, it was fairly easy to find a quick solution.\n",
    "\n",
    "Other cases may not be so easy: two difficulties that we run into include:\n",
    "\n",
    "* dealing with duplicates\n",
    "* arranging by individual items versus types of items\n",
    "\n",
    "To help us with calculating the number of arrangements in a sample space, we will look at factorials, permutations and combinations (with and without replacement)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Factorials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **factorial** is the product of every whole number from `n` to 1. Factorials are written in the following manner:\n",
    "\n",
    "$\\Large n!$\n",
    "\n",
    "For example:\n",
    "\n",
    "$\\Large 2! = 2 \\times 1 = 2$\n",
    "\n",
    "$\\Large 3! = 3 \\times 2 \\times 1 = 6$\n",
    "\n",
    "$\\Large 4! = 4 \\times 3 \\times 2 \\times 1 = 24$\n",
    "\n",
    "$\\Large 10! = 10 \\times 9 \\times 8 \\times 7 \\times 6 \\times 5 \\times 4 \\times 3 \\times 2 \\times 1 = 3628800$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Factorials present an easy way to write certain large numbers and are often used in statistics, especially in terms of calculating permutations and combinations.\n",
    "\n",
    "A great attribute of factorials is that when performing math with factorials, you can often simplify your work greatly if you need to do things by hand OR want to get a rough order of magnitude. In this example, the :\n",
    "\n",
    "$\\Large \\frac{5!}{3!} = \\frac{5 \\times 4 \\times 3 \\times 2 \\times 1}{3 \\times 2 \\times 1} = \\frac{5 \\times 4}{1}  = 20$\n",
    "\n",
    "$\\Large \\frac{5!  \\times 4!}{3! \\times 2!} =\n",
    " \\frac{5 \\times 4 \\times 3 \\times 2 \\times 1}{3 \\times 2 \\times 1 } \\times \\frac{4 \\times 3 \\times 2 \\times 1 }{\\times 2 \\times 1}\n",
    "      {} = \\frac{5 \\times 4}{1} \\times \\frac{4 \\times 3}{1} = 20 \\times 12 = 240$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    '''Return the factorial of a given integer input.'''    \n",
    "    \n",
    "    if n == 1:\n",
    "        return 1\n",
    "    elif n >= 2:\n",
    "        return n * factorial(n - 1)\n",
    "    elif n == 0:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "factorial(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "factorial(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Real world solution**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Warning... as noted above... the code snippets here (using a roll-your-solution) are not robust and should not be relied upon for anything requiring speed or performance is the if performance is goal, but can certainly be useful to learn new things.\n",
    "\n",
    "Some issues that affect factorials:\n",
    "\n",
    "On some computing hardware, the size of an integer may be limited... \n",
    "* integers on 32-bit hardware max out around 12!\n",
    "* integers on 64-bit hardware max out around 20!\n",
    "\n",
    "Floating point representations/approximations of values and other techniques can sometimes be used to get past these limits.\n",
    "\n",
    "To improve speeds, some implementations will simply do lookups for fairly small factorials, versus computing them.\n",
    "\n",
    "Formulas such as Stirling's formula can approximate large values.\n",
    "\n",
    "Some implementations use a divide and conquer approach.\n",
    "\n",
    "Let's take a quick look at my roll-your-own versus the implementation in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import factorial as f\n",
    "\n",
    "f(4)        # returns 4, as expected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's cut both functions loose on a mid-size factorial and see how they do, performance-wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit factorial(40)    # my version\n",
    "\n",
    "# Performance when writing this tutorial (your mileage may vary)\n",
    "# 7.28 µs ± 179 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit f(40)            # builtin version\n",
    "\n",
    "# Performance when writing this tutorial (your mileage may vary)\n",
    "# 363 ns ± 10.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Permutations and Combinations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definitions:\n",
    "\n",
    "**permutations (w/o replacement)**: number of ways to arrange a subset of objects from a finite set of distinct objects. In permutations, order is important and once an object has been used, it is not used again. Examples include: how many ways can you arrange four out of five books on a shelf, how many ways can three out of 10 horses cross the finish line? \n",
    "\n",
    "$\\Large\\frac{n!}{(n - k)!}$\n",
    "\n",
    "**combinations**: number of subsets of objects from a finite set of distinct objects. In combinations, order is not important and objects are not replaced. Examples include: items in a salad (lettuce, tomatoes, dressing, croutons), picking players to be on the floor in a basketball game.\n",
    "\n",
    "$\\Large\\frac{n!}{k!(n - k)!}$\n",
    "\n",
    "**product**: is much like permutations, where order matters AND includes the replacement of objects back into the pool. Examples include: all possible sequences for a lock where the numbers can be reused, all possible selections of ball from a lottery cage, where the balls are replaced.\n",
    "\n",
    "$\\Large n^k$\n",
    "\n",
    "**combinations with replacement**: is the same as combinations, but includes the replacement of the objects back in the pool.\n",
    "\n",
    "$\\Large\\frac{(k + n - 1)!}{k!(n - 1)!}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "||Without replacement|With replacement|\n",
    "|:-|:-|:-|\n",
    "|**Order matters**|permutations|product???|\n",
    "|**Order doesn't matter**|combinations|combinations with repl.|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the above formula to calculate how many items are in each of these possible categories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Permutations\n",
    "\n",
    "factorial(3) / factorial(3 - 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combinations\n",
    "\n",
    "factorial(3) / (factorial(2) * factorial(3 - 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prod\n",
    "\n",
    "3 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combs with rep...\n",
    "\n",
    "factorial(2 + 3 - 1) / (factorial(2) * factorial(3 - 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This worked fine to give us the counts, but what if we needed to see OR use the actual arrangements?\n",
    "\n",
    "Python has a module in the Standard Library, called `itertools` that can help create each of the arrangements in any category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "l = [1, 2, 3]\n",
    "\n",
    "print('Permutations:', list(itertools.permutations(l, 2)))\n",
    "print('Combinations:', list(itertools.combinations(l, 2)))\n",
    "\n",
    "print('Product w/ R:', list(itertools.product(l, repeat=2)))\n",
    "print('Combin. w/ R:', list(itertools.combinations_with_replacement(l, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some practical application"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does all this mean, anyway... thus far in our earlier examples we generally just focused on a specific event OR events in a sample space:\n",
    "\n",
    "* probability of drawing an Ace of Hearts from a standard 52-card deck\n",
    "* probability of rolling an even number on a d20\n",
    "\n",
    "Sadly, much of probability is not that simple..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, in a superhero foot race, how many different ways can the superheroes cross the finish line would be an example of looking at a problem where order matters:\n",
    "\n",
    "||First, Second, Third|\n",
    "|:--|:--|\n",
    "|Order 1|iron man, black widow, black panther|\n",
    "|Order 2|iron man, black panther, black widow|\n",
    "|Order 3|black widow, iron man, black panther|\n",
    "|Order 4|black widow, black panther, iron man|\n",
    "|Order 5|black panther, iron man, black widow|\n",
    "|Order 6|black panther, black widow, iron man|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use our newfound skills to calculate something similar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "heroes = ['iron man', 'black widow', 'black panther', 'captain america']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we will look at all the possible outcomes and count those outcomes:\n",
    "\n",
    "* What are the possible orderings (permutations)?\n",
    "* How many possible ordering are there (i.e. what is the size of the sample space)?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we can find out how many possible outcomes are available by using our function `factorial()`, but this is somewhat limiting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(factorial(len(heroes)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is somewhat limiting in that we don't know the order of the items and such.\n",
    "\n",
    "To actually get the ordering:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: pretty printing as provided by the module pprint is useful to align some data types when they are printed to screen. \n",
    "\n",
    "import pprint as pp\n",
    "\n",
    "S = list(itertools.permutations(heroes, 2))\n",
    "pp.pprint(S)\n",
    "print()\n",
    "print('Total number of permutations:', len(S))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = list(itertools.combinations(heroes, 2))\n",
    "pp.pprint(S)\n",
    "print()\n",
    "print('Total number of combinations:', len(S))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = list(itertools.product(heroes, repeat=2))\n",
    "pp.pprint(S)\n",
    "print()\n",
    "print('Total number of product arrangements:', len(S))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = list(itertools.combinations_with_replacement(heroes, 2))\n",
    "pp.pprint(S)\n",
    "print()\n",
    "print('Total number of combinations_with_replacement:', len(S))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experience Points\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complete the following exercises:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the following arrangements of objects, taken 3 at a time, using a list of five animals as an input:\n",
    "\n",
    "`animals = ['fox', 'cat', 'dog', 'owl', 'alligator']`\n",
    "\n",
    "* Permutations\n",
    "* Combinations\n",
    "* Product\n",
    "* Combinations w/ Replacement\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you (and your partner, if you're working in pairs) are done, then you can put your green sticky up! This is how we know you're done.\n",
    "\n",
    "<img src='images/green_sticky.300px.png' width='200' style='float:left'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resources\n",
    "\n",
    "* [Python Statistics Module](https://docs.python.org/3/library/statistics.html)\n",
    "* [numpy library](https://www.numpy.org/devdocs/reference/index.html)\n",
    "* [scipy library](https://docs.scipy.org/doc/scipy/reference/index.html)\n",
    "* [pandas library](http://pandas.pydata.org/pandas-docs/stable/)"
   ]
  },
  {
   "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
}