data-science-fundamentals-completed-2018.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "![ADSA Logo](http://i.imgur.com/BV0CdHZ.png?2 \"ADSA Logo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spring 2018 ADSA Workshop - Data Science Fundamentals Series: Numpy, Statistics and Probability\n",
    "\n",
    "Workshop content adapted from:\n",
    "* https://github.com/ADSA-UIUC/PythonWorkshop_2\n",
    "* [Data Science from Scratch - First Principles with Python](http://www.amazon.com/Data-Science-Scratch-Principles-Python/dp/149190142X/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This workshop dives into data science fundamentals - statistics and probability. We will talk about the following topics:\n",
    "* How to use NumPy\n",
    "* Linear Algebra\n",
    "* Statistics\n",
    "* Histograms\n",
    "* Probability with Python\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An Introduction to NumPy\n",
    "\n",
    "NumPy (or Numerical Python), is part of a great set of free scientific computing libraries called SciPy that provide mathematical and numerical functions that work very fast. NumPy is like MATLAB, and you can use it to create very powerful arrays and matrices, and it also has various kinds of optimization algorithms and linear algebra functions that are very useful for data science and analytics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's import numpy to use some of its functions\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The central feature of NumPy is the array object class. Arrays are similar to lists in Python, except that every element of an array must be of the same type, typically a numeric type like `float` or `int`. Arrays make operations with large amounts of numeric data very fast and are generally much more efficient than lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5 8]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 4, 5, 8]\n",
    "a = np.array(my_list)\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array elements are accessed, sliced, and manipulated just like lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "[1 4]\n",
      "[5 4 5 8]\n"
     ]
    }
   ],
   "source": [
    "# accessing elements of the array using an index\n",
    "# return the 4th element in the array (0-indexed!)\n",
    "print(a[3])\n",
    "\n",
    "# accessing multiple continuous elements of the array, also called slicing\n",
    "print(a[:2])\n",
    "\n",
    "# modifying elements of the array\n",
    "a[0] = 5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the type of a is **`ndarray`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that numpy can handle multi-dimensional arrays. Let's create a 2-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array( [[1, 2, 3], [4, 5, 6]] )\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# access the element is the first row, second column\n",
    "print(b[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 6]\n"
     ]
    }
   ],
   "source": [
    "# slice the array and access only the 3rd column\n",
    "print(b[:, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **`shape`** property returns the size of each dimension of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,)\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(a.shape)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **`in`** statement can be used to check if values are present in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(3 in b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(7 in a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays can be reshaped to different dimension sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]\n",
      "(10,)\n"
     ]
    }
   ],
   "source": [
    "a = np.array(range(10), float)\n",
    "print(a)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1.]\n",
      " [2. 3.]\n",
      " [4. 5.]\n",
      " [6. 7.]\n",
      " [8. 9.]]\n",
      "(5, 2)\n"
     ]
    }
   ],
   "source": [
    "# reshape (10,) array to (5,2)\n",
    "a = a.reshape((5, 2))\n",
    "print(a)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create special matrices in NumPy too! Remember that they are still referred to as arrays in NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# create the identity 2-dimensional array of shape (4,4)\n",
    "i = np.identity(4)\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# create a (3,3) array with all ones\n",
    "o = np.ones((3,3))\n",
    "print(o)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even do math operations on these arrays. All of the operations below happen element-wise. To do matrix multiplication and other matrix-specific math, we will have to use NumPy's linear algebra functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n",
      "[5. 2. 6.]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3], float)\n",
    "b = np.array([5,2,6], float)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6. 4. 9.]\n"
     ]
    }
   ],
   "source": [
    "print(a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-4.  0. -3.]\n"
     ]
    }
   ],
   "source": [
    "print(a - b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5.  4. 18.]\n"
     ]
    }
   ],
   "source": [
    "print(a * b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5. 1. 2.]\n"
     ]
    }
   ],
   "source": [
    "print(b / a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  5.   4. 216.]\n"
     ]
    }
   ],
   "source": [
    "print(b ** a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "## Linear Algebra: Vectors\n",
    "\n",
    "Linear Algebra is very important in the context of data science. It provides concepts and structures that allow data scientists to efficiently represent data, and do various computations with them. There are two structures that we will talk about today, **vectors** and **matrices**.\n",
    "\n",
    "Abstractly, vectors are objects that can be added together (to form new vectors) and that can be multiplied by scalars (i.e., numbers), also to form new vectors.\n",
    "\n",
    "For example, if you have the heights, weights, and ages of a large number of people, you can treat your data as three-dimensional vectors `(height, weight, age)`. If youâre teaching a class with four exams, you can treat student grades as four-dimensional vectors `(exam1, exam2, exam3, exam4)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 70 170  40]\n"
     ]
    }
   ],
   "source": [
    "mike_data = np.array([70,  # inches,\n",
    "                      170, # pounds,\n",
    "                      40   # years\n",
    "                     ])\n",
    "print(mike_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To begin with, weâll frequently need to **add** two vectors. Vectors add componentwise. This means that if two vectors v and w are the same length, their sum is just the vector whose first element is `v[0] + w[0]`, whose second element is `v[1] + w[1]`, and so on. (If theyâre not the same length, then weâre not allowed to add them.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[142 362  71]\n"
     ]
    }
   ],
   "source": [
    "# create a second vector with Adam's data\n",
    "adam_data = np.array([72, 192, 31])\n",
    "\n",
    "print(mike_data + adam_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly we can **subtract** vectors too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -2 -22   9]\n"
     ]
    }
   ],
   "source": [
    "print(mike_data - adam_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weâll also need to be able to multiply a vector by a **scalar**, which we do simply by multiplying each element of the vector by that number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[165.6 441.6  71.3]\n"
     ]
    }
   ],
   "source": [
    "print(2.3 * adam_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A less obvious tool is the **dot** product. The dot product of two vectors is the sum of their componentwise products. The mathematical computation for $v \\cdot w$ looks like this: $v_1 w_1 + v_2 w_2 + \\dots + v_n w_n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38920\n"
     ]
    }
   ],
   "source": [
    "print(mike_data.dot(adam_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot product measures how far the vector `v` extends in the `w` direction. For example, if `w = [1, 0]` then `dot(v, w)` is just the first component of `v`. Another way of saying this is that itâs the length of the vector you would get if you projected `v` onto `w`.\n",
    "![Dot Product Graph](http://i.imgur.com/jPBLBEK.png?1)\n",
    "\n",
    "Finally, we need to be able to compute the **magnitude** of a vector. In graphical terms, it is just the length of the vector. The mathematical computation for the magnitude of a vector `v` is:\n",
    "$\\sqrt{v_1 ^ 2 + v_2 ^ 2 + \\dots + v_n ^ 2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188.1488772222678\n"
     ]
    }
   ],
   "source": [
    "# print magnitude of mike_data\n",
    "print(np.sqrt(mike_data[0]**2 + mike_data[1]**2 + mike_data[2]**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188.1488772222678\n"
     ]
    }
   ],
   "source": [
    "# another way to compute the magnitude of a vector\n",
    "print(np.sqrt(mike_data.dot(mike_data)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "## Linear Algebra: Matrices\n",
    "\n",
    "A matrix is a two-dimensional collection of numbers. We will represent matrices as `lists` of `lists`, with each inner list having the same size and representing a row of the matrix. If `A` is a matrix, then `A[i][j]` is the element in the `i`th row and the `j`th column. Per mathematical convention, we will typically use capital letters to represent matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      " [[ 1  2]\n",
      " [ 5  6]\n",
      " [14 15]]\n",
      "\n",
      "Matrix B:\n",
      " [[ 4  5  6]\n",
      " [ 8  9 10]]\n"
     ]
    }
   ],
   "source": [
    "mat_a = np.array( [[1, 2], [5, 6], [14, 15]] )\n",
    "mat_b = np.array( [[4, 5, 6], [8, 9, 10]] )\n",
    "\n",
    "print(\"Matrix A:\\n\", mat_a)\n",
    "print(\"\\nMatrix B:\\n\", mat_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find out what the dimensions (number of rows vs. number of columns) of a matrix are, we can use the Numpy shape property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A shape:  (3, 2)\n",
      "Matrix B shape:  (2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(\"Matrix A shape: \", mat_a.shape)\n",
    "print(\"Matrix B shape: \", mat_b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices will be important to us for several reasons.\n",
    "\n",
    "First, we can use a matrix to represent a data set consisting of multiple vectors, simply by considering each vector as a row of the matrix. For example, if you had the heights, weights, and ages of 1,000 people you could put them in a 1,000 Ã 3 matrix:\n",
    "\n",
    "    data = [[70, 170, 40],\n",
    "            [65, 120, 26],\n",
    "            [77, 250, 19],\n",
    "            # ....\n",
    "            ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A differentiating feature of matrices is an operation called transpose. This swaps elements of the matrix along the leading diagonal. It can be thought of as an operation that makes all the rows - columns, and all the columns - rows. Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      " [[ 1  2]\n",
      " [ 5  6]\n",
      " [14 15]]\n",
      "\n",
      "Matrix A Transposed:\n",
      " [[ 1  5 14]\n",
      " [ 2  6 15]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Matrix A:\\n\", mat_a)\n",
    "print(\"\\nMatrix A Transposed:\\n\", mat_a.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can run similar mathematical operations with matrices, like we did with vectors.\n",
    "\n",
    "**Adding** and **subtracting** matrices (matrices need to have similar shapes):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: operands could not be broadcast together with shapes (3,2) (2,3) \n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(mat_a + mat_b) # will throw an error\n",
    "except ValueError as e:\n",
    "    print(\"Error:\", e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5 10]\n",
      " [10 15]\n",
      " [20 25]]\n"
     ]
    }
   ],
   "source": [
    "print(mat_a + mat_b.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Element-wise multiplication**, which returns a matrix of the same dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  4  16]\n",
      " [ 25  54]\n",
      " [ 84 150]]\n"
     ]
    }
   ],
   "source": [
    "print(mat_a * mat_b.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Matrix multiplication** is a more complex calculation, which computes a dot product of the rows of the first matrix and the columns of the second matrix, to return a new matrix. You can learn more about matrix multiplication at [Khan Academy â Basic Matrix operations](http://www.khanacademy.org/math/algebra/algebra-matrices) and [Khan Academy â Linear Algebra](http://www.khanacademy.org/math/linear-algebra)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "## Statistics\n",
    "\n",
    "Along with managing sets of data, python and numpy give you the tools to describe your set of data. \n",
    "\n",
    "Ways to describe data sets:\n",
    "* Length\n",
    "* Max/Min\n",
    "* Mean, Median, Mode\n",
    "* Dispersion (Spread) of values\n",
    "* Standard Deviation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "basic_list = [14, 7, 15, 7, 3, 5, 6, 8, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length:  9\n"
     ]
    }
   ],
   "source": [
    "print(\"length: \", len(basic_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min:  3\n",
      "max:  15\n"
     ]
    }
   ],
   "source": [
    "print(\"min: \", min(basic_list))\n",
    "print(\"max: \", max(basic_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average:  8.333333333333334\n"
     ]
    }
   ],
   "source": [
    "def mean(x):\n",
    "    return sum(x) / len(x)\n",
    "\n",
    "print(\"average: \", mean(basic_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also easily sort lists with sorted(), which helps when defining central tendencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original:  [14, 7, 15, 7, 3, 5, 6, 8, 10]\n",
      "sorted:    [3, 5, 6, 7, 7, 8, 10, 14, 15]\n"
     ]
    }
   ],
   "source": [
    "print(\"original: \", basic_list)\n",
    "sorted_list = sorted(basic_list)\n",
    "print(\"sorted:   \", sorted_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you already have a sorted list, you can use indexes to get the min/max values: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min:  3\n",
      "Max:  15\n"
     ]
    }
   ],
   "source": [
    "print(\"Min: \", sorted_list[0])\n",
    "print(\"Max: \", sorted_list[-1]) # 1st from last"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otherwise you can also use the `min` and `max` functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min:  3\n",
      "Max:  15\n"
     ]
    }
   ],
   "source": [
    "print(\"Min: \", min(basic_list))\n",
    "print(\"Max: \", max(basic_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finding the median is a little less straightforward, just depends on whether length is even or odd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def median(v):\n",
    "    n = len(v)\n",
    "    sorted_v = sorted(v)\n",
    "    midpoint = n // 2 # the '//' makes sure result is an int\n",
    "    if n % 2 == 1: # if odd, return the middle value\n",
    "        return sorted_v[midpoint]\n",
    "    else: # if even, return the average of the middle values\n",
    "        lo = midpoint - 1\n",
    "        hi = midpoint\n",
    "        return((sorted_v[lo] + sorted_v[hi]) / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Median:  7\n"
     ]
    }
   ],
   "source": [
    "print(\"Median: \", median(basic_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quantile of a data set returns the pth percentile value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quantile(x, p):\n",
    "    p_index = int(p * len(x))\n",
    "    return sorted(x)[p_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st Quartile (25th Percantile):  6\n",
      "3rd Quartile (75th Percantile):  10\n"
     ]
    }
   ],
   "source": [
    "print(\"1st Quartile (25th Percantile): \", quantile(basic_list, .25))\n",
    "print(\"3rd Quartile (75th Percantile): \", quantile(basic_list, .75))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def IQR(x): #IQR - interquartile range\n",
    "    return quantile(x, 0.75) - quantile(x, 0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interquartile Range:  4\n"
     ]
    }
   ],
   "source": [
    "print(\"Interquartile Range: \", IQR(basic_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the many simple statistical functions you can write yourself, numpy gives you access to a lot more, including the common ones from above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standard Deviation:  3.7712361663282534\n"
     ]
    }
   ],
   "source": [
    "print(\"Standard Deviation: \", np.std(basic_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation between x and y: \n",
      " [[1.         0.46158177]\n",
      " [0.46158177 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "x = [14, 7, 15, 7, 3, 5, 6, 8, 10]\n",
    "y = [44, 3, 7, 2, 17, 5, 3, 11, 14]\n",
    "print(\"Correlation between x and y: \\n\", np.corrcoef(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histograms\n",
    "Histograms are a diagram consisting of rectangles whose area is proportional to the frequency of a variable and whose width is equal to the class interval. They are a very useful tool in visualizing data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 2, 1]), array([0, 1, 2, 3]))\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.mlab as mlab\n",
    "\n",
    "data = [1,2,1]\n",
    "bins = [0,1,2,3]\n",
    "x = np.histogram(data, bins)\n",
    "print(x) #output is a tuple of the number of occurences in each bin and the bins. \n",
    "        #x[0] is the frequency of each bin, x[1] is the range of each bin. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What are bins? For this example, we have 3 bins. Ranging from 0 to 1, 1 to 2, and 2 to 3, respectively. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEWCAYAAABliCz2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAE35JREFUeJzt3X+0ZWV93/H3hwEd4I7QlFH56cRK\nbyBYEMYfCavtDMUsBGO0bUxMpK2NmaT+qFZtROuKmsRV2xUNtWZVaTQqJtgxiDUYiVi5WFsTdBAZ\nEMe6dCwwFLSKw+WHODPf/nH29F7h/jh3uPvuOzzv11pncfY5z97P9z6L+Zx9nrPPc1JVSJIe/Q4Z\nugBJ0sow8CWpEQa+JDXCwJekRhj4ktQIA1+SGmHgS0CS6SRPHroOqU8GvgaV5J8l2Z7kviT/J8l/\nSnL0MvdRSZ7ykMfekuTD+7eraqKqvrnIcTYluW05a5NWkoGvwSR5LfDvgH8NHAU8C3gScHWSxxzA\n8Q5d3gpXVpI1Q9egRzcDX4NI8jjgrcArq+qqqvpRVe0EXsgo9F/ctftAkt+btd+PnWUn2Znk9Ulu\nBO490NCf/S4gyflJvprkniS3J3ldkiOBTwHHddM/00mOS/LYJBcn2dXdLk7y2FnH/a0kd3TPvfQh\n/Xyge0fzF0nuBTYnuSDJl5PsTnJrkrfMOtaGbv+XdM99P8lvJnl6khuT3J3k3Qfy96sNBr6G8rPA\nWuBjsx+sqmlGwfrsJRzrRcAFwNFVtWcZansf8BtVtQ44DfhsVd0LPAfY1U3/TFTVLuDfMHpncgZw\nOvAM4E0ASc4DXgOcCzwF+Ptz9PUrwNuAdcDngXuBfwIc3f1N/yLJ8x+yzzOBk4FfAi7uajgX+Gng\nhUnm6kcy8DWYY4DvzhPQd3TPj+tdVXVrVd2/QJvruzPgu5PcDVy0QNsfAacmeVxVfb+qrl+g7a8C\nv1NVd1XVdxi9a7mwe+6FwB9X1c1VdV/33EP916r6H1W1r6oeqKqpqtrebd8IXMbDXyh+t2v7aUYv\nEJd1/d8O/HfgaQvUq4YZ+BrKd4Fj5pmCObZ7fly3jtHmzKo6ev8NePsCbf8RcD7w7STXJvmZBdoe\nB3x71va3u8f2Pze7trnq/LHHkjwzyTVJvpPkB8Bv8vAXvztn3b9/ju2JBepVwwx8DeULwA+Bfzj7\nwW6u/DnAf+seuhc4YlaTJ85xrGVd8rWqvlhVvwA8Hvg4sHWBfnYx+sxhv5O6x2D0TuWEWc+dOFd3\nD9n+U+ATwIlVdRTwHiBL+gOkeRj4GkRV/YDRFMd/THJeksOSbAA+CtwGXNo1vQE4P8lPJHki8Oo+\n60rymCS/muSoqvoRsBvY2z19J/A3kxw1a5fLgDclWZ/kGOC3gf2Xe24FXpLklCRHdM8tZh3wvap6\nIMkzGM3xS8vCwNdgqurfA28Efp9RsP41oymOf1BVP+yaXQp8BdgJfBr4LytQ2oXAziS7GU2pvLir\n92uMAv6b3WcBxwG/B3wJuBHYDlzfPUZVfQp4F3AN8A1G72pg9M5mPi8DfifJPYxeILYu0FZakvgD\nKNLKSHIKcBPw2GW6mkhaEs/wpR4leUE3TfQ3GH3J7M8New2l1zP8JDuBexjNge6pqo29dSatQkmu\nAn6G0b+Ba4GXVdUdw1alVq1E4G+sqqVcYidJ6oFTOpLUiL7P8L8FfJ/RtcbvrapL5mizBdgCsHbt\n2rNOOumk3uo5mOzbt49DDvH12HGY4VjMcCxmfP3rX/9uVa0fp23fgX9cVe1K8njgakYLZX1uvvaT\nk5O1Y8eO3uo5mExNTbFp06ahyxic4zDDsZjhWMxIsm3cz0d7fYnsFpeiqu4CrmC0sJQkaQC9BX6S\nI5Os238f+DlG1yBLkgbQ5w9GPAG4Isn+fv60qq7qsT9J0gJ6C/zu5+JO7+v4kqSl8WNuSWqEgS9J\njTDwJakRBr4kNcLAl6RGGPiS1AgDX5IaYeBLUiMMfElqhIEvSY0w8CWpEQa+JDXCwJekRhj4ktQI\nA1+SGmHgS1IjDHxJaoSBL0mNMPAlqREGviQ1wsCXpEYY+JLUCANfkhph4EtSIwx8SWqEgS9JjTDw\nJakRBr4kNcLAl6RGGPiS1AgDX5IaYeBLUiMMfElqhIEvSY0w8CWpEb0HfpI1Sb6c5Mq++5IkzW8l\nzvBfBdyyAv1IkhbQa+AnOQG4APijPvuRJC0uVdXfwZM/A/4tsA54XVU9d442W4AtAOvXrz9r69at\nvdVzMJmenmZiYmLoMgbnOMxwLGY4FjM2b968rao2jtP20L6KSPJc4K6q2pZk03ztquoS4BKAycnJ\n2rRp3qZNmZqawrFwHGZzLGY4Fgemzymds4HnJdkJfAQ4J8mHe+xPkrSA3gK/qt5QVSdU1Qbgl4HP\nVtWL++pPkrQwr8OXpEb0Noc/W1VNAVMr0ZckaW6e4UtSIwx8SWqEgS9JjTDwJakRBr4kNcLAl6RG\nGPiS1AgDX5IaYeBLUiMMfElqhIEvSY0w8CWpEQa+JDXCwJekRhj4ktQIA1+SGmHgS1IjDHxJaoSB\nL0mNMPAlqREGviQ1wsCXpEYY+JLUCANfkhph4EtSIwx8SWqEgS9JjTDwJakRBr4kNcLAl6RGGPiS\n1AgDX5IaYeBLUiMMfElqRG+Bn2RtkuuSfCXJzUne2ldfkqTFjRX4SU47gGP/EDinqk4HzgDOS/Ks\nAziOJGkZjHuG/57ubP1lSY4eZ4came42D+tudSBFSpIeuVSNl8FJTgb+OfCLwHXAH1fV1YvsswbY\nBjwF+MOqev0cbbYAWwDWr19/1tatW5f0BzxaTU9PMzExMXQZg3McZjgWMxyLGZs3b95WVRvHaTt2\n4MP/D/DnA+8CdgMB3lhVH1tkv6OBK4BXVtVN87WbnJysHTt2jF3Po9nU1BSbNm0auozBOQ4zHIsZ\njsWMJGMH/rhz+H8nyR8AtwDnAD9fVad09/9gsf2r6m5gCjhvnP4kSctv3Dn8dwPXA6dX1cur6nqA\nqtoFvGmuHZKs3z/fn+Rw4Fzga4+8ZEnSgTh0zHbnA/dX1V6AJIcAa6vqvqq6dJ59jgU+2E0DHQJs\nraorH3HFkqQDMm7gf4bRGfr+q26OAD4N/Ox8O1TVjcDTHlF1kqRlM+6UztpZl1jS3T+in5IkSX0Y\nN/DvTXLm/o0kZwH391OSJKkP407pvBr4aJJd3faxwC/1U5IkqQ9jBX5VfTHJTwGTjK69/1pV/ajX\nyiRJy2rcM3yApwMbun2eloSq+lAvVUmSlt1YgZ/kUuBvATcAe7uHCzDwJekgMe4Z/kbg1FrKOgyS\npFVl3Kt0bgKe2GchkqR+jXuGfwzw1STXMVrnHoCqel4vVUmSlt24gf+WPouQJPVv3Msyr03yJODk\nqvpMkiOANf2WJklaTuMuj/zrwJ8B7+0eOh74eF9FSZKW37gf2r4cOJvRj55QVf8LeHxfRUmSlt+4\ngf/Dqnpw/0aSQ/H3aSXpoDJu4F+b5I3A4UmeDXwU+PP+ypIkLbdxA/8i4DvAduA3gL9gnl+6kiSt\nTuNepbMP+M/dTZJ0EBp3LZ1vMcecfVU9edkrkiT1Yilr6ey3FvhF4CeWvxxJUl/GmsOvqv8763Z7\nVV0MnNNzbZKkZTTulM6ZszYPYXTGv66XiiRJvRh3Sucds+7vAXYCL1z2aiRJvRn3Kp3NfRciSerX\nuFM6r1no+ap65/KUI0nqy1Ku0nk68Ilu++eBzwG39lGUJGn5LeUHUM6sqnsAkrwF+GhVvbSvwiRJ\ny2vcpRVOAh6ctf0gsGHZq5Ek9WbcM/xLgeuSXMHoG7cvAD7UW1WSpGU37lU6b0vyKeDvdg+9pKq+\n3F9ZkqTlNu6UDsARwO6q+g/AbUl+sqeaJEk9GPcnDt8MvB54Q/fQYcCH+ypKkrT8xj3DfwHwPOBe\ngKrahUsrSNJBZdzAf7Cqim6J5CRH9leSJKkP4wb+1iTvBY5O8uvAZ/DHUCTpoDLuVTq/3/2W7W5g\nEvjtqrq618okSctq0cBPsgb4y6o6Fxg75JOcyOha/ScC+4BLuit8JEkDWHRKp6r2AvclOWqJx94D\nvLaqTgGeBbw8yakHUKMkaRmM+03bB4DtSa6mu1IHoKr+5Xw7VNUdwB3d/XuS3AIcD3z1wMuVJB2o\njC6+WaRR8k/neryqPjhWJ8kGRqtrnlZVux/y3BZgC8D69evP2rp16ziHHMT223+wYn094XC48/7+\n+3nq8Ut947aypqenmZiYGLqMVcGxmOFYzNi8efO2qtq4eMtFAj/JSVX1vx9JMUkmgGuBt1XVxxZq\nOzk5WTt27Hgk3fVqw0WfXLG+XvvUPbxj+7hvwA7czrdf0Hsfj8TU1BSbNm0auoxVwbGY4VjMSDJ2\n4C82h//xWQe9/AAKOQy4HPiTxcJektSvxQI/s+4/eSkHThLgfcAt/iKWJA1vscCvee6P42zgQuCc\nJDd0t/OXeAxJ0jJZbJL49CS7GZ3pH97dp9uuqnrcfDtW1ef58XcIkqQBLRj4VbVmpQqRJPVrKevh\nS5IOYga+JDXCwJekRhj4ktQIA1+SGmHgS1IjDHxJaoSBL0mNMPAlqREGviQ1wsCXpEYY+JLUCANf\nkhph4EtSIwx8SWqEgS9JjTDwJakRBr4kNcLAl6RGGPiS1AgDX5IaYeBLUiMMfElqhIEvSY0w8CWp\nEQa+JDXCwJekRhj4ktQIA1+SGmHgS1IjDHxJaoSBL0mNMPAlqRG9BX6S9ye5K8lNffUhSRpfn2f4\nHwDO6/H4kqQl6C3wq+pzwPf6Or4kaWlSVf0dPNkAXFlVpy3QZguwBWD9+vVnbd26tbd6Hqntt/9g\nxfp6wuFw5/399/PU4486oP1WaixWahzgwMdipUxPTzMxMTF0GauCYzFj8+bN26pq4zhtBw/82SYn\nJ2vHjh291fNIbbjokyvW12ufuod3bD+09352vv2CA9pvpcZipcYBDnwsVsrU1BSbNm0auoxVwbGY\nkWTswPcqHUlqhIEvSY3o87LMy4AvAJNJbkvya331JUlaXG+To1X1or6OLUlaOqd0JKkRBr4kNcLA\nl6RGGPiS1AgDX5IaYeBLUiMMfElqhIEvSY0w8CWpEQa+JDXCwJekRhj4ktQIA1+SGmHgS1IjDHxJ\naoSBL0mNMPAlqREGviQ1wsCXpEYY+JLUCANfkhph4EtSIwx8SWqEgS9JjTDwJakRBr4kNcLAl6RG\nGPiS1AgDX5IaYeBLUiMMfElqhIEvSY0w8CWpEQa+JDXCwJekRvQa+EnOS7IjyTeSXNRnX5KkhfUW\n+EnWAH8IPAc4FXhRklP76k+StLA+z/CfAXyjqr5ZVQ8CHwF+ocf+JEkLSFX1c+DkHwPnVdVLu+0L\ngWdW1Sse0m4LsKXbPA24qZeCDj7HAN8duohVwHGY4VjMcCxmTFbVunEaHtpjEZnjsYe9ulTVJcAl\nAEm+VFUbe6zpoOFYjDgOMxyLGY7FjCRfGrdtn1M6twEnzto+AdjVY3+SpAX0GfhfBE5O8pNJHgP8\nMvCJHvuTJC2gtymdqtqT5BXAXwJrgPdX1c2L7HZJX/UchByLEcdhhmMxw7GYMfZY9PahrSRpdfGb\ntpLUCANfkhqxKgLfJRhGkrw/yV1Jmv8uQpITk1yT5JYkNyd51dA1DSXJ2iTXJflKNxZvHbqmoSVZ\nk+TLSa4cupYhJdmZZHuSG8a5PHPwOfxuCYavA89mdCnnF4EXVdVXBy1sAEn+HjANfKiqThu6niEl\nORY4tqquT7IO2AY8v9H/LwIcWVXTSQ4DPg+8qqr+auDSBpPkNcBG4HFV9dyh6xlKkp3Axqoa60to\nq+EM3yUYOlX1OeB7Q9exGlTVHVV1fXf/HuAW4PhhqxpGjUx3m4d1t2avtkhyAnAB8EdD13KwWQ2B\nfzxw66zt22j0H7bmlmQD8DTgr4etZDjdFMYNwF3A1VXV7FgAFwO/BewbupBVoIBPJ9nWLVOzoNUQ\n+GMtwaA2JZkALgdeXVW7h65nKFW1t6rOYPSN9WckaXLKL8lzgbuqatvQtawSZ1fVmYxWJX55Ny08\nr9UQ+C7BoDl189WXA39SVR8bup7VoKruBqaA8wYuZShnA8/r5q4/ApyT5MPDljScqtrV/fcu4ApG\nU+TzWg2B7xIMepjug8r3AbdU1TuHrmdISdYnObq7fzhwLvC1YasaRlW9oapOqKoNjLLis1X14oHL\nGkSSI7sLGkhyJPBzLLLa8OCBX1V7gP1LMNwCbB1jCYZHpSSXAV8AJpPcluTXhq5pQGcDFzI6g7uh\nu50/dFEDORa4JsmNjE6Qrq6qpi9HFABPAD6f5CvAdcAnq+qqhXYY/LJMSdLKGPwMX5K0Mgx8SWqE\ngS9JjTDwJakRBr4kNcLAV7OS7O0u97y5W4nyNUkW/DeRZEOSX1mpGqXlZOCrZfdX1RlV9dOMVms9\nH3jzIvtsAAx8HZS8Dl/NSjJdVROztp/M6ItNxwBPAi4FjuyefkVV/c8kfwWcAnwL+CCjr7M/rN0K\n/QnSkhj4atZDA7977PvATwH3APuq6oEkJwOXVdXGJJuA1+1fgz3JEXO1W9m/RBrPoUMXIK0y+1dv\nPQx4d5IzgL3A356n/bjtpMEZ+FKnm9LZy2jN+TcDdwKnM/qs64F5dvtXY7aTBueHthKjFSmB9wDv\nrtE851HAHVW1j9Eibmu6pvcA62btOl87adVxDl/NSrIX2M5oWmYPow9f31lV+7r5+MuB+4BrgFdW\n1US3Rv9VjD7Y/QBw5VztVvpvkcZh4EtSI5zSkaRGGPiS1AgDX5IaYeBLUiMMfElqhIEvSY0w8CWp\nEf8PJtet6L6rYV0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x119838f28>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(range(0,3),x[0])\n",
    "\n",
    "plt.title('Our Histogram')\n",
    "plt.xlabel('Data')\n",
    "plt.ylabel('Frequency')\n",
    "plt.axis([0, 5, 0, 5])#[start of x-axis, end of x-axis, start of y-axis, end of y-axis]\n",
    "plt.grid(True)\n",
    "\n",
    "plt.show()\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "## Probability\n",
    "\n",
    "Now it's time for some basic probability to help with the upcoming workshops.\n",
    "\n",
    "What is probability? It is the process of quantifiying the uncertainty associated with a certain set of events. There are plenty of random events in nature that make probability very useful for building and evaluating models that analyze and predict on data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dependent vs Independent Events\n",
    "\n",
    "Two events E and F are independent if $P(E, F) = P(E) \\cdot P(F)$.\n",
    "That is, the probability of both E and F happening is $P(E) \\cdot P(F)$.\n",
    "\n",
    "E and F are dependent events when $P(E | F) = \\frac{P(E,F)}{P(F)} = P(E | F) \\cdot P(F)$\n",
    "\n",
    "Let's program some examples in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tricky Example 1: Family with two children\n",
    "\n",
    "Let's assume the following statements:\n",
    "1. Each child is equally likely to be a boy or a girl\n",
    "2. The gender of the second child is independent of the gender of the first child\n",
    "\n",
    "Based on these assumptions, we know that the event âno girlsâ has probability $\\frac{1}{4}$, the event âone girl, one boyâ has probability $\\frac{1}{2}$, and the event âtwo girlsâ has probability $\\frac{1}{4}$.\n",
    "\n",
    "Now, let's think about the events:\n",
    "* B = \"both children are girls\"\n",
    "* G = \"the older child is a girl\"\n",
    "* L = \"at least one of the children is a girl\"\n",
    "\n",
    "Using the concept of conditional probability, we can ask what is the likelihood of these events conditioned on each other. Or, what is the probability that both children are girls and the older child is a girl?\n",
    "\n",
    "By mathematical calculation, we know $P(B|G) = \\frac{P(B, G)}{P(G)} = \\frac{P(B)}{P(G)} = \\frac{1}{2}$\n",
    "\n",
    "And this makes sense because the event B and G (âboth children are girls and the older child is a girlâ) is just the event B. (Once you know that both children are girls, itâs necessarily true that the older child is a girl.)\n",
    "\n",
    "We could also ask about the probability of the event âboth children are girlsâ conditional on the event âat least one of the children is a girlâ (L). Surprisingly, the answer is different from before! We know that the event B and L (âboth children are girls and at least one of the children is a girlâ) is just the event B.\n",
    "\n",
    "This means we have $P(B|L) = \\frac{P(B,L)}{P(L)} = \\frac{P(B)}{P(L)} = \\frac{\\frac{1}{4}}{\\frac{3}{4}} = \\frac{1}{3}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P(both | older): 0.5100178536004761\n",
      "P(both | either):  0.3408006362672322\n"
     ]
    }
   ],
   "source": [
    "# a function that randomly returns a choice between \"boy\" and \"girl\"\n",
    "def random_kid():\n",
    "    return np.random.choice([\"boy\", \"girl\"])\n",
    "\n",
    "# counter variables\n",
    "both_girls = 0.0\n",
    "older_girl = 0.0\n",
    "either_girl = 0.0\n",
    "\n",
    "for i in range(10000):\n",
    "    younger = random_kid()\n",
    "    older = random_kid()\n",
    "    if older == \"girl\":\n",
    "        older_girl += 1\n",
    "    if older == \"girl\" and younger == \"girl\":\n",
    "        both_girls += 1\n",
    "    if older == \"girl\" or younger == \"girl\":\n",
    "        either_girl += 1\n",
    "        \n",
    "\n",
    "print(\"P(both | older):\", both_girls / older_girl) # 1/2\n",
    "print(\"P(both | either): \", both_girls / either_girl) # 1/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tricky Example 2: The famous Monty Hall Problem\n",
    "\n",
    "Suppose you're on a game show, and you're given the choice of three doors: Behind one door is a car; behind the others, goats. You pick a door, say No. 1. The host, who knows what's behind the doors, opens one of the two remaining doors which will have a goat, say No. 3.\n",
    "\n",
    "He then says to you, \"Do you want to stay with door No. 1 or pick door No. 2?\" Is it to your advantage to switch your choice?\n",
    "\n",
    "Intuition says no, the chance should be the same regardless of whether you stay with your choice or switch doors\n",
    "\n",
    "A key insight is that, under these standard conditions, there is more information about doors 2 and 3 that was not available at the beginning of the game, when the door 1 was chosen by the player: the host's deliberate action adds value to the door he did not choose to eliminate, but not to the one chosen by the contestant originally.\n",
    "\n",
    "But how can we prove it? Let's simulate an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def montyhall():\n",
    "    carscore = 0.0\n",
    "    goatscore = 0.0\n",
    "\n",
    "    # Set swap for this set of runs\n",
    "    swap = input(\"Do you want to change your choice of door for this run? (y or n) \")\n",
    "    # Set number of runs\n",
    "    test_count = int(input(\"Enter number runs: \"))\n",
    "    \n",
    "    for count in range(test_count):\n",
    "        # Set random choice\n",
    "        choice = random.randint(0, 2)\n",
    "        # Initialize doors list\n",
    "        doors = [\"\", \"\", \"\"]\n",
    "\n",
    "        # Set random door that has car prize\n",
    "        car_prize_door = random.randint(0, 2)\n",
    "        # Populate doors list\n",
    "        for i in range(3):\n",
    "            if i == car_prize_door:\n",
    "                doors[i] = \"Car\"\n",
    "            else:\n",
    "                doors[i] = \"Goat\"\n",
    "\n",
    "        # If player's chosen door has car inside\n",
    "        if doors[choice] == \"Car\":\n",
    "            # Set door that Monty Hall opens to either 1 or 2\n",
    "            open_door = random.randint(1, 2)\n",
    "\n",
    "            # Set open_door to 0 if the choice is the same as the random door\n",
    "            # If they are not the same, the random door definitely has a \"Goat\"\n",
    "            if choice == 1 and open_door == 1:\n",
    "                open_door = 0\n",
    "            if choice == 2 and open_door == 2:\n",
    "                open_door = 0\n",
    "        else:\n",
    "            # Set open_door to the one that doesn't have \"Car\"\n",
    "            # and is not the chosen door\n",
    "            for i in range(3):\n",
    "                if doors[i] != \"Car\" and i != choice:\n",
    "                    open_door = i\n",
    "\n",
    "        # Swap if set to \"y\", else do nothing\n",
    "        if swap == \"y\":\n",
    "            if choice == 0:\n",
    "                if open_door == 1:\n",
    "                    choice = 2\n",
    "                else:\n",
    "                    choice = 1\n",
    "            elif choice == 1:\n",
    "                if open_door == 0:\n",
    "                    choice = 2\n",
    "                else:\n",
    "                    choice = 0\n",
    "            else:\n",
    "                if open_door == 0:\n",
    "                    choice = 1\n",
    "                else:\n",
    "                    choice = 0\n",
    "\n",
    "        if doors[choice] == \"Car\":\n",
    "            carscore += 1\n",
    "        else:\n",
    "            goatscore += 1\n",
    "\n",
    "    winpercent = (carscore / test_count) * 100\n",
    "    print(\"\\nCar Score:\", carscore)\n",
    "    print(\"Goat Score:\" , goatscore)\n",
    "    print(\"Win Percent:\", winpercent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do you want to change your choice of door for this run? (y or n) y\n",
      "Enter number runs: 3\n",
      "\n",
      "Car Score: 3.0\n",
      "Goat Score: 0.0\n",
      "Win Percent: 100.0\n"
     ]
    }
   ],
   "source": [
    "montyhall()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do you want to change your choice of door for this run? (y or n) yt\n",
      "Enter number runs: 5\n",
      "\n",
      "Car Score: 1.0\n",
      "Goat Score: 4.0\n",
      "Win Percent: 20.0\n"
     ]
    }
   ],
   "source": [
    "montyhall()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.3"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}