hist3368-week4-for-loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For citation information, please see the \"Source Information\" section listed in the associated README file: https://github.com/stephbuon/digital-history/tree/master/hist3368-week2-critical-word-count"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hist 3368 - For Loops "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this week's assignment, you'll learn how to loop over lists of data.  You'll also start the process of thinking critically about which words matter to you for the purposes of text mining, and how to use a thesaurus and the powers of reason to expand your expert vocabulary and divide it into categories of information. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we'll be looking at commands that tell Python to repeat:\n",
    "\n",
    "    take an item in a list\n",
    "    do something to it \n",
    "    take the next item in the list\n",
    "    do something to it\n",
    "    repeat until all the items in the list have been touched."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This structure is called a \"loop\" because when Python reaches the end of the statements in the body, it \"loops\" back to the beginning of the body, and executes the same statements again (this time with the next item in the list).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The list comprehension syntax discussed earlier is very powerful: it allows you to succinctly transform one list into another list by a repeated modification. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the 'for'...'in' formula"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 'in' operator is part of the grammar of most for loops.  'In' usually tells Python to iterate over the variables in a list.\n",
    "\n",
    "The basic 'for loop' formula that we'll be using in this class using the formula:\n",
    "\n",
    "for [dummy variable] in [list]:\n",
    "    [do something to the] [dummy variable]\n",
    "    \n",
    "What you should notice:\n",
    "    \n",
    "    * notice that the line begins with 'for'\n",
    "    * note the use of 'in'\n",
    "    * notice that the 'for' line closes with a colon -- ':' -- which is right next to the name of the list.\n",
    "    * note that the name of the dummy variable called by 'for' is repeated inside the loop.\n",
    "    \n",
    "That may seem terribly abstract, so let's look at a hands-on example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start out with a list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['it', 'was', 'the', 'best', 'of', 'times', 'it', 'was', 'the', 'worst', 'of', 'times']\n"
     ]
    }
   ],
   "source": [
    "wordstring = ['it', 'was', 'the', 'best', 'of', 'times', 'it', 'was', 'the', 'worst', 'of', 'times']\n",
    "print(wordstring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a for loop to format wordstring in new ways."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it\n",
      "was\n",
      "the\n",
      "best\n",
      "of\n",
      "times\n",
      "it\n",
      "was\n",
      "the\n",
      "worst\n",
      "of\n",
      "times\n"
     ]
    }
   ],
   "source": [
    "for word in wordstring:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it!!\n",
      "was!!\n",
      "the!!\n",
      "best!!\n",
      "of!!\n",
      "times!!\n",
      "it!!\n",
      "was!!\n",
      "the!!\n",
      "worst!!\n",
      "of!!\n",
      "times!!\n"
     ]
    }
   ],
   "source": [
    "for word in wordstring:\n",
    "    print(word + '!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might be wondering where we got the 'word' in the formula 'for [blank] in [list].' This is important: **word** in wordstring could be anything.  'word' is just a dummy variable.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it\n",
      "was\n",
      "the\n",
      "best\n",
      "of\n",
      "times\n",
      "it\n",
      "was\n",
      "the\n",
      "worst\n",
      "of\n",
      "times\n"
     ]
    }
   ],
   "source": [
    "for rutabaga in wordstring:\n",
    "    print(rutabaga)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's important is consistency. Whatever you name a dummy variable, you must continue to use that same variable name **inside** the for loop.  Otherwise you'll be telling Python to do something very different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n",
      "times\n"
     ]
    }
   ],
   "source": [
    "for tyrannosaurus in wordstring:\n",
    "    print(rutabaga)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it\n",
      "was\n",
      "the\n",
      "best\n",
      "of\n",
      "times\n",
      "it\n",
      "was\n",
      "the\n",
      "worst\n",
      "of\n",
      "times\n"
     ]
    }
   ],
   "source": [
    "for tyrannosaurus in wordstring:\n",
    "    print(tyrannosaurus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Can you see what is different between the two commands above?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is 'for' doing?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"For\" is Python's command to repeat.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider this: if you wanted to print out each word in 'wordstring,' you could just write out a series of commands like so:'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it!!!\n",
      "was!!!\n",
      "the!!!\n",
      "best!!!\n",
      "of!!!\n",
      "times!!!\n",
      "it!!!\n",
      "was!!!\n",
      "the!!!\n",
      "worst!!!\n",
      "of!!!\n",
      "times!!!\n"
     ]
    }
   ],
   "source": [
    "print(wordstring[0]+'!!!')\n",
    "print(wordstring[1]+'!!!')\n",
    "print(wordstring[2]+'!!!')\n",
    "print(wordstring[3]+'!!!')\n",
    "print(wordstring[4]+'!!!')\n",
    "print(wordstring[5]+'!!!')\n",
    "print(wordstring[6]+'!!!')\n",
    "print(wordstring[7]+'!!!')\n",
    "print(wordstring[8]+'!!!')\n",
    "print(wordstring[9]+'!!!')\n",
    "print(wordstring[10]+'!!!')\n",
    "print(wordstring[11]+'!!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But that's a lot of typing.  'For' saves you from unnecessary, repetitive typing. It's one of the kinds of repeated tasks that computers are great at."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it -- is the best word! \n",
      "was -- is the best word! \n",
      "the -- is the best word! \n",
      "best -- is the best word! \n",
      "of -- is the best word! \n",
      "times -- is the best word! \n",
      "it -- is the best word! \n",
      "was -- is the best word! \n",
      "the -- is the best word! \n",
      "worst -- is the best word! \n",
      "of -- is the best word! \n",
      "times -- is the best word! \n"
     ]
    }
   ],
   "source": [
    "for word in wordstring:\n",
    "    print(word + ' -- is the best word! ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a mathematical example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "numberlist = [1, 2, 3, 4]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "2000\n",
      "3000\n",
      "4000\n"
     ]
    }
   ],
   "source": [
    "for int in numberlist:\n",
    "    print(int * 1000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the rest of this class, we won't be making up silly punctuation for lines of words. But we will want to count the number of words for every document in a given year. We will want to change the punctuation or spelling  or plural form of many words so as to produce a uniform text that is ieasy to count.  So we will have many occasions to use repeated commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other formats for for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also 'for' loops that don't use 'in.'  \n",
    "\n",
    "Sometimes they use other commandments.  For instance, 'range()' is often used with for loops.  \n",
    "\n",
    "'Range' calls up a list of integers leading up to a number. Thus 'range(4)' produces \"0, 1, 2, 3, 4\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example that follows, we make an empty list with the line\n",
    "\n",
    "    integers = []\n",
    "    \n",
    "We then invoke 'for' and 'range' to tell Python to repeat the next command in a 'loop'.\n",
    "\n",
    "    for i in range(10): -- tells Python to do the next line 11 times \n",
    "        integers.append(i)  --- this line tells Python to 'append' the contents of the changing variable 'i' to the list 'integers'\n",
    "        \n",
    "The result of this for loop is that Python takes the dummy variable 'i' and 'appends' it as a new member in the list 'integers.'  \n",
    "\n",
    "Because of the structure of for...range, for each loop of 'for i', the variable i increases from 0 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "integers = []\n",
    "\n",
    "for i in range(10):\n",
    "   integers.append(i)\n",
    "\n",
    "print(integers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Doing More than One Thing inside a For Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "    \n",
    "Of course, the body of the loop can have more than one statement, and you can assign values to variables inside the loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IT\n",
      "WAS\n",
      "THE\n",
      "BEST\n",
      "OF\n",
      "TIMES\n",
      "IT\n",
      "WAS\n",
      "THE\n",
      "WORST\n",
      "OF\n",
      "TIMES\n"
     ]
    }
   ],
   "source": [
    "for item in wordstring:\n",
    "    yelling = item.upper()\n",
    "    print(yelling)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even put a loop inside a for loop.  This is called a 'nested for loop'.\n",
    "\n",
    "The nested for loop below contains TWO for statements.  \n",
    "    * The first statemetn ('for item in wordstring') moves through each word in wordstring, as we saw above.\n",
    "    * The second statement ('for letter in item') moves through each letter in each word.\n",
    "\n",
    "The result is to print out one letter per line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i\n",
      "t\n",
      "w\n",
      "a\n",
      "s\n",
      "t\n",
      "h\n",
      "e\n",
      "b\n",
      "e\n",
      "s\n",
      "t\n",
      "o\n",
      "f\n",
      "t\n",
      "i\n",
      "m\n",
      "e\n",
      "s\n",
      "i\n",
      "t\n",
      "w\n",
      "a\n",
      "s\n",
      "t\n",
      "h\n",
      "e\n",
      "w\n",
      "o\n",
      "r\n",
      "s\n",
      "t\n",
      "o\n",
      "f\n",
      "t\n",
      "i\n",
      "m\n",
      "e\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "for item in wordstring:\n",
    "    for letter in item:\n",
    "        print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example of a nested for loop that calls two lists in succession."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_list = [1, 2, 3]\n",
    "alpha_list = ['a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "   a\n",
      "   b\n",
      "   c\n",
      "2\n",
      "   a\n",
      "   b\n",
      "   c\n",
      "3\n",
      "   a\n",
      "   b\n",
      "   c\n"
     ]
    }
   ],
   "source": [
    "for number in num_list:\n",
    "    print(number)\n",
    "    for letter in alpha_list:\n",
    "        print('   ' + letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First the **first** for loop calls an item from num_list.\n",
    "\n",
    "Then the **second** for loop calls all the items from alpha_list, printing each slightly indented.\n",
    "\n",
    "The loop repeats until all the numbers in num_list are exhausted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also include other kinds of nested statements inside the for loop.  \n",
    "\n",
    "\"Conditional\" statements, for instance \"if\", ask the computer to first consider whether a certain condition is true before proceeding. \n",
    "\n",
    "In the code below, the \"if\" statement asks if the length of item in characters is 2 -- in other words: \n",
    "\n",
    "    if len(item) == 2:\n",
    "    \n",
    "If that statement is true, then the computer will obey the next command, which tells Python to print words that meet the above condition in uppercase:\n",
    "\n",
    "    print(item.upper())\n",
    "   \n",
    "In other words, the command\n",
    "\n",
    "    if len(item) == 2:\n",
    "         print(item.upper())\n",
    "\n",
    "means that the computer will look for ONLY two-character words in wordstring, and those two-character words will be printed in uppercase. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IT\n",
      "OF\n",
      "IT\n",
      "OF\n"
     ]
    }
   ],
   "source": [
    "\n",
    "for item in wordstring:\n",
    "    if len(item) == 2:\n",
    "        print(item.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditional statements can become very complicated. You might not see very many of these in our class, but it's useful to have seen the commands just in case.\n",
    "\n",
    "\"If\" statements are often followed by one or more \"elif\" statements that mean: \"if the conditions for the original 'if' are wrong, test the next condition\"\n",
    "\n",
    "    elif len(item) == 3:\n",
    "        print(\"   \" + item)\n",
    "        \n",
    "\"If\" and \"elif\" statements are often given with an alternative, which is formatted as \"else.\" An \"else\" statement tells the computer what to do \n",
    "    else:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IT\n",
      "   was\n",
      "   the\n",
      "best\n",
      "OF\n",
      "times\n",
      "IT\n",
      "   was\n",
      "   the\n",
      "worst\n",
      "OF\n",
      "times\n"
     ]
    }
   ],
   "source": [
    "\n",
    "for item in wordstring:\n",
    "    if len(item) == 2:\n",
    "        print(item.upper())\n",
    "    elif len(item) == 3:\n",
    "        print(\"   \" + item)\n",
    "    else:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Digression: Doing things with Text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's enough for loops for now.  Let's quickly pick up a few more functions that are useful for working with text."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducing the .split() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One quick way to make a list out of a line of text is to use the \".split()\" function.  Applied to a line of text, .split() will *split* the variable string of text into a list of words."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say that you want to print every string in a list. Here's a short text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"it was the best of times, it was the worst of times\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make a list of all the words in the text by splitting on whitespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = text.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, we can see what's in the list simply by evaluating the variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['it',\n",
       " 'was',\n",
       " 'the',\n",
       " 'best',\n",
       " 'of',\n",
       " 'times,',\n",
       " 'it',\n",
       " 'was',\n",
       " 'the',\n",
       " 'worst',\n",
       " 'of',\n",
       " 'times']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Join: Making strings from lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we've created a list of words, it's a common task to want to take that list and \"glue\" it back together, so it's a single string again, instead of a list. So, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hydrogen, and helium, and lithium, and beryllium, and boron'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "element_list = [\"hydrogen\", \"helium\", \"lithium\", \"beryllium\", \"boron\"]\n",
    "glue = \", and \"\n",
    "glue.join(element_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The .join() method needs a \"glue\" string to the left of it---this is the string that will be placed in between the list elements. In the parentheses to the right, you need to put an expression that evaluates to a list. Very frequently with .join(), programmers don't bother to assign the \"glue\" string to a variable first, so you end up with code that looks like this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a test'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words = [\"this\", \"is\", \"a\", \"test\"]\n",
    "\" \".join(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "* Write a list that contains your full name as a series of words in quotation marks separated by commas.\n",
    "\n",
    "* Write a for loop that prints out your full name one word at a time.\n",
    "\n",
    "* Write a nested for loop that prints out your full name one character at a time.\n",
    "\n",
    "* WRite a for loop using range() that counts to 20 by fives."
   ]
  }
 ],
 "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.9.10 (main, Feb 25 2022, 18:07:24) \n[Clang 13.0.0 (clang-1300.0.29.30)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}