data_science_worksheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Science Worksheet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This worksheet is designed to help you learn the basics of doing data science in Python. Specifically, this worksheet is designed to give you practice in data structures in the NumPy and Pandas libraries, and plotting in Matplotlib/Pyplot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we get started, you should make sure you have the necessary packages: NumPy, Pandas, and Matplotlib.\n",
    "\n",
    "If you have the standard distribution of Anaconda, these should already be installed. If not, you can install them with `conda install numpy pandas matplotlib`.\n",
    "\n",
    "If you don't have Anaconda but are on Ubuntu, you should install the packages `python3-numpy`, `python3-pandas`, and `python3-matplotlib` with `apt`.\n",
    "\n",
    "Otherwise, you should install the packages using the command `pip3 install -U numpy pandas matplotlib` from a terminal.\n",
    "\n",
    "To test whether all of this works, try running the cell below. It should produce no output. If you get an error, you do not have the necessary packages. If you think you have installed them but it still does not work, you can try restarting the notebook kernel by selecting `Kernel -> Restart` in the top menu of Jupyter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that all of these import statements use the `import foo as bar` format, which allows you to refer to the package by the second name (which is usually shorter). In practice, it's particularly common to use `np`, `pd`, and `plt` to refer to NumPy, Pandas, and Pyplot, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is mainly a library for working with *arrays* or *matrices* (which term you use typically depends on how many dimensions you are working with and whether you have a computing or mathematical background). NumPy uses the term *array* to refer to all of these.\n",
    "\n",
    "In its simplest form, an array is an ordered set of items (usually numbers) organized along a set of dimensions. If you are working in pure Python, you can think of an array in one dimension as a list (like `[1, 2, 3]`), an array in two dimensions as a list of lists where each inner list has the same length (like `[[1, 2, 3], [4, 5, 6]]`), and so on.\n",
    "\n",
    "In NumPy, arrays are classes that maintain items in this way, with some optimizations for scientific computing. The usual class for these arrays is called the `ndarray`, and you can read about it in great detail [here](https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Components of an Array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create a NumPy array using the function `np.array`. The function takes a set of items organized as an array and creates a NumPy array out of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "example_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This array has two rows and three columns. As you would in Python, you can access a specific element in the array like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array[1][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In NumPy, you can also provide both the row and column at once like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array[1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also access a range of elements at once:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array[:, 1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `:` by itself will give you the whole range of the row or column so you don't need to know the size of the array.\n",
    "\n",
    "You can technically take the length of an array as you would a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(example_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But notice you'll only get the number of rows. No matter how many dimensions an array has, you can get the size in each dimension like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, a list can mix different types, but in NumPy, all elements of an array must have the same type. The type of the array's elements can be found like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this array, each element is of type `int64`, which refers to a 64-bit signed integer, which can have any value between $-2^{63}$ and $2^{63} - 1$ (inclusive). For a list of available built-in types, see [this list](https://docs.scipy.org/doc/numpy/reference/arrays.scalars.html#arrays-scalars-built-in). You can also define your own data type, but you should only do so when none of the built-in types work for your needs. You can read more about data types [here](https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html).\n",
    "\n",
    "When you use `np.array`, you can set the `dtype` of the array by adding `dtype=\"foo\"` to the function call (where `foo` is replaced with the appropriate value. This might be helpful, for example, if your array is supposed to represent something like population counts. By default, the `dtype` of integer arrays on modern systems is often `int64`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1402291520, 1361261670, 329549922, 266911900, 219346520]).dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But for representing population counts, it makes sense to use a `dtype` of `uint64`, which does not allow negative values. Since populations can't ever be negative, this is a reasonable thing to do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('uint64')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_populations = np.array([1402291520, 1361261670, 329549922, 266911900, 219346520], dtype='uint64')\n",
    "top_populations.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But be aware that the default `dtype` depends on what machine you are running on. You might end up with `int32` as the default type on older systems or smaller hardware like a Raspberry Pi, so you should be careful about what assumptions you make. You could also just be explicit about the `dtype` if it's crucial and you want to be safe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can do basic arithmetic operations on arrays as if they were scalar numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 4],\n",
       "       [5, 6, 7]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 1. , 1.5],\n",
       "       [2. , 2.5, 3. ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the second example, notice that the values of the arrays are floats rather than integers. When you see `1.` written with the decimal point after it, that indicates that it's a float. Specifically, it's a 64-bit float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(example_array / 2).dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perhaps strangely, you can also compare arrays to scalars:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_array > 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, this returns an array of boolean values with the same shape as the array. Each value of `True` or `False` indicates whether the corresponding value in `example_array` matches the comparison.\n",
    "\n",
    "If you pass an array of booleans like this as an index to an array, you can get only the values that correspond to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "larger_than_one = example_array > 1\n",
    "example_array[larger_than_one]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the values are returned in a single row because this filtering would otherwise break the array's shape.\n",
    "\n",
    "If you want to combine multiple conditions, you need to use `&` and `|` for `and` and `or` respectively, and surround each condition in parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True,  True],\n",
       "       [ True,  True, False]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(example_array > 1) & (example_array < 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few quirks you should be aware of in NumPy. First, note that in computing in general, floating-point numbers can have some odd and unexpected behavior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because of rounding errors in the bit-level representation of these numbers. This can lead to some odd behavior. For example, `np.arange` is a function that behaves similarly to the `range` function in Python, but returns an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 10, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But when you use this function with non-integer values, you can get some unexpected results, as the [documentation](https://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html) warns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8.  , 8.05, 8.1 , 8.15, 8.2 , 8.25, 8.3 ])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(8, 8.35, 0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seems like the expected behavior, but see what happens when we change the upper limit slightly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8.  , 8.05, 8.1 , 8.15, 8.2 , 8.25, 8.3 , 8.35, 8.4 ])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(8, 8.4, 0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another odd quirk has to do with `np.nan` (which stands for *not a number*), which is a placeholder value for invalid values. **Be aware that running the following code cell will produce warnings; it's fine to ignore them in this case.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\thele\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log\n",
      "  \n",
      "C:\\Users\\thele\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in log\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ nan, -inf,   0.])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nan_example = np.array([-1, 0, 1])\n",
    "np.log(nan_example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see here that we got three different values. Taking the logarithm of 1 is always 0, which we can see in the third element. Taking the logarithm of 0 is not defined in math, but works out to an infinitely small value, which we represent as negative infinity (`-inf`) as seen in the second element. Finally, it doesn't make sense to take the logarithm of a negative number, so we get `nan` (if you're used to other languages like MATLAB, you can also use `NaN`).\n",
    "\n",
    "Somewhat unintuitively, `nan` and `-inf` both evaluate to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(np.nan) and bool(np.inf) and bool(-np.inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should be aware that both in NumPy and in Python, *any non-zero numeric value* evaluates to `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, you should know that NumPy provides a variety of functions that work on entire arrays, and it's best to use these rather than iterating through the values of the array. Under the hood, NumPy arrays are implemented in the C programming language, which makes them much faster than a `for` loop in Python.\n",
    "\n",
    "To see this, consider the following functions to count the number of even integers in an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_evens_numpy(array):\n",
    "    return array[array % 2 == 0].size\n",
    "\n",
    "\n",
    "def count_evens_python(array):\n",
    "    num_evens = 0\n",
    "    for element in np.nditer(array):\n",
    "        if element % 2 == 0:\n",
    "            num_evens += 1\n",
    "    return num_evens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test this, we can generate an array of 100 random integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_array = np.random.randint(1, 100, (1, 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can compare the speeds:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NumPy: 0.041 seconds for 10000 iterations\n",
      "Python: 1.7 seconds for 10000 iterations (41.7x slower)\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "num_iterations=10000\n",
    "numpy_time = timeit.timeit(lambda: count_evens_numpy(test_array), number=num_iterations)\n",
    "python_time = timeit.timeit(lambda: count_evens_python(test_array), number=num_iterations)\n",
    "print(f\"NumPy: {numpy_time:.2} seconds for {num_iterations} iterations\")\n",
    "print(f\"Python: {python_time:.2} seconds for {num_iterations} iterations ({python_time/numpy_time:.3}x slower)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Useful Array Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays in NumPy offer a variety of useful functions. Some of the more commonly used ones are listed below. The documentation is linked for each, and you are recommended to explore their specifics.\n",
    "\n",
    "* `all`: return whether all elements of the array evaluate to `True`. `any` is the same but only requires one element to be `True`. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.all.html)\n",
    "* `argmax`: find the argument (index) producing the maximum value. `argmin` is the same but for the minimum value. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmax.html)\n",
    "* `copy`: make a copy of an array. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.copy.html)\n",
    "* `fill`: fill an array with a value. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.fill.html)\n",
    "* `flatten`: turn a multi-dimensional array into a single-dimensional version. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.flatten.html)\n",
    "* `linspace`: return a set of evenly-spaced numbers as an array (more consistently than `arange`). [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html)\n",
    "* `max`: find the maximum value of an array. `min` is the same but for the minimum value. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.max.html)\n",
    "* `mean`: find the mean/average of an array. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.mean.html)\n",
    "* `polyfit`: fit a polynomial function to an array of $x$- and $y$-values. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.polyfit.html)\n",
    "* `reshape`: change an array's shape. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html)\n",
    "* `sort`: sort the values in an array. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.sort.html)\n",
    "* `std`: find the standard deviation of an array. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.std.html)\n",
    "* `sum`: add the values in an array. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html)\n",
    "* `tolist`: turn an array into an equivalent set of Python lists. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.tolist.html)\n",
    "* `transpose`: flip the axes of an array. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.transpose.html)\n",
    "* `var`: find the variance of an array. [Doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.var.html)\n",
    "\n",
    "Note that most of these functions come in two versions: one that is a method of an array (`example_array.sum`) and one that takes the array as an argument (`np.sum(example_array)`). Use whichever one is convenient to you, but be aware of the differences and try to be consistent.\n",
    "\n",
    "Also note that many of the functions allow you to specify a dimension or *axis* along which to apply the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Playing with Dice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following exercises are designed to give you practice with array functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now consider the following list of lists in Python, which represents the possible combinations of rolling a pair of dice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "dice_rolls = []\n",
    "for i in range(6):\n",
    "    for j in range(6):\n",
    "        dice_rolls.append([i + 1, j + 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the array looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [1, 2],\n",
       "       [1, 3],\n",
       "       [1, 4],\n",
       "       [1, 5],\n",
       "       [1, 6],\n",
       "       [2, 1],\n",
       "       [2, 2],\n",
       "       [2, 3],\n",
       "       [2, 4],\n",
       "       [2, 5],\n",
       "       [2, 6],\n",
       "       [3, 1],\n",
       "       [3, 2],\n",
       "       [3, 3],\n",
       "       [3, 4],\n",
       "       [3, 5],\n",
       "       [3, 6],\n",
       "       [4, 1],\n",
       "       [4, 2],\n",
       "       [4, 3],\n",
       "       [4, 4],\n",
       "       [4, 5],\n",
       "       [4, 6],\n",
       "       [5, 1],\n",
       "       [5, 2],\n",
       "       [5, 3],\n",
       "       [5, 4],\n",
       "       [5, 5],\n",
       "       [5, 6],\n",
       "       [6, 1],\n",
       "       [6, 2],\n",
       "       [6, 3],\n",
       "       [6, 4],\n",
       "       [6, 5],\n",
       "       [6, 6]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dice_roll_array = np.array(dice_rolls)\n",
    "dice_roll_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use NumPy functions to calculate the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The average total dice roll.\n",
    "\n",
    "#### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I took this to mean \"take the mean of all the individual rolls (where a roll could be [3,4] for example)\"\n",
    "np.mean(dice_roll_array.sum(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The probability of rolling a total higher than 6 (not including 6).\n",
    "\n",
    "#### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5833333333333334"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(dice_roll_array.sum(axis=1) > 6)/np.size(dice_roll_array.sum(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* How the standard deviation of the total dice roll compares to the standard deviation of rolling a single die.\n",
    "\n",
    "#### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7074043300383068"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(dice_roll_array.sum(axis=1))-np.std(dice_roll_array[:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Transforming Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a Python list of numbers under 1000 that only contain 0, 1, or 2 as digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "ternary_digits = [0, 1, 2, 10, 11, 12, 20, 21, 22,\n",
    "                  100, 101, 102, 110, 111, 112, 120, 121, 122,\n",
    "                  200, 201, 202, 210, 211, 212, 220, 221, 222]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we turn this list into a 3 x 3 x 3 NumPy array, transpose it, and turn it back into a single Python list. What will that list be?\n",
    "\n",
    "For this question, it's helpful to try to do operations one at a time. So for example, you might write\n",
    "\n",
    "```python\n",
    "single_row_array = numpy.array([1, 2, 3])\n",
    "single_column_array = single_row_array.transpose()\n",
    "# etc...\n",
    "```\n",
    "\n",
    "Writing your code this way will make it easier to check that each step is correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[[0, 100, 200], [10, 110, 210], [20, 120, 220]],\n",
       " [[1, 101, 201], [11, 111, 211], [21, 121, 221]],\n",
       " [[2, 102, 202], [12, 112, 212], [22, 122, 222]]]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "single_row_array = np.array(ternary_digits)\n",
    "array_3_by_3 = single_row_array.reshape(3,3,3)\n",
    "array_3_by_3_transposed = array_3_by_3.transpose()\n",
    "array_3_by_3_transposed.tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Further Reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are interested in more features of NumPy, you can check out the [Quickstart Guide](https://docs.scipy.org/doc/numpy/user/quickstart.html). Be warned that is is quite long - the above is intended to be a condensed version of it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas is a library for working with and analyzing data in various formats. Pandas contains two classes, *series* and *data frames*, that make it quite easy to work with structured data. Pandas also provides several convenience functions that make it straightforward to create and work with these classes.\n",
    "\n",
    "A very high-level way of thinking about the Pandas data structures is that a series represents a single column of data and a data frame represents a spreadsheet-like table of data. As you might expect from a spreadsheet, it is possible to name or otherwise index the rows and columns. You can then work with the data using these names.\n",
    "\n",
    "While we could try to reinvent the wheel and explain the different features of Pandas, their tutorials are excellent, and so we will link the relevant ones here:\n",
    "\n",
    "* [What kind of data does Pandas handle?](https://pandas.pydata.org/docs/getting_started/intro_tutorials/01_table_oriented.html)\n",
    "* [How do I read and write tabular data?](https://pandas.pydata.org/docs/getting_started/intro_tutorials/02_read_write.html)\n",
    "* [How do I select a subset of a DataFrame?](https://pandas.pydata.org/docs/getting_started/intro_tutorials/03_subset_data.html)\n",
    "* [How to create new columns derived from existing columns?](https://pandas.pydata.org/docs/getting_started/intro_tutorials/05_add_columns.html)\n",
    "* [How to calculate summary statistics?](https://pandas.pydata.org/docs/getting_started/intro_tutorials/06_calculate_statistics.html)\n",
    "\n",
    "Feel free to read the other tutorial pages as well, but the ones above are especially helpful for learning the basics of working with Pandas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Average Flight Time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This exercise is designed to give you some practice in working with data frames."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code below, `flight_data` is a string representing the location of the data file you will use for this exercise. It contains data for flights on United Airlines in February 2019, which consists of an origin and destination airport code, the number of passengers carried (across all flights from the origin to destination in that month), and the total time spent in the air from the origin to destination (in minutes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "data_folder = \"data\"\n",
    "flight_data = os.path.join(data_folder, \"data_science_flight_data.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your job is to read this data in as a data frame, and create a data frame that ranks the flights from longest to shortest average airtime. Specifically, the data frame should consist of three columns, Origin, Destination, and Average Flight Time, and be sorted from highest to lowest flight time.\n",
    "\n",
    "For estimating the average flight time, you can assume that each flight carries 180 people. (But think about how many flights you need to transport 181 people.)\n",
    "\n",
    "Then, write a few sentences about whether this data makes sense, looking up a few of the airports involved and their approximate flight times. If the results are different from what you expected, take a guess as to why."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Origin</th>\n",
       "      <th>Destination</th>\n",
       "      <th>Average Flight Time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>EWR</td>\n",
       "      <td>PSP</td>\n",
       "      <td>873.909091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>LAX</td>\n",
       "      <td>LIH</td>\n",
       "      <td>848.833333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CVG</td>\n",
       "      <td>SFO</td>\n",
       "      <td>753.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DTW</td>\n",
       "      <td>SFO</td>\n",
       "      <td>702.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>EWR</td>\n",
       "      <td>SNA</td>\n",
       "      <td>683.105263</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>714</th>\n",
       "      <td>SJC</td>\n",
       "      <td>SFO</td>\n",
       "      <td>23.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>715</th>\n",
       "      <td>BUF</td>\n",
       "      <td>ROC</td>\n",
       "      <td>23.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>716</th>\n",
       "      <td>SWF</td>\n",
       "      <td>EWR</td>\n",
       "      <td>19.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>717</th>\n",
       "      <td>COS</td>\n",
       "      <td>DEN</td>\n",
       "      <td>18.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>718</th>\n",
       "      <td>MIA</td>\n",
       "      <td>FLL</td>\n",
       "      <td>11.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>719 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    Origin Destination  Average Flight Time\n",
       "0      EWR         PSP           873.909091\n",
       "1      LAX         LIH           848.833333\n",
       "2      CVG         SFO           753.300000\n",
       "3      DTW         SFO           702.500000\n",
       "4      EWR         SNA           683.105263\n",
       "..     ...         ...                  ...\n",
       "714    SJC         SFO            23.000000\n",
       "715    BUF         ROC            23.000000\n",
       "716    SWF         EWR            19.000000\n",
       "717    COS         DEN            18.000000\n",
       "718    MIA         FLL            11.000000\n",
       "\n",
       "[719 rows x 3 columns]"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flight_data_dataframe = pd.read_csv(flight_data)\n",
    "flight_data_dataframe[\"Planes\"] = flight_data_dataframe[\"Passengers\"]/180\n",
    "flight_data_dataframe[\"Planes\"] = flight_data_dataframe[\"Planes\"].apply(np.ceil) # This solution found here: https://datatofish.com/round-values-pandas-dataframe/\n",
    "flight_data_dataframe[\"Average Flight Time\"] = flight_data_dataframe[\"Airtime\"]/flight_data_dataframe[\"Planes\"]\n",
    "flight_data_dataframe = flight_data_dataframe.sort_values([\"Average Flight Time\"], ascending=False)\n",
    "flight_data_dataframe = flight_data_dataframe[[\"Origin\",\"Destination\",\"Average Flight Time\"]]\n",
    "flight_data_dataframe = flight_data_dataframe.reset_index(drop=True)\n",
    "flight_data_dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the distance between some of these airports (EWR to PSP, LAX to LIH, etc.), the long flight data doesn't surprise me. Looking at the end of the dataframe, short flights like MIA to FLL or COS to DEN make a lot of sense as well since these airports are close to each other."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib and Pyplot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib is a plotting library for Python. Its syntax was designed to be realtively similar to the plotting syntax of MATLAB. Pyplot is a part of Matplotlib that is particularly well-suited for interactively working with plots, as you often do in Jupyter notebooks.\n",
    "\n",
    "In this worksheet, we will focus on Pyplot. To make plots show up within the notebook itself, you'll need to run the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with Pandas, Matplotlib includes some excellent tutorials, which you should go through to learn about how to use the library. We recommend you read the tutorials below in order:\n",
    "\n",
    "* [Pyplot tutorial](https://matplotlib.org/3.2.1/tutorials/introductory/pyplot.html)\n",
    "* [Usage Guide](https://matplotlib.org/3.2.1/tutorials/introductory/usage.html#sphx-glr-tutorials-introductory-usage-py) (up to, but not including, the \"Backends\" section)\n",
    "* [How to create plots in pandas?](https://pandas.pydata.org/pandas-docs/stable/getting_started/intro_tutorials/04_plotting.html)\n",
    "* [The Lifecycle of a Plot](https://matplotlib.org/3.2.1/tutorials/introductory/lifecycle.html#sphx-glr-tutorials-introductory-lifecycle-py) (optional, but helpful as an example)\n",
    "\n",
    "You may notice that there are differences between Matplotlib's object-oriented style of working with plots and the one used in Pyplot. Again, we will focus on Pyplot for this worksheet, but you should be aware of the other way of doing things, which is often more helpful when writing functions or scripts to do the plotting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting Tips"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Though the tutorials above explain a good deal about how to create and work with plots, they don't say much about what actually makes a good plot.\n",
    "\n",
    "Below, we provide a few helpful guidelines in how to design a good plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What's Your Point?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By far the most important thing to know as when you design and create a plot is the point you are trying to make.\n",
    "\n",
    "Here is a set of two plots from the Pyplot tutorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(t):\n",
    "    return np.exp(-t) * np.cos(2*np.pi*t)\n",
    "\n",
    "t1 = np.arange(0.0, 5.0, 0.1)\n",
    "t2 = np.arange(0.0, 5.0, 0.02)\n",
    "\n",
    "plt.figure()\n",
    "plt.subplot(211)\n",
    "plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')\n",
    "\n",
    "plt.subplot(212)\n",
    "plt.plot(t2, np.cos(2*np.pi*t2), 'r--')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't know the point this graphic is trying to make for a number of reasons: (1) we have no idea what the numbers on the $x$ or $y$ axis represent, (2) the plot doesn't have a title, so we don't know what the overall plot is of, and (3) we don't have the context, so we don't know why we are seeing this plot.\n",
    "\n",
    "**The purpose of a plot is to provide evidence or support for a claim you make.** So for example, suppose that you have two swings, one of which is rusty, and claim that the rusty swing stops earlier than the other. You could conduct an experiment to analyze this: sit the same person on each swing in turn, start them forward of center, and release them, tracking their distance from the normal hanging center of the swing over time. Then, saying that the blue plot represents the position of the person in the more rusted swing over time gives more credibility to your claim.\n",
    "\n",
    "In general, always explain the point of your plots with proper context, especially when making them publicly accessible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Detail Your Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we now know what the point of the above plot is, we still don't know some key details. How heavy was the person sitting in the swing? How long did you track their position for? Is their position measured in feet, inches, or meters?\n",
    "\n",
    "To make sure that the plot effectively provides evidence for a claim, this type of information is necessary. However, not all of it has to be included in the plot itself. Typically, it's best if the plot includes a title and labeled axes, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_LABEL = \"Time (s)\"\n",
    "Y_LABEL = \"Dist. from center (m)\"\n",
    "TITLE = \"{} swing position with 68kg person\"\n",
    "\n",
    "plt.figure()\n",
    "plt.subplot(211)\n",
    "plt.title(TITLE.format(\"Rusty\"))\n",
    "plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')\n",
    "plt.xlabel(X_LABEL)\n",
    "plt.ylabel(Y_LABEL)\n",
    "\n",
    "plt.subplot(212)\n",
    "plt.title(TITLE.format(\"Normal\"))\n",
    "plt.plot(t2, np.cos(2*np.pi*t2), 'r--')\n",
    "plt.xlabel(X_LABEL)\n",
    "plt.ylabel(Y_LABEL)\n",
    "\n",
    "plt.subplots_adjust(hspace=0.6)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to show both the quantity represented and the units when labeling axes. (The exception is if the quantity has no units.) Also, the titles clearly indicate which plot is which and what the plot represents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Explain the Plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beyond properly labeling the plots and making a point, it's important to highlight the important parts of the plot so it's clear how the plot provides evidence for your point. Don't assume that the reader will just make the connection on their own. For example, you might write the following after showing the plot above:\n",
    "\n",
    "> Figure X shows the positions of the two swings over time. As we can see, the rusty swing shows a clear decrease in the distance from the center over time, with the peak distance at less than 50cm from the center at 1 second. The normal swing, on the other hand, has almost the same distance (if not the same) even at 5 seconds, when the rusty swing has almost stopped moving.\n",
    "\n",
    "This explanation makes it very clear how the plot connects with your claim, and the plot itself includes enough precise information to effectively back up your claim."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Tell a Story with a Plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise, you will get some practice with Pyplot as well as the plotting principles discussed above.\n",
    "\n",
    "Choose some data, either from this worksheet or from one of your previous projects. Make a claim about this data. Then create a plot of the data, including a title, axis labels, and an explanation of how the plot connects to and supports your claim."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "names = []\n",
    "for i in range(flight_data_dataframe[\"Origin\"].size):\n",
    "    if i%50==0:\n",
    "        current_name = flight_data_dataframe[\"Origin\"][i] + \" to \" + flight_data_dataframe[\"Destination\"][i]\n",
    "        names.append(current_name)\n",
    "\n",
    "durations = flight_data_dataframe[\"Average Flight Time\"]/60\n",
    "durations = durations.tolist()\n",
    "durations = durations[::50] # Solution found here: https://stackoverflow.com/questions/1403674/pythonic-way-to-return-list-of-every-nth-item-in-a-larger-list\n",
    "\n",
    "distance_between_airports = [2352.58,1648.43,3297.98,1557.69,1707.72,1544.88,1575.04,1472.09,628.35,721.27,923.02,802.13,314.72,284.41,140.01] # I found these manually using Google Maps\n",
    "\n",
    "plt.figure()\n",
    "plt.bar(names, distance_between_airports, color=\"red\")\n",
    "plt.xticks(rotation=45, ha=\"right\")\n",
    "plt.xlabel(\"Flight (Origin to Destination)\")\n",
    "plt.ylabel(\"Miles Between Airports\", color=\"red\")\n",
    "plt.title(\"Distances Between Airports vs. Flight Hours\")\n",
    "\n",
    "plt2 = plt.twinx()\n",
    "plt2.bar(names, durations, alpha=0.6)\n",
    "plt.ylabel(\"Hours Enroute\", color=\"blue\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above figure shows the distance between a given set of airports \"as the crow flies\". Before making the plot, I believed the distance between a set of airports would be proportional to the length of a flight between them. As shown in this plot, however, the distance between a given set of airports (plotted in red) appears to be almost randomly correlated to the length of a flight between them (plotted in translucent blue). While the data loosely aligns, outliers like OGG to DEN throw the perceived alignment off."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Mystery Datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise, you will analyze four datasets using various techniques.\n",
    "\n",
    "The locations of the files are defined below for your convenience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "data_folder = \"data\"\n",
    "file_1 = os.path.join(data_folder, \"data_science_1.csv\")\n",
    "file_2 = os.path.join(data_folder, \"data_science_2.csv\")\n",
    "file_3 = os.path.join(data_folder, \"data_science_3.csv\")\n",
    "file_4 = os.path.join(data_folder, \"data_science_4.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These files represent sets of $x$ and $y$ coordinates. Your job is to talk about how these datasets are similar and different. To do this, you can use summary statistics, try to fit/plot the data, etc.\n",
    "\n",
    "Then construct a short \"computational essay\" below, where you explain the similarities and differences among the datasets and intersperse text and code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll begin by formatting the data in a way that will be helpful later. In this case, that means reading each file as a Pandas dataframe and as a set of x- and y-coordinates, formatted as lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_1_dataframe = pd.read_csv(file_1, header=None)\n",
    "file_1_x = file_1_dataframe.iloc[:,0].tolist()\n",
    "file_1_y = file_1_dataframe.iloc[:,1].tolist()\n",
    "\n",
    "file_2_dataframe = pd.read_csv(file_2, header=None)\n",
    "file_2_x = file_2_dataframe.iloc[:,0].tolist()\n",
    "file_2_y = file_2_dataframe.iloc[:,1].tolist()\n",
    "\n",
    "file_3_dataframe = pd.read_csv(file_3, header=None)\n",
    "file_3_x = file_3_dataframe.iloc[:,0].tolist()\n",
    "file_3_y = file_3_dataframe.iloc[:,1].tolist()\n",
    "\n",
    "file_4_dataframe = pd.read_csv(file_4, header=None)\n",
    "file_4_x = file_4_dataframe.iloc[:,0].tolist()\n",
    "file_4_y = file_4_dataframe.iloc[:,1].tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll get some information about each file, to be thorough:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Info about file 1:\n",
      "               0          1\n",
      "count  11.000000  11.000000\n",
      "mean    9.000000   7.500909\n",
      "std     3.316625   2.031568\n",
      "min     4.000000   4.260000\n",
      "25%     6.500000   6.315000\n",
      "50%     9.000000   7.580000\n",
      "75%    11.500000   8.570000\n",
      "max    14.000000  10.840000\n",
      "\n",
      "Info about file 2:\n",
      "               0          1\n",
      "count  11.000000  11.000000\n",
      "mean    9.000000   7.500909\n",
      "std     3.316625   2.031657\n",
      "min     4.000000   3.100000\n",
      "25%     6.500000   6.695000\n",
      "50%     9.000000   8.140000\n",
      "75%    11.500000   8.950000\n",
      "max    14.000000   9.260000\n",
      "\n",
      "Info about file 3:\n",
      "               0          1\n",
      "count  11.000000  11.000000\n",
      "mean    9.000000   7.500091\n",
      "std     3.316625   2.030682\n",
      "min     4.000000   5.390000\n",
      "25%     6.500000   6.250000\n",
      "50%     9.000000   7.110000\n",
      "75%    11.500000   7.980000\n",
      "max    14.000000  12.741000\n",
      "\n",
      "Info about file 4:\n",
      "               0          1\n",
      "count  11.000000  11.000000\n",
      "mean    9.000000   7.500000\n",
      "std     3.316625   2.030478\n",
      "min     8.000000   5.250000\n",
      "25%     8.000000   6.170000\n",
      "50%     8.000000   7.040000\n",
      "75%     8.000000   8.190000\n",
      "max    19.000000  12.500000\n"
     ]
    }
   ],
   "source": [
    "print(\"Info about file 1:\\n\", file_1_dataframe.describe(), sep='')\n",
    "print(\"\\nInfo about file 2:\\n\", file_2_dataframe.describe(), sep='')\n",
    "print(\"\\nInfo about file 3:\\n\", file_3_dataframe.describe(), sep='')\n",
    "print(\"\\nInfo about file 4:\\n\", file_4_dataframe.describe(), sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do we know? Well, first, based on the \"count\" section, each file appears to be the same size (same number of rows and columns). Interestingly, the maximum x-value of each of the first three files is 14, while the last file's maximum x-value is 19. Also curiously, the mean and standard deviation of the x-values and y-values of all of the datasets are consistently the same. While we don't know whether or not these datasets are correlated, this may be an indicator of a relationship between them. At this point, we could try to do more analysis, but I think it would be more useful to plot the data and see what happens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.plot(file_1_x, file_1_y, \"r*\")\n",
    "plt.plot(file_1_x, file_1_y, \"-\")\n",
    "\n",
    "plt.subplot(222)\n",
    "plt.plot(file_2_x, file_2_y, \"r*\")\n",
    "plt.plot(file_2_x, file_2_y, \"-\")\n",
    "\n",
    "plt.subplot(223)\n",
    "plt.plot(file_3_x, file_3_y, \"r*\")\n",
    "plt.plot(file_3_x, file_3_y, \"-\")\n",
    "\n",
    "plt.subplot(224)\n",
    "plt.plot(file_4_x, file_4_y, \"r*\")\n",
    "plt.plot(file_4_x, file_4_y, \"-\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much better! The first file appears to be pretty randomly-scattered data, but it might be increasing approximately linearly. The second file appears to be a quadratic-ish function of some sort. Interestingly, none of the data points thus far seem to be in the order we would expect (take the second file, for example, which has connecting lines all over it).\n",
    "\n",
    "The third file looks like a linear increase with one outlier. This might be data from a scientific instrument, and the outlier might be an incorrect reading, for example. The fourth file is similar, having one outlier, but the majority of the data lies upon one x-value."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}