assignment_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment 1: Basic Python Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "* [Task 1: Compute the Mean](#Task-1:-Compute-the-Mean)\n",
    "    * [Description of the Mean](#Description-of-the-Mean)\n",
    "    * [Summing a List of Numbers](#Summing-a-List-of-Numbers)\n",
    "        * [For Loop With an Index](#For-Loop-With-an-Index)\n",
    "        * [For Loop Without an Index](#For-Loop-Without-an-Index)\n",
    "        * [Python's Built-In Sum](#Python's-Built-In-Sum)\n",
    "    * [Your Mean Function](#Your-Mean-Function)\n",
    "* [Task 2: Compute the Variance](#Task-2:-Compute-the-Variance)\n",
    "    * [Description of Variance](#Description-of-Variance)\n",
    "    * [Creating a New List From an Old One](#Creating-a-New-List-From-an-Old-One)\n",
    "        * [Ceating a New List With a For Loop](#Ceating-a-New-List-With-a-For-Loop)\n",
    "        * [Creating a New List With a List Comprehension](#Creating-a-New-List-With-a-List-Comprehension)\n",
    "    * [Your Variance Function](#Your-Variance-Function)\n",
    "* [Task 3: Compute the Skewness](#Task-3:-Compute-the-Skewness)\n",
    "    * [Description of Skewness](#Description-of-Skewness)\n",
    "    * [Your Skewness Function](#Your-Skewness-Function)\n",
    "* [Task 4: Compute Arbitrary Central Moments](#Task-4:-Compute-Arbitrary-Central-Moments)\n",
    "    * [Description of Central Moments](#Description-of-Central-Moments)\n",
    "    * [Your Central Moment Function](#Your-Central-Moment-Function)\n",
    "* [Bonus Task 4.1: A Function to Make Central Moment Functions](#Bonus-Task-4.1:-A-Function-to-Make-Central-Moment-Functions)\n",
    "    * [Example of a Function Returning Function](#Example-of-a-Function-Returning-Function)\n",
    "    * [Your Central Moment Function Function](#Your-Central-Moment-Function-Function)\n",
    "* [Task 5: Assemble Your Statistics Module](#Task-5:-Assemble-Your-Statistics-Module)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1: Compute the Mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Description of the Mean\n",
    "\n",
    "Consider the dataset of numbers $X = (1, 4, 3, -5, 2)$. For convenience we refer to the individual values with a subscript, so $x_0 = 1$ and $x_3 = -4$. The [mean](https://en.wikipedia.org/wiki/Expected_value) of a dataset, written $\\overline{x}$ or $\\mu$ or $\\text{E}(X)$, is one way to measure its centre (the other common ways being median and mode). To compute the mean we must add up the numbers in the set and divide by the number of numbers in the set. That is\n",
    "\n",
    "$$\n",
    "\\mu = \\frac{1+4+3-5+2}{5} = 1 .\n",
    "$$\n",
    "\n",
    "For a general dataset $(x_0, x_1, \\dots, x_{n+1})$, the mean is\n",
    "\n",
    "$$\n",
    "\\mu = \\frac{x_0+x_2+\\dots+x_{n-1}}{n}.\n",
    "$$\n",
    "\n",
    "We can write this a bit more compactly with big-sigma notation, like\n",
    "\n",
    "$$\n",
    "\\mu = \\frac{1}{n} \\sum_{i=0}^{n-1} x_i .\n",
    "$$\n",
    "\n",
    "You will write a function that computes the mean of a list of numbers. However, first we must work out how to sum a list of numbers. We'll use the list `[1, 4, 3, -5, 2]` for experiments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [1, 4, 3, -5, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summing a List of Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For Loop With an Index\n",
    "\n",
    "First I'll write pseudocode for summing a list. Remember, pseudocode is just a rough statement of the steps, not real Python code.\n",
    "\n",
    "```\n",
    "For each index, i, from 0 to the last\n",
    "    Add the number at index i to the sum\n",
    "```\n",
    "\n",
    "There are three parts to this: iterating over all indices from 0 to $n$, looking up the number at that index, and adding that number to a sum variable.\n",
    "\n",
    "Python's `range` function will generate the list of indices from 0 to $n-1$, but how do I get $n$? $n$ is the number of numbers in the list, which is returned by Python's `len` function. So `range(len(data))` will return the list `0, 1, 2, ..., n-1` (remember that `range` doesn't return the ending value).\n",
    "\n",
    "`i` is a typical name for an index, so I can iterate over the indices of the list with the line\n",
    "\n",
    "```python\n",
    "for i in range(len(data)):\n",
    "```\n",
    "\n",
    "Inside the `for` loop we have to look up the number at index `i` and add it to the sum. `sum` is a special name in Python, so I'll name the sum `s`. To look up something in a list in Python (and most programming languages) you use square brackets, like `data[i]`. To add something to a variable you use the `+=` operator. The for loop will then look like\n",
    "\n",
    "```python\n",
    "for i in range(len(data)):\n",
    "    s += data[i]\n",
    "```\n",
    "\n",
    "However, if you run this code, you get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(data)):\n",
    "    s += data[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I've told Python to add to `s`, but I didn't give it a value to start with (called \"initializing\"). That's easily fixed by assigning 0 to `s`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s= 0\n",
    "\n",
    "for i in range(len(data)):\n",
    "    s += data[i]\n",
    "    \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, I can wrap this in a function which takes a list and returns the sum. Again, `sum` is a special name in Python, but I can use `my_sum`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_sum(lst):\n",
    "    \"\"\"Add up the values in a list.\"\"\"\n",
    "    s = 0\n",
    "    \n",
    "    for i in range(len(lst)):\n",
    "        s += lst[i]\n",
    "        \n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`list` is another special name in Python, so `lst` is commonly used to name a list variable (only if a more specific name isn't appropriate!).\n",
    "\n",
    "Notice that I've included a doctring. Every function you ever write should have a docstring. Yours don't have to be as formal as mine, but a stranger should be able to read it and understand what your function does. Remember that you can read a functions docstring with `help` or `?`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(my_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sum?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, I will test my function. Many books have been written on how to test code, but I'll make do by checking a few different lists with sums I know."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sum(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplying a list by a positive integer repeats the list, so [1] * 10 is a list of ten ones.\n",
    "my_sum([1] * 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sum(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sum([-1.1, 2.2, 3.3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For Loop Without an Index\n",
    "\n",
    "The previous code works perfectly well, but Python provides an easier way to iterate over a list. Notice that I didn't really care about the index `i` in my code. I only used `i` to get a value from the list, and Python's `for` loop lets me skip that middle step. I can iterate over the values in the list directly like so\n",
    "\n",
    "```python\n",
    "for value in data:\n",
    "```\n",
    "\n",
    "I can now rewrite my earlier loop a bit more simply."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 0\n",
    "\n",
    "for value in data:\n",
    "    s += value\n",
    "    \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the `for` loop knows when to stop, so I can't mix up the final index of the list.\n",
    "\n",
    "I can rewrite my function as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_sum(lst):\n",
    "    \"\"\"Add up the values in a list.\"\"\"\n",
    "    s = 0\n",
    "    \n",
    "    for value in lst:\n",
    "        s += value\n",
    "        \n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll run a few tests, just to make sure I *actually* didn't change anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sum(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sum([-1.1, 2.2, 3.3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python's Built-In Sum\n",
    "\n",
    "Summing a list is such a common task that Python has a built-in function for it: `sum`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([-1.1, 2.2, 3.3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `sum` is coloured green in a code cell. Jupyter notebooks highlight all Python special words like that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum, list, abs, min, int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Mean Function\n",
    "\n",
    "Now you will write a function to calculate the mean of a list of numbers. You can write your own code to sum the list, or use Python's built-in `sum` function. I have provided a template to fill in, as well as some tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(lst):\n",
    "    \"\"\"docstring\"\"\"\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 1.\n",
    "mean(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 2.\n",
    "mean([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 1.\n",
    "mean([1, 1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is -3.\n",
    "mean([-2, -1, -6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2: Compute the Variance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Description of Variance\n",
    "\n",
    "The [variance](https://en.wikipedia.org/wiki/Variance) of a dataset, written $\\sigma^2$ or $\\text{Var}(X)$, is a measure of how spread out its values are. It is always positive, and a larger variance means more of the data are far away from the mean. To compute the variance we first compute how far each value is from the mean, square those distances, then average the squares. Our example data, $X = (1, 3, 4, -5, 2)$, has mean 1, so this looks like\n",
    "\n",
    "$$\n",
    "\\sigma^2 = \\frac{(1-1)^2 + (3-1)^2 + (4-1)^2 + (-5-1)^2 + (2-1)^2}{5} = 10 .\n",
    "$$\n",
    "\n",
    "For a general dataset with mean $\\mu$ this becomes\n",
    "\n",
    "$$\n",
    "\\sigma^2 = \\frac{(x_0-\\mu)^2 + (x_1-\\mu)^2 + \\dots + (x_{n-1}-\\mu)^2}{n} ,\n",
    "$$\n",
    "\n",
    "or, in big-sigma notation,\n",
    "\n",
    "$$\n",
    "\\sigma^2 = \\frac{1}{n} \\sum_{i=0}^{n-1} (x_i - \\mu)^2 .\n",
    "$$\n",
    "\n",
    "Note that this is the *biased* variance. Another common form is the unbiased variance, which is divided by $n-1$ instead of $n$. The difference between them is meaningful, but outside the focus of this assignment.\n",
    "\n",
    "The variance is a bit more complicated to compute. You still need to sum a list, but not the list you're given. Instead you must modify the list by subtracting the mean from each value and squaring the result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a New List From an Old One"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ceating a New List With a For Loop\n",
    "\n",
    "I can do this with an explicit `for` loop. Consider the following pseudocode.\n",
    "\n",
    "```\n",
    "Compute the mean of the list\n",
    "Create a new empty list\n",
    "For each value in the data list\n",
    "    Subtract the mean from the value\n",
    "    Square the result\n",
    "    Append the result to the new list\n",
    "```\n",
    "\n",
    "I've already used the name `mean` for a function, so I'll name this variable `data_mean`. Since the `mean` function isn't filled in as I'm writing this (you have to write it), I'll just pretend the mean is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_mean = 1\n",
    "modified_data = []\n",
    "\n",
    "for value in data:\n",
    "    modified_data.append((value - data_mean)**2)\n",
    "    \n",
    "modified_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating a New List With a List Comprehension\n",
    "\n",
    "Python makes working with lists easy. I can simplify my code using a *list comprehension*. I specify what to do with each element, then where the elements are coming from. A list comprehension looks like\n",
    "\n",
    "```python\n",
    "[code_to_compute_new_value for name_for_old_value in name_of_list]\n",
    "```\n",
    "\n",
    "My code can be rewritten like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_mean = 1\n",
    "modified_data = [(value - data_mean)**2 for value in data]\n",
    "modified_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Variance Function\n",
    "\n",
    "Now you will write a function to calculate the variance of a list of numbers. Use the `mean` function you wrote earlier. I have provided a template to fill in, as well as some tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variance(lst):\n",
    "    \"\"\"docstring\"\"\"\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 10.\n",
    "variance(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 0.\n",
    "variance([1, 1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 2.0\n",
    "variance([0, 1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Task 3: Compute the Skewness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Description of Skewness\n",
    "\n",
    "The [skewness](https://en.wikipedia.org/wiki/Skewness) of a dataset, written $\\gamma_1$, is a measure of how asymmetric the values are about the mean. Negative skew means most of the data are to the right of the mean, positive skew means most of the data are on the left, and zero skew means the data are symmetric about the mean. Skewness is computed similarly to variance, but with a cube instead of a square, and all values are divided by the standard deviation to normalize them (remember that the standard deviation is the square root of the variance). In big-sigma notation, this is\n",
    "\n",
    "$$\n",
    "\\gamma_1 = \\frac{1}{n} \\sum_{i=0}^{n-1} \\left( \\frac{x_i - \\mu}{\\sigma} \\right)^3 .\n",
    "$$\n",
    "\n",
    "Our example data, $X = (1, 3, 4, -5, 2)$, has mean 1 and variance 10, so this looks like\n",
    "\n",
    "$$\n",
    "\\gamma_1 = \\frac{1}{5} \\left( \\left( \\frac{1-1}{\\sqrt{10}} \\right)^3 + \\left( \\frac{3-1}{\\sqrt{10}} \\right)^3 + \\left( \\frac{4-1}{\\sqrt{10}} \\right)^3 + \\left( \\frac{-5-1}{\\sqrt{10}} \\right)^3 + \\left( \\frac{2-1}{\\sqrt{10}} \\right)^3 \\right) = \\frac{-180}{50 \\sqrt{10}} \\approx -1.1384.\n",
    "$$\n",
    "\n",
    "Once again there is a distinction between biased and unbiased skewness, but we won't get into it here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Skewness Function\n",
    "\n",
    "You will write a function to compute the skewness of a list of numbers. Use the `mean` and `variance` functions you wrote earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def skewness(lst):\n",
    "    \"\"\"docstring\"\"\"\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is -1.1384199576606167.\n",
    "skewness(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 0.\n",
    "skewness([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 1.4783451126101497.\n",
    "skewness([-1, 2, 6, -3, 100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 4: Compute Arbitrary Central Moments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Description of Central Moments\n",
    "\n",
    "Notice that formulas for variance and skewness both contain something like $\\frac{1}{n} \\sum (x-\\mu)^k$. These are called the [central moments](https://en.wikipedia.org/wiki/Central_moment) of the distribution, and they show up a lot. The $k$th central moment, written $\\mu_k$ is\n",
    "\n",
    "$$\n",
    "\\mu_k = \\frac{1}{n} \\sum_{i=0}^{n-1} (x - \\mu)^k .\n",
    "$$\n",
    "\n",
    "With this definition, the variance is the second central moment and the skewness is $\\gamma_1 = \\mu_3 / \\mu_2^{3/2}$. Many important statitistical values have very simple formulas in terms of central moments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Central Moment Function\n",
    "\n",
    "You will write a function to compute the $k$th central moment of a list of numbers, for any $k$. Your function doesn't need to check that $k$ is a valid power just yet. Use the `mean` function you wrote earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def central_moment(lst, k):\n",
    "    \"\"\"docstring\"\"\"\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Corrent value is 0.\n",
    "central_moment(data, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is 10.\n",
    "central_moment(data, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is -36.\n",
    "central_moment(data, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus Task 4.1: A Function to Make Central Moment Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of a Function-Returning Function\n",
    "\n",
    "A Python function doesn't have to return a constant like `3` or `'asdf'`. A function can create and return a function. for example, the following function returns a function which appends a string to its input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def appender_factory(suffix):\n",
    "    def appender(string):\n",
    "        return string + suffix\n",
    "    \n",
    "    return appender"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `appender` is defined inside the body of `append_factory` and returned. The name `appender` isn't visible outside of `appender_factory`, but you can assign it to a name you choose and use it like any other function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "append_asdf = appender_factory('asdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`append_asdf` is a function which appends `'asdf'` to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "append_asdf('qwer')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create any number of different appender functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "append_foo = appender_factory('foo')\n",
    "append_foo('qwer')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "append_asdf(append_foo('qwer'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You don't technically need to assign the returned function before you use it. This is almost certainly a bad idea, though. Readability counts!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "appender_factory('the very model of a modern Major General')('I am the ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Central Moment Function Function\n",
    "\n",
    "You will write a function which returns a function which computes the $k$th central moment of a list, for any $k$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def central_moment_factory(k):\n",
    "    \"\"\"docstring\"\"\"\n",
    "    def central_moment(lst):\n",
    "        return 1\n",
    "    \n",
    "    return central_moment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your central moment function should return functions which do similar things to your `variance` and `skewness` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is True.\n",
    "variance_from_factory = central_moment_factory(2)\n",
    "variance_from_factory(data) == variance(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct value is True.\n",
    "third_moment = central_moment_factory(3)\n",
    "\n",
    "def skewness_from_factory(lst):\n",
    "    return third_moment(lst) / variance_from_factory(lst)**(3/2)\n",
    "\n",
    "skewness_from_factory(data) == skewness(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 5: Assemble Your Statistics Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have a few general purpose functions you should package them up into a module. A module can be imported into any other Python code so you don't have to copy and paste your code.\n",
    "\n",
    "You will first create a file called `statistics.py` and copy your `mean`, `variance`, `skewness`, and `central_moment` function defintions (and `central_moment_factory` if you wrote one) into it. You can do this by creating a new text file and changing its name. Creating a new Python 3 file won't work because that creates a Python 3 Jupyter notebook.\n",
    "\n",
    "Next you will create a file called `__init__.py` with nothing in it. This file simply tells Python that there are modules in this directory. You can do more with it, but that's beyond the scope of this assignment.\n",
    "\n",
    "You can import the functions from a module with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions in `statistics.py` are now accessible through the name `statistics`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics.variance(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics.skewness(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have to be a bit careful with modules and Jupyter notebooks. Once you've imported a module the notebook won't always notice if you change the module's code. If you're working on a module and changes aren't showing up in a notebook, just restart the notebook's kernel (in the Kernel menu)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the end of this assignment you should be comfortable with:\n",
    "\n",
    "* iterating over a list with a `for` loop,\n",
    "* creating a list with a list comprehension,\n",
    "* writing a simple function to compute a value,\n",
    "* writing docstrings, and\n",
    "* putting code into a reusable module."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}