week3-wed-python-lists-loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Doing Things Again (and Again)\n",
    "\n",
    "The theme for today's class is repeating things. Or, rather, it's getting started with making python repeat things. At its most basic level, most of the revolution in computation over the last 100 years, from adding machines and mechanical calculators onwards, has been about making computers do simple things over and over again, faster and faster. Making use of this power consists mostly of figuring out how to reduce complicated tasks down to simple ones. Modern computers provide many levels of **abstraction** to help with this, by hiding the details of how things work. Abstraction is a bottom-up view of the same hierarchy of complexity: computers, for example, deal in binary, but in python, we get to use base 10. Or, more relevant to this course, we get to deal with texts, and rely on Unicode to convert letters and symbols into numbers, which in turn get converted into 1s and 0s and so on.\n",
    "\n",
    "Python is a high level language, which means we only have to break things down so far (no 1s and 0s needed), and we get a lot of tools to help with the job. One caveat, though: if we want to make python do things over and over (and we do—have you ever counted the words in a novel by hand?\\*) we're going to have to keep track of them, which means we have to learn to count like python.\n",
    "\n",
    "\\* Terrifyingly, people used to do this for Shakespeare plays to try to figure out who wrote them. It's actually (arguably) the root of all of DH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0-based Indexing\n",
    "\n",
    "This might be one of the things you already knew about python, or about computers in general (it's actually not true of all programming langauges, though): counting starts with 0. It's weird and it's unintuitive and sometimes weird, but that's the way it is.\n",
    "\n",
    "Consider the following string:\n",
    "\n",
    "`H E R E   A R E   S O M E   L E T T E R S`\n",
    "`0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0`\n",
    "\n",
    "So letter one is 'E', which isn't too bad, except that while the last letter in the string is letter 20, try running this next cell:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str = \"HERE ARE SOME LETTERS\"\n",
    "len(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If this annoys you as much as it should, it may or may not help to know that the laternative would be worse, since there are, in fact, 21 characters and it would suck to lose one of them. \n",
    "\n",
    "Incidentally, there's a word for what happens when you get this mixed-up: **off-by-one** error. It'll happen *all the time* in this class, and you should be okay with that. Sometimes, it's actually easiest to wing it and fix the results, rather than figure out where you need to be subtracting or adding one.\n",
    "\n",
    "Now that we know how to count letters, though, we can take advantage of this to pull apart our string. This is called **string slicing** though it also works on a few other things (notably, lists, which we'll get to in a bit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HERE ARE SOME LETTERS\n",
      "HERE A\n",
      "E\n",
      "ARE SOME L\n",
      "evil_word\n"
     ]
    }
   ],
   "source": [
    "print(str)\n",
    "str_prefix = str[0:6]\n",
    "print(str_prefix)\n",
    "letter_7 = str[7]\n",
    "print(letter_7)\n",
    "str_mid = str[5:15]\n",
    "print(str_mid)\n",
    "\n",
    "bad_str = \"evil_word\"\n",
    "print(bad_str[0:9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OME LETTERS\n",
      "HERE ARE SOME LETTERS\n"
     ]
    }
   ],
   "source": [
    "# Incidentally, you don't need to store the results in a variable:\n",
    "print(str[10:21])\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, slicing up the string doesn't actually change it. If you want to keep your slice, you need to save it somewhere. This is because strings in python are what's called *immutable*: once you've said what `str` is, you can't change the thing. Imagine it like this: your string is some words. When you assign them to `str`, you put them in a box and label it `str`. Anytime you want, you can look in the box, count the letters, etc. And you can copy them to another box, or only a set of them or whatever. *BUT*, you can't change what's in the box. The only thing you can do is take the `str` label and stick it on another box. \n",
    "\n",
    "You might think this is sort of restrictive, but it's actually not, because we can actually fake a change to str really easily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new string\n",
      "new\n"
     ]
    }
   ],
   "source": [
    "s = \"new string\"\n",
    "print(str)\n",
    "s =  str[0:3]\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If this seems weird and out of bounds to you, it may help to know that it works because everything on the right of the `=` is *evaluated* before anything is assigned, so by the time the assignment happens, there's no refernce to `str` left (the box has been opened up, the letters looked at and the slice calculated) and there's nothing circular about it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Ultimately we're aiming at the idea of the loop here, where we can use python to do something to each of a number of elements in turn. But while it's possible to loop over strings (and we will in this course!), it's helpful to introduce another python construction first: the list.\n",
    "\n",
    "The list is the first of Python's two major data structures, which basically means it's a way of organizing other things, which could be integers, strings, or anything else we can think of (even other lists).\n",
    "\n",
    "In the way we interact with it, the list is a lot like a string: it puts each of it's elements in order, and lets us access them by their index number (which, like for strings, starts from 0). Python's lists are enclosed in square brackets, and the items are separated by commas, so we have `word_list = [\"these\", \"are\", \"words\", \"in\", \"a\", \"list\"]`, and `word_list[1]` is `\"are\"`, `word_list[0:2]` is `[\"these\", \"are\", \"words\"]`, etc\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The word list contains 6 elements\n"
     ]
    }
   ],
   "source": [
    "word_list = [\"these\", \"are\", \"words\", \"in\", \"a\", \"list\"]\n",
    "print(f\"The word list contains {len(word_list)} elements\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-ec1c4e164e31>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-4-ec1c4e164e31>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    new_list = word_list[]\u001b[0m\n\u001b[1;37m                         ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# use a slice to create a new list that contains the first half of the list (from zero to halfway). \n",
    "# you should use integer division: // (this list has 6 elements, but you don't want to write something where you're asking for teh 8.5th element in the list)\n",
    "new_list = word_list[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List notes\n",
    "- If you have experience coding in a non-python environment, the list works much more like a dynamic array or vector than a linked-list. \n",
    "- For... reasons, you can store elements of multiple types in lists. You may occasionally use this as a way to bundle together information, e.g., \\[\"string\", word_count] but it's not a common use-case"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loops\n",
    "\n",
    "Part of the value of lists is that we can use them as structures to organize repetition, which we accomplish with **loops**. A loop is a way to say \"do x over and over until y\". In python, the simplest loops are loops over structures like lists or strings, where we can write a loop that does something to each of the elements in turn. \n",
    "\n",
    "For example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "these\n",
      "are\n",
      "words\n",
      "in\n",
      "a\n",
      "list\n"
     ]
    }
   ],
   "source": [
    "for word in word_list:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, let's take that apart a bit. \n",
    "\n",
    "First, the syntax: we write for \\<thing> in \\<structure> followed by a colon, and then indent the contents of the loop underneath (like an if-statement). \n",
    "\n",
    "Second, the /<thing>: this is actually a way to assign a variable, so we can call /<word> anything we want. Python doesn't give us words because it sees what we've asked for; instead it just gives us whatever the constituent unit of the thing we're looping over is. For a list, that's each element in the list, like this monstrosity here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "nums = [1, 2, 3, 4, 5]\n",
    "for word in nums:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incidentally, what do you think will happen if we do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n",
      "h\n",
      "i\n",
      "s\n",
      " \n",
      "i\n",
      "s\n",
      " \n",
      "a\n",
      " \n",
      "s\n",
      "h\n",
      "o\n",
      "r\n",
      "t\n",
      "-\n",
      "i\n",
      "s\n",
      "h\n",
      " \n",
      "s\n",
      "t\n",
      "r\n",
      "i\n",
      "n\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "ex_string = \"This is a short-ish string\"\n",
    "for elem in ex_string:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Was that what you expected? Maybe, maybe not. Incidentally, you might be offended that if we store, say, a line of poetry in a list, it's really ugly when we print it: `['The', 'book', 'of', 'my', 'enemy', 'has', 'been', 'remaindered']` ([Excellent poem, by the way](https://web.cs.dal.ca/~johnston/poetry/bookofmyenemy.html])) We can fix this by using our new list strucutre to turn the list into a string. We'll start with an empty string, and then for each word in our list, we'll add it to the string (remember how we learned last time that when we \"change\" a string, we actually make a new string, though!)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = ['The', 'book', 'of', 'my', 'enemy', 'has', 'been', 'remaindered']\n",
    "\n",
    "result = \"\"\n",
    "for word in ls:\n",
    "    result = result + word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try adding a line to print the result---does it match your dreams of beautifully formatted poetry (in monospace type)? Yeah, mine neither. Not all of our code in the loop has to refer to anything to do with the loop, though. So, each time we run through the loop to add another word to `result`, we can also add other thigns to tidy it up, too. Try changing the loop to clean up the output. You can either add another line to add extra chracters to result, or you can take advantage of the way that string get added together and do it all with just one line: `result = result + word + [other stuff]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's fine and good, but unless you get quite creative (we'll get creative later in this quarter) it's hard to get all the spacing right (you usually end up with extra spaces at the begining or the end of the string). \n",
    "\n",
    "Instead, we can make python do most of our work for us, using two string-related functions that give us ways to convert from strings to lists and back. Both of these functions are what are called \"methods\", which as far as we're concerned just means that they look a bit different when we use them. instead of writing `function(object)` like we do with `len()` or `print()`, with methods, we write `object.method()` In general, methods are more specific to the kind of thing they're acting on: you can take the length of lots of things, but turning a string to lowercase is a method in part because you can really only do that to strings. Let's start with our two string<->list methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'book', 'of', 'my', 'enemy', 'has', 'been', 'remaindered']\n",
      "And I am glad\n",
      "Thebookofmyenemyhasbeenremaindered\n",
      "['And', 'I', 'am', 'glad']\n"
     ]
    }
   ],
   "source": [
    "ls = ['The', 'book', 'of', 'my', 'enemy', 'has', 'been', 'remaindered'] # by the way, list is python's word for list class of entity, so it's better not to call your list \"list\" (same with \"str\")\n",
    "s = \"And I am glad\"\n",
    "print(ls)\n",
    "print(s)\n",
    "\n",
    "str_from_ls = ''.join(ls)\n",
    "ls_from_str = s.split()\n",
    "print(str_from_ls)\n",
    "print(ls_from_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, so several things here. First of all, `string.split()` probably worked the way we watned. It breaks the string on all occurences of whitespace (including `\\n`, by the way) and add each element to a list. If you want, you can pass a string inside the parentheses, so that the string gets broken on, say `'.!?'`, like in the example below.\n",
    "\n",
    "Now, `str.join()`. This one... makes less sense. Sorry about that. `join` is just kind of awkward. Would it make more sense to be `<thing we join>.join('separator')`? Yes and no. Yes because that's how a normal person would expect it to work; no because the thing we want to join is probably not a string, and this is a string method. You win some, you lose some. Now, in terms of actually fixing our new string, the empty string I passed in as a separator is probably not what we wanted. If we change it to `' '` or something else useful, we should have proper results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The book of my enemy has been remaindered\n",
      "And I am pleased.\n",
      "In vast quantities it has been remaindered\n",
      "Like a van-load of counterfeit that has been seized\n",
      "And sits in piles in a police warehouse,\n",
      "My enemy's much-prized effort sits in piles\n",
      "In the kind of bookshop where remaindering occurs.\n",
      "Great, square stacks of rejected books and, between them, aisles\n",
      "One passes down reflecting on life's vanities,\n",
      "Pausing to remember all those thoughtful reviews\n",
      "Lavished to no avail upon one's enemy's book --\n",
      "For behold, here is that book\n",
      "Among these ranks and banks of duds,\n",
      "These ponderous and seeminly irreducible cairns\n",
      "Of complete stiffs.\n",
      "['The book of my enemy has been remaindered', 'And I am pleased.', 'In vast quantities it has been remaindered', 'Like a van-load of counterfeit that has been seized', 'And sits in piles in a police warehouse,', \"My enemy's much-prized effort sits in piles\", 'In the kind of bookshop where remaindering occurs.', 'Great, square stacks of rejected books and, between them, aisles', \"One passes down reflecting on life's vanities,\", 'Pausing to remember all those thoughtful reviews', \"Lavished to no avail upon one's enemy's book --\", 'For behold, here is that book', 'Among these ranks and banks of duds,', 'These ponderous and seeminly irreducible cairns', 'Of complete stiffs.']\n"
     ]
    }
   ],
   "source": [
    "long_str = (\"The book of my enemy has been remaindered\\n\"\\\n",
    "            \"And I am pleased.\\n\"\\\n",
    "            \"In vast quantities it has been remaindered\\n\"\\\n",
    "            \"Like a van-load of counterfeit that has been seized\\n\"\\\n",
    "            \"And sits in piles in a police warehouse,\\n\"\\\n",
    "            \"My enemy's much-prized effort sits in piles\\n\"\\\n",
    "            \"In the kind of bookshop where remaindering occurs.\\n\"\\\n",
    "            \"Great, square stacks of rejected books and, between them, aisles\\n\"\\\n",
    "            \"One passes down reflecting on life's vanities,\\n\"\\\n",
    "            \"Pausing to remember all those thoughtful reviews\\n\"\\\n",
    "            \"Lavished to no avail upon one's enemy's book --\\n\"\\\n",
    "            \"For behold, here is that book\\n\"\\\n",
    "            \"Among these ranks and banks of duds,\\n\"\\\n",
    "            \"These ponderous and seeminly irreducible cairns\\n\"\\\n",
    "            \"Of complete stiffs.\")\n",
    "print(long_str)\n",
    "long_ls = long_str.split('\\n')\n",
    "print(long_ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(In general you should avoid directly writing long strings into your code, but if you have to, take note: if you open parentheses and put a backslash at the end of the line, python treats the next line as a part of the first line—and recall that `'str' 'ing'` is `'string'` to python)\n",
    "\n",
    "## Other string methods\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "string = \"\"\n",
    "\n",
    "string.upper() # returns an ALL-CAPS version of the string\n",
    "string.lower() # more useful than the former; check out str.casefold.() if working with non-English Unicode\n",
    "\n",
    "string.isupper() # these rteturn true if all chars in the string to be upper lower - most useful for checking single chars\n",
    "string.islower()\n",
    "\n",
    "string.isalpha() # these methods return true if all of the characters in the string are alphabetic, alphanumberic, etc. All work logically with Unicode\n",
    "string.isalnum()\n",
    "string.isdigit()\n",
    "string.isdecimal() # \"anything that can be used to form numbers in base 10\", according to the documentation\n",
    "string.isspace() # checks for all whitespace, not just ' '; string must not be length 0\n",
    "\n",
    "string = 'Great, square stacks of rejected books'\n",
    "result = ''\n",
    "for char in string:\n",
    "    pass # write code here to check if the letter is uppercase. if it is, add the lowercase version to result; otherwise, add something else (whatever you like)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}