class3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intermediate Python: Programming\n",
    "\n",
    "# Class 3\n",
    "\n",
    "In our previous class, \n",
    "we explored how to make decisions using code,\n",
    "how to write our own functions,\n",
    "and how to connect these programming structures with for loops.\n",
    "\n",
    "In this class, \n",
    "we'll learn additional ways to improve the usability and robustness of our functions.\n",
    "By the end of this class, you should be able to:\n",
    "\n",
    "- identify and correct different types of errors as reported by python\n",
    "- test and validate complex functions\n",
    "- include help documentation and define defaults for a function\n",
    "- apply assertions to defensively program\n",
    "\n",
    "## Interpreting errors\n",
    "\n",
    "You've probably noticed by now that a lot of time spent coding\n",
    "is actually spent troubleshooting after receiving a warning or error.\n",
    "Let's look at some of the error messages you're likely to receive,\n",
    "and think about ways you may be able to resolve them.\n",
    "\n",
    "> Errors are defined as problems with the basic way code is written.\n",
    "Exceptions refer to external features of code (like variable names)\n",
    "that interrupt the flow of the program.\n",
    "We'll discuss them in this section collectively.\n",
    "\n",
    "Take the following code, \n",
    "which wraps an example we covered in our last class inside a function:\n",
    "```python\n",
    "def pos_neg(x):\n",
    "    if x > 0:\n",
    "        print(x, \"is positive\")\n",
    "    elif x == 0: \n",
    "        print(x, \"is zero\")\n",
    "    else:\n",
    "        print(x, \"is negative, will be converted\")\n",
    "        x = -x\n",
    "    return x\n",
    "        \n",
    "num = \"-3\"\n",
    "\n",
    "pos_neg(num)\n",
    "```\n",
    "\n",
    "This code will produce the following error message:\n",
    "```python\n",
    "---------------------------------------------------------------------------\n",
    "TypeError                                 Traceback (most recent call last)\n",
    "<ipython-input-14-8ada265733cc> in <module>()\n",
    "      9 num = \"-3\"\n",
    "     10 \n",
    "---> 11 pos_neg(num)\n",
    "\n",
    "<ipython-input-14-8ada265733cc> in pos_neg(x)\n",
    "      1 def pos_neg(x):\n",
    "----> 2     if x > 0:\n",
    "      3         print(x, \"is positive\")\n",
    "      4     elif x == 0:\n",
    "      5         print(x, \"is zero\")\n",
    "\n",
    "TypeError: '>' not supported between instances of 'str' and 'int'\n",
    "```\n",
    "\n",
    "The error messages in Python are called tracebacks. \n",
    "It includes enough information that you should be able to determine which part of your code created the error, \n",
    "and ideally,\n",
    "how to correct it.\n",
    "The number of arrows on the lefthand side indicate the number of levels of the error.\n",
    "Here, there are two levels. \n",
    "The first arrow points to line 11,\n",
    "in which the function is called.\n",
    "This traces back to the second arrow,\n",
    "in line 2,\n",
    "which is where the actual error has occurred. \n",
    "The last line of the traceback tells us the type of error and how that error relates to our code. \n",
    "In this case, \n",
    "we're trying to use `>` to compare 0, an integer,\n",
    "with `x`, a string (`num`, which we were using to test our function,\n",
    "and has accidentally been assigned using quotation marks).\n",
    "These different types of data can't be compared in this way.\n",
    "We could resolve this by using an integer to test our code instead.\n",
    "\n",
    "There are three main types of errors you'll see reported from Python:\n",
    "\n",
    "### Syntax errors\n",
    "\n",
    "Syntax errors are related to the basic symbols used to specify actions in code.\n",
    "Examples include:\n",
    "\n",
    "#### Missing a symbol\n",
    "\n",
    "```python\n",
    "def fahr_to_celsius(temp)\n",
    "    return ((temp - 32) * (5/9))\n",
    "```\n",
    "There is a colon missing at the end of the first line,\n",
    "where the function is defined,\n",
    "and is reported as `SyntaxError`,\n",
    "with the explanation of `invalid syntax`.\n",
    "\n",
    "#### Indentation\n",
    "\n",
    "```python\n",
    "def fahr_to_celsius(temp):\n",
    "return ((temp - 32) * (5/9))\n",
    "```\n",
    "The indentation at the beginning of the second line is missing, \n",
    "which is reported as `IndentationError` because `expected an indented block`.\n",
    "\n",
    "Indentation matters in Python,\n",
    "as whitespace (tabs and spaces) is how code chunks are organized into units.\n",
    "Python doesn't allow mixing of whitespace types, \n",
    "so many interpreters correct spaces that are meant to be tabs.\n",
    "Keep in mind that this isn't a failsafe against all possible syntax errors of this type.\n",
    "\n",
    "### Variable name errors\n",
    "\n",
    "Let's say you're trying to print something:\n",
    "```python\n",
    "print(octopus)\n",
    "```\n",
    "You'll see a `NameError`,\n",
    "specifically, \n",
    "that `name 'octopus' is not defined`.\n",
    "One common reason for this is because octopus isn't a variable, \n",
    "but rather, a string around which you forgot to place quotation marks.\n",
    "\n",
    "Another common problem is if you forgot to create a variable before using it,\n",
    "or if you have a typo (e.g., capitalization mismatch) between variable references:\n",
    "```python\n",
    "name = \"octopus\"\n",
    "print(Name)\n",
    "```\n",
    "\n",
    "### Index errors\n",
    "\n",
    "If you are attempting to access an element in a list,\n",
    "but there is no element at the index position specified,\n",
    "you'll receive an `IndexError`.\n",
    "```python\n",
    "name = \"octopus\"\n",
    "name[7]\n",
    "```\n",
    "For this error, the explanation is `string index out of range`.\n",
    "This means that the string,\n",
    "`octopus`, does not have a character at index position 7.\n",
    "\n",
    "### File errors\n",
    "\n",
    "If you had a typo in a filename when trying to load data in one of our previous classes, \n",
    "you probably saw an error citing `OSError`.\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "data = np.loadtxt(fname=\"data/inflamation-01.csv\", delimiter=\",\")\n",
    "```\n",
    "The explanation is that the file is `not found`,\n",
    "which means that either the name of the file is wrong,\n",
    "or its location isn't correct (e.g., if you forgot to include `data/` before the filename).\n",
    "\n",
    "> These are the most common errors you're likely to encounter, \n",
    "although this list is not exhaustive. \n",
    "The Python documentation explains [built-in errors and exceptions](https://docs.python.org/3/library/exceptions.html), \n",
    "although if you're using someone else's code, \n",
    "it's possible they've written a custom exception.\n",
    "\n",
    ">#### Challenge-errors\n",
    "Using the error message included below the code, \n",
    "identify the type of error and why it is occurring.\n",
    "\n",
    "*Code:*\n",
    "```python\n",
    "def print_message(day):\n",
    "    messages = {\n",
    "        \"monday\": \"Hello, world!\",\n",
    "        \"tuesday\": \"Today is tuesday!\",\n",
    "        \"wednesday\": \"It is the middle of the week.\",\n",
    "        \"thursday\": \"Today is Donnerstag in German!\",\n",
    "        \"friday\": \"Last day of the week!\",\n",
    "        \"saturday\": \"Hooray for the weekend!\",\n",
    "        \"sunday\": \"Aw, the weekend is almost over.\"\n",
    "    }\n",
    "    print(messages[day])\n",
    "\n",
    "def print_friday_message():\n",
    "    print_message(\"Friday\")\n",
    "\n",
    "print_friday_message()\n",
    "```\n",
    "*Error:*\n",
    "```python\n",
    "---------------------------------------------------------------------------\n",
    "KeyError                                  Traceback (most recent call last)\n",
    "<ipython-input-33-ce8c0be5fdfb> in <module>()\n",
    "     14     print_message(\"Friday\")\n",
    "     15 \n",
    "---> 16 print_friday_message()\n",
    "\n",
    "<ipython-input-33-ce8c0be5fdfb> in print_friday_message()\n",
    "     12 \n",
    "     13 def print_friday_message():\n",
    "---> 14     print_message(\"Friday\")\n",
    "     15 \n",
    "     16 print_friday_message()\n",
    "\n",
    "<ipython-input-33-ce8c0be5fdfb> in print_message(day)\n",
    "      9         \"sunday\": \"Aw, the weekend is almost over.\"\n",
    "     10     }\n",
    "---> 11     print(messages[day])\n",
    "     12 \n",
    "     13 def print_friday_message():\n",
    "\n",
    "KeyError: 'Friday'\n",
    "```\n",
    "\n",
    "We'll talk more about troubleshooting and debugging code in our next class\n",
    "but this framework of understanding errors should be useful as we proceed to increase the robustness of our functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing and validating\n",
    "\n",
    "When writing custom functions,\n",
    "you are the one responsible for determining whether they are running correctly. \n",
    "\n",
    "What does it mean to run \"correctly\"? \n",
    "In general, \n",
    "this means ensuring the function works as expected,\n",
    "which involves answering two different questions:\n",
    "\n",
    "1. *Does the code perform the task we've specified?* \n",
    "Ensuring the code runs without error and in the manner you intend is referred to as **verification**,\n",
    "sometimes and is confirmed through testing (often against a test dataset or task).\n",
    "2. *Does the code meet stated goal?*\n",
    "Ensuring the code performs specific tasks that meet our specific need is referred to as **validation**,\n",
    "and requires careful inspection of the tasks performed by the code,\n",
    "as well as how they fit into the rest of the software being used.\n",
    "\n",
    "Let's apply this framework to the challenge exercise from our last class,\n",
    "in which you wrote a function to count the number of vowels in a string.\n",
    "You verified the function was working correctly by using a few short example strings with known numbers of vowels.\n",
    "To validate this function, however,\n",
    "you would also need to confirm whether capitalization matters,\n",
    "and whether the letter y should be included as a vowel.\n",
    "\n",
    "Since validation relies on external factors, \n",
    "we'll rely in this class on specifying tasks to the best of our ability,\n",
    "and instead focus on testing through verification.\n",
    "To examine this process,\n",
    "we'll first write a function that offsets the data in an array by a specific value supplied by the user:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def offset_mean(data, target_mean_value):\n",
    "    return (data - np.mean(data)) + target_mean_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll create a test dataset to use with the function to ensure it's working as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test dataset: [[0. 0.]\n",
      " [0. 0.]]\n",
      "offset data: [[3. 3.]\n",
      " [3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "# create test dataset\n",
    "z = np.zeros((2,2))\n",
    "print(\"test dataset:\", z)\n",
    "# test new function\n",
    "print(\"offset data:\", offset_mean(z, 3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we've also used `np.zeros`, \n",
    "a useful function for creating test datasets entirely of zeros \n",
    "(which allow mathematical manipulations to be more easily interpreted).\n",
    "\n",
    "Finally, we can assess the output from an inflammation dataset to ensure our approach seems reasonable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "offset inflammation: [[-6.14875 -6.14875 -5.14875 ... -3.14875 -6.14875 -6.14875]\n",
      " [-6.14875 -5.14875 -4.14875 ... -5.14875 -6.14875 -5.14875]\n",
      " [-6.14875 -5.14875 -5.14875 ... -4.14875 -5.14875 -5.14875]\n",
      " ...\n",
      " [-6.14875 -5.14875 -5.14875 ... -5.14875 -5.14875 -5.14875]\n",
      " [-6.14875 -6.14875 -6.14875 ... -6.14875 -4.14875 -6.14875]\n",
      " [-6.14875 -6.14875 -5.14875 ... -5.14875 -5.14875 -6.14875]]\n"
     ]
    }
   ],
   "source": [
    "# use offset function on real data\n",
    "data = np.loadtxt(fname=\"data/inflammation-01.csv\", delimiter=\",\")\n",
    "print(\"offset inflammation:\", offset_mean(data, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run some basic summary statistics on the original and offset data to ensure the offset is working as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original min, mean, and max are: 0.0 6.14875 20.0\n",
      "min, mean, and max of offset data are: -6.14875 2.842170943040401e-16 13.85125\n"
     ]
    }
   ],
   "source": [
    "# confirm offset has worked\n",
    "print('original min, mean, and max are:', np.min(data), np.mean(data), np.max(data))\n",
    "offset_data = offset_mean(data, 0)\n",
    "print('min, mean, and max of offset data are:',\n",
    "      np.min(offset_data),\n",
    "      np.mean(offset_data),\n",
    "      np.max(offset_data))\n",
    "# offset isn't exact, but is close\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given that the mean of the original data is 6.14875,\n",
    "we expect the offset summary stats to be:\n",
    "- min = -6.14875 (original min of 0 - 6.14875)\n",
    "- mean = 0 (original min of 6.14875 - 6.14875)\n",
    "- max = 13.85125 (original max of 20 - 6.14875)\n",
    "\n",
    "The offset isn't exact (because of rounding during calculations),\n",
    "but they are very close.\n",
    "Let's check the standard deviation, \n",
    "and instead use an extra calculation that will make it easier to quickly assess if they're the same:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "difference in standard deviations before and after: 0.0\n"
     ]
    }
   ],
   "source": [
    "print('difference in standard deviations before and after:',\n",
    "      np.std(data) - np.std(offset_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we are confident our function works as intended,\n",
    "we should add documentation to record its purpose.\n",
    "In the code above,\n",
    "we used code comments to share information about the function.\n",
    "While this technically documents our code, \n",
    "a more effective way is to embed help documentation within the code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def offset_mean(data, target_mean_value):\n",
    "    'offset array by value'\n",
    "    return (data - np.mean(data)) + target_mean_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While technically correct,\n",
    "this may not be useful in a few months.\n",
    "We can include a bit more information if we use three sets of quotation marks,\n",
    "so we can include text on multiple lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def offset_mean(data, target_mean_value):\n",
    "    '''Return a new array containing the original data\n",
    "       with its mean offset to match the desired value.'''\n",
    "    return (data - np.mean(data)) + target_mean_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This format allows us to access the help documentation,\n",
    "in the same way we would another function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function offset_mean in module __main__:\n",
      "\n",
      "offset_mean(data, target_mean_value)\n",
      "    Return a new array containing the original data\n",
      "    with its mean offset to match the desired value.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(offset_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">#### Challenge-docstring\n",
    "In our last class, we created a function for temperature conversion.\n",
    "Add a docstring to document the code:\n",
    "```python\n",
    "def fahr_to_celsius(temp):\n",
    "    return ((temp - 32) * (5/9))\n",
    "```\n",
    "\n",
    "## Defining defaults\n",
    "\n",
    "The next step in developing our function is to define defaults.\n",
    "The default parameters are what the function assumes to use,\n",
    "unless you specify something different.\n",
    "\n",
    "An example of a program default can been seen in how we loaded our data:\n",
    "\n",
    "```\n",
    "np.loadtxt(fname=\"data/inflammation-01.csv\", delimiter=\",\")\n",
    "```\n",
    "\n",
    "Without `delimiter=\",\"`, \n",
    "the function will assume the columns are separated by whitespace.\n",
    "\n",
    "We can include a default value in our custon function,\n",
    "here setting the target mean to zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def offset_mean(data, target_mean_value=0.0):\n",
    "    '''Return a new array containing the original data with its mean offset to match the\n",
    "       desired value (0 by default).\n",
    "    Example: offset_mean([1, 2, 3], 0) => [-1, 0, 1]'''\n",
    "    return (data - np.mean(data)) + target_mean_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, we should also update the documentation to ensure it still reflects the current state of the function.\n",
    "It is also useful to include an example \n",
    "(input and output) of how the function is used.\n",
    "\n",
    "We can use our function to explore how Python handles defaults,\n",
    "by testing our function and still using two arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test data [[0. 0.]\n",
      " [0. 0.]]\n",
      "offset data [[3. 3.]\n",
      " [3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "test_data = np.zeros((2, 2))\n",
    "print(\"test data\", test_data)\n",
    "print(\"offset data\", offset_mean(test_data, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to apply the default value of zero,\n",
    "we would need to modify our test data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data before mean offset: [[5. 5.]\n",
      " [5. 5.]]\n",
      "offset data: [[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# modify data so default value can be applied with effect\n",
    "more_data = 5 + np.zeros((2, 2))\n",
    "print('data before mean offset:', more_data)\n",
    "# offsetting data with default parameter\n",
    "print('offset data:', offset_mean(more_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, we can see the offset still working,\n",
    "even though we haven't specified a value by which to offset.\n",
    "\n",
    "Let's explore how Python matches values to parameters\n",
    "using a simple example function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no parameters:\n",
      "a: 1 b: 2 c: 3\n",
      "one parameter:\n",
      "a: 55 b: 2 c: 3\n",
      "two parameters:\n",
      "a: 55 b: 66 c: 3\n"
     ]
    }
   ],
   "source": [
    "def display(a=1, b=2, c=3):\n",
    "    print('a:', a, 'b:', b, 'c:', c)\n",
    "\n",
    "print('no parameters:')\n",
    "display()\n",
    "print('one parameter:')\n",
    "display(55)\n",
    "print('two parameters:')\n",
    "display(55, 66)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output above illustrates two rules for parameters:\n",
    "\n",
    "- parameters are matched with values inside the parentheses from left to right \n",
    "- any parameter without a value assigned by the user is automatically given the default value\n",
    "\n",
    "The example above relies solely on the relative position of values.\n",
    "We can override the positional assumptions by naming a value as it's entered:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 1 b: 2 c: 77\n"
     ]
    }
   ],
   "source": [
    "display(c=77)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the default values for `a` and `b` remain unchanged,\n",
    "while `c` has changed to suit our needs.\n",
    "\n",
    "> You may see references to values or parameters being \"passed.\"\n",
    "This is the same thing as saying \"entering\" or \"giving\" a value,\n",
    "such as `c=11` in the example above. \n",
    "In this case, 11 is the value being passed.\n",
    "\n",
    "With this understanding of default values,\n",
    "you should now be better equipped to understand the help documentation associated with the functions we've already been using.\n",
    "\n",
    "Executing `help(np.loadtxt)`, for example,\n",
    "lets us know the function:\n",
    "\n",
    "- has a parameter called fname that doesn’t have a default value\n",
    "- has eight others parameters that do have default values\n",
    "- needs to have delimiters defined \n",
    "(e.g., `delimiter=\",\"` rather than only `\",\"`) \n",
    "because there are so many other parameters available\n",
    "\n",
    ">#### Challenge-parameters\n",
    "What does the following code display when run, and why?\n",
    "\n",
    "```python\n",
    "def numbers(one, two=2, three, four=4):\n",
    "    n = str(one) + str(two) + str(three) + str(four)\n",
    "    return n\n",
    "\n",
    "print(numbers(1, three=3))\n",
    "```\n",
    "\n",
    ">#### Challenge-parameters2\n",
    "What does the following code display when run, and why?\n",
    "\n",
    "```python\n",
    "def func(a, b=3, c=6):\n",
    "    print('a:', a, 'b:', b, 'c:', c)\n",
    "\n",
    "func(-1, 2)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assertions and defensive programming\n",
    "\n",
    "Understanding how to effectively debug is important for our ability to write code,\n",
    "but is also useful for protecting ourselves from making future mistakes.\n",
    "In this section, we'll explore defensive programming as a strategy to improve our effectiveness as coders.\n",
    "Defensive programming assumes that mistakes will happen,\n",
    "and provides information (via code) to guard against them.\n",
    "\n",
    "Assertions are one of the main tools we can apply in programming defensively. \n",
    "Assertions are statements assessing whether something is true at a given point in a program.\n",
    "If the statement is true, the program proceeds,\n",
    "but if it is false, Python prints a specified error message.\n",
    "\n",
    "Let's take a look at how assertions work with a simple example.\n",
    "We'll create two test datasets,\n",
    "one that includes numbers that are all positive, \n",
    "and another that includes negative numbers: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers_pos = [1.5, 5.2, 3.5, 4.1]\n",
    "numbers_neg = [1.5, 5.2, -3.5, 4.1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll write a for loop that adds the numbers together.\n",
    "\n",
    "The assertion we include here requires that all data should be positive.\n",
    "Technically, an assertion only needs state the criteria \n",
    "(e.g., `assert n > 0.0`), \n",
    "but we include a statement that makes the mistake understandable\n",
    "without having to dig into the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value: 1.5\n",
      "value: 5.2\n",
      "value: -3.5\n"
     ]
    },
    {
     "ename": "AssertionError",
     "evalue": "Data should only contain positive values",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-da31dbef32fc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnumbers_neg\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"value:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Data should only contain positive values'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mtotal\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'total is:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtotal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: Data should only contain positive values"
     ]
    }
   ],
   "source": [
    "total = 0.0\n",
    "for n in numbers_neg:\n",
    "    print(\"value:\", n)\n",
    "    assert n > 0.0, 'Data should only contain positive values'\n",
    "    total += n\n",
    "print('total is:', total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loop runs fine with `numbers_pos`, \n",
    "which we can treat like a positive control in an experimental setting.\n",
    "If we replace it with `numbers_neg`, \n",
    "though, the assertion is reported:\n",
    "\n",
    "```python\n",
    "total = 0.0\n",
    "for n in numbers_neg:\n",
    "    assert n > 0.0, 'Data should only contain positive values'\n",
    "    total += n\n",
    "print('total is:', total)\n",
    "```\n",
    "\n",
    "```python\n",
    "value: 1.5\n",
    "value: 5.2\n",
    "value: -3.5\n",
    "---------------------------------------------------------------------------\n",
    "AssertionError                            Traceback (most recent call last)\n",
    "<ipython-input-18-da31dbef32fc> in <module>\n",
    "      2 for n in numbers_neg:\n",
    "      3     print(\"value:\", n)\n",
    "----> 4     assert n > 0.0, 'Data should only contain positive values'\n",
    "      5     total += n\n",
    "      6 print('total is:', total)\n",
    "\n",
    "AssertionError: Data should only contain positive values\n",
    "```\n",
    "\n",
    "We can then use this error information to help us figure out how to use the code correctly.\n",
    "Because we've printed the values inside the for loop,\n",
    "we can use the output to illustrate how far the process proceeds before the assertion fails. \n",
    "\n",
    "There are three types of assertions:\n",
    "\n",
    "- *precondition:* something that must be true at the start of the function in order for it to work correctly\n",
    "- *postcondition:* something that the function guarantees is true when it finishes\n",
    "- *invariant:* something that is always true at a particular point inside a piece of code\n",
    "\n",
    ">#### Challenge-pre-post\n",
    "Suppose you are writing a function called `average` that calculates the average of the numbers in a list. What pre-conditions and post-conditions would you write for it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrapping up\n",
    "\n",
    "In this class, \n",
    "we explored types of errors in Python, \n",
    "testing/validating functions,\n",
    "including help documentation and defaults for functions,\n",
    "and assertions to program defensively.\n",
    "\n",
    "In our next and final class,\n",
    "we'll continue to develop our functions for other people to use \n",
    "by exploring debugging, test-driven development, \n",
    "and creating command-line programs from our python scripts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}