Lectures/Week-07-BooleansPt1-if-else.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spring 2018 Status: GOOD\n",
    "\n",
    "# Booleans!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean expressions and conditional checks\n",
    "\n",
    "Generally speaking, booleans allow us to make decision statements.  We can use this to check inputs, create more complex algorithms, and data filtering.\n",
    "\n",
    "Let's review an essential concepy: the expression. These are pieces of code that evaluate to a value. For example:\n",
    "\n",
    "* `2 + 2` evaluates to `4`\n",
    "* `\"hello there\".split()\"` evaluates to a list `[\"hello\", \"there\"]`\n",
    "\n",
    "Sometimes we need to do more than just evaluate something. Sometimes you need to do _something_ if _something else_ is true. To do this, we need to introduce something new: decision statements.\n",
    "\n",
    "Crafting a decision statement requires that you create a boolean expression. To do this, we need two words: `True` or `False`.\n",
    "\n",
    "And before we continue, there are two things to consider. Booleans are both 1). a concept (logic, etc) and 2). a data type.\n",
    "\n",
    "* **boolean**: this is a data type, representing the two logical objects\n",
    "    * **`True`** and **`False`**: these are the two boolean objects available in Python, note that capitalization matters\n",
    "* __conditional check__: this is an expression will end up as `True` or `False`.  Examples will be anything that has the `==` in it, or a method/function that returns a `True` or `False`.  You can also use `!=` to indicate 'not equal to'.\n",
    "\n",
    "# Crafting a boolean expression\n",
    "\n",
    "These are expressions that evaluate to either `True` or `False` and there are several ways to create them.  The two primary ways are using an operator (math looking thing) or a method/function (including a custom function that you write!) specifically designed to return a boolean value.\n",
    "\n",
    "## core boolean operators\n",
    "\n",
    "* `==` (read as \"double equals\")  this is the equality check operator, which should appear between two objects and will return either `True` or `False`, e.g.: \n",
    "    * `1 == 1` will return `True`\n",
    "    * `2 == 4` will return `False`\n",
    "    * Important:  this will check equivalence and not object identity.  This is a concept that we will not really bo covering too heavily.  But you may see the `is` keyword, which will check identity.  This may appear to be functionally equivalent, but that is not the case.  For our purposes, avoid the use of `is`.\n",
    "    \n",
    "Then the usual math suspects:\n",
    "\n",
    "* `>` (greater than)\n",
    "* `<` (less than)\n",
    "* `<=` (less than or equal to)\n",
    "* `>=` (greater than or equal to) \n",
    "\n",
    "There is an important distinction between the greater/less than and the greater/less than or equal to operators.  Example:  10 is not less than 10, but it is equal to it.  So if you were trying to check if something is a number under, but including 10, you need to use `num <= 10`.  This is functionall equivalent to `num < 11`.  You well develop your own personal style.\n",
    "\n",
    "---\n",
    "\n",
    "# traversing from the top down\n",
    "\n",
    "As you begin to design decision statements, you have to think about the order. Let's think first of what a decision tree looks like:  https://en.wikipedia.org/wiki/Decision_tree\n",
    "\n",
    "You start at the top and traverse down until there is either nothing left or you have recieved a value. This means a few things:\n",
    "\n",
    "* order matters, so you may not be tested against every condition\n",
    "* it can be possible to 'fall out' of a decision tree if you do not recieve a value\n",
    "* once you receve a value, you exit the tree\n",
    "\n",
    "So the question or order should come with all you questions about what to test. \n",
    "\n",
    "As we discovered with functions, these are very generic structures that support very divergent and creative usage patterns. This means that there may be many ways to solve the same problem.  So structures have strengths and weaknesses that will need to be accounted for, but will otherwise do the same job.\n",
    "\n",
    " Here are some of the common questions:\n",
    "\n",
    "* **What is the right way to do something?**  \n",
    "    * There really isn't, so long as you are testing things and accomplishing the task. You'll develop your own style through experience.\n",
    "    \n",
    "* **Is there a specific pattern to use?**\n",
    "    * I'll give you some suggested patterns to start with that you can branch off with. Prioritize patterns that you are comfortable with and understand well. \n",
    "    \n",
    "* **How important is short code?**\n",
    "    * At this point, we aren't concerned about optimization or efficiency. Our first and only priority with this is correctness. You will find that defensive and informative patterns will naturally be longer, and that some pieces seem useless. However, remember that we're working in very small prescribed chunk of problems. In an authentic task, a defensive and inforamtive pattern will serve you well through an iterative development process. Even if you think there's no chance that a piece of your decision tree will ever run, it certainly won't hurt anything to leave it in there in case something changes.\n",
    "    \n",
    "---\n",
    "    \n",
    "# General steps to crafting a decision statement\n",
    "\n",
    "1. Figure out the boolean expression that tests what your truth is. Pay attention to the language of the question in your head and try to match that.  Experiment with this expression on your data or a representative sample of the data, printing out the boolean results to do an eyeball spot check.\n",
    "2. Add that expression into an if block\n",
    "3. Add bits and bobs as necessary\n",
    "    \n",
    "# the `if` block\n",
    "\n",
    "Your first step is to figure out the boolean expression that you want to be checking.  Once you have that, you can place it into you if block.  \n",
    "\n",
    "This if block must appear once and at the beginning of every decision structure.  You can add stuff after it, but we'll look at it alone first.\n",
    "\n",
    "This is a one way check.  You will provide it a boolean expression, and the code in the `if` block will be executed if that expression evaluates to `True`.  Nothing will happen if the condition evaluates to `False`.  This is an example of the value dropping out of the decision tree. We'll explore how we can build off this `if` block later, but we need to get this down first.\n",
    "\n",
    "* `if` this is your base keyword that every conditional check that will open with, and you may only use this once at the very beginning. You have to pass this a conditional check.  Example usage:\n",
    "\n",
    "    * ```python\n",
    "    if boolean_expression:\n",
    "        # stuff to do if the conditional check is True```\n",
    "        \n",
    "We're going to work on a program that checks if a child's height is within limits for a roller coaster ride.  All passengers must be 34 inches or above.\n",
    "\n",
    "All conditional checks require 3 pieces:\n",
    "\n",
    "1.  The thing being cheked, usually this is your variable\n",
    "2.  The thing to check it against\n",
    "3.  How do you want to check it?\n",
    "\n",
    "Let's answer this for our current problem:\n",
    "\n",
    "1.  We want to check the child's height in the variable: `height_of_child_inches`\n",
    "2.  We want to check that against the minimum height of 34 inches\n",
    "3.  This in inclusive, so 34 inches or any height can ride.  So we have `>=`\n",
    "\n",
    "Putting these three together, we have:\n",
    "\n",
    "`height_of_child_inches >= 34` \n",
    "\n",
    "Now we can place this in an `if` block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This person can ride this attraction.\n"
     ]
    }
   ],
   "source": [
    "height_of_child_inches = 38\n",
    "\n",
    "if height_of_child_inches >= 34:\n",
    "    print(\"This person can ride this attraction.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "38 is indeed `greater than or equal to 34`, so the code in the if block executed.\n",
    "\n",
    "Next we'll look at what happen when it does not evaluate to `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "height_of_child_inches = 32\n",
    "\n",
    "if height_of_child_inches >= 34:\n",
    "    print(\"The person can ride this attraction.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "32 is not greater than or equal to 34, so under a false contition, it did not execute the code under the for loop block.  Sometimes we'll be ok with just a single if statement, but in many cases it's nice to have some feedback that the conditional check evaluated as false.  This is where our next pattern comes in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The `if/else` pattern\n",
    "\n",
    "As you are starting with this and getting comfortable, I suggest that you always start with an `if/else` pattern (unless it's clear that you need the next pattern--more on that later.  This pattern allows you to have two blocks of code:\n",
    "\n",
    "1. stuff to run if the condition is `True`, this is the `if` block\n",
    "2. stuff to run if the condition is `False`, this is the `else` block\n",
    "\n",
    "    * ```python\n",
    "    if (conditional check statement):\n",
    "        # stuff to do if the conditional check is True\n",
    "    else: \n",
    "        # stuff to do if the conditional check is False```\n",
    "        \n",
    "Things to note:\n",
    "\n",
    "* the else block opener is at the same indent level as the if statement\n",
    "* there's a colon after the else, but no other code\n",
    "* even though there isn't any visual connection between these two blocks, they are connected.\n",
    "* the else statement may only appear after the if statement\n",
    "* the else statement may only appear when there is an if statement (so it cannot appear alone)\n",
    "\n",
    "Let's add something to our previous example, so that we can give a rejection statement if the potential rider is too short.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The person can ride this attraction.\n"
     ]
    }
   ],
   "source": [
    "height_of_child_inches = 38\n",
    "\n",
    "if height_of_child_inches >= 34:\n",
    "    print(\"The person can ride this attraction.\")\n",
    "else:\n",
    "    print(\"The person CANNOT ride this attraction.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The person CANNOT ride this attraction.\n"
     ]
    }
   ],
   "source": [
    "height_of_child_inches = 32\n",
    "\n",
    "if height_of_child_inches >= 34:\n",
    "    print(\"The person can ride this attraction.\")\n",
    "else:\n",
    "    print(\"The person CANNOT ride this attraction.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now recieve some feedback from our conditional block now no matter what condition.  The `else` block will execute no matter why the `if` block was false.\n",
    "\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem statement\n",
    "\n",
    "Problem: find all mentions of alphabet characters, and produce data for how many characters are spoken about in each line.\n",
    "\n",
    "What we know:\n",
    "\n",
    "1. All alphabet characters are single letters.\n",
    "2. All alphabet characters are in upper case.\n",
    "\n",
    "So, first step, let's start reading in the lines of this file.  Our first level of interest is with lines, so we can use `.readlines()` to read them all in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A told B, and B told C, \"I'll meet you at the top of the coconut tree.\"\n",
      "\n",
      "\"Wheee!\" said D to E F G, \"I'll beat you to the top of the coconut tree.\"\n",
      "\n",
      "Chicka chicka boom boom! Will there be enough room? Here comes H up the coconut tree,\n",
      "\n",
      "and I and J and tag-along K, all on their way up the coconut tree.\n",
      "\n",
      "Chicka chicka boom boom! Will there be enough room? Look who's coming! L M N O P!\n",
      "\n",
      "And Q R S! And T U V! Still more - W! And X Y Z!\n",
      "\n",
      "The whole alphabet up the - Oh, no! Chicka chicka... BOOM! BOOM!\n",
      "\n",
      "Skit skat skoodle doot. Flip flop flee. Everybody running to the coconut tree.\n",
      "\n",
      "Mamas and papas and uncles and aunts hug their little dears, then dust their pants.\n",
      "\n",
      "\"Help us up,\" cried A B C.\n",
      "\n",
      "Next from the pileup skinned-knee D and stubbed-toe E and patched-up F. Then comes G all out of breath.\n",
      "\n",
      "H is tangled up with I. J and K are about to cry. L is knotted like a tie.\n",
      "\n",
      "M is looped. N is stopped. O is twisted alley-oop. Skit skat skoodle doot. Flip flop flee.\n",
      "\n",
      "Look who's coming! It's black-eyed P, Q R S, and loose-tooth T. Then U V W wiggle-jiggle free.\n",
      "\n",
      "Last to come X Y Z. And the sun goes down on the coconut tree...\n",
      "\n",
      "But - chicka chicka boom boom! Look, there's a full moon.\n",
      "\n",
      "A is out of bed, and this is what he said, \"Dare double dare, you can't catch me.\n",
      "\n",
      "Chicka chicka BOOM! BOOM!Chicka chicka BOOM! BOOM!\n",
      "\n",
      "I'll beat you to the top of the coconut tree.\"\n",
      "\n",
      "Chicka chicka BOOM! BOOM!\n"
     ]
    }
   ],
   "source": [
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have the individual lines isolated, we can tend to our next level of granularity:  the words.\n",
    "\n",
    "Remember that we can use `line.split()` to have the line string split up on the white space.  This will give us a list with each word in it.  Again, a bit rudamentary, but a decent place to start.  Right now we're going to add them in and just pring it out so that we can look at it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'told', 'B,', 'and', 'B', 'told', 'C,', '\"I\\'ll', 'meet', 'you', 'at', 'the', 'top', 'of', 'the', 'coconut', 'tree.\"']\n",
      "['\"Wheee!\"', 'said', 'D', 'to', 'E', 'F', 'G,', '\"I\\'ll', 'beat', 'you', 'to', 'the', 'top', 'of', 'the', 'coconut', 'tree.\"']\n",
      "['Chicka', 'chicka', 'boom', 'boom!', 'Will', 'there', 'be', 'enough', 'room?', 'Here', 'comes', 'H', 'up', 'the', 'coconut', 'tree,']\n",
      "['and', 'I', 'and', 'J', 'and', 'tag-along', 'K,', 'all', 'on', 'their', 'way', 'up', 'the', 'coconut', 'tree.']\n",
      "['Chicka', 'chicka', 'boom', 'boom!', 'Will', 'there', 'be', 'enough', 'room?', 'Look', \"who's\", 'coming!', 'L', 'M', 'N', 'O', 'P!']\n",
      "['And', 'Q', 'R', 'S!', 'And', 'T', 'U', 'V!', 'Still', 'more', '-', 'W!', 'And', 'X', 'Y', 'Z!']\n",
      "['The', 'whole', 'alphabet', 'up', 'the', '-', 'Oh,', 'no!', 'Chicka', 'chicka...', 'BOOM!', 'BOOM!']\n",
      "['Skit', 'skat', 'skoodle', 'doot.', 'Flip', 'flop', 'flee.', 'Everybody', 'running', 'to', 'the', 'coconut', 'tree.']\n",
      "['Mamas', 'and', 'papas', 'and', 'uncles', 'and', 'aunts', 'hug', 'their', 'little', 'dears,', 'then', 'dust', 'their', 'pants.']\n",
      "['\"Help', 'us', 'up,\"', 'cried', 'A', 'B', 'C.']\n",
      "['Next', 'from', 'the', 'pileup', 'skinned-knee', 'D', 'and', 'stubbed-toe', 'E', 'and', 'patched-up', 'F.', 'Then', 'comes', 'G', 'all', 'out', 'of', 'breath.']\n",
      "['H', 'is', 'tangled', 'up', 'with', 'I.', 'J', 'and', 'K', 'are', 'about', 'to', 'cry.', 'L', 'is', 'knotted', 'like', 'a', 'tie.']\n",
      "['M', 'is', 'looped.', 'N', 'is', 'stopped.', 'O', 'is', 'twisted', 'alley-oop.', 'Skit', 'skat', 'skoodle', 'doot.', 'Flip', 'flop', 'flee.']\n",
      "['Look', \"who's\", 'coming!', \"It's\", 'black-eyed', 'P,', 'Q', 'R', 'S,', 'and', 'loose-tooth', 'T.', 'Then', 'U', 'V', 'W', 'wiggle-jiggle', 'free.']\n",
      "['Last', 'to', 'come', 'X', 'Y', 'Z.', 'And', 'the', 'sun', 'goes', 'down', 'on', 'the', 'coconut', 'tree...']\n",
      "['But', '-', 'chicka', 'chicka', 'boom', 'boom!', 'Look,', \"there's\", 'a', 'full', 'moon.']\n",
      "['A', 'is', 'out', 'of', 'bed,', 'and', 'this', 'is', 'what', 'he', 'said,', '\"Dare', 'double', 'dare,', 'you', \"can't\", 'catch', 'me.']\n",
      "['Chicka', 'chicka', 'BOOM!', 'BOOM!Chicka', 'chicka', 'BOOM!', 'BOOM!']\n",
      "[\"I'll\", 'beat', 'you', 'to', 'the', 'top', 'of', 'the', 'coconut', 'tree.\"']\n",
      "['Chicka', 'chicka', 'BOOM!', 'BOOM!']\n"
     ]
    }
   ],
   "source": [
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    print(line.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is working, but the punctuation is getting in the way.  We have a few examples of \"T.\" etc.  How can we get it out?\n",
    "\n",
    "We can write a function that takes in a line as a string, removes all punctuation from it, and returns that clean string back to us.  As a first pass, when adding this function into our program we will just set up the input/output to ensure that it is working."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'told', 'B,', 'and', 'B', 'told', 'C,', '\"I\\'ll', 'meet', 'you', 'at', 'the', 'top', 'of', 'the', 'coconut', 'tree.\"']\n",
      "['\"Wheee!\"', 'said', 'D', 'to', 'E', 'F', 'G,', '\"I\\'ll', 'beat', 'you', 'to', 'the', 'top', 'of', 'the', 'coconut', 'tree.\"']\n",
      "['Chicka', 'chicka', 'boom', 'boom!', 'Will', 'there', 'be', 'enough', 'room?', 'Here', 'comes', 'H', 'up', 'the', 'coconut', 'tree,']\n",
      "['and', 'I', 'and', 'J', 'and', 'tag-along', 'K,', 'all', 'on', 'their', 'way', 'up', 'the', 'coconut', 'tree.']\n",
      "['Chicka', 'chicka', 'boom', 'boom!', 'Will', 'there', 'be', 'enough', 'room?', 'Look', \"who's\", 'coming!', 'L', 'M', 'N', 'O', 'P!']\n",
      "['And', 'Q', 'R', 'S!', 'And', 'T', 'U', 'V!', 'Still', 'more', '-', 'W!', 'And', 'X', 'Y', 'Z!']\n",
      "['The', 'whole', 'alphabet', 'up', 'the', '-', 'Oh,', 'no!', 'Chicka', 'chicka...', 'BOOM!', 'BOOM!']\n",
      "['Skit', 'skat', 'skoodle', 'doot.', 'Flip', 'flop', 'flee.', 'Everybody', 'running', 'to', 'the', 'coconut', 'tree.']\n",
      "['Mamas', 'and', 'papas', 'and', 'uncles', 'and', 'aunts', 'hug', 'their', 'little', 'dears,', 'then', 'dust', 'their', 'pants.']\n",
      "['\"Help', 'us', 'up,\"', 'cried', 'A', 'B', 'C.']\n",
      "['Next', 'from', 'the', 'pileup', 'skinned-knee', 'D', 'and', 'stubbed-toe', 'E', 'and', 'patched-up', 'F.', 'Then', 'comes', 'G', 'all', 'out', 'of', 'breath.']\n",
      "['H', 'is', 'tangled', 'up', 'with', 'I.', 'J', 'and', 'K', 'are', 'about', 'to', 'cry.', 'L', 'is', 'knotted', 'like', 'a', 'tie.']\n",
      "['M', 'is', 'looped.', 'N', 'is', 'stopped.', 'O', 'is', 'twisted', 'alley-oop.', 'Skit', 'skat', 'skoodle', 'doot.', 'Flip', 'flop', 'flee.']\n",
      "['Look', \"who's\", 'coming!', \"It's\", 'black-eyed', 'P,', 'Q', 'R', 'S,', 'and', 'loose-tooth', 'T.', 'Then', 'U', 'V', 'W', 'wiggle-jiggle', 'free.']\n",
      "['Last', 'to', 'come', 'X', 'Y', 'Z.', 'And', 'the', 'sun', 'goes', 'down', 'on', 'the', 'coconut', 'tree...']\n",
      "['But', '-', 'chicka', 'chicka', 'boom', 'boom!', 'Look,', \"there's\", 'a', 'full', 'moon.']\n",
      "['A', 'is', 'out', 'of', 'bed,', 'and', 'this', 'is', 'what', 'he', 'said,', '\"Dare', 'double', 'dare,', 'you', \"can't\", 'catch', 'me.']\n",
      "['Chicka', 'chicka', 'BOOM!', 'BOOM!Chicka', 'chicka', 'BOOM!', 'BOOM!']\n",
      "[\"I'll\", 'beat', 'you', 'to', 'the', 'top', 'of', 'the', 'coconut', 'tree.\"']\n",
      "['Chicka', 'chicka', 'BOOM!', 'BOOM!']\n"
     ]
    }
   ],
   "source": [
    "def clean_line(line_str):\n",
    "    return line\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    print(clean.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, we are sucessfully sending our line to our function and recieving it back.  Now we can fuss with what we do in the function.\n",
    "\n",
    "How do we got all the punctuation out?  Remember that `.replace(old, new)` will replace the old value with the new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fizzy'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"fizzy.\".replace(\".\", \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use this pattern to remove punctuation that we want, but it can only do 1 at a time.\n",
    "\n",
    "The solution to this is looping over a sequence of all the punctuations we want to remove them each, one at a time.\n",
    "\n",
    "This is going to use a modified sort of accumulator.\n",
    "\n",
    "1. start with the original line. this is like our accumulator base\n",
    "2. loop over the individual punctuation characters that we want to remove\n",
    "3. replace that character from the line.  Our old is the punctuation and our new is nothing.\n",
    "4. update our line base to this new version of the line.  This is our increment.\n",
    "\n",
    "We can play with a small version of this to demonstrate the concept."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm removing: ,\n",
      "old line: A meat popcicle, I am.\n",
      "new line: A meat popcicle I am.\n",
      "done with one line\n",
      "I'm removing: .\n",
      "old line: A meat popcicle I am.\n",
      "new line: A meat popcicle I am\n",
      "done with one line\n"
     ]
    }
   ],
   "source": [
    "line = \"A meat popcicle, I am.\"\n",
    "\n",
    "# we've got 2 puntuations in here to remove:  . and ,\n",
    "\n",
    "for punc in ',.':\n",
    "    print(\"I'm removing:\", punc)\n",
    "    cleanline = line.replace(punc, \"\")\n",
    "    print(\"old line:\", line)\n",
    "    print(\"new line:\", cleanline)\n",
    "    line = cleanline\n",
    "    print(\"done with one line\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Except we have many pieces of puncuation to remove, and that can make for a lot of typing.  There's a shorthand that we can use to look up all the punctuation characters.  `string.puncuation` within the string module.  THat lack of () is not a typo.  We don't need to worry about the technical reason right now, but just remember that sometimes modules will work like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "print(string.punctuation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a string of characters, which means we can loop over this instead of ',.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm removing: !\n",
      "I'm removing: \"\n",
      "I'm removing: #\n",
      "I'm removing: $\n",
      "I'm removing: %\n",
      "I'm removing: &\n",
      "I'm removing: '\n",
      "I'm removing: (\n",
      "I'm removing: )\n",
      "I'm removing: *\n",
      "I'm removing: +\n",
      "I'm removing: ,\n",
      "I'm removing: -\n",
      "I'm removing: .\n",
      "I'm removing: /\n",
      "I'm removing: :\n",
      "I'm removing: ;\n",
      "I'm removing: <\n",
      "I'm removing: =\n",
      "I'm removing: >\n",
      "I'm removing: ?\n",
      "I'm removing: @\n",
      "I'm removing: [\n",
      "I'm removing: \\\n",
      "I'm removing: ]\n",
      "I'm removing: ^\n",
      "I'm removing: _\n",
      "I'm removing: `\n",
      "I'm removing: {\n",
      "I'm removing: |\n",
      "I'm removing: }\n",
      "I'm removing: ~\n",
      "done, the clean line is: A meat popcicle I am More things are here dont be a funny person\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "line = \"A meat popcicle, I am. More (things) are here don't be a \\\"funny\\\" {person}.\"\n",
    "\n",
    "# we've got 2 puntuations in here to remove:  . and ,\n",
    "\n",
    "for punc in string.punctuation:\n",
    "    print(\"I'm removing:\", punc)\n",
    "    cleanline = line.replace(punc, \"\")\n",
    "    #print(\"old line:\", line)\n",
    "    #print(\"new line:\", cleanline)\n",
    "    line = cleanline\n",
    "    #print(\"done with one line\")\n",
    "    \n",
    "print(\"done, the clean line is:\", line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go back to our function and add this mechanism in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'told', 'B', 'and', 'B', 'told', 'C', 'Ill', 'meet', 'you', 'at', 'the', 'top', 'of', 'the', 'coconut', 'tree']\n",
      "['Wheee', 'said', 'D', 'to', 'E', 'F', 'G', 'Ill', 'beat', 'you', 'to', 'the', 'top', 'of', 'the', 'coconut', 'tree']\n",
      "['Chicka', 'chicka', 'boom', 'boom', 'Will', 'there', 'be', 'enough', 'room', 'Here', 'comes', 'H', 'up', 'the', 'coconut', 'tree']\n",
      "['and', 'I', 'and', 'J', 'and', 'tagalong', 'K', 'all', 'on', 'their', 'way', 'up', 'the', 'coconut', 'tree']\n",
      "['Chicka', 'chicka', 'boom', 'boom', 'Will', 'there', 'be', 'enough', 'room', 'Look', 'whos', 'coming', 'L', 'M', 'N', 'O', 'P']\n",
      "['And', 'Q', 'R', 'S', 'And', 'T', 'U', 'V', 'Still', 'more', 'W', 'And', 'X', 'Y', 'Z']\n",
      "['The', 'whole', 'alphabet', 'up', 'the', 'Oh', 'no', 'Chicka', 'chicka', 'BOOM', 'BOOM']\n",
      "['Skit', 'skat', 'skoodle', 'doot', 'Flip', 'flop', 'flee', 'Everybody', 'running', 'to', 'the', 'coconut', 'tree']\n",
      "['Mamas', 'and', 'papas', 'and', 'uncles', 'and', 'aunts', 'hug', 'their', 'little', 'dears', 'then', 'dust', 'their', 'pants']\n",
      "['Help', 'us', 'up', 'cried', 'A', 'B', 'C']\n",
      "['Next', 'from', 'the', 'pileup', 'skinnedknee', 'D', 'and', 'stubbedtoe', 'E', 'and', 'patchedup', 'F', 'Then', 'comes', 'G', 'all', 'out', 'of', 'breath']\n",
      "['H', 'is', 'tangled', 'up', 'with', 'I', 'J', 'and', 'K', 'are', 'about', 'to', 'cry', 'L', 'is', 'knotted', 'like', 'a', 'tie']\n",
      "['M', 'is', 'looped', 'N', 'is', 'stopped', 'O', 'is', 'twisted', 'alleyoop', 'Skit', 'skat', 'skoodle', 'doot', 'Flip', 'flop', 'flee']\n",
      "['Look', 'whos', 'coming', 'Its', 'blackeyed', 'P', 'Q', 'R', 'S', 'and', 'loosetooth', 'T', 'Then', 'U', 'V', 'W', 'wigglejiggle', 'free']\n",
      "['Last', 'to', 'come', 'X', 'Y', 'Z', 'And', 'the', 'sun', 'goes', 'down', 'on', 'the', 'coconut', 'tree']\n",
      "['But', 'chicka', 'chicka', 'boom', 'boom', 'Look', 'theres', 'a', 'full', 'moon']\n",
      "['A', 'is', 'out', 'of', 'bed', 'and', 'this', 'is', 'what', 'he', 'said', 'Dare', 'double', 'dare', 'you', 'cant', 'catch', 'me']\n",
      "['Chicka', 'chicka', 'BOOM', 'BOOMChicka', 'chicka', 'BOOM', 'BOOM']\n",
      "['Ill', 'beat', 'you', 'to', 'the', 'top', 'of', 'the', 'coconut', 'tree']\n",
      "['Chicka', 'chicka', 'BOOM', 'BOOM']\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def clean_line(line_str):\n",
    "    cleanline = line_str\n",
    "    for punc in string.punctuation:\n",
    "        cleanline = cleanline.replace(punc, \"\")\n",
    "    return cleanline\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    print(clean.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks better!  Now we can get back to booleans.  First, we can remind ourselves of what we're doing.  We want to process that clean line's words and find just the letters being mentioned.\n",
    "\n",
    "1. these are always an their own\n",
    "2. these are always capital\n",
    "\n",
    "Let's start with that first one and see what we end up with.  So we want to find all the strings of length 1 in here.  We can play with a small version first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A hit!\n"
     ]
    }
   ],
   "source": [
    "if len(\"A\") == 1:\n",
    "    print(\"A hit!\")\n",
    "else:\n",
    "    print(\"A miss!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A miss!\n"
     ]
    }
   ],
   "source": [
    "if len(\"hello\") == 1:\n",
    "    print(\"A hit!\")\n",
    "else:\n",
    "    print(\"A miss!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Going back to our program, we can loop through our list of words and apply what we've done here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "NOPENOPE told\n",
      "B\n",
      "NOPENOPE and\n",
      "B\n",
      "NOPENOPE told\n",
      "C\n",
      "NOPENOPE Ill\n",
      "NOPENOPE meet\n",
      "NOPENOPE you\n",
      "NOPENOPE at\n",
      "NOPENOPE the\n",
      "NOPENOPE top\n",
      "NOPENOPE of\n",
      "NOPENOPE the\n",
      "NOPENOPE coconut\n",
      "NOPENOPE tree\n",
      "NOPENOPE Wheee\n",
      "NOPENOPE said\n",
      "D\n",
      "NOPENOPE to\n",
      "E\n",
      "F\n",
      "G\n",
      "NOPENOPE Ill\n",
      "NOPENOPE beat\n",
      "NOPENOPE you\n",
      "NOPENOPE to\n",
      "NOPENOPE the\n",
      "NOPENOPE top\n",
      "NOPENOPE of\n",
      "NOPENOPE the\n",
      "NOPENOPE coconut\n",
      "NOPENOPE tree\n",
      "NOPENOPE Chicka\n",
      "NOPENOPE chicka\n",
      "NOPENOPE boom\n",
      "NOPENOPE boom\n",
      "NOPENOPE Will\n",
      "NOPENOPE there\n",
      "NOPENOPE be\n",
      "NOPENOPE enough\n",
      "NOPENOPE room\n",
      "NOPENOPE Here\n",
      "NOPENOPE comes\n",
      "H\n",
      "NOPENOPE up\n",
      "NOPENOPE the\n",
      "NOPENOPE coconut\n",
      "NOPENOPE tree\n",
      "NOPENOPE and\n",
      "I\n",
      "NOPENOPE and\n",
      "J\n",
      "NOPENOPE and\n",
      "NOPENOPE tagalong\n",
      "K\n",
      "NOPENOPE all\n",
      "NOPENOPE on\n",
      "NOPENOPE their\n",
      "NOPENOPE way\n",
      "NOPENOPE up\n",
      "NOPENOPE the\n",
      "NOPENOPE coconut\n",
      "NOPENOPE tree\n",
      "NOPENOPE Chicka\n",
      "NOPENOPE chicka\n",
      "NOPENOPE boom\n",
      "NOPENOPE boom\n",
      "NOPENOPE Will\n",
      "NOPENOPE there\n",
      "NOPENOPE be\n",
      "NOPENOPE enough\n",
      "NOPENOPE room\n",
      "NOPENOPE Look\n",
      "NOPENOPE whos\n",
      "NOPENOPE coming\n",
      "L\n",
      "M\n",
      "N\n",
      "O\n",
      "P\n",
      "NOPENOPE And\n",
      "Q\n",
      "R\n",
      "S\n",
      "NOPENOPE And\n",
      "T\n",
      "U\n",
      "V\n",
      "NOPENOPE Still\n",
      "NOPENOPE more\n",
      "W\n",
      "NOPENOPE And\n",
      "X\n",
      "Y\n",
      "Z\n",
      "NOPENOPE The\n",
      "NOPENOPE whole\n",
      "NOPENOPE alphabet\n",
      "NOPENOPE up\n",
      "NOPENOPE the\n",
      "NOPENOPE Oh\n",
      "NOPENOPE no\n",
      "NOPENOPE Chicka\n",
      "NOPENOPE chicka\n",
      "NOPENOPE BOOM\n",
      "NOPENOPE BOOM\n",
      "NOPENOPE Skit\n",
      "NOPENOPE skat\n",
      "NOPENOPE skoodle\n",
      "NOPENOPE doot\n",
      "NOPENOPE Flip\n",
      "NOPENOPE flop\n",
      "NOPENOPE flee\n",
      "NOPENOPE Everybody\n",
      "NOPENOPE running\n",
      "NOPENOPE to\n",
      "NOPENOPE the\n",
      "NOPENOPE coconut\n",
      "NOPENOPE tree\n",
      "NOPENOPE Mamas\n",
      "NOPENOPE and\n",
      "NOPENOPE papas\n",
      "NOPENOPE and\n",
      "NOPENOPE uncles\n",
      "NOPENOPE and\n",
      "NOPENOPE aunts\n",
      "NOPENOPE hug\n",
      "NOPENOPE their\n",
      "NOPENOPE little\n",
      "NOPENOPE dears\n",
      "NOPENOPE then\n",
      "NOPENOPE dust\n",
      "NOPENOPE their\n",
      "NOPENOPE pants\n",
      "NOPENOPE Help\n",
      "NOPENOPE us\n",
      "NOPENOPE up\n",
      "NOPENOPE cried\n",
      "A\n",
      "B\n",
      "C\n",
      "NOPENOPE Next\n",
      "NOPENOPE from\n",
      "NOPENOPE the\n",
      "NOPENOPE pileup\n",
      "NOPENOPE skinnedknee\n",
      "D\n",
      "NOPENOPE and\n",
      "NOPENOPE stubbedtoe\n",
      "E\n",
      "NOPENOPE and\n",
      "NOPENOPE patchedup\n",
      "F\n",
      "NOPENOPE Then\n",
      "NOPENOPE comes\n",
      "G\n",
      "NOPENOPE all\n",
      "NOPENOPE out\n",
      "NOPENOPE of\n",
      "NOPENOPE breath\n",
      "H\n",
      "NOPENOPE is\n",
      "NOPENOPE tangled\n",
      "NOPENOPE up\n",
      "NOPENOPE with\n",
      "I\n",
      "J\n",
      "NOPENOPE and\n",
      "K\n",
      "NOPENOPE are\n",
      "NOPENOPE about\n",
      "NOPENOPE to\n",
      "NOPENOPE cry\n",
      "L\n",
      "NOPENOPE is\n",
      "NOPENOPE knotted\n",
      "NOPENOPE like\n",
      "a\n",
      "NOPENOPE tie\n",
      "M\n",
      "NOPENOPE is\n",
      "NOPENOPE looped\n",
      "N\n",
      "NOPENOPE is\n",
      "NOPENOPE stopped\n",
      "O\n",
      "NOPENOPE is\n",
      "NOPENOPE twisted\n",
      "NOPENOPE alleyoop\n",
      "NOPENOPE Skit\n",
      "NOPENOPE skat\n",
      "NOPENOPE skoodle\n",
      "NOPENOPE doot\n",
      "NOPENOPE Flip\n",
      "NOPENOPE flop\n",
      "NOPENOPE flee\n",
      "NOPENOPE Look\n",
      "NOPENOPE whos\n",
      "NOPENOPE coming\n",
      "NOPENOPE Its\n",
      "NOPENOPE blackeyed\n",
      "P\n",
      "Q\n",
      "R\n",
      "S\n",
      "NOPENOPE and\n",
      "NOPENOPE loosetooth\n",
      "T\n",
      "NOPENOPE Then\n",
      "U\n",
      "V\n",
      "W\n",
      "NOPENOPE wigglejiggle\n",
      "NOPENOPE free\n",
      "NOPENOPE Last\n",
      "NOPENOPE to\n",
      "NOPENOPE come\n",
      "X\n",
      "Y\n",
      "Z\n",
      "NOPENOPE And\n",
      "NOPENOPE the\n",
      "NOPENOPE sun\n",
      "NOPENOPE goes\n",
      "NOPENOPE down\n",
      "NOPENOPE on\n",
      "NOPENOPE the\n",
      "NOPENOPE coconut\n",
      "NOPENOPE tree\n",
      "NOPENOPE But\n",
      "NOPENOPE chicka\n",
      "NOPENOPE chicka\n",
      "NOPENOPE boom\n",
      "NOPENOPE boom\n",
      "NOPENOPE Look\n",
      "NOPENOPE theres\n",
      "a\n",
      "NOPENOPE full\n",
      "NOPENOPE moon\n",
      "A\n",
      "NOPENOPE is\n",
      "NOPENOPE out\n",
      "NOPENOPE of\n",
      "NOPENOPE bed\n",
      "NOPENOPE and\n",
      "NOPENOPE this\n",
      "NOPENOPE is\n",
      "NOPENOPE what\n",
      "NOPENOPE he\n",
      "NOPENOPE said\n",
      "NOPENOPE Dare\n",
      "NOPENOPE double\n",
      "NOPENOPE dare\n",
      "NOPENOPE you\n",
      "NOPENOPE cant\n",
      "NOPENOPE catch\n",
      "NOPENOPE me\n",
      "NOPENOPE Chicka\n",
      "NOPENOPE chicka\n",
      "NOPENOPE BOOM\n",
      "NOPENOPE BOOMChicka\n",
      "NOPENOPE chicka\n",
      "NOPENOPE BOOM\n",
      "NOPENOPE BOOM\n",
      "NOPENOPE Ill\n",
      "NOPENOPE beat\n",
      "NOPENOPE you\n",
      "NOPENOPE to\n",
      "NOPENOPE the\n",
      "NOPENOPE top\n",
      "NOPENOPE of\n",
      "NOPENOPE the\n",
      "NOPENOPE coconut\n",
      "NOPENOPE tree\n",
      "NOPENOPE Chicka\n",
      "NOPENOPE chicka\n",
      "NOPENOPE BOOM\n",
      "NOPENOPE BOOM\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def clean_line(line_str):\n",
    "    cleanline = line_str\n",
    "    for punc in string.punctuation:\n",
    "        cleanline = cleanline.replace(punc, \"\")\n",
    "    return cleanline\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    clean_words = clean.split()\n",
    "    for word in clean_words:\n",
    "        if len(word) == 1:\n",
    "            print(word)\n",
    "        else:\n",
    "            print(\"NOPENOPE\", word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's a lot here, but we can visually inspect the results.  This is all working well and good, but we've got some false positives.  We can take out that else in there to quiet things down."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "B\n",
      "C\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "H\n",
      "I\n",
      "J\n",
      "K\n",
      "L\n",
      "M\n",
      "N\n",
      "O\n",
      "P\n",
      "Q\n",
      "R\n",
      "S\n",
      "T\n",
      "U\n",
      "V\n",
      "W\n",
      "X\n",
      "Y\n",
      "Z\n",
      "A\n",
      "B\n",
      "C\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "H\n",
      "I\n",
      "J\n",
      "K\n",
      "L\n",
      "a\n",
      "M\n",
      "N\n",
      "O\n",
      "P\n",
      "Q\n",
      "R\n",
      "S\n",
      "T\n",
      "U\n",
      "V\n",
      "W\n",
      "X\n",
      "Y\n",
      "Z\n",
      "a\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def clean_line(line_str):\n",
    "    cleanline = line_str\n",
    "    for punc in string.punctuation:\n",
    "        cleanline = cleanline.replace(punc, \"\")\n",
    "    return cleanline\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    clean_words = clean.split()\n",
    "    for word in clean_words:\n",
    "        if len(word) == 1:\n",
    "            print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This word a is throwing us off.  We don't have any other advanced tools at hand, so we need to thing of a single condition to check to make this true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside that string module is `string.ascii_uppercase`, which contains all our uppercase characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n"
     ]
    }
   ],
   "source": [
    "print(string.ascii_uppercase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `in` keyword is something often used in condetionals, and it checks if some value os part of another value.  It works differently depending on the datatype."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"hell\" in \"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"A\" in [\"A\", \"B\", \"C\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"fizzy\" in [\"A\", \"B\", \"C\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you see how we might use that second example?  We could use the first, and it fact it would work, but looking again, we could imagine something like \"NO\" appearing, which would be true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"NO\" in string.ascii_uppercase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to change things so that only single characters will match, but we still want the `in` keyword we work. If we could change the contents of our `string.ascii_uppercase` to be in a lisy (one character at a time), we could do this.  Passing a string to the `list` method will split out all the characters into individual elements.  So now \"NO\" should not be found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n"
     ]
    }
   ],
   "source": [
    "print(list(string.ascii_uppercase))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"NO\" in list(string.ascii_uppercase))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's change our if statement to check to this instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "B\n",
      "C\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "H\n",
      "I\n",
      "J\n",
      "K\n",
      "L\n",
      "M\n",
      "N\n",
      "O\n",
      "P\n",
      "Q\n",
      "R\n",
      "S\n",
      "T\n",
      "U\n",
      "V\n",
      "W\n",
      "X\n",
      "Y\n",
      "Z\n",
      "A\n",
      "B\n",
      "C\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "H\n",
      "I\n",
      "J\n",
      "K\n",
      "L\n",
      "M\n",
      "N\n",
      "O\n",
      "P\n",
      "Q\n",
      "R\n",
      "S\n",
      "T\n",
      "U\n",
      "V\n",
      "W\n",
      "X\n",
      "Y\n",
      "Z\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def clean_line(line_str):\n",
    "    cleanline = line_str\n",
    "    for punc in string.punctuation:\n",
    "        cleanline = cleanline.replace(punc, \"\")\n",
    "    return cleanline\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    clean_words = clean.split()\n",
    "    for word in clean_words:\n",
    "        if word in list(string.ascii_uppercase):\n",
    "            print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All good now!  Returning to our original problem statement, we are reminded that we want to know how many letters are in each line.  So we need to add an acuumulator here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "B\n",
      "C\n",
      "4 in this line\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "4 in this line\n",
      "H\n",
      "1 in this line\n",
      "I\n",
      "J\n",
      "K\n",
      "3 in this line\n",
      "L\n",
      "M\n",
      "N\n",
      "O\n",
      "P\n",
      "5 in this line\n",
      "Q\n",
      "R\n",
      "S\n",
      "T\n",
      "U\n",
      "V\n",
      "W\n",
      "X\n",
      "Y\n",
      "Z\n",
      "10 in this line\n",
      "0 in this line\n",
      "0 in this line\n",
      "0 in this line\n",
      "A\n",
      "B\n",
      "C\n",
      "3 in this line\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "4 in this line\n",
      "H\n",
      "I\n",
      "J\n",
      "K\n",
      "L\n",
      "5 in this line\n",
      "M\n",
      "N\n",
      "O\n",
      "3 in this line\n",
      "P\n",
      "Q\n",
      "R\n",
      "S\n",
      "T\n",
      "U\n",
      "V\n",
      "W\n",
      "8 in this line\n",
      "X\n",
      "Y\n",
      "Z\n",
      "3 in this line\n",
      "0 in this line\n",
      "A\n",
      "1 in this line\n",
      "0 in this line\n",
      "0 in this line\n",
      "0 in this line\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def clean_line(line_str):\n",
    "    cleanline = line_str\n",
    "    for punc in string.punctuation:\n",
    "        cleanline = cleanline.replace(punc, \"\")\n",
    "    return cleanline\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    clean_words = clean.split()\n",
    "    alpha_char_count = 0\n",
    "    for word in clean_words:\n",
    "        if word in list(string.ascii_uppercase):\n",
    "            print(word)\n",
    "            alpha_char_count += 1\n",
    "    print(alpha_char_count, \"in this line\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is kind of ugly output, so we can fuss with `end=` to make it nicer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABBC  4 in this line\n",
      "DEFG  4 in this line\n",
      "H  1 in this line\n",
      "IJK  3 in this line\n",
      "LMNOP  5 in this line\n",
      "QRSTUVWXYZ  10 in this line\n",
      "  0 in this line\n",
      "  0 in this line\n",
      "  0 in this line\n",
      "ABC  3 in this line\n",
      "DEFG  4 in this line\n",
      "HIJKL  5 in this line\n",
      "MNO  3 in this line\n",
      "PQRSTUVW  8 in this line\n",
      "XYZ  3 in this line\n",
      "  0 in this line\n",
      "A  1 in this line\n",
      "  0 in this line\n",
      "  0 in this line\n",
      "  0 in this line\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def clean_line(line_str):\n",
    "    cleanline = line_str\n",
    "    for punc in string.punctuation:\n",
    "        cleanline = cleanline.replace(punc, \"\")\n",
    "    return cleanline\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    clean_words = clean.split()\n",
    "    alpha_char_count = 0\n",
    "    for word in clean_words:\n",
    "        if word in list(string.ascii_uppercase):\n",
    "            print(word, end = \"\")\n",
    "            alpha_char_count += 1\n",
    "    print(\" \", alpha_char_count, \"in this line\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we don't always want to print out the results, often we want to collect the data so we can use it elsewhere.  We can do this with a list accumulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 in this line\n",
      "4 in this line\n",
      "1 in this line\n",
      "3 in this line\n",
      "5 in this line\n",
      "10 in this line\n",
      "0 in this line\n",
      "0 in this line\n",
      "0 in this line\n",
      "3 in this line\n",
      "4 in this line\n",
      "5 in this line\n",
      "3 in this line\n",
      "8 in this line\n",
      "3 in this line\n",
      "0 in this line\n",
      "1 in this line\n",
      "0 in this line\n",
      "0 in this line\n",
      "0 in this line\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def clean_line(line_str):\n",
    "    cleanline = line_str\n",
    "    for punc in string.punctuation:\n",
    "        cleanline = cleanline.replace(punc, \"\")\n",
    "    return cleanline\n",
    "\n",
    "fileio = open('boomboom.txt', 'r')\n",
    "\n",
    "chicka_lines = fileio.readlines()\n",
    "\n",
    "letter_counts = []\n",
    "\n",
    "for line in chicka_lines:\n",
    "    clean = clean_line(line)\n",
    "    clean_words = clean.split()\n",
    "    alpha_char_count = 0\n",
    "    for word in clean_words:\n",
    "        if word in list(string.ascii_uppercase):\n",
    "#             print(word, end = \"\")\n",
    "            alpha_char_count += 1\n",
    "    print(alpha_char_count, \"in this line\")\n",
    "    letter_counts.append(alpha_char_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now we can use it elsewhere!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(letter_counts)\n",
    "plt.title(\"Letter counts by line for\\nChicka Chicka Boom Boom\")\n",
    "plt.xlabel(\"Line Number\")\n",
    "plt.ylabel(\"Number of characters mentioned\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# dumping ground\n",
    "\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.  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`: 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",
    "         ```\n",
    "         \n",
    "A tl;dr summary:\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."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}