data-science-fundamentals-fall-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": null,
   "metadata": {
    "collapsed": true
   },
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 4, 5, 8]\n",
    "a = np.array(my_list)\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Array elements are accessed, sliced, and manipulated just like lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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 **`numpy.ndarray`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array( [[1, 2, 3], [4, 5, 6]] )\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# access the element is the first row, second column\n",
    "print(b[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3 in b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if 7 is in the array a. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#insert code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays can be reshaped to different dimension sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array(range(10), float)\n",
    "print(a)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reshape (10,) array to (5,2)\n",
    "a = a.reshape((5, 2))#the product of the two arguements \n",
    "                     #must equal the total elements in the array\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the identity 2-dimensional array of shape (4,4)\n",
    "i = np.identity(4)\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sum "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#subtract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#square each elemet"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mike_data.dot(adam_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the cross product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.cross(mike_data, 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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another way to compute the magnitude of a vector \n",
    "# insert code here"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "basic_list = [14, 7, 15, 7, 3, 5, 6, 8, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"length: \", len(basic_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"min: \", min(basic_list))\n",
    "print(\"max: \", max(basic_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(x):\n",
    "    return sum(x) / len(x)\n",
    "\n",
    "print(\"average: \", mean(basic_list))\n",
    "\n",
    "#numpy has a mean function as well\n",
    "#insert code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also easily sort lists with sorted(), which helps when defining central tendencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#insert code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otherwise you can also use the `min` and `max` functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#insert code here"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#median function\n",
    "#def median(v):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def IQR(x): #IQR - interquartile range\n",
    "    return quantile(x, 0.75) - quantile(x, 0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Standard Deviation: \", np.std(basic_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": [
    "***\n",
    "## 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.mlab as mlab\n",
    "\n",
    "data = [0,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": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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()"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  }
 ],
 "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
}