Lectures/Week-02-ExpressionsAndLoops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Spring 2018 Status: ~90% there\n",
    "\n",
    "# Submitting homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "The narrative file should include:\n",
    "\n",
    "* Some description of your thoughts through each problem\n",
    "* Any supporting screenshots, etc. if you want.\n",
    "* Answers to your homework problems (when applicable), you don't need to write another narrative about this problem unless you want to.\n",
    "* A short reflection on the week.  Garrick and I will be reviewing these.\n",
    "* We aren't grading on style, we just want to know your thoughts on things. So feel free to come up with your own format that makes sense. We aren't grading these like papers, so really, don't worry about it so much.\n",
    "* We'll give you feedback about your narrative for this first assignment to let you know if you're on the wrong track with it. Chances are whatever you come up with is fine!\n",
    "* Seriously, don't stress about the narrative. Just write some stuff.\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",
    "This is more than just a recipe.  Think of this as a script in a play.  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.  You're taking it line by line and dealing with things as they come.\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\" stage. I personally wouldn't have incorporated this style so quickly in the book, but in an effort to be coherent, 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": [
    "# 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.\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",
    "Much of the action driven in Python is done so by loops.  These things tell the program to repeat stuff.\n",
    "\n",
    "There are three kinds of loops:\n",
    "\n",
    "1. do something some arbitrary number of times (think:  take 50 steps forward)\n",
    "2. unpack some content and loop over those elements one at a time\n",
    "3. loop over something for the purposes of looking up another thing\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",
    "# Problem 1\n",
    "\n",
    "Abstract:  You have a thing and want to loop through the contents.  This will give you access to the indidividual 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 inidividual 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": [
    "## 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",
    "\n",
    "```\n",
    "for iterable_variable in sequence:\n",
    "    do this stuff\n",
    "\n",
    "```\n",
    "Let's do a vocabulary lesson for the anatomy of a for loop:\n",
    "\n",
    "* declared and opened with a `for` keyword\n",
    "* a sequence that is being iterated over (the `\"Once\"` string)\n",
    "* an iterable variable (`letter`) 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 (`print(letter)`)\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",
    "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": [
    "# Introducing your new best friend and worst enemy: the `range()` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": [
    "# Essential pattern:  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
}