Lectures/Week-02-ExpressionsAndLoops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Week 2: Python essentials\n",
    "\n",
    "Today we're going to go over some administrative stuff to get you ready for doing homework and settled more into moodle.\n",
    "\n",
    "# But first, getting started with homework and moodle and stuff\n",
    "\n",
    "## Reading a homework assignment\n",
    "\n",
    "In each assignment there will be a long list of text.  There are only a few problems, so much of this text is background information and hints.  Occasionally there are added restrictions that I've put in for a particular problem from the book. \n",
    "\n",
    "As we move forward in the semester, many of the homework problems to complete are not from the Zelle book but something I've written just in the assignment text.  This is hopefully clear by the indent level, but you're always welcome to email us for clarification.  \n",
    "\n",
    "Sometimes there will be an attached python file for you to work with.\n",
    "\n",
    "Be sure to check back regularly to the assignment text in case there's a relevant hint or restriction that you forgot about. The assignment text won't be changing during that week the assignment is due, and if there are any major revisions that week I'll send out a note about it.\n",
    "\n",
    "## Submitting homework\n",
    "\n",
    "A submission should include:\n",
    "* a narrative file (pdf or word, pdf is easier on us)\n",
    "* .py files for each of your homework problems requiring code for a solution\n",
    "* some homework problems are inherently narrative (like the discussion items), so the answer in your narrative file is fine.\n",
    "\n",
    "\n",
    "### Narratives!\n",
    "\n",
    "There's a giant section of the syllabus that describes the narrative.  I'll leave this information about it there. [syllabus link](../syllabus.md) Seriously, don't stress about the narrative. Just write some stuff.  Something more than \"it was fine\" and something less than every thought that you had in the process.\n",
    "\n",
    "There are also sample narrative answers in the moodle page.\n",
    "\n",
    "We use these narratives to better understand what happened if something went wrong, and we can often award partial credit or avoid taking off points based on what was going on with your narrative.\n",
    "\n",
    "The .py files should include:\n",
    "* code, obviously\n",
    "* which problem number it is for, in the file name and in a short code comment, preferably\n",
    "* any code comments you'd like to throw in, to point things out to the graders or add clarification about what you're doing\n",
    "* some comments showing an example input (this will make more sense in later assignments) and an example of how the output should look (you can provide just the first line of output, you don't need to do all of it).\n",
    "* remember that you can find these files within the project folder you created when you set up pycharm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What does it mean to be a script?\n",
    "\n",
    "Think of this as a script in a play.  \n",
    "\n",
    "You are handed this thing, and you don't need to know what the end says to start reading through it.  You don't know what it is going to tell you to do, but you know that you'll just follow the directions.  \n",
    "\n",
    "The script sometimes tells you to say things.  Other times it's telling you to go somewhere or do something.  \n",
    "\n",
    "You're taking it line by line and dealing with things as they come.\n",
    "\n",
    "Hopefully you know how to say the words and do the actions it's asking for. There may be times where you aren't sure and can't go on.  This is what it means when Python hits an error.\n",
    "\n",
    "Say I want you to walk in a square.  Let's imagine you're directing someone for how to walk in a square.  You need to tell them two things:  \n",
    "\n",
    "1. how many steps ahead to walk\n",
    "2. how many degrees to turn (you can't just tell them left or right)\n",
    "\n",
    "So some questions:\n",
    "\n",
    "1. How many times will I need to walk forward?\n",
    "2. How many times will I need to turn?\n",
    "3. How far should I turn?\n",
    "\n",
    "Now you all tell me how to do this.\n",
    "\n",
    "## Let's take a look at turtle\n",
    "\n",
    "Here is a repl for you to play with: https://repl.it/@elliewix/Week02-TurtleBase\n",
    "\n",
    "Much like the directions that you needed to tell me, you must tell the turtle how to move.  It takes these values in order.\n",
    "\n",
    "1. to move ahead, you use `friend.forward(50)` to tell it to move forward 50 pixels\n",
    "2. to tell it to turn, you use `friend.right(90)` to tell it to turn right 90 degrees.\n",
    "\n",
    "## Challenge:  how do we complete the square\n",
    "\n",
    "See the direction of the arrow of your turtle friend?  That is the direction that it will start moving when you tell it to go forward.  So with the code already in place, your turtle is ready to start walking again in that direction.  \n",
    "\n",
    "### Pair up and try it\n",
    "\n",
    "Pair up with the person next to you and take 5 minutes to try and finish your square.\n",
    "\n",
    "## Second challenge:  make another shape\n",
    "\n",
    "You have to tell it to turn a certain number of degrees, and this turn is what determines the shape that it will draw.  You can calulate how many degrees it will turn with this:\n",
    "\n",
    "`360 / (how many sides do you want?)`\n",
    "\n",
    "So for a square, this was `360 / 4` giving us `90`.\n",
    "\n",
    "Spend 5 minutes with your parter messing with this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transition back\n",
    "\n",
    "OK, we've been playing with making python draw shapes.  What you've been executing is a complete Python program.  It does it one thing at a time.\n",
    "\n",
    "We're going to explore a bit about the `main()` that you're going to see in the book, then explore for loops, and finally start messing with some data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A quick note on the main() business\n",
    "\n",
    "We haven't talked about functions yet, so this is a pretty annoying \"roll with it\" kind of problem. I personally wouldn't have incorporated this style so quickly in the book, but in an effort to be coherent with how Zelle is presenting things in the book, we'll use it.\n",
    "\n",
    "Some tips:\n",
    "* Keep your indents in order.\n",
    "* Everything tabbed in under the def line will 'belong' to that function.\n",
    "* None of the code within the def main(): block will run if you don't 'call' the function.\n",
    "* Perfect looking script executing without an output? This is likely the culprit.\n",
    "* You need to have a main() as your last line of code without any indents.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fizzy pop sandwich\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    print(\"fizzy pop sandwich\")\n",
    "    # more code goes here\n",
    "\n",
    "main() # last line, no indents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Things to note in this little piece of code:\n",
    "\n",
    "* the indented code after the `def` line is what is executed \n",
    "* the `def` keyword opens up a function definition block of code.  We need to provide code to live within the \n",
    "* the `main()` call comes after the definition of the function\n",
    "* the `main()` call is also indented over back to the left.  This is how python knows that you've finished telling it what code belongs in the function definition.\n",
    "* forgetting to include the function call means that nothing runs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# My presumtion at this point\n",
    "\n",
    "I presume that you have worked through chapter 2, maybe chapter 1.  Have executed some code, and are roughly OK with the core data types (there are numbers and strings is what I'm after here).\n",
    "\n",
    "# More context about what I'll cover in lecture\n",
    "\n",
    "My lectures are not meant to be 1:1 what is in the book or perfectly and only what you need for the homework.  There will be many places where I'll have a clearly direct example for the homework, but I'm also preparing you for the midterm.  All the information you'll need for the homework will be in the book (if it is a book problem).  My goal with lecture is to give you an alternative presentation reinforce and explore what you have been learning in your readings.  \n",
    "\n",
    "Otherwise, there would be no point in lecture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "\n",
    "## Concept\n",
    "\n",
    "Much of the action driven in Python is done so by loops.  These things tell the program to repeat stuff.  Having a computer repeat a calculation or just keep trying something through a series of values is the power of computing.  We're going to be focused on looping through a set of known values.\n",
    "\n",
    "You're going to use for loops in nearly every Python program that you write for this class. Sometimes these for loops will look really similar, but you'll be using them for very different purposes.  **This is one of the most challenging aspects of the first month of this class.**\n",
    "\n",
    "## Specific types of this loop\n",
    "\n",
    "While there is a single syntax rule for `for` loop, there are many types.  We're going to start off with the three core patterns.  We'll learn more patterns as we move forward, but all of those are tweaks or expansions off of one of these three core patterns.\n",
    "\n",
    "There are three kinds of loops:\n",
    "\n",
    "1. repeat a task some arbitrary number of times\n",
    "    * your input is the number of times\n",
    "2. unpack some sequence of content and loop over those elements one at a time\n",
    "    * your input is the sequence, python will unpack it for you\n",
    "3. loop over something for the purposes of looking up another thing\n",
    "    * this one is strange, where you provide the sequence of items that represent the lookup key for another item.  These keys may be just numbers counting up, or they may be other kinds of content in a sequence (such as letters or words).\n",
    "\n",
    "There three uses will have a very similar syntax and can be difficult to tell the difference between.  For the sake of names, let's call them:\n",
    "\n",
    "1. a range loop\n",
    "2. an unpacking loop\n",
    "3. a reference loop\n",
    "\n",
    "We're going to explore and reinforce our understanding of data types and other stuff as we play with loops.\n",
    "\n",
    "Sometimes you'll need to mix and match these.  For example, the reference loop will often start off life as a range loop.\n",
    "\n",
    "## Core syntax reference \n",
    "\n",
    "What does this for loop look like?\n",
    "\n",
    "```\n",
    "for iterable_variable in sequence:\n",
    "    do this stuff\n",
    "\n",
    "```\n",
    "\n",
    "This will loop over the `sequence` you provide, unpacking each value into the `iterable_variable`.  This variable will hold an individual value, one at a time, for each loop through.  \n",
    "\n",
    "Let's give names to all of these things:\n",
    "\n",
    "* declared and opened with a `for` keyword\n",
    "* a sequence that is being iterated over\n",
    "* an iterable variable to hold the variable contents of the sequence during each loop\n",
    "* white space (the tab) that defines where the executable code lives\n",
    "* the code to be executed each loop\n",
    "\n",
    "Some important notes:  \n",
    "\n",
    "* the iterable variable name can be literally any valid variable name and does not need to be declared previously\n",
    "* the colon at the end of the `for` line block is required and indicates that the declaration line is done\n",
    "* the `in` keyword separates the iterable variable name from the sequence\n",
    "* this case has the sequence literal in the declaration line, but could also be a variable\n",
    "\n",
    "### What is a sequence?\n",
    "\n",
    "That's a good question with a weird answer.  Sequences are data types in Python that internally support sequencing.  That is, you can ask it \"what's next?\" and it can give you an answer.\n",
    "\n",
    "Some things aren't sequences.  Such as numbers (`int`s and `float`s).  You can try asking the number 1 \"what's next?\" but it doesn't know.  Are you counting by 1?  Are you counting by -1? Are you counting by .1?  The question is too ambiguous.  \n",
    "\n",
    "Some things are sequences.  Let's look at a word:  `\"hello\"`.  If I ask this word \"What's next?\" I'll be told the individual letters, getting one at a time during the loop.  The iterable variable will hold those values in succession.  \n",
    "\n",
    "### A note on the iterable variable\n",
    "\n",
    "You can give this variable any name you want (but following the standard variable name rules), and it doesn't need to exist before.  It will feel strange, that you are typing in this variable to be used that doesn't yet have a value.\n",
    "\n",
    "The for loop takes care of it for you.  It will make all the assignment statements for that sequence for you to that variable.\n",
    "\n",
    "But it will persist after the for loop has completed! \n",
    "\n",
    "More on this as we progress.\n",
    "\n",
    "## Setting up a for loop\n",
    "\n",
    "There are three steps for setting up a for loop.  We'll be going through all of these in much more detail as we work through examples. This section is just to set up your thought process.\n",
    "\n",
    "1.  Determine what kind of pattern you'll be executing.  \n",
    "    * This is a thinking stage, where you need to think through what kind of pattern will move your program forward.\n",
    "2.  Identify your sequence.\n",
    "    * Once you know the kind of pattern you want, this will help you determine the kind of sequence.  There are times when the sequence will be very clear to you, and others where you'll be crafting one (for example in a reference loop) to generate the values you need.\n",
    "3.  Give your iterable variable a good name.\n",
    "    * You can technically call it `kitten`, but that isn't helpful.  Think about what it is and try to name it, being sure that you are matching the plural correctly.  For example, if you are working over a sequence of numbers, you might want to call it `num`, or if it's a string you could call it `character`.  \n",
    "    * Be very careful not to repeat any of your previous variable names, as their previous values will be erased for the iterable variable's value.  You may end up blowing away your data and weird things happen.  \n",
    "    * This name must also be different from the sequence's variable name (if it has one), because it might word and end up with really strange results.\n",
    "\n",
    "# Worked examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The unpacking loop\n",
    "\n",
    "Abstract:  You have a thing and want to loop through the contents.  This will give you access to the individual components, one at a time.  As you are going through those things, you want to count the position number of that thing.\n",
    "\n",
    "Concrete:  You are given a sentence and want to print out each character with the position numbers along with each character.\n",
    "\n",
    "Whoa that's a lot of crap in there.  As will be the case for all your homework problems.  So we need to practice picking out the individual elements.\n",
    "\n",
    "There are two steps here:\n",
    "\n",
    "1. loop through each character of the sentence and print it out\n",
    "2. calculate the position number for each character and also print that out\n",
    "\n",
    "Let's work with the first line of the Raven to start with.\n",
    "\n",
    "`Once upon a midnight dreary, while I pondered, weak and weary`\n",
    "\n",
    "We want to save this value to mess with, so let's put it in a variable.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "line = \"Once upon a midnight dreary, while I pondered, weak and weary\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This line of code is what we can call an expression.  These usually include:\n",
    "\n",
    "* literals (that string)\n",
    "* varables (the variable name)\n",
    "* operators (the `=` in there)\n",
    "\n",
    "And some things that we will be meeting later:\n",
    "\n",
    "* functions\n",
    "* other keywords"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type 1:  The unpacking loop\n",
    "\n",
    "Now that we have the text stored in a variable, we can mess with it more now.\n",
    "\n",
    "Let's play with our for loops here.  The best way to learn about for loops is to play with them.  We're going to use a single word for space purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O\n",
      "n\n",
      "c\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for letter in \"Once\":\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This prints one letter at a time.\n",
    "\n",
    "A loop is only as useful as what you do with the contents.  What you choose to do is where creativity and cleverness comes into play.  There are often many ways to solve a problem, your responsibility is to test the accuracy and completeness of your solution.\n",
    "\n",
    "So now we've got each letter isolated through each loop.  What we need to do now is add those numbers.  Let's say we want our results to look like:\n",
    "\n",
    "```1: O\n",
    "2: n\n",
    "3: c\n",
    "4: e```\n",
    "\n",
    "What's the pattern here?\n",
    "\n",
    "`the number number + a colon + a space + the letter`\n",
    "\n",
    "Our string concatination skills tell us that we can constuct the middle bit like this:  `\": \"`.  Our number and letter will need to be stored in variables.\n",
    "\n",
    "As a first pass, we can do a proof of concept that shows we can concatinate stuff inside the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number: O\n",
      "number: n\n",
      "number: c\n",
      "number: e\n"
     ]
    }
   ],
   "source": [
    "for letter in \"Once\":\n",
    "    print(\"number: \" + letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we know 2 things:\n",
    "\n",
    "1. We can do stuff to the iterable variable contents inside the loop.\n",
    "2. We can see where we would need to put the number we want, once we figure out how to get that number.\n",
    "\n",
    "Getting that number is our next step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type 2: the `range()` loop\n",
    "\n",
    "The `range()` function is often your key to cleverness.  When faced with a new problem, your first instinct should be:  \"how can I solve this problem with range?\"  Even if it doesn't seem to involve numbers.\n",
    "\n",
    "But what is range?  It's a function to easily make lists of numbers in a variety of ways.  Let's play with it for a bit.\n",
    "\n",
    "Other than print, this is our first real function.\n",
    "\n",
    "### Functions!\n",
    "\n",
    "These are little mini programs that you can call up.  You know you are looking at a function when you see a name followed by `()`.  You've seen this with `print()`.  The () are there for you to pass the function an input to process.  Then the function gives you back a result OR does something OR does something to something else.\n",
    "\n",
    "Fun fuction facts:\n",
    "\n",
    "* the () are always required, even if empty\n",
    "* the name of the function is the text before the ()\n",
    "* function names roughly have to abide by variable name rules\n",
    "* referring to a function without the () will work sometimes and give you really weird looking errors\n",
    "* you have to refer to documentation or your book for how the work\n",
    "* you can provide more than one input in the (), and separate these by commas\n",
    "\n",
    "Fun function vocabulary:\n",
    "\n",
    "* \"call\" means to use a function, like `print(\"hello\")` is calling a function\n",
    "* \"pass\" means you put a value in the (), like that \"hello\" you see there.  These can be literals or variable names.\n",
    "\n",
    "There's more, but that's it for now.\n",
    "\n",
    "### making `range()` work\n",
    "\n",
    "There are three ways to use range, and we're only going to focus on one.  In this form, you only pass one value to it when calling the function.  \n",
    "\n",
    "`range(number)` but you replace number with an integer number.\n",
    "\n",
    "You provide in integer number to `range` and it will produce a series of numbers.  In this form, it will start at 0 and go up to, but not inluding the number that you have just given it.\n",
    "\n",
    "There are two other ways to use range, but we're going to focus on this primary method first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n"
     ]
    }
   ],
   "source": [
    "print(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range`, that's not very helpful.  Sigh, yes, we need to de another step to see the magic of `range`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a technical reason why this is happening, but nothing worth getting into just yet.  Just remember that you'll need to recast the results of `range` into a list to see/print (with human eyes) the all the numbers that range is making.  Python will get all the numbers just fine when using this as part of your code.\n",
    "\n",
    "You'll also see that range starts at 0, which is both incredibly convenient sometimes and horribly annoying in others.  Just write this fact into your brain for a bit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for whats_this_number in range(10):\n",
    "    print(whats_this_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What this really works out to is:  this is an unpacking loop that will make a thing to unpack of arbirary length.  The number you give range will be how many times the loop executes (roughly).  What it unpacks happens to be numbers, but you can choose to ignore them if you wish.\n",
    "\n",
    "## So we've got two pieces of our puzzle here\n",
    "\n",
    "1. looping over our word and concatinating stuff\n",
    "2. a way to make numbers\n",
    "\n",
    "But neither of these is enough to solve the problem.  We need something that sits in the middle.  We know that a range loop will make the numbers that we need but not give us the letters, and looping through the letters will not give us the numbers.\n",
    "\n",
    "Putting there together is less obvious.  There are two methods that could work:\n",
    "\n",
    "1.  loop through the letters and (somehow) count how many times we've looped\n",
    "    * we don't know how to do this yet, but we will!\n",
    "2.  do a reference loop and use the numbers in our range loop to look up the letters in the string.\n",
    "    * this allows us to make a fake unpacking loop.  \n",
    "\n",
    "When data has an order you can usually look up items by position.  Those positions are generally integer values counting up, which is exactly the power we get with `range`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type 3:  the reference loop\n",
    "\n",
    "Facts:\n",
    "\n",
    "* Strings are ordered sets of characters.  \n",
    "* Each character in a string has a position.\n",
    "* You can look up those characters with a position number.\n",
    "* Postion numbers can be generated with a range function call.\n",
    "\n",
    "So instead of looping over the word itself, we can loop over the results of range and look up the letter in the process.\n",
    "\n",
    "For this, we need to find a way to get a range function call with the right number of positions.  Certainly we could count the number of characters and directly code that into our range call.\n",
    "\n",
    "So this is going to introduce many players into our game.  We need to test out each moving piece as we go.  Here's our general steps.\n",
    "\n",
    "We want to use the numbers produced by range as position numbers for our string.  \n",
    "\n",
    "1. Check that we are producing the right numbers for use as position numbers.\n",
    "2. Check that the position numbers are yanking in what we expect from our string.\n",
    "3. Make the output pretty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "word = \"Once\"\n",
    "wordlength = 4 # counted via eyeballs\n",
    "\n",
    "print(list(range(wordlength)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we'd have to do this for every word we want to run through the program, which woulde defeat the purpose of programming.  What we need is a way to detect the length of an arbitrory string.  \n",
    "\n",
    "# `len()` is an essential partner of `range()`\n",
    "\n",
    "Many types of objects have a length, and each object that works with it has its own definition of what 'length' means. When you pass `len()` a string it counts the number of characters in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(word))\n",
    "print(wordlength)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can substitute this call to `len` in our previous expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(len(word))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whoo, that's getting long!  Luckily, the `range(len(word))` is the important piece.  The rest is just to get the results to print out for our human eyes to see.\n",
    "\n",
    "Let's start filling things in.  First step, get a for loop going over those results of `range`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for number in range(len(word)):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As general practice (but not hard and fast rule), your first step to writing for loops should be to set up the declaration line and throw the iterable item into a print statement so that you know what you are looping over.  This will help reinforce what the data type is that you are supposed to be working with, and allows you to double check that you are actually iterating over what you expect.\n",
    "\n",
    "So now we have our for loop going over the results of range on the length of the words.  Now we need to remember what we were going to use this number for.\n",
    "\n",
    "We were going to use it to look up the letter in the word.\n",
    "\n",
    "# String slicing\n",
    "\n",
    "Slicing means that you are taking a chunk out of something. Many data types that include content with position values can be sliced.  The good thing is that they all share a pretty similar syntax, so you only have one thing to learn.  The bad thing is that this means that the code for these instances will all start looking the same, which is where descriptive variable names come in handy.  You may even want to put the (expected/presumed/hopeful) data type in the variable name.\n",
    "\n",
    "Anyhow, slicing notation revolves around (or inside...) the `[]` characters.  To get a single letter out of a string, you place the desired position value in the `[]` at the end of the string or the variable containing the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\"[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nope, that's not an h.  Remember how `range` starts at 0?   Python is pretty consistent that when counting positions or dealing with a series of numbers, it starts from 0.  Meanwhile, when measuring things like length it starts from 1.  There are historical and technical reasons for this, entire injokes about it, and no shortage of tears shed over it.\n",
    "\n",
    "This is just one of those things that you need to memorize but will still mess up sometimes no matter how much experience you have.\n",
    "\n",
    "So let's place this in our for loop to just see what happens.\n",
    "\n",
    "# final form"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O\n",
      "n\n",
      "c\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for number in range(len(word)):\n",
    "    print(word[number])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All I've done here is add the string slicing lookup into my print statement.  I'm not looping over the word at all.  I'm just making the range based off the length of the loop and looking up the letter.\n",
    "\n",
    "You might be asking about the value of these extra steps rather than just looping over the string directly.  Certainly if my interest was only in the letters this did add unnecessary complication.  However, if you look more closely I have access to much more information in the process.  I not only have the letter, but I also have access to the position of that letter.\n",
    "\n",
    "Watch below as I change nothing about the for loop from above except add more information to the print statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The character at position 0 is O\n",
      "The character at position 1 is n\n",
      "The character at position 2 is c\n",
      "The character at position 3 is e\n"
     ]
    }
   ],
   "source": [
    "for number in range(len(word)):\n",
    "    print(\"The character at position \" + str(number) + \" is \" + word[number])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is getting closer to what we want!  (note that I did have to recast the number value to a string so that it would work with the `+` operator)\n",
    "\n",
    "One problem is:  the numbers start at 0 but we want them to start at 1.  Easily solved with some math.  We can operate on the iterable number without changing the value.  Look in the `str` function to see the change.  Because I'm recasting the number to a string so that I can use the `+` for concatination, I need to make this change while I still have it as a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The character at position 1 is O\n",
      "The character at position 2 is n\n",
      "The character at position 3 is c\n",
      "The character at position 4 is e\n"
     ]
    }
   ],
   "source": [
    "for number in range(len(word)):\n",
    "    print(\"The character at position \" + str(number + 1) + \" is \" + word[number])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we have it!  Let's grab the wording that we wanted before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: O\n",
      "2: n\n",
      "3: c\n",
      "4: e\n"
     ]
    }
   ],
   "source": [
    "for number in range(len(word)):\n",
    "    print(str(number + 1) + \": \" + word[number])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: O\n",
      "2: n\n",
      "3: c\n",
      "4: e\n",
      "5:  \n",
      "6: u\n",
      "7: p\n",
      "8: o\n",
      "9: n\n",
      "10:  \n",
      "11: a\n",
      "12:  \n",
      "13: m\n",
      "14: i\n",
      "15: d\n",
      "16: n\n",
      "17: i\n",
      "18: g\n",
      "19: h\n",
      "20: t\n",
      "21:  \n",
      "22: d\n",
      "23: r\n",
      "24: e\n",
      "25: a\n",
      "26: r\n",
      "27: y\n",
      "28: ,\n",
      "29:  \n",
      "30: w\n",
      "31: h\n",
      "32: i\n",
      "33: l\n",
      "34: e\n",
      "35:  \n",
      "36: I\n",
      "37:  \n",
      "38: p\n",
      "39: o\n",
      "40: n\n",
      "41: d\n",
      "42: e\n",
      "43: r\n",
      "44: e\n",
      "45: d\n",
      "46: ,\n",
      "47:  \n",
      "48: w\n",
      "49: e\n",
      "50: a\n",
      "51: k\n",
      "52:  \n",
      "53: a\n",
      "54: n\n",
      "55: d\n",
      "56:  \n",
      "57: w\n",
      "58: e\n",
      "59: a\n",
      "60: r\n",
      "61: y\n"
     ]
    }
   ],
   "source": [
    "for number in range(len(line)):\n",
    "    print(str(number + 1) + \": \" + line[number])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fun stuff if we get there: `enumerate()` is a more direct path\n",
    "\n",
    "As a quick aside, there is a more direct path to this sort of thing, when you want acess to both the content and a counted position.  The `enumerate()` function provides these pairs in an easy syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<enumerate object at 0x1021aea20>\n",
      "[(0, 'O'), (1, 'n'), (2, 'c'), (3, 'e')]\n"
     ]
    }
   ],
   "source": [
    "print(enumerate(word)) # yes, another one of those\n",
    "print(list(enumerate(word)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking closely, we have pairs of the counted position and the content.  We can loop over these pairs (an important distictction!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'O')\n",
      "(1, 'n')\n",
      "(2, 'c')\n",
      "(3, 'e')\n"
     ]
    }
   ],
   "source": [
    "for pair in enumerate(word):\n",
    "    print(pair)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More of a fun demo here, but these pairs are tuples that we can unpack.  This way we can avoid having to do a lookup.  There's nothing wrong with doing a lookup, but sometimes this can be clearer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: O\n",
      "2: n\n",
      "3: c\n",
      "4: e\n",
      "5:  \n",
      "6: u\n",
      "7: p\n",
      "8: o\n",
      "9: n\n",
      "10:  \n",
      "11: a\n",
      "12:  \n",
      "13: m\n",
      "14: i\n",
      "15: d\n",
      "16: n\n",
      "17: i\n",
      "18: g\n",
      "19: h\n",
      "20: t\n",
      "21:  \n",
      "22: d\n",
      "23: r\n",
      "24: e\n",
      "25: a\n",
      "26: r\n",
      "27: y\n",
      "28: ,\n",
      "29:  \n",
      "30: w\n",
      "31: h\n",
      "32: i\n",
      "33: l\n",
      "34: e\n",
      "35:  \n",
      "36: I\n",
      "37:  \n",
      "38: p\n",
      "39: o\n",
      "40: n\n",
      "41: d\n",
      "42: e\n",
      "43: r\n",
      "44: e\n",
      "45: d\n",
      "46: ,\n",
      "47:  \n",
      "48: w\n",
      "49: e\n",
      "50: a\n",
      "51: k\n",
      "52:  \n",
      "53: a\n",
      "54: n\n",
      "55: d\n",
      "56:  \n",
      "57: w\n",
      "58: e\n",
      "59: a\n",
      "60: r\n",
      "61: y\n"
     ]
    }
   ],
   "source": [
    "for number, letter in enumerate(line):\n",
    "    print(str(number + 1) + \": \" + letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# a cool example with previews to future lessons\n",
    "\n",
    "Say we have the first stanza of The Raven."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stanza1string = \"\"\"Once upon a midnight dreary, while I pondered, weak and weary, \n",
    "Over many a quaint and curious volume of forgotten lore, \n",
    "While I nodded, nearly napping, suddenly there came a tapping, \n",
    "As of some one gently rapping, rapping at my chamber door. \n",
    "\\\"\\'Tis some visitor,\" I muttered, \\\"tapping at my chamber door- \n",
    "                Only this, and nothing more.\\\"\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to print our each line with a line number and each word with a word number.  This would make each word uniquely identify each word with a specific set of 'coordinates.  We will actually need a nested loop.  So in human words, we could say:\n",
    "\n",
    "\"For each line, label it with a number.  For each word in that line, label it with a word number.\"\n",
    "\n",
    "There are several string processing tools we haven't explored yet, but allow us to break this string into lines and those lines into words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Once', 'upon', 'a', 'midnight', 'dreary,', 'while', 'I', 'pondered,', 'weak', 'and', 'weary,']\n",
      "['Over', 'many', 'a', 'quaint', 'and', 'curious', 'volume', 'of', 'forgotten', 'lore,']\n",
      "['While', 'I', 'nodded,', 'nearly', 'napping,', 'suddenly', 'there', 'came', 'a', 'tapping,']\n",
      "['As', 'of', 'some', 'one', 'gently', 'rapping,', 'rapping', 'at', 'my', 'chamber', 'door.']\n",
      "['\"\\'Tis', 'some', 'visitor,\"', 'I', 'muttered,', '\"tapping', 'at', 'my', 'chamber', 'door-']\n",
      "['Only', 'this,', 'and', 'nothing', 'more.\"']\n"
     ]
    }
   ],
   "source": [
    "stanza1lines = stanza1string.split('\\n')\n",
    "\n",
    "# first we just check that we are splitting things apart as we hope\n",
    "for line in stanza1lines:\n",
    "    thislineswords = line.split()\n",
    "    print(thislineswords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line 0: (0)Once (1)upon (2)a (3)midnight (4)dreary, (5)while (6)I (7)pondered, (8)weak (9)and (10)weary, \n",
      "Line 1: (0)Over (1)many (2)a (3)quaint (4)and (5)curious (6)volume (7)of (8)forgotten (9)lore, \n",
      "Line 2: (0)While (1)I (2)nodded, (3)nearly (4)napping, (5)suddenly (6)there (7)came (8)a (9)tapping, \n",
      "Line 3: (0)As (1)of (2)some (3)one (4)gently (5)rapping, (6)rapping (7)at (8)my (9)chamber (10)door. \n",
      "Line 4: (0)\"'Tis (1)some (2)visitor,\" (3)I (4)muttered, (5)\"tapping (6)at (7)my (8)chamber (9)door- \n",
      "Line 5: (0)Only (1)this, (2)and (3)nothing (4)more.\" \n"
     ]
    }
   ],
   "source": [
    "for linenum, line in enumerate(stanza1string.split('\\n')): # loop over the lines with enumerate\n",
    "    thislineswords = line.split() # split the line into words\n",
    "    print(\"Line\", str(linenum) + \":\", end = \" \") # print the line label\n",
    "    for wordnum, wordstring in enumerate(thislineswords): # loop over the words with enumerate\n",
    "        print(\"(\" + str(wordnum) + \")\" + wordstring, end = \" \") # print the individual words and nums\n",
    "    print()"
   ]
  }
 ],
 "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
}