Lectures/Week-08-BooleanRedo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More boolean examples\n",
    "\n",
    "Now that you have all the vocabulary, we can talk through more problems.\n",
    "\n",
    "# How are all these patterns used?\n",
    "\n",
    "There are roughly 3 kinds of purposes for using a decision structure:\n",
    "\n",
    "1. Filtering\n",
    "    * used for tossing out data or retaining something\n",
    "    * examples: tossing out empty string\n",
    "    * these usually look like small if/else statements.\n",
    "2. Complex boolean decision trees\n",
    "    * used to encode complex logic trees with branching logic, etc. These are often used to classify things, make a decision about something, etc. There are ofter a complex set of rules to go along with things.\n",
    "    * examples: determining if a year is a leap year.\n",
    "    * these often look like heavily nested if statments, have complex booleans, etc.\n",
    "3. Case/switch statements\n",
    "    * used to assign an approprate value or label. Ususually these are times when you don't have a lot of overlab between the categories, and just need to determine which label something needs or an action.\n",
    "    * example: determining the letter grade of a score\n",
    "    * these often look like a long chain of if/elif/else staments with little branching. The order of control flow in the stamment presumes that all the previous categories are true, so there is usalally littly compound boolean stamements.\n",
    "    \n",
    "The purpose of having these categories is to help you understand and classify the kinds of situations where these are used and how their needs determine the approach.  These are also very general descriptions, so there will often be hybrid situations or tasks that are a mix of some or all of these groups."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last week we covered the core concepts of using booleans in our programs.  We covered if/else, and today we'll cover expanding this into the if/elif/else combination.  This allows us to create larger boolean blocks to have more precise control over the processing flow of our program.\n",
    "\n",
    "Recall this pattern:\n",
    "\n",
    "```\n",
    "if something:\n",
    "    stuff to do if something is True\n",
    "else:\n",
    "    stuff to do if something is False\n",
    "```\n",
    "\n",
    "That `else` there belongs to the if block, and will only execute when that `if` condition is false.  Keeping these two conditions together and dependent on eachother will give us tighter control over our logical checks.  This is effectively saying that there is only one question at hand, and there are 2 possible answers.  \n",
    "\n",
    "However, there are many cases where we have a single question but there are many possible answers.  This is where `elif` comes in.  It is short for \"else if\", and like the `else` statement, will only be attempted if the statement before it has a conditional check evaluate to False.  It may only appear after an if statement.\n",
    "\n",
    "# Core if/elif model\n",
    "* `elif`: short for 'else if', may come after an `if` block and should be on the same indent level as the parent `if` block.  Must be followed by a conditional check.  I almost always include an `else` statement with this structure, but it is not required.  Example usage:\n",
    "\n",
    "    * ```python\n",
    "    if x > 10:\n",
    "        print(\"it is greater than 10\")\n",
    "     elif x >= 0 and x < 10:\n",
    "         print(\"it is between 0 and 9 (inclusive)\")```\n",
    "* `else`: this is an optional block that will catch anything that didn't pass on the previous conditional checks, you may only use this once and it can only appear at the end.  Example usage:\n",
    "    * ```python\n",
    "    if x > 10:\n",
    "        print(\"it is greater than 10\")\n",
    "     elif x >= 0 and x < 10:\n",
    "         print(\"it is between 0 and 9 (inclusive)\")\n",
    "     else:\n",
    "         print(\"x is below 0\")\n",
    "         ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it is between 0 and 9 (inclusive)\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "if x > 10:\n",
    "    print(\"it is greater than 10\")\n",
    "elif x >= 0:\n",
    "     print(\"it is between 0 and 9 (inclusive)\")\n",
    "else:\n",
    "     print(\"x is below 0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is below 0\n"
     ]
    }
   ],
   "source": [
    "x = -9000\n",
    "\n",
    "if x > 10:\n",
    "    print(\"it is greater than 10\")\n",
    "elif x >= 0:\n",
    "     print(\"it is between 0 and 9 (inclusive)\")\n",
    "else:\n",
    "     print(\"x is below 0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compare this to a bunch of if statements in a line.  Remember that if statements will not connect to eachother, so each will have their conditional check evaluated.  We can explore the protection of this by looking at our friend: `10/0` again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dividing by: -5\n",
      "this is less than 5!\n",
      "dividing by: -4\n",
      "this is less than 5!\n",
      "dividing by: -3\n",
      "this is less than 5!\n",
      "dividing by: -2\n",
      "this is less than 5!\n",
      "dividing by: -1\n",
      "this is less than 5!\n",
      "dividing by: 0\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-9f779a891ac2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdivide10by\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-3-9f779a891ac2>\u001b[0m in \u001b[0;36mdivide10by\u001b[0;34m(divisor)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdivide10by\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdivisor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"dividing by:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdivisor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mdivisor\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;34m\"this is less than 5!\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "def divide10by(divisor):\n",
    "    print(\"dividing by:\", divisor)\n",
    "    if 10/divisor < 5:\n",
    "        return \"this is less than 5!\"\n",
    "    else:\n",
    "        return \"result is between 5 and 10.\"\n",
    "        \n",
    "for i in range(-5, 5):\n",
    "    print(divide10by(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see here that even attempting to evaluate that conditional check relults in a syntax error. We can use a if/elif/else block here to add another check so that if the divisor is 0 it will never attempt to execute that conditional check."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dividing by: -5\n",
      "this is less than 5!\n",
      "dividing by: -4\n",
      "this is less than 5!\n",
      "dividing by: -3\n",
      "this is less than 5!\n",
      "dividing by: -2\n",
      "this is less than 5!\n",
      "dividing by: -1\n",
      "this is less than 5!\n",
      "dividing by: 0\n",
      "sorry, can't do that\n",
      "dividing by: 1\n",
      "result is between 5 and 10.\n",
      "dividing by: 2\n",
      "result is between 5 and 10.\n",
      "dividing by: 3\n",
      "this is less than 5!\n",
      "dividing by: 4\n",
      "this is less than 5!\n"
     ]
    }
   ],
   "source": [
    "divisor = 0\n",
    "\n",
    "def divide10by(divisor):\n",
    "    print(\"dividing by:\", divisor)\n",
    "    if divisor == 0:\n",
    "        return \"sorry, can't do that\"\n",
    "    elif 10/divisor < 5:\n",
    "        return \"this is less than 5!\"\n",
    "    else:\n",
    "        return \"result is between 5 and 10.\"\n",
    "    \n",
    "for i in range(-5,5):\n",
    "    print(divide10by(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, you can think of using these things as a chain of conditions, and you can presume that all the previous conditions have been False beforehand.  This can help make your canditional checks shorter and your meaning behind things clearer.\n",
    "\n",
    "Say that we want to make a pass/fail grader.  50+ is passing, less than 50 is failing, and anything less than 0 or above 100 is invalid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 too low\n",
      "0 noneset\n",
      "10 fail\n",
      "20 fail\n",
      "30 fail\n",
      "40 fail\n",
      "50 pass\n",
      "60 pass\n",
      "70 pass\n",
      "80 pass\n",
      "90 pass\n",
      "100 pass\n"
     ]
    }
   ],
   "source": [
    "def gradethehardway(score):\n",
    "    grade = \"noneset\"\n",
    "    if score > 100:\n",
    "        grade = \"too high\"\n",
    "    if score < 0:\n",
    "        grade = \"too low\"\n",
    "    if score <= 100 and score >= 50:\n",
    "        grade = \"pass\"\n",
    "    if score < 50 and score > 0:\n",
    "        grade = \"fail\"\n",
    "    return grade\n",
    "\n",
    "for i in range(-10,110,10):\n",
    "    print(i, gradethehardway(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several things going on here.  I've used multiple if statements here, meaning that each conditional check will be executed.  It is possible to write your statements this way so that everything is tidy so this will work.  However, this means that you now have to have a bunch of extra conditional checks.\n",
    "\n",
    "And we still didn't catch all of them!  I've missed a condition for 0.  I've got > 0 and < 0, but nothing equal to 0 will make any of these true.  Sometimes you want each if statement to be checked, is which case it is fine to have several if blocks in a row.  Otherwise, do this in an if/elif/else block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 too low\n",
      "0 fail\n",
      "10 fail\n",
      "20 fail\n",
      "30 fail\n",
      "40 fail\n",
      "50 pass\n",
      "60 pass\n",
      "70 pass\n",
      "80 pass\n",
      "90 pass\n",
      "100 pass\n"
     ]
    }
   ],
   "source": [
    "def gradeeasier(score):\n",
    "    grade = \"noneset\"\n",
    "    if score > 100:\n",
    "        grade = \"too high\"\n",
    "    elif score >= 50:\n",
    "        grade = \"pass\"\n",
    "    elif score >= 0:\n",
    "        grade = \"fail\"\n",
    "    else:\n",
    "        grade = \"too low\"\n",
    "    return grade\n",
    "\n",
    "for i in range(-10,110,10):\n",
    "    print(i, gradeeasier(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this kind of structure requires that we do our conditions in order, we have fewer conditional expressions and our design/intent is a bit easier to follow.\n",
    "\n",
    "Taking a look at just this section:\n",
    "\n",
    "```python \n",
    "    elif score >= 50:\n",
    "        grade = \"pass\"\n",
    "```\n",
    "\n",
    "This is coming after our if statement that checks if the score is greater than 100.  If the evaluation gets to the point of checking this conditional statement, we can presume that previous check was false.  Therefor, we don't need to reassert that condition.\n",
    "\n",
    "This structure forms a conditional chain, where you can presume that the previous conditions all failed by the time that it gets to the chunk that will actually execute.  You can alse presume then, that a chunk well never perform the conditional check or execute unless everything before it has failed.\n",
    "\n",
    "This is sort of like the \"20 questios model\", where you are asking a series of questions over and over until you find the right chunk.  The other pattern that we will be covering after this will be how to add more complexity in your questions.\n",
    "\n",
    "Our tl;dr summary from last week:\n",
    "\n",
    "* `if`: required, only once, and always your first statement. Put a conditional check after.\n",
    "* `elif`: optional, may appear many times, and must be directly after an `if` statement. On the same block level as your `if` statement.\n",
    "* `else`: optional, may appear once, and only as your last statement in the if block.  On the same block level as your if statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# compound booleans\n",
    "\n",
    "Sometimes several conditions must be met inside of the some conditional check area.  We want to keep these two together because we don't want to execute anything if just one of the pieces is true.  We can link boolean expressions with keywords such as `and` and `or`.  \n",
    "\n",
    "We can look at our previous example \n",
    "\n",
    "``` python\n",
    "def gradeeasier(score):\n",
    "    grade = \"noneset\"\n",
    "    if score > 100:\n",
    "        grade = \"too high\"\n",
    "    elif score >= 50:\n",
    "        grade = \"pass\"\n",
    "    elif score >= 0:\n",
    "        grade = \"fail\"\n",
    "    else:\n",
    "        grade = \"too low\"\n",
    "    return grade\n",
    "```\n",
    "\n",
    "We might not want to do anything specical for the too high and too low situations, and instead just have a blanket \"invalid\" message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 invalid\n",
      "0 fail\n",
      "10 fail\n",
      "20 fail\n",
      "30 fail\n",
      "40 fail\n",
      "50 pass\n",
      "60 pass\n",
      "70 pass\n",
      "80 pass\n",
      "90 pass\n",
      "100 pass\n",
      "110 invalid\n"
     ]
    }
   ],
   "source": [
    "def gradeeasier(score):\n",
    "    grade = \"noneset\"\n",
    "    if score <= 100 and score >= 50:\n",
    "        grade = \"pass\"\n",
    "    elif score <= 100 and score >= 0:\n",
    "        grade = \"fail\"\n",
    "    else:\n",
    "        grade = \"invalid\"\n",
    "    return grade\n",
    "\n",
    "for i in range(-10,120,10):\n",
    "    print(i, gradeeasier(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case we had to add the `>= 100` check to each of our checks because those values weren't tho first thing tossed out.  To clean things up, we could switch things to test for bad values as our first check, so we don't have to worry about things after that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 invalid\n",
      "0 fail\n",
      "10 fail\n",
      "20 fail\n",
      "30 fail\n",
      "40 fail\n",
      "50 pass\n",
      "60 pass\n",
      "70 pass\n",
      "80 pass\n",
      "90 pass\n",
      "100 pass\n",
      "110 invalid\n"
     ]
    }
   ],
   "source": [
    "def gradeeasier(score):\n",
    "    grade = \"noneset\"\n",
    "    if score > 100 or score < 0:\n",
    "        grade = \"invalid\"\n",
    "    elif score >= 50:\n",
    "        grade = \"pass\"\n",
    "    elif score >= 0:\n",
    "        grade = \"fail\"\n",
    "    else:\n",
    "        grade = \"invalid\"\n",
    "    return grade\n",
    "\n",
    "for i in range(-10,120,10):\n",
    "    print(i, gradeeasier(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I left that last if statement in there, even though it should be unnecessary.  However, it can be dangerous to leave an if block open without an else statement to catch things that unexpectantly fall through.  When first developing a program you will want to leave them in until you are certain.  Just give yourself a good warning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 invalid\n",
      "0 fail\n",
      "10 fail\n",
      "20 fail\n",
      "30 fail\n",
      "40 fail\n",
      "50 pass\n",
      "60 pass\n",
      "70 pass\n",
      "80 pass\n",
      "90 pass\n",
      "100 pass\n",
      "110 invalid\n"
     ]
    }
   ],
   "source": [
    "def gradeeasier(score):\n",
    "    grade = \"noneset\"\n",
    "    if score > 100 or score < 0:\n",
    "        grade = \"invalid\"\n",
    "    elif score >= 50:\n",
    "        grade = \"pass\"\n",
    "    elif score >= 0:\n",
    "        grade = \"fail\"\n",
    "    else:\n",
    "        grade = \"THIS SHOULD NEVER EXECUTE\" # here's our warning\n",
    "    return grade\n",
    "\n",
    "for i in range(-10,120,10):\n",
    "    print(i, gradeeasier(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nested if statements and compound boolean\n",
    "\n",
    "Meanwhile, sometimes you have a more detailed question that has several conditional checks.  Sometimes this pattern and the chain pattern can be interchangable, depending on how you form your conditional checks, but there will be cases when one of these patterns is more staight forward or really the only way to get the job done.\n",
    "\n",
    "## nested if statements\n",
    "\n",
    "This is where you have a conditional check and want to ask a subsequent check only if that first one comes out as true.\n",
    "\n",
    "def divide10by(divisor):\n",
    "    print(\"dividing by:\", divisor)\n",
    "    if divisor != 0:\n",
    "        if 10/divisor < 5:\n",
    "            return \"this is less than 5!\"\n",
    "        else:\n",
    "            return \"result is between 5 and 10.\"\n",
    "        \n",
    "for i in range(-5, 5):\n",
    "    print(divide10by(i))\n",
    "    \n",
    "We've taken our previous example and retooled it so that our core if/else block will only have the opportunity to start if the divisor is not 0.\n",
    "\n",
    "There are cases where this is the only pattern that is reasonable, but this pattern adds visual complexity and can start to make things difficult to debug and understand.  \n",
    "\n",
    "This kind of situation remains better solved with the if/elif/else pattern, so that there's no chance that the problematic conditional check will execute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Think about what the data is that you're working with\n",
    "\n",
    "For example, are you actually working with numbers?  Or do those numbers represent other stuff?  Think aout the meaning of the actual data points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical data\n",
    "\n",
    "This is PE2 here, so you have:\n",
    "\n",
    "* 5 is A\n",
    "* 4 is B\n",
    "* 3 is C\n",
    "* 2 is D\n",
    "* 1 is F\n",
    "* 0 is F\n",
    "\n",
    "So these are numbers, but they could be pretty much anything else.  In this kind of cirucumstance, you could also use a lookup datastructure.  That might be sufficient for some tasks, but as you will see that this structure gives you more flexibility.\n",
    "\n",
    "In this case, each of these will be an `==` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 F\n",
      "1 F\n",
      "2 D\n",
      "3 C\n",
      "4 B\n",
      "5 A\n",
      "6 unknown\n",
      "7 unknown\n",
      "8 unknown\n",
      "9 unknown\n"
     ]
    }
   ],
   "source": [
    "def quizgrade(score):\n",
    "    grade = \"notset\"\n",
    "    if score == 5:\n",
    "        grade = \"A\"\n",
    "    elif score == 4:\n",
    "        grade = \"B\"\n",
    "    elif score == 3:\n",
    "        grade = \"C\"\n",
    "    elif score == 2:\n",
    "        grade = \"D\"\n",
    "    elif score == 1 or score == 0:\n",
    "        grade = \"F\"\n",
    "    else:\n",
    "        grade = \"unknown\"\n",
    "    return grade\n",
    "\n",
    "for i in range(10):\n",
    "    print(i, quizgrade(i))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, this will only work with the exact integer values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 F\n",
      "0.5 unknown\n",
      "1 F\n",
      "1.5 unknown\n",
      "2 D\n",
      "2.5 unknown\n",
      "3 C\n",
      "3.5 unknown\n",
      "4 B\n",
      "4.5 unknown\n",
      "5 A\n",
      "5.5 unknown\n"
     ]
    }
   ],
   "source": [
    "for i in [0, .5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5]:\n",
    "    print(i, quizgrade(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's more context that we would need to firmly deal with this.  But this gets us to our next pattern."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continuous data with an upper/lower limit\n",
    "\n",
    "So let's start with PE2, but say that the grading scale was changed so that partial credit could be given.  This means that instead of 6 unique values, you now have a 6 sets of ranges.\n",
    "\n",
    "We need to define all these ranges first.  Let's say that 5 is still the max score, presuming that you have full credit on all the questions.  The lowest is still 0.  We still want to give out letter scores for the changes over from integer numbers. In these cases it can be useful to start from the bottom. I'll be using 1 decimal place as a shorthand for 1.999999 repeating.\n",
    "\n",
    "* Max: 5, Min: 0\n",
    "* F: 0.0 - .09\n",
    "* F: 1.0 - 1.9\n",
    "* D: 2.0 - 2.9\n",
    "* C: 3.0 - 3.9\n",
    "* B: 4.0 - 4.9\n",
    "* A: 5?\n",
    "\n",
    "This seems really silly, but it you think about having 5 questions, each of which are worth between 0 and 1 points each.\n",
    "\n",
    "We want it to be this way, where the A range in between and 5.\n",
    "\n",
    "```\n",
    "0.0 - 0.99 x 1.0 - 1.99 x 2.0 - 2.99 x 3.0 - 3.9 x 4.0 - 5\n",
    "____F____________D____________C____________B___________A__\n",
    "\n",
    "```\n",
    "\n",
    "However, this is how it would need to work with the previous scale.\n",
    "\n",
    "```\n",
    "0.0 - 0.99 x 1.0 - 1.99 x 2.0 - 2.99 x 3.0 - 3.9 x 4.0 - 4.9 x 5.0 - \n",
    "____F____________F____________D____________C___________B___________A\n",
    "\n",
    "```\n",
    "\n",
    "So F spans 0-2, and the only way to get an A is to get full points on each question.  \n",
    "\n",
    "Anyhow, let's pretend that we checked with our stakeholder and they confirmed that the wacky way is indeed what they want.\n",
    "\n",
    "We can start with our previous one, and come up with a nicely simple set of changes that work because we've got a meaningful chain happening with our elifs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 F\n",
      "1 F\n",
      "2 D\n",
      "3 C\n",
      "4 B\n",
      "5 A\n",
      "6 B\n",
      "7 B\n",
      "8 B\n",
      "9 B\n"
     ]
    }
   ],
   "source": [
    "def quizgrade(score):\n",
    "    grade = \"notset\"\n",
    "    if score == 5: # this one's still good\n",
    "        grade = \"A\"\n",
    "    elif score >= 4: # from == to >=\n",
    "        grade = \"B\"\n",
    "    elif score >= 3: # from == to >=\n",
    "        grade = \"C\"\n",
    "    elif score >= 2: # from == to >=\n",
    "        grade = \"D\"\n",
    "    elif score >= 0: # we can eliminate the othe condition\n",
    "        grade = \"F\"\n",
    "    else:\n",
    "        grade = \"unknown\"\n",
    "    return grade\n",
    "\n",
    "for i in range(10):\n",
    "    print(i, quizgrade(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh, we have an error here!  You can see that the things going out of bounds are doing so because I'm depending on the first if check to catch all the upper values.  In this case, I need to add another check to snip out those values.  Since my structure is kind of depending on the move from highest to lowest, I need to add this at the top."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-5 unknown\n",
      "-4.322936638244716 unknown\n",
      "-4 unknown\n",
      "-3.9008224252661847 unknown\n",
      "-3 unknown\n",
      "-2.3344318802821324 unknown\n",
      "-2 unknown\n",
      "-1.5339635686026267 unknown\n",
      "-1 unknown\n",
      "-0.07465302125986362 unknown\n",
      "0 F\n",
      "0.36051658863696934 F\n",
      "1 F\n",
      "1.5869464136966474 F\n",
      "2 D\n",
      "2.8672278053395206 D\n",
      "3 C\n",
      "3.0360208680034044 C\n",
      "4 B\n",
      "4.388323219014264 B\n",
      "5 A\n",
      "5.103697556288449 unknown\n",
      "6 unknown\n",
      "6.952936829101748 unknown\n",
      "7 unknown\n",
      "7.482327368993284 unknown\n",
      "8 unknown\n",
      "8.349176763324277 unknown\n",
      "9 unknown\n",
      "9.636143137425103 unknown\n"
     ]
    }
   ],
   "source": [
    "def quizgrade(score):\n",
    "    grade = \"notset\"\n",
    "    if score > 5: # remember that == is a specific condition we care about\n",
    "        grade = \"unknown\"\n",
    "    elif score == 5: # this one's still good\n",
    "        grade = \"A\"\n",
    "    elif score >= 4: # from == to >=\n",
    "        grade = \"B\"\n",
    "    elif score >= 3: # from == to >=\n",
    "        grade = \"C\"\n",
    "    elif score >= 2: # from == to >=\n",
    "        grade = \"D\"\n",
    "    elif score >= 0: # we can eliminate the othe condition\n",
    "        grade = \"F\"\n",
    "    else:\n",
    "        grade = \"unknown\"\n",
    "    return grade\n",
    "\n",
    "import random\n",
    "\n",
    "for i in range(-5, 10):\n",
    "    newi = i + random.random()\n",
    "    print(i, quizgrade(i))\n",
    "    print(newi, quizgrade(newi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continuous data without upper and/or lower limit\n",
    "\n",
    "There's a potentially unlimited number of cats to own:\n",
    "\n",
    "```______Number of cats______  \n",
    "x ---------------//----> ∞```\n",
    "\n",
    "But somewhere there is a cut off where you have too many cats.\n",
    "\n",
    "* 1 cat needs 500 sq ft of space.\n",
    "* given a house size, calculate the max cat threshold and tell the user if they have too many cats, just enough cats, or have room for more cats\n",
    "* you can round using normal rounding rules\n",
    "* report out how many more cats someone could have, if thiy still have room\n",
    "\n",
    "Let's just start with being able to do the calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def cat_space_calculator(house_size, current_cat_count):\n",
    "    print(\"For\", house_size, \"sq/ft:\")\n",
    "    space_per_cat = 500\n",
    "    total_cat_slots = house_size / space_per_cat\n",
    "    rounded_total_cat_slots = round(total_cat_slots)\n",
    "    print(\" * You have\", total_cat_slots, \"cat slots, which is being rounded up to:\", rounded_total_cat_slots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For 350 sq/ft:\n",
      " * You have 0.7 cat slots, which is being rounded up to: 1\n",
      "For 2150 sq/ft:\n",
      " * You have 4.3 cat slots, which is being rounded up to: 4\n",
      "For 2400 sq/ft:\n",
      " * You have 4.8 cat slots, which is being rounded up to: 5\n"
     ]
    }
   ],
   "source": [
    "cat_space_calculator(350, 2)\n",
    "cat_space_calculator(2150, 2)\n",
    "cat_space_calculator(2400, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a number to work with, we can consider our decision tree:\n",
    "\n",
    "* More cats than the number of allowed slots\n",
    "    * This will be a `>` situation\n",
    "* Right at the number of allowed slots\n",
    "    * This will be an `==` situation\n",
    "* Fewer cats than the number of allewed slots\n",
    "    * This will be a `<` situation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def cat_space_calculator(house_size, current_cat_count):\n",
    "    print(\"For\", house_size, \"sq/ft and\", current_cat_count, \"cats:\")\n",
    "    \n",
    "    space_per_cat = 500\n",
    "    total_cat_slots = house_size / space_per_cat\n",
    "    rounded_total_cat_slots = round(total_cat_slots)\n",
    "    \n",
    "    print(\" * You have\", rounded_total_cat_slots, \"cat slots.\")\n",
    "    \n",
    "    if current_cat_count > rounded_total_cat_slots:\n",
    "        print(\" * You have too many cats! Reduce cat consumption by\", current_cat_count - rounded_total_cat_slots)\n",
    "    elif current_cat_count == rounded_total_cat_slots:\n",
    "        print(\" * You have exactly the right number of cats. (=^･^=)\")\n",
    "    elif current_cat_count < rounded_total_cat_slots:\n",
    "        print(\" * You have room for\", rounded_total_cat_slots - current_cat_count, \"more cats\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For 350 sq/ft and 2 cats:\n",
      " * You have 1 cat slots.\n",
      " * You have too many cats! Reduce cat consumption by 1\n",
      "For 2150 sq/ft and 2 cats:\n",
      " * You have 4 cat slots.\n",
      " * You have room for 2 more cats\n",
      "For 2400 sq/ft and 2 cats:\n",
      " * You have 5 cat slots.\n",
      " * You have room for 3 more cats\n"
     ]
    }
   ],
   "source": [
    "cat_space_calculator(350, 2)\n",
    "cat_space_calculator(2150, 2)\n",
    "cat_space_calculator(2400, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For 1049 sq/ft and 0 cats:\n",
      " * You have 2 cat slots.\n",
      " * You have room for 2 more cats\n",
      "For 1049 sq/ft and 1 cats:\n",
      " * You have 2 cat slots.\n",
      " * You have room for 1 more cats\n",
      "For 1049 sq/ft and 2 cats:\n",
      " * You have 2 cat slots.\n",
      " * You have exactly the right number of cats. (=^･^=)\n",
      "For 1049 sq/ft and 3 cats:\n",
      " * You have 2 cat slots.\n",
      " * You have too many cats! Reduce cat consumption by 1\n",
      "For 1049 sq/ft and 4 cats:\n",
      " * You have 2 cat slots.\n",
      " * You have too many cats! Reduce cat consumption by 2\n"
     ]
    }
   ],
   "source": [
    "for cats in range(0,5):\n",
    "    cat_space_calculator(1049, cats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# There are a billion conditions and the numbers are just made up lies\n",
    "\n",
    "Sometimes there's just a million things you need to check for, and the numbers are just labels.  If you read this far, send me a nerdiest knock knock joke you can think of and I'll give you extra credit.  Jump in and start testing stuff with known values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PE11: A year is a leap year if it is divisible by 4, unless it is a century year that is not divisible by 400.  (1800 and 1900 are not leap years while 1600 and 2000 are).   Write a program that calculates whether a year is a leap year.\n",
    "\n",
    "* What's the input?\n",
    "    * a year, thus an integer\n",
    "* What's the output?\n",
    "    * It doesn't specify, but this a yes/no question, thus boolean\n",
    "    * so return either `True` or `False`\n",
    "    \n",
    "Let's start unpacking these rules:\n",
    "\n",
    "* divisble by 4\n",
    "    * `year % 4 == 0`\n",
    "* century year not divisible by 4\n",
    "    * `year % 100 == 0` and `year % 400 != 0`\n",
    "    \n",
    "Let's start setting up this function, but better yet, let's set up a battery of tests for oursevles.\n",
    "\n",
    "I just googled for a list of leap years.  OO, check this out:  https://en.wikipedia.org/wiki/Leap_year#Algorithm\n",
    "\n",
    "* if (year is not divisible by 4) then (it is a common year)\n",
    "* else if (year is not divisible by 100) then (it is a leap year)\n",
    "* else if (year is not divisible by 400) then (it is a common year)\n",
    "* else (it is a leap year)\n",
    "\n",
    "We are also in a position where we can seed ourselves some test cases where we know what the answer should be.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "list_o_years = [1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, \n",
    "                1936, 1940, 1944, 1948, 1952, 1956, 1960, 1964, \n",
    "                1968, 1972, 1976, 1980, 1984, 1988, 1992, 1996, \n",
    "                2000, 2004, 2008, 2012, 2016, 2020]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1904 is False\n",
      "1908 is False\n",
      "1912 is False\n",
      "1916 is False\n",
      "1920 is False\n",
      "1924 is False\n",
      "1928 is False\n",
      "1932 is False\n",
      "1936 is False\n",
      "1940 is False\n",
      "1944 is False\n",
      "1948 is False\n",
      "1952 is False\n",
      "1956 is False\n",
      "1960 is False\n",
      "1964 is False\n",
      "1968 is False\n",
      "1972 is False\n",
      "1976 is False\n",
      "1980 is False\n",
      "1984 is False\n",
      "1988 is False\n",
      "1992 is False\n",
      "1996 is False\n",
      "2000 is False\n",
      "2004 is False\n",
      "2008 is False\n",
      "2012 is False\n",
      "2016 is False\n",
      "2020 is False\n"
     ]
    }
   ],
   "source": [
    "# let's get a base\n",
    "\n",
    "\n",
    "def is_leap_year(year):\n",
    "    \"\"\"Return True if a year is a leap year\"\"\"\n",
    "    return False\n",
    "\n",
    "for year in list_o_years:\n",
    "    # we know all of these should be true, so let's \n",
    "    print(year, \"is\", is_leap_year(year)) # no newlines for shortness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1904 is False\n",
      "1908 is False\n",
      "1912 is False\n",
      "1916 is False\n",
      "1920 is False\n",
      "1924 is False\n",
      "1928 is False\n",
      "1932 is False\n",
      "1936 is False\n",
      "1940 is False\n"
     ]
    }
   ],
   "source": [
    "# starting to fill things out via the wikipedia algorithm\n",
    "\n",
    "def is_leap_year(year):\n",
    "    \"\"\"Return True if a year is a leap year\"\"\"\n",
    "    # if (year is not divisible by 4) then (it is a common year)\n",
    "    if year % 4 != 0:\n",
    "        return False\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "for year in list_o_years[:10]: # let's start with a smaller group\n",
    "    # we know all of these should be true, so let's \n",
    "    print(year, \"is\", is_leap_year(year))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1904 is True\n",
      "1908 is True\n",
      "1912 is True\n",
      "1916 is True\n",
      "1920 is True\n",
      "1924 is True\n",
      "1928 is True\n",
      "1932 is True\n",
      "1936 is True\n",
      "1940 is True\n"
     ]
    }
   ],
   "source": [
    "# starting to fill things out via the wikipedia algorithm\n",
    "\n",
    "def is_leap_year(year):\n",
    "    \"\"\"Return True if a year is a leap year\"\"\"\n",
    "    # if (year is not divisible by 4) then (it is a common year)\n",
    "    if year % 4 != 0:\n",
    "        return False\n",
    "    # else if (year is not divisible by 100) then (it is a leap year)\n",
    "    elif year % 100 != 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "for year in list_o_years[:10]: # let's start with a smaller group\n",
    "    # we know all of these should be true, so let's \n",
    "    print(year, \"is\", is_leap_year(year))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh look! All of our years are coming up as True, which is great.  Let's check the rest now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1904 is True\n",
      "1908 is True\n",
      "1912 is True\n",
      "1916 is True\n",
      "1920 is True\n",
      "1924 is True\n",
      "1928 is True\n",
      "1932 is True\n",
      "1936 is True\n",
      "1940 is True\n",
      "1944 is True\n",
      "1948 is True\n",
      "1952 is True\n",
      "1956 is True\n",
      "1960 is True\n",
      "1964 is True\n",
      "1968 is True\n",
      "1972 is True\n",
      "1976 is True\n",
      "1980 is True\n",
      "1984 is True\n",
      "1988 is True\n",
      "1992 is True\n",
      "1996 is True\n",
      "2000 is False\n",
      "2004 is True\n",
      "2008 is True\n",
      "2012 is True\n",
      "2016 is True\n",
      "2020 is True\n"
     ]
    }
   ],
   "source": [
    "for year in list_o_years: # let's start with a smaller group\n",
    "    # we know all of these should be true, so let's \n",
    "    print(year, \"is\", is_leap_year(year))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That one failure!!!! Let's be sure and finish adding in the algorithm.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1904 is True\n",
      "1908 is True\n",
      "1912 is True\n",
      "1916 is True\n",
      "1920 is True\n",
      "1924 is True\n",
      "1928 is True\n",
      "1932 is True\n",
      "1936 is True\n",
      "1940 is True\n",
      "1944 is True\n",
      "1948 is True\n",
      "1952 is True\n",
      "1956 is True\n",
      "1960 is True\n",
      "1964 is True\n",
      "1968 is True\n",
      "1972 is True\n",
      "1976 is True\n",
      "1980 is True\n",
      "1984 is True\n",
      "1988 is True\n",
      "1992 is True\n",
      "1996 is True\n",
      "2000 is True\n",
      "2004 is True\n",
      "2008 is True\n",
      "2012 is True\n",
      "2016 is True\n",
      "2020 is True\n"
     ]
    }
   ],
   "source": [
    "def is_leap_year(year):\n",
    "    \"\"\"Return True if a year is a leap year\"\"\"\n",
    "    # if (year is not divisible by 4) then (it is a common year)\n",
    "    if year % 4 != 0:\n",
    "        return False\n",
    "    # else if (year is not divisible by 100) then (it is a leap year)\n",
    "    elif year % 100 != 0:\n",
    "        return True\n",
    "    # else if (year is not divisible by 400) then (it is a common year)\n",
    "    elif year % 400 != 0:\n",
    "        return False\n",
    "    else:\n",
    "    # else (it is a leap year)\n",
    "        return True\n",
    "\n",
    "for year in list_o_years: # let's start with a smaller group\n",
    "    # we know all of these should be true, so let's \n",
    "    print(year, \"is\", is_leap_year(year))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1900 is NOT a leap year\n",
      "1901 is NOT a leap year\n",
      "1902 is NOT a leap year\n",
      "1903 is NOT a leap year\n",
      "1904 IS a leap year\n",
      "1905 is NOT a leap year\n",
      "1906 is NOT a leap year\n",
      "1907 is NOT a leap year\n",
      "1908 IS a leap year\n",
      "1909 is NOT a leap year\n",
      "1910 is NOT a leap year\n",
      "1911 is NOT a leap year\n",
      "1912 IS a leap year\n",
      "1913 is NOT a leap year\n",
      "1914 is NOT a leap year\n",
      "1915 is NOT a leap year\n",
      "1916 IS a leap year\n",
      "1917 is NOT a leap year\n",
      "1918 is NOT a leap year\n",
      "1919 is NOT a leap year\n",
      "1920 IS a leap year\n",
      "1921 is NOT a leap year\n",
      "1922 is NOT a leap year\n",
      "1923 is NOT a leap year\n",
      "1924 IS a leap year\n",
      "1925 is NOT a leap year\n",
      "1926 is NOT a leap year\n",
      "1927 is NOT a leap year\n",
      "1928 IS a leap year\n",
      "1929 is NOT a leap year\n",
      "1930 is NOT a leap year\n",
      "1931 is NOT a leap year\n",
      "1932 IS a leap year\n",
      "1933 is NOT a leap year\n",
      "1934 is NOT a leap year\n",
      "1935 is NOT a leap year\n",
      "1936 IS a leap year\n",
      "1937 is NOT a leap year\n",
      "1938 is NOT a leap year\n",
      "1939 is NOT a leap year\n",
      "1940 IS a leap year\n",
      "1941 is NOT a leap year\n",
      "1942 is NOT a leap year\n",
      "1943 is NOT a leap year\n",
      "1944 IS a leap year\n",
      "1945 is NOT a leap year\n",
      "1946 is NOT a leap year\n",
      "1947 is NOT a leap year\n",
      "1948 IS a leap year\n",
      "1949 is NOT a leap year\n",
      "1950 is NOT a leap year\n",
      "1951 is NOT a leap year\n",
      "1952 IS a leap year\n",
      "1953 is NOT a leap year\n",
      "1954 is NOT a leap year\n",
      "1955 is NOT a leap year\n",
      "1956 IS a leap year\n",
      "1957 is NOT a leap year\n",
      "1958 is NOT a leap year\n",
      "1959 is NOT a leap year\n",
      "1960 IS a leap year\n",
      "1961 is NOT a leap year\n",
      "1962 is NOT a leap year\n",
      "1963 is NOT a leap year\n",
      "1964 IS a leap year\n",
      "1965 is NOT a leap year\n",
      "1966 is NOT a leap year\n",
      "1967 is NOT a leap year\n",
      "1968 IS a leap year\n",
      "1969 is NOT a leap year\n",
      "1970 is NOT a leap year\n",
      "1971 is NOT a leap year\n",
      "1972 IS a leap year\n",
      "1973 is NOT a leap year\n",
      "1974 is NOT a leap year\n",
      "1975 is NOT a leap year\n",
      "1976 IS a leap year\n",
      "1977 is NOT a leap year\n",
      "1978 is NOT a leap year\n",
      "1979 is NOT a leap year\n",
      "1980 IS a leap year\n",
      "1981 is NOT a leap year\n",
      "1982 is NOT a leap year\n",
      "1983 is NOT a leap year\n",
      "1984 IS a leap year\n",
      "1985 is NOT a leap year\n",
      "1986 is NOT a leap year\n",
      "1987 is NOT a leap year\n",
      "1988 IS a leap year\n",
      "1989 is NOT a leap year\n",
      "1990 is NOT a leap year\n",
      "1991 is NOT a leap year\n",
      "1992 IS a leap year\n",
      "1993 is NOT a leap year\n",
      "1994 is NOT a leap year\n",
      "1995 is NOT a leap year\n",
      "1996 IS a leap year\n",
      "1997 is NOT a leap year\n",
      "1998 is NOT a leap year\n",
      "1999 is NOT a leap year\n",
      "2000 IS a leap year\n",
      "2001 is NOT a leap year\n",
      "2002 is NOT a leap year\n",
      "2003 is NOT a leap year\n",
      "2004 IS a leap year\n",
      "2005 is NOT a leap year\n",
      "2006 is NOT a leap year\n",
      "2007 is NOT a leap year\n",
      "2008 IS a leap year\n",
      "2009 is NOT a leap year\n",
      "2010 is NOT a leap year\n",
      "2011 is NOT a leap year\n",
      "2012 IS a leap year\n",
      "2013 is NOT a leap year\n",
      "2014 is NOT a leap year\n",
      "2015 is NOT a leap year\n",
      "2016 IS a leap year\n"
     ]
    }
   ],
   "source": [
    "for i in range(1900, 2017):\n",
    "    if is_leap_year(i):\n",
    "        print(i, \"IS a leap year\")\n",
    "    else:\n",
    "        print(i, \"is NOT a leap year\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# more years from https://kalender-365.de/leap-years.php\n",
    "moreyears = [1804, 1808, 1812, 1816, 1820, 1824, 1828, 1832, 1836, 1840, 1844, \n",
    "             1848, 1852, 1856, 1860, 1864, 1868, 1872, 1876, 1880, 1884, 1888, \n",
    "             1892, 1896, 1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936, \n",
    "             1940, 1944, 1948, 1952, 1956, 1960, 1964, 1968, 1972, 1976, 1980, \n",
    "             1984, 1988, 1992, 1996, 2000, 2004, 2008, 2012, 2016, 2020, 2024, \n",
    "             2028, 2032, 2036, 2040, 2044, 2048, 2052, 2056, 2060, 2064, 2068, \n",
    "             2072, 2076, 2080, 2084, 2088, 2092, 2096, 2104, 2108, 2112, 2116, \n",
    "             2120, 2124, 2128, 2132, 2136, 2140, 2144, 2148, 2152, 2156, 2160, \n",
    "             2164, 2168, 2172, 2176, 2180, 2184, 2188, 2192, 2196, 2204, 2208, \n",
    "             2212, 2216, 2220, 2224, 2228, 2232, 2236, 2240, 2244, 2248, 2252, \n",
    "             2256, 2260, 2264, 2268, 2272, 2276, 2280, 2284, 2288, 2292, 2296, \n",
    "             2304, 2308, 2312, 2316, 2320, 2324, 2328, 2332, 2336, 2340, 2344, \n",
    "             2348, 2352, 2356, 2360, 2364, 2368, 2372, 2376, 2380, 2384, 2388, \n",
    "             2392, 2396, 2400]\n",
    "\n",
    "for year in moreyears:\n",
    "    print(is_leap_year(year))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is such a long list, it is hard to tell what is what.  We can use boolean testing in another way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for year in moreyears:\n",
    "    if not is_leap_year(year):\n",
    "        print(year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nothing came up!  That's to be expected if everything is working, but we can't see anything, so let's throw a kink in just to watch it work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017\n"
     ]
    }
   ],
   "source": [
    "moreyears.append(2017)\n",
    "\n",
    "for year in moreyears:\n",
    "    if not is_leap_year(year):\n",
    "        print(year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yup, it works!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}