mynotes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 6: Strings and Text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learn Python the Hard Way, 3rd Edition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__What is the difference between %r and %s?__\n",
    "\n",
    "Use the `%r` for debugging, since it displays the \"raw\" data of the variable, but the others are used for displaying purposes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Why do you put ' (single-quotes) around some strings and not others?__\n",
    "\n",
    "Mostly it's a matter of style, but the author uses a single-quote inside a string that has double-quotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 7: More Printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Can I use single-quotes or double-quotes to make a string or do they do different things?__\n",
    "\n",
    "In Python eigher way to make a string is acceptable although typically we'll use singl-quotes for any short strings like 'a' or 'snow'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__What effect does a comma have in a print statement?__\n",
    "\n",
    "It prints a space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 8: Printing, Printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Should I use %s or %r for formatting?__\n",
    "\n",
    "You should use `%s` and only use `%r` for getting debugging information about something. The `%r` will give you the \"raw programmer's\" version of variable, also known as the \"representation.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Why do I have to put quotes around \"one\" but not around True or False?__\n",
    "\n",
    "Python recognizes `True` and `False` as _keywords_ representing the concept of true and false. If you put quotes around them then they are turned into strings and won't work. You'll learn more about how these work in Exercise 27."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Why does %r sometimes print things with single-quotes when I wrote them with double-quotes?__\n",
    "\n",
    "Python is going to print the strings in the most efficient way it can, not replicate exactly the way you wrote them. This is perfectly fine since `%r` is used for debugging and inspection, so it's not necessary that it be pretty."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excercise 9: Printing, Printing, Printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Why do the `\\n` newlines not work when I use `%r`?__\n",
    "\n",
    "That's how `%r` formatting works; it prints it the way you wrote it (or close to it). It's the \"__raw__\" format for _debugging_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Why do I get an error when I put spaces between the three double-quotes?__\n",
    "\n",
    "You have to type them like `\"\"\"` and not `\" \" \"`, meaning with _no_ spaces between each one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 10: What Was That?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two ways to make a string that goes across multiple lines:\n",
    "\n",
    "1. Using the characters `\\n` (backslash n).\n",
    "2. Using triple-quotes, which is just `\"\"\"`.\n",
    "\n",
    "This `\\` (backslash) character encodes difficult-to-type characters into a string. There are various \"escape sequences\" available for different characters you might want to use.\n",
    "\n",
    "The triple-quotes work like a string, but you also can put as many lines of text as you want until you type `\"\"\"` again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__When I use a `%r` format none of the escape sequences work.__\n",
    "\n",
    "That's because `%r` is printing out the __raw__ representation of what you typed, which is going to include the _original escape sequences_. Use `%s` instead. Always remember this: \n",
    "\n",
    "* `%r` is for _debugging_\n",
    "* `%s` is for _displaying_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__What's better, `'''` or `\"\"\"`?__\n",
    "\n",
    "It's entirely based on style. Go with the `'''` (triple-single-quote) style for now but be ready to use either depending on what feels best or what everyone else is doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 11: Asking Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The author puts a `,` (comma) at the end of each print line. This is so print doesn't end the line with a newline character and go to the next line. In Python 3, the `print` statement has been changed into a _function_ so we can instead do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "."
     ]
    }
   ],
   "source": [
    "print(\".\", end = \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__See how the single-quote needs to be escaped because otherwise it would end the string?__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__How do I get a number from someone so I can do math?__\n",
    "\n",
    "That's a little advanced, but try"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "89\n"
     ]
    }
   ],
   "source": [
    "x = int(input())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "89\n"
     ]
    }
   ],
   "source": [
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above gets the number as a _string_ from `input()` then converts it to an _integer_ using `int()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__What's the difference between `input()` and `raw_input()` in Python 2?__\n",
    "\n",
    "The `input()` function will try to convert things you enter as if they were Python code, but it has security proglems as we should avoid it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__When my strings print out there's a `u` in front of them, as in `u'35'`.__\n",
    "\n",
    "That's how Python tells you that the string is Unicode. Use a `%s` format instead and you'll see it printed like normal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 12: Prompting People"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Study Drills"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. In Terminal where you normally run `python` to run your scripts, type `pydoc3 input`.\n",
    "2. Get out of `pydoc3` by typing `q` to quit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Why would I use `%r` over `%s`?__\n",
    "\n",
    "Remember `%r` is for debugging and is \"raw representation\" while `%s` is for display."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 13: Parameters, Unpacking, Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In this exercise we will cover one more input method we can use to pass variables to a script (i.e. `.py` files) that usually forms an \"argument\" in command line.\n",
    "\n",
    "We use `import` to add features to our scripts from the Python feature set. Rather than give us all the features at once, Python asks what we plan to use. This keeps our programs small, but it also acts as documentation for other programmers who read our code later.\n",
    "\n",
    "The `argv` is the \"argument variable\", a very standard name in programming.\n",
    "\n",
    "`script, first, second, third = argv` \"unpacks\" `argv` so that, rather than holding all the arguments, it gets assigned to the four variables we can work with: `script`, `first`, `second` and `third`. It says \"Take whatever is in `argv`, _unpack_ it, and assign it to all of these variables on the left in order.\" Note: **multiple assignments** can be achieved via unpacking in an extremely concise way. \n",
    "\n",
    "#### Hold Up! Features Have Another Name\n",
    "We `import` \"features\" $\\Longleftrightarrow$ _modules_ $\\Longleftrightarrow$ \"libraries\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that _modules_ give us _features_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What's the difference between `argv` and `input()`?__\n",
    "\n",
    "The difference has to do with where/when the user is required to give input. If they give our script inputs on the command line, then we use `argv`. If we want them to input using the keyboard while the script is _running_, then use `input()`.\n",
    "\n",
    "__Are the command line arguments strings?__\n",
    "\n",
    "Yes, they come in as **_strings_**, even if you typed numbers on the command line. Use `int()` to convert them just like with `int(input())`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercise 14: Prompting and Passing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Study Drills"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure we understand how the author combined `\"\"\"` style multi-line string with the `%` format activator as the last input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 15: Reading Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we want to do is \"open\" that file in our script and print it out. However, we do not want to just \"hard code\" the name `ex15_sample.txt` into our script. \"Hard coding\" means putting some bit of information that should come from the user as a string directly in our source code. That's bad because we want it to load other files later. The solution is to use `argv` or `raw_input` to ask the user what file to open instead of \"hard coding\" the file's name.\n",
    "\n",
    "We call a function on `txt` named `read`. What you get back from `open` is a `file`, and it also has commands you can give to it. You give a file a command by using the `.` (dot or period), the name of the command, and parameters. Just like with `open` and `raw_input`. The difference is that `txt.read()` says, \"Hey `txt`! Do your read command with no parameters!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "__Does `txt = open(filename)` return the contents of the file?__\n",
    "\n",
    "No, it doesn't. It actually makes something called a \"file object.\"\n",
    "\n",
    "__Why is there no error when we open the same file twice?__\n",
    "\n",
    "Python will not restrict us from opening a file more than once and sometimes it is necessary.\n",
    "\n",
    "__What does `from sys import argv` mean?\n",
    "\n",
    "For now just understand that `sys` is a package, and this phrase says to get the `argv` feature from that package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 16: Reading and Writing Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "1. There's too much repetition in this file. Use strings, formats, and escapes to print out `line1`, `line2`, and `line3` with just one `target.write()` command instead of six. See `ex16_3.py` for the code.\n",
    "\n",
    "2. Find out why we had to pass a '`w`' as an extra parameter to open. Hint: open tries to be safe by making you explicitly say you want to write a file.\n",
    "\n",
    "3. If you open the file with '`w`' mode, then do you really need the `target.truncate()`? Read the documentation for Python's `open` function and see if that's true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What does '`w`' mean?__\n",
    "\n",
    "* `w`: write\n",
    "* `r`: read\n",
    "* `a`: append\n",
    "\n",
    "__What modifiers to the file modes can I use?__\n",
    "\n",
    "The most important one to know for now is the `+` modifier, so you can do '`w+`', '`r+`', and '`a+`'. This will open the file in both read and write mode, and depending on the character use position the file in different ways."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercise 17: More Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's do a few more things with files. We'll write a Python script to copy one file to another. It'll be very short but will give us ideas about other things we can do with files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "1. See how short we can make the script. The author could make it one line long.\n",
    "\n",
    "2. Notice at the end of the _What You Should See_ the author used something called `cat`? It's an old command that \"con**cat**enates\" files together, but mostly it's just an easy way to print a file to the screen. Type `man cat` to read about it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__No way you can make this one line!__\n",
    "\n",
    "That;depend;on;how;you;define;one;line;of;code.\n",
    "\n",
    "__What does the `len()` function do?__\n",
    "\n",
    "It gets the length of the string that you pass to it then returns that as a number. Play with it.\n",
    "\n",
    "__When I try to make this script shorter I get an error when I close the files at the end.__\n",
    "\n",
    "You probably did something like this, `indata = open(from_file).read()`, which means you don't need to then do `in_file.close()` when you reach the end of the script. It should already be closed by Python once that one line runs.\n",
    "\n",
    "__I get a `Syntax:EOL while scanning string literal` error.__\n",
    "\n",
    "ou forgot to end a string properly with a quote. Go look at that line again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 18: Names, Variables, Code and Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are \"mini-scripts\" or \"tiny commands.\"\n",
    "\n",
    "Let's break down the first function, `print_two`, which is the most similar to what you already know from making scripts:\n",
    "\n",
    "1. First we tell Python we want to make a function using `def` for \"define\".\n",
    "\n",
    "2. On the same line as `def` we give the function a name. In this case we just called it \"print_two\" but it could also be \"peanuts\". It doesn't matter, except that your function should have a short name that says what it does.\n",
    "\n",
    "3. Then we tell it we want `*args` (asterisk args) which is a lot like your `argv` parameter but for functions. This _has_ to go inside `()` parentheses to work.\n",
    "\n",
    "4. Then we end this line with a `:` colon, and start _indenting_.\n",
    "\n",
    "5. After the colon all the lines that are indented four spaces will become attached to this name, _print_two_. Our first indented line is one that unpacks the arguments the same as with your scripts.\n",
    "\n",
    "6. To demonstrate how it works we print these arguments out, just like we would in a script.\n",
    "\n",
    "Right away you can see how a function works. Notice that you used your functions the way you use things like `exists`, `open`, and other \"commands.\" In fact, The author has been tricking us because in Python those \"commands\" are just functions. This means we can make our own commands and use them in your scripts too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Study Drills\n",
    "reate a _function checklist_ for later exercises. Write these checks on an index card and keep it by you while you complete the rest of these exercises or until you feel you do not need the index card anymore:\n",
    "\n",
    "1. Did you start your function definition with `def`?\n",
    "\n",
    "2. Does the function name have only characters and `_` (underscore) characters?\n",
    "\n",
    "3. Did I put an open parenthesis `(` right after the function name?\n",
    "\n",
    "4. Did I put our arguments after the parenthesis `(` separated by commas?\n",
    "\n",
    "5. Did I make each argument unique (meaning no duplicated names)?\n",
    "\n",
    "6. Did I put a close parenthesis and a colon `):` after the arguments?\n",
    "\n",
    "7. Did I **indent** all lines of code you want in the function four spaces? No more, no less.\n",
    "\n",
    "8. Did I \"end\" our function by going back to writing with no indent (`dedenting` we call it)?\n",
    "\n",
    "When I run (\"use\" or \"call\") a function, check these things:\n",
    "\n",
    "1. Did I call/use/run this function by typing its name?\n",
    "\n",
    "2. Did I put the `(` character after the name to run it?\n",
    "\n",
    "3. Did I put the values we want into the parenthesis separated by commas?\n",
    "\n",
    "4. Did I end the function call with a `)` character?\n",
    "\n",
    "Use these checklist on the remaining lessons until I do not need them anymore.\n",
    "\n",
    "Finally, repeat this a few times:\n",
    "\n",
    "\"To 'run', 'call' or 'use' a function all mean the same thing.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What's allowed in a function name?__\n",
    "\n",
    "The same as variable names. Anything that does not start with a number, and is letters, numbers or underscores will work.\n",
    "\n",
    "\n",
    "__What does the `*` in `*args` do?__\n",
    "\n",
    "This tells Python to take _all_ the arguments to the function and then put them in `args` as a **list**. It's like `argv` that we've been using, but for functions. It's not normally used unless specifically needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 19: Functions and Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows all the different ways we're able to give our function `cheese_and_crackers` the values it needs to print them: \n",
    "\n",
    "* straight numbers\n",
    "* variables\n",
    "* math\n",
    "* combine math and variables.\n",
    "\n",
    "In a way, the arguments of a function are kinda like our `=` operator when we make a variable. In fact, if we can use `=` to name something, we can usually pass it to a function as an argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What if I want to ask the user for the number of cheese and crackers?__\n",
    "\n",
    "We need to use `int()` to _convert_ what we get from `input()`.\n",
    "\n",
    "__Does making the variable `amount_of_cheese` change the variable cheese_count in the function?__\n",
    "\n",
    "No, those variables are separate and _live outside_ the function. They are then passed to the function and _temporary versions_ are made just for the function's run. When the function exits these temporary variables _go away_ and everything keeps working. Keep going in the book and this should become clearer.\n",
    "\n",
    "__Is it bad to have global variables (like `amount_of_cheese`) with the same name as function variables?__\n",
    "\n",
    "Yes, since then we're not quite sure which one we're talking about. But sometimes necessity means you have to use the same name, or you might do it on accident. Just avoid it whenever you can.\n",
    "\n",
    "__Is there a limit to the number of arguments a function can have?__\n",
    "\n",
    "It depends on the version of Python and the computer you're on, but it is fairly large. The practical limit though is about **five** arguments before the function becomes annoying to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 20: Functions and Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Remember our checklist for functions, then do this exercise paying close attention to how functions and files can work together to make useful stuff."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "1. Research the _shorthand_ notation `+=` and rewrite the script to use `+=` instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__Explain the purpose of `f.seek(0)`?__\n",
    "\n",
    "A file in Python is kinda like an old tape drive on a mainframe, or maybe a DVD player. It has a \"read head\", and we can \"seek\" this read head around the file to positions, then work with it there. Each time we do `f.seek(0)` we're moving to the start of the file. Each time we do `f.readline()` we're reading a line from the file and moving the read head to right after the `\\n` that ends that line.\n",
    "\n",
    "__Why does `seek(0)` not set the `current_line` to 0?__\n",
    "\n",
    "First, the `seek()` function is dealing with _bytes_, not lines. The code `seek(0)` moves the file to the 0 byte (first byte) in the file. Second, `current_line` is just a variable and it has no real connection to the file at all. We are manually incrementing it.\n",
    "\n",
    "__What is `+=` ?__\n",
    "\n",
    "In English we can rewrite \"it is\" as \"it's\" and \"you are\" as \"you're\". This is called _contraction_: here it is a contraction of two operations `=` and `+`. This means `x = x + y` is the same as `x += y`.\n",
    "\n",
    "__How does `readline()` know where each line is?__\n",
    "\n",
    "Inside `readline()` there is code that _scans each byte_ of the file until it finds a `\\n` character, then it stops reading the file to return what it found so far. The file `f` is responsible for maintaining the current position in the file afer each `readline()` call, so that it will keep reading each line.\n",
    "\n",
    "__Why are there emptyt lines between the lines in the file?__\n",
    "\n",
    "The `readline()` function returns the `\\n` that's in the file at the end of that line. Add a `,` at the end of our `pirint()` function calls to avoid adding double `\\n` to evey line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 21: Functions Can Return Something"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have been using the `=` character to name variables and set them to numbers or strings. We're now going to showi how to use `=` and a new Python word `return` to set variables to be a value from a _function_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "1. We can return anything that we can put to the right hand side of an `=`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Qustions.\n",
    "\n",
    "__Why does Python print the formula or the functions \"backward\"?__\n",
    "\n",
    "It's not really backward but \"inside out.\" When we start breaking down the function into separate formulae and function calls we'll see how it works. Try to understand what the author meant by \"inside out\" rather than \"backward.\"\n",
    "\n",
    "__How can I use `input()` to enter my own values?__\n",
    "\n",
    "Remember `int(input())`? The problem with that is then we cannot enter floating point, so also try using `float(input())` instead.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 22: What Do We Know So Far?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What We Are Learning\n",
    "\n",
    "It's important when you are doing a boring, mindless memorization exercise like this to know why. It helps you focus on a goal and know the purpose of all your efforts.\n",
    "\n",
    "In this exercise you are learning the names of symbols so that you can read source code more easily. It's similar to learning the alphabet and basic words of English, except this Python alphabet has extra symbols you might not know.\n",
    "\n",
    "Just take it slow and do not hurt your brain. It's best to take 15 minutes at a time with your list and then take a break. Giving your brain a rest will help you learn faster with less frustration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 23: Read Some Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thrown into the deep end. When you do this exercise, think of yourself as an anthropologist, trucking through a new land with just barely enough of the local language to get around and survive. Except, of course, that you will actually get out alive because the internet isn't a jungle.\n",
    "\n",
    "That's it. Your job is to use what you know so far and see if you can read the code and get a grasp of what it does. Try skimming the code first, and then read it in detail. Try taking very difficult parts and read each symbol you know out loud."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 24: More Practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are getting to the end of this section. We should have enough Python \"under our fingers\" to move on to learning about how programming really works, but we should do some more practice. This exercise is longer and all about building up **stamina**. The next exercise will be similar. Do them, get them exactly right, and do our checks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__Why do you call the variable `jelly_beans` but the name `beans` later?__\n",
    "\n",
    "That's part of how a function works. Remember that inside the function the variable is temporary. When you return it then it can be assigned to a variable for later. I'm just making a new variable named `beans` to hold the return value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 25: Even More Practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What We Should See"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['All', 'good', 'things', 'come', 'to', 'those', 'who', 'wait.']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import ex25\n",
    "sentence = \"All good things come to those who wait.\"\n",
    "words = ex25.break_words(sentence)\n",
    "words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_words = ex25.sort_words(words)\n",
    "sorted_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All\n"
     ]
    }
   ],
   "source": [
    "ex25.print_first_word(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wait.\n"
     ]
    }
   ],
   "source": [
    "ex25.print_last_word(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['good', 'things', 'come', 'to', 'those', 'who']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All\n"
     ]
    }
   ],
   "source": [
    "ex25.print_first_word(sorted_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "who\n"
     ]
    }
   ],
   "source": [
    "ex25.print_last_word(sorted_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['come', 'good', 'things', 'those', 'to', 'wait.']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sorted_words = ex25.sort_sentence(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All\n",
      "wait.\n"
     ]
    }
   ],
   "source": [
    "ex25.print_first_and_last(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All\n",
      "who\n"
     ]
    }
   ],
   "source": [
    "ex25.print_first_and_last_sorted(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module ex25:\n",
      "\n",
      "NAME\n",
      "    ex25\n",
      "\n",
      "FUNCTIONS\n",
      "    break_words(stuff)\n",
      "        This function will break up words for us.\n",
      "    \n",
      "    print_first_and_last(sentence)\n",
      "        Prints the first and last words of the sentence.\n",
      "    \n",
      "    print_first_and_last_sorted(sentence)\n",
      "        Sorts the words then prints the first and last one.\n",
      "    \n",
      "    print_first_word(words)\n",
      "        Prints the first word after popping it off.\n",
      "    \n",
      "    print_last_word(words)\n",
      "        Prints the last word after popping it off.\n",
      "    \n",
      "    sort_sentence(sentence)\n",
      "        Takes in a full sentence and returns the sorted words.\n",
      "    \n",
      "    sort_words(words)\n",
      "        Sorts the words.\n",
      "\n",
      "FILE\n",
      "    /home/jerry/Dropbox/Self-study/python/lpthw/ex25.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(ex25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function break_words in module ex25:\n",
      "\n",
      "break_words(stuff)\n",
      "    This function will break up words for us.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(ex25.break_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "1. Try doing this: `help(ex25)` and also `help(ex25.break_words)`. Notice how you get help for your module, and how the help is those odd \"\"\" strings you put after each function in ex25? Those special strings are called _documentation comments_ and we'll be seeing more of them.\n",
    "\n",
    "2. Typing `ex25.` is annoying. A shortcut is to do your import like this: `from ex25 import *` which is like saying, \"Import everything from `ex25`.\" Programmers like saying things backward. Start a new session and see how all your functions are right there.\n",
    "\n",
    "3. Try breaking your file and see what it looks like in python when you use it. You will have to quit `python` with `quit()` to be able to **reload** it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['All', 'good', 'things', 'come', 'to', 'those', 'who', 'wait.']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ex25 import *\n",
    "sentence = \"All good things come to those who wait.\"\n",
    "words = break_words(sentence)\n",
    "words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__I get `None` printed out for some of the functions.__\n",
    "\n",
    "You probably have a function that is missing the `return` at the end. Go backward through the file and confirm that every line is right.\n",
    "\n",
    "__I get `ImportError: No module named ex25.py` when I type import `ex25.py`.__\n",
    "\n",
    "Don't add the `.py` to the end. Python knows the file ends in `.py` so you just type `import ex25`.\n",
    "\n",
    "__I get `SyntaxError: invalid syntax` when I run this.__\n",
    "\n",
    "That means you have something like a missing ( or \" or similar syntax error on that line or above it. Any time you get that error, start at the line it mentions and check that it's right, then _go backward_ checking each line above that.\n",
    "\n",
    "__How can the words.pop function change the words variable?__\n",
    "\n",
    "That's a complicated question, but in this case `words` is a _list_, and because of that you can give it commands and it'll **retain** the results of those commands. This is similar to how files and many other things worked when you were working with them.\n",
    "\n",
    "__When should I `print` instead of `return` in a function?__\n",
    "\n",
    "The `return` from a function gives the line of code that called the function a result. You can think of a function as taking input through its arguments, and returning output through `return`. The `print` is _completely unrelated_ to this, and only deals with printing output to the terminal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 26: Congratulations, Take a Test!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These programmers are stupid people who care little for others. A good programmer assumes, like a good scientist, that there's always some probability their code is wrong. Good programmers start from the premise that their software is broken and then work to rule out all possible ways it could be wrong before finally admitting that maybe it really is the other guy's code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 27: Memorising Logic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 28: Boolean Practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The logic combinations you learned from the last exercise are called \"boolean\" logic expressions. Boolean logic is used _everywhere_ in programming. It is a fundamental part of computation and knowing them very well is akin to knowing your scales in music."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1 and 2 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"test\" == \"test\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1 or 2 != 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and 1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False and 0 != 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or 1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"test\" == \"testing\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 != 0 and 2 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"test\" != \"testing\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"test\" == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (True and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (1 == 1and 0 != 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (10 == 1 or 1000 == 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (1 != 10 or 3 == 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (\"testing\" == \"testing\" and \"Zed\" == \"Cool Guy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1 and (not (\"testing\" == 1 or 1 == 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"chunky\" == \"bacon\" and (not (3 == 4 or 3 == 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 == 3 and (not (\"testing\" == \"testing\" or \"Python\" == \"Fun\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"logic gymnastics\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__Why does `\"test\" and \"test\"` return `\"test\"` or `1 and 1` return `1` instead of `True`?__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'test'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"test\" and \"test\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 and 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python and many languages like to return one of the operands to their boolean expressions rather than just `True` or `False`. This means that if you did `False and 1` you get the first operand (`False`) but if you do `True and 1` your get the second (`1`). Play with this a bit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Is there any difference between `!=` and `<>`?__\n",
    "\n",
    "Python has deprecated `<>` in favour of `!=`, so use `!=`. Other than that there is no difference.\n",
    "\n",
    "__Isn't there a shortcut?__\n",
    "\n",
    "Yes. Any `and` expression that has a `False` is immediately `False`, so we can stop there. Any `or` expression that has a `True` is immediately `True`, so we can stop there. But make sure that we can process the whole expression because later it becomes helpful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 29: What If"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "1. Why does the code under `if` need to be _indented_ four spaces? They belong to the same logic block.\n",
    "\n",
    "2. What happens if it is not indented? They become parallel - logic is wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What does `+=` mean?__\n",
    "\n",
    "The code `x += 1` is the same as `x = x + 1` but involves less typing. We can call this the \"increment by\" operator. The same goes for `-=` and many other expressions we'll learn later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 30: Else and If"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Why does the code under the `if` need to be _indented_ four spaces? A _colon_ at the end of a line is how we tell Python we are going to create a new \"block\" of code, and then indenting four spaces tells Python what lines of code are in that block. This is exactly the same thing we did when we made functions.\n",
    "\n",
    "2. What happens if it isn't indented? If it isn't indented, we will most likely create a Python error. Python expects us to indent _something_ after we end a line with a `:` (colon).\n",
    "\n",
    "3. Make sure we _really_ understand the concept of a \"_block_\" of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What happens if multiple `elif` blocks are `True`?__\n",
    "\n",
    "Python starts from the top and runs the first block that is `True`, so it will run only the first one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 31: Making Decisions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A key point here is that we are now putting the `if-statements` _inside_ `if-statements` as code that can run. This is very powerful and can be used to create \"**nested**\" decisions, where one branch leads to another and another."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__Can you replace `elif` with a sequence of `if-else` combinations?__\n",
    "\n",
    "You can in some situations, but it depends on how each `if/else` is written. It also means that Python will check _every_ `if-else` combination, rather than just the first false ones like it would with if-elif-else. Try to make some of these to figure out the differences.\n",
    "\n",
    "__How do I tell if a number is between a range of numbers?__\n",
    "\n",
    "We have two options: Use `0 < x < 10` or `1 <= x < 10`, which is the classic notation, or use `x in range(1, 10)`.\n",
    "\n",
    "__What if I wanted more options in the `if-elif-else` blocks?__\n",
    "\n",
    "Add more `elif` blocks for each possible choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 32: Loops and Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programs also need to do repetitive things very quickly. We are going to use a `for-loop` in this exercise to build and print various lists.\n",
    "\n",
    "Before we can use a `for-loop`, we need a way to _store_ the results of loops somewhere. The best way to do this is with `lists`. `Lists` are exactly what their name suggest: a container of things that are organised in order from first to last. It's not complicated; we just have to learn a new syntax. First, there's how we make `lists`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hairs = ['brown', 'blond', 'red']\n",
    "eyes = ['brown', 'blue', 'green']\n",
    "weights = [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start the `list`with `[` (left bracket) which \"opens\" the `list`. Then we put each item we want in the list separated by commas, similar to function arguments. Lastly, end the `list` with a `]` (right bracket) to indicate it's over. Python then takes this `list` and all its contents and assigns them to a variable.\n",
    "\n",
    "Nested structures are all over the place in programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "1. Could we have avoided that `for-loop` entirely on line 22 and just assigned `range(0,6)` directly to elements? Yes, see `ex32_2.py` for the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__How do you make a 2-dimentional (2D) list?__\n",
    "\n",
    "That's a list in a list like: `[[1, 2, 3], [4, 5, 6]]`.\n",
    "\n",
    "__Aren't lists and arrays the same thing?__\n",
    "\n",
    "Depends on the language and the implementation. In classic terms a list is very different from an array because of hwo they're implemented. In Ruby though, they call these arrays. In Python they call them lists. Just call these lists for now since that's what Python calls them.\n",
    "\n",
    "__Why is a `for-loop` able to use a variable that isn't defined yet?__\n",
    "\n",
    "The variable is defined by a `for-loop` when it starts, initialising it to the current element of the loop iteration, each time through.\n",
    "\n",
    "__Why does `for i in range(1, 3):` only loop two times instead of three times?__\n",
    "\n",
    "The `range()` function only does numbers from the first to the last, _not including_ the last. So it stops at 2, not 3 in the above. This turns out to be the most common way to do this kind of loop.\n",
    "\n",
    "__What does `element.append()` do?__\n",
    "\n",
    "It simply appends to the _end of the list_. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 33: While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now to totally blow your mind with a new loop, the` while-loop`. A `while-loop` will keep executing the code block under it as long as a boolean expression is `True`.\n",
    "\n",
    "Wait, we have been keeping up with the terminology, right? That if we write a line and _end_ it with a `:` (__colon__) then that tells Python to _start a new block of code_? Then we __indent__ and that's the new code. This is all about _structuring_ your programs so that Python knows what you mean. If you do not get that idea then go back and do some more work with `if-statements`, `functions`, and the `for-loop` until you get it.\n",
    "\n",
    "Later on we'll have some exercises that will train your brain to _read these structures_, similar to how we **burned** boolean expressions into your brain.\n",
    "\n",
    "Back to `while-loops`. What they do is simply do a test like an `if-statement`, but instead of running the code block _once_, they jump back to the \"top\" where the `while` is, and repeat. A `while-loop` runs until the expression is `False`.\n",
    "\n",
    "Here's the problem with `while-loops`: Sometimes they do not stop. This is great if our intention is to just keep looping until the end of the universe. Otherwise we almost always want our loops to end eventually.\n",
    "\n",
    "To avoid these problems, there are some rules to follow:\n",
    "\n",
    "1. Make sure that we use `while-loops` sparingly. Usually a `for-loop` is better.\n",
    "2. Review our `while` statements and make sure that the `boolean` test will become `False` at some point.\n",
    "3. When in doubt, print out test variable at the top and bottom of the `while-loop` to see what it's doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What's the difference between a 'for-loop' and a `while-loop`?__\n",
    "\n",
    "A `for-loop` and only iterate (loop) \"over\" _collections_ of things. A `while-loop`, on the other hand, can do any kind of iteration (looping) we want. However, `while-loops` are harder to get right and we normally can get many things done with `for-loops`.\n",
    "\n",
    "__Loops are hard. How do I figure them out?__\n",
    "\n",
    "The main reason people don't understand loops is because they can't follow the \"jumping\" that the code does. When a loop runs, it goes through its block of code, and at the end it jumps back to the top. To visualize this, put print statements all over the loop printing out where in the loop Python is running and what the variables are set to at those points. Write `print` lines before the loop, at the top of the loop, in the middle, and at the bottom. Study the output and try to understand the jumping that's going on.\n",
    "\n",
    "A manifestation of \"simpler is better!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 34: Accessing Elements of Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Lists are pretty useful, but unless you can get at the things in them they aren't all that good. You can already go through the elements of a list in order, but what if you want say, the fifth element? You need to know how to access the elements of a list. Here's how you would access the _first_ element of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "animals = ['bear', 'tiger', 'penguin', 'zebra']\n",
    "bear = animals[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You take a list of animals, and then you get the first (1st) one using `0`?! How does that work? Because of the way math works, Python starts its lists at 0 rather than 1. It seems weird, but there are many advantages to this, even though it is mostly arbitrary.\n",
    "\n",
    "The best way to explain why is by showing you the difference between how you use numbers and how programmers use numbers.\n",
    "\n",
    "Programmers, however, can't think this way because they can pick any element out of a list at any point. To programmers, the list is more like a deck of cards. This need to pull elements out of lists at random means that they need a way to indicate elements consistently by an _address_, or an \"**index**,\" and the best way to do that is to start the indices at 0. Trust me on this: the math is _way_ easier for these kinds of accesses. This kind of number is a \"cardinal\" number and means you can _pick at random_, so there needs to be a 0 element.\n",
    "\n",
    "Remember: ordinal == ordered, 1st; cardinal == cards at random, 0.\n",
    "\n",
    "__cardinal number__\n",
    "\n",
    "A number denoting quantity (one, two, three, etc.), as opposed to an ordinal number (first, second, third, etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "__With what you know of the difference between these types of numbers, can you explain why the year 2010 in \"January 1, 2010,\" really is 2010 and not 2009? (Hint: you can't pick years at random.)__\n",
    "\n",
    "Makes more sense?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 35: Branches and Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "1. The `gold_room` has a weird way of getting you to type a number. What are all the bugs in this way of doing it? Can you make it better than what I've written? Look at how `int()` works for clues. See `ex35_2.py` for one of the solutions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__Why `while True`?__\n",
    "\n",
    "This makes an infinite loop.\n",
    "\n",
    "__What does __exit(0)__ do?__\n",
    "\n",
    "On many operating systems a program can abort with `exit(0)`, and the number passed in will indicate an error or not. If you do `exit(1)` then it will be an error, but `exit(0)` will be a good exit. The reason it's backward from normal boolean logic (with `0==False`) is that you can use different numbers to indicate different error results. You can do `exit(100)` for a different error result than `exit(2)` or `exit(1)`.\n",
    "\n",
    "__Why is raw_input() sometimes written as `input('> ')`?__\n",
    "\n",
    "The parameter to `input()` is a string that it should print as a prompt before getting the user's input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 36: Designing and Debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rule for If-Statements\n",
    "\n",
    "1. Every `if-statement` must have an `else`.\n",
    "2. If this `else` should never run because it doesn't make sense, then you must use a `die` function in the `else` that prints out an error message and dies, just like we did in the last exercise. This will find _many_ errors.\n",
    "3. Never nest `if-statements` more than two deep and always try to do them one deep.\n",
    "4. Treat `if-statements` like _paragraphs_, where each `if-elif-else` grouping is like a set of sentences. Put _blank_ lines _before_ and _after_.\n",
    "5. Your boolean test should be simple. If they are complex, move their calculations to variables earlier in your function and use a good name for the variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rule for Loops\n",
    "\n",
    "1. Use a `while-loop` only to loop _forever_, and that means probably never. This only applies to Python; other languages are different.\n",
    "\n",
    "2. Use a `for-loop` for all other kinds of looping, especially if there is a fixed or limited number of things to loop over."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tips for Debugging\n",
    "\n",
    "1. Do not use a \"debugger.\" A debugger is like doing a full-body scan on a sick person. You do not get any specific useful information, and you find a whole lot of information that doesn't help and is just confusing.\n",
    "\n",
    "2. The best way to debug a program is to use `print()` to print out the values of variables at points in the program to see where they go wrong.\n",
    "\n",
    "3. Make sure parts of your programs work as you work on them. Do not write massive files of code before you try to run them. _Code a little, run a little and fix a little_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tips\n",
    "\n",
    "The best way to work on a piece of software is in small chunks like this:\n",
    "\n",
    "1. On a sheet of paper or an index card, write a _list of tasks_ you need to complete to finish the software. This is your to do list.\n",
    "2. Pick the easiest thing you can do from your list.\n",
    "3. Write out English comments/pseudocode in your source file as a _guide_ for how you would accomplish this task in your code.\n",
    "4. Write some of the code under the English comments.\n",
    "5. Quickly run your script so see if that code worked.\n",
    "6. Keep working in a _cycle_ of writing some code, running it to test it, and fixing it until it works.\n",
    "7. Cross this task off your list, then pick your next easiest task and repeat.\n",
    "\n",
    "This process will help you work on software in a _methodical_ and _consistent_ manner. As you work, update your list by removing tasks you don't really need and adding ones you do."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 37: Symbol Review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's time to review the symbols and Python words you know and to try to pick up a few more for the next few lessons. I have written out all the Python _symbols_ and _keywords_ that are important to know.\n",
    "\n",
    "In this lesson take each keyword and first try to write out what it does from memory. Next, search online for it and see what it really does. This may be difficult because some of these are difficult to search for, but try anyway.\n",
    "\n",
    "If you get one of these wrong from memory, make an index card with the correct definition and try to _\"correct\" your memory_.\n",
    "\n",
    "Finally, use each of these in a small Python program, or as many as you can get done. The goal is to find out what the symbol does, make sure you got it right, correct it if you do not, then use it to _lock it in_.\n",
    "\n",
    "__Print out this exercise as reference.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading Code\n",
    "\n",
    "Take notes of the following:\n",
    "\n",
    "1. Functions and what they do.\n",
    "2. Where each variable is first given a value.\n",
    "3. Any variables with the same names in different parts of the program. These may be trouble later.\n",
    "4. Any if-statements without else clauses. Are they right?\n",
    "5. Any while-loops that might not end.\n",
    "6. Any parts of code that you can't understand for whatever reason.\n",
    "\n",
    "Try to explain it to yourself by writing comments as you go. Explain the functions, how they are used, what variables are involved and anything you can to figure this code out. Write in the margin the value of each variable that you need to \"trace.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What's the difference between `%d` and `%i` formatting?__\n",
    "\n",
    "Shouldn't be any difference, other than people use `%d` more due to historical reasons."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 38: Doing Things to Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you write `mystuff.append('hello')` you are actually setting off a chain of events inside Python to cause something to happen to the mystuff list. Here's how it works:\n",
    "\n",
    "1. Python sees you mentioned `mystuff` and looks up that variable. It might have to look backward to see if you created with `=`, if it is a function argument, or if it's a global variable. Either way it has to find the `mystuff` first.\n",
    "\n",
    "2. Once it finds `mystuff` it reads the `.` (period) operator and starts to look at _variables_ that are a part of `mystuff`. Since mystuff is a list, it knows that mystuff has a bunch of functions.\n",
    "\n",
    "3. It then hits `append` and compares the name to all the names that `mystuff` says it owns. If `append` is in there (it is) then Python grabs _that_ to use.\n",
    "\n",
    "4. Next Python sees the `(` (parenthesis) and realizes, \"Oh hey, this should be a function.\" At this point it _calls_ (runs, executes) the function just like normally, but instead it calls the function with an _extra_ argument.\n",
    "\n",
    "5. That extra argument is ... `mystuff`! I know, weird, right? But that's how Python works so it's best to just remember it and assume that's the result. What happens, at the end of all this, is a function call that looks like: `append(mystuff, 'hello')` instead of what you read which is `mystuff.append('hello')`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What Lists Can Do\n",
    "\n",
    "What's a data structure? If you think about it, a \"data structure\" is just a formal way to _structure_ (organise) some _data_ (facts). It really is that simple, even though some data structures can get insanely complex, all they are is just a way to store facts inside a program so you can access them in different ways. They _structure data_.\n",
    "\n",
    "Lists are one of the most _common_ data structures programmers use. They are simply **ordered** lists of facts we want to _store_ and _access randomly or linearly by an index_. What?! Remember what I said though, just because a programmer said \"list is a list\" doesn't mean that it's any more complex than what a list already is in the real world. Let's look at the deck of cards as an example of a list:\n",
    "\n",
    "1. We have a bunch of cards with values.\n",
    "2. These cards are in a stack, list, or list from the top card to the bottom card.\n",
    "3. We can take cards off the top, the bottom and the middle at random.\n",
    "4. If we want to find a specific card, we have to grab the deck and go through it one at a time.\n",
    "\n",
    "Let's look at what we said:\n",
    "\n",
    "\"**An ordered list**\"\n",
    "\n",
    "Yes, deck of cards is in order with a first and a last.\n",
    "\n",
    "\"**and access randomly**\"\n",
    "\n",
    "Yes, we can grab a card from anywhere in the deck.\n",
    "\n",
    "\"**or linearly**\"\n",
    "\n",
    "Yes, if we want to find a specific card we can start at the beginning and go in order.\n",
    "\n",
    "\"**by an index**\"\n",
    "\n",
    "Almost, since with a deck of cards if we were told to get the card at index 19, we'd have to count until we find that one. In our Python lists the computer can just jump right to any index we give.\n",
    "\n",
    "That is all a list does, and this should give you a way to figure out concepts in programming. _Every_ concept in programming usually has some relationship to the real world. At least the useful ones do. If we can figure out what the _analog_ in the real world is, then we can use that to figure out what the data structure should be able to do."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### When to Use Lists\n",
    "\n",
    "We use a list whenever we have something that matches the list data structure's useful feature:\n",
    "\n",
    "1. If we need to _maintain **order**_. Remember, this is _listed_ order, not _sorted_ order. Lists do not sort for us.\n",
    "2. If we need to _access the contents **randomly**_ by a number. Remember, this is using _**cardinal**_ numbers starting at 0.\n",
    "3. If we need to go through the contents _**linearly**_ (first to last). Remember, that's what `for-loops` are for.\n",
    "\n",
    "That's when we use a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "1. Do not worry If you do not have any idea what I'm talking about. Programmers like to feel smart so they invented object-oriented programming, named it OOP, and then used it way too much. If you think that's hard, you should try to use \"_functional programming_.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__Didn't you say to not use `while-loops`?__\n",
    "\n",
    "Yes, so just remember sometimes we can break the rules if we have a good reason. _Only idiots are slaves to rules all the time._\n",
    "\n",
    "__Why does `join(' ', stuff)` not work?__\n",
    "\n",
    "The way the documentation for `join` is written doesn't make sense. It does not work like that and is instead a method we call on the _inserted_ string to put between the list to be joined. Rewrite it like `' '.join(stuff)`.\n",
    "\n",
    "__Why did you use a `while-loop`?__\n",
    "\n",
    "Try rewriting it with a `for-loop` and see if it's easier.\n",
    "\n",
    "__What does `stuff[3:5]` do?__\n",
    "\n",
    "That extracts a \"slice\" from the `stuff` list that is from element 3 to element 4, meaning it does _not_ include element 5. It's similar to how `range(3, 5)` works.\n",
    "\n",
    "In Python, the two arguments to these functions/methods resemble _left-closed-and-right-open_ intervals.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 39: Dictionaries, Oh Lovely Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now going to learn about the Dictionary data structure in Python. A Dictionary (or \"dict\") is a way to store data just like a `list`, but instead of using only numbers to get the data, we can use almost anything. This lets us treat a `dict` like it's a _database_ for storing and organising data.\n",
    "\n",
    "Let's compare what `dicts` can do to what `lists` can do. A list lets us do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "z\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['a', 'z', 'c', 'd']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "things = ['a', 'b', 'c', 'd']\n",
    "print(things[1])\n",
    "\n",
    "things[1] = 'z'\n",
    "print(things[1])\n",
    "\n",
    "things"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use integers to \"**index**\" into a list, meaning we can use _integers_ to find out what's in lists. Make sure we understand that we can _only_ use _integers_ to get items out of a list.\n",
    "\n",
    "What a `dict` does is letting us use _anything_, not just integers. A `dict` associates one thing to another, no matter what it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zed\n",
      "39\n",
      "74\n",
      "San Francisco\n",
      "Wow\n",
      "Neato\n",
      "{1: 'Wow', 2: 'Neato', 'name': 'Zed', 'age': 39, 'city': 'San Francisco', 'height': 74}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'age': 39, 'height': 74, 'name': 'Zed'}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stuff = {'name': 'Zed', 'age': 39, 'height': 6 * 12 + 2}\n",
    "\n",
    "print(stuff['name'])\n",
    "print(stuff['age'])\n",
    "print(stuff['height'])\n",
    "\n",
    "stuff['city'] = \"San Francisco\"\n",
    "print(stuff['city'])\n",
    "\n",
    "# It doesn't have to be strings though.\n",
    "stuff[1] = \"Wow\"\n",
    "stuff[2] = \"Neato\"\n",
    "\n",
    "print(stuff[1])\n",
    "print(stuff[2])\n",
    "\n",
    "print(stuff)\n",
    "\n",
    "# Here's how to delete things with the del keyword\n",
    "del stuff['city']\n",
    "del stuff[1]\n",
    "del stuff[2]\n",
    "\n",
    "stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Dictionary Example\n",
    "\n",
    "Remember, \"**mapping**\" or \"**associating**\" is the key concept in a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What Dictionaries Can Do\n",
    "\n",
    "Dictionaries are another example of a data structure, and like lists they are one of the _most commonly used_ data structures in programming. A dictionary is used to _map_ or _associate_ things we want to store to the keys that we need to get them. Again, programmers don't use a term like \"dictionary\" for something like that and it doesn't work like an actual dictionary full of words. There are plenty of real world examples.\n",
    "\n",
    " A `dict` in Python is just like a dictionary in the real world like the _Oxford English Dictionary_ (OED). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What is the difference between a list and a dictionary?__\n",
    "\n",
    "A `list` is for an _**ordered**_ list of items. A dictionary (or `dict`) is for _matching/mapping_ some items (called \"keys\") to other items (called \"values\"). Dictionaries do _not_ have order.\n",
    "\n",
    "__What would I use a dictionary for?__\n",
    "\n",
    "When you have to take one value and \"look up\" another value. In fact, we could call dictionaries \"look-up tables\".\n",
    "\n",
    "__What would I use a list for?__\n",
    "\n",
    "Use a list for any _sequence_ of things that need to be _in order_, and we only need to look them up by a _numeric index_.\n",
    "\n",
    "__What if I need a dictionary in order?__\n",
    "\n",
    "Take a look at `collections.OrderedDict` data structure in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 40: Modules, Classes and Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is called an \"object-oriented programming language.\" This means there is a _construct_ in Python called a class that lets us _structure_ our software in a particular way. Using classes, we can add _consistency_ to our programs so that they can be used in a cleaner way. At least that's the theory.\n",
    "\n",
    "This is the beginnings of object-oriented programming, classes and objects using what we already know about dictionaries and modules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules Are Like Dictionaries\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already know how a dictionary is created and used and that it is a way to _map_ one thing to anothers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I AM APPLES!\n"
     ]
    }
   ],
   "source": [
    "mystuff = {'apple': \"I AM APPLES!\"}\n",
    "print(mystuff['apple'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keep this idea of \"getting X from Y\" in our heads, now think about modules. A module is\n",
    "\n",
    "1. A Python file with some functions or variables in it ...\n",
    "2. We import that file.\n",
    "3. And we can _access_ the functions or variables in that module using the `.` _(dot) operator_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I AM AN APPLE!\n",
      "Living reflection of a dream\n"
     ]
    }
   ],
   "source": [
    "import mystuff\n",
    "\n",
    "mystuff.apple()\n",
    "print(mystuff.tangerine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Refer back to the dictionary and we should start to see how this is similar to using a dictionary, but the syntax is different. Let's compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I AM AN APPLE!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Living reflection of a dream'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mystuff['apple'] # get apple() from dict does not work in Python 3\n",
    "mystuff.apple() # get apple from the module\n",
    "mystuff.tangerine # same thing, it's just a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means we have a _very_ common pattern in Python:\n",
    "\n",
    "1. Take a `key = value` style _container_.\n",
    "2. Get something out of it by the key's name.\n",
    "\n",
    "In the case of a dictionary, the key is a string and the syntax is `[key]`. In the case of the module, the key is an identifier and the syntax is `.key`. Other than this they are nearly the same thing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes Are Like Modules\n",
    "\n",
    "We can think of a module as a _specialised dictionary_ that can store Python code so we can access it with the `.` operator. Python also has another construct that serves a similar purpose called a class. A class is a way to take a _grouping_ of functions and data and place them inside a _container_ so they ccan be accessed via the `.` (dot) operator.\n",
    "\n",
    "`MyStuff.py` looks complicated compared to modules, and there is definitely a lot going on by comparison, but we should be able to make out how this is like a \"mini-module\" with `MyStuff` having an `apple()` function in it. What is probably confusing is the `__init__()` function and use of `self.tangerine` for setting the `tangerine` instance variable.\n",
    "\n",
    "Here's why classes are used instead of modules: We can take this `MyStuff` class and use it to craft many of them, millions at a time if we want, and each one won't interfere with each other. When we import a module there is only one for the entire program unless we do some monster hacks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objects Are Like Import\n",
    "\n",
    "If a class is like a \"mini-module,\" then there has to be a similar concept to `import` but for classes. That concept is called \"i**nstantiate**\", which is just a fancy, obnoxious, overly smart way to say \"create.\" When we instantiate a class, what we get is called an object.\n",
    "\n",
    "We instantiate (create) a class by calling the class like it's a function, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I AM CLASSY APPLES!\n",
      "And now a thousand years between\n"
     ]
    }
   ],
   "source": [
    "from mystuff import *\n",
    "\n",
    "thing = MyStuff()\n",
    "thing.apple()\n",
    "print(thing.tangerine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line is the \"**instantiate**\" operation, and it's a lot like calling a function. However, Python coordinates a sequence of events behind the scenes. We'll go through these steps using the above code for `MyStuff`:\n",
    "\n",
    "1. Python looks for `MyStuff()` and sees that it is a class we've defined.\n",
    "2. Python crafts an _empty_ object with _all_ the functions specified in the class using `def`.\n",
    "3. Python then checks if a \"**magic**\" `__init__` function is made. If so, it calls this function to _initialise_ the newly created empty object.\n",
    "4. In the `MyStuff` function `__init__` we then get this _extra_ variable `self` that is the empty object Python just made. So we can set variables on it just like we would with a module, dictionary and other objects. Now the object is initialised.\n",
    "5. Python takes this newly minted object and assign it to the `thing` variable for us to work with.\n",
    "\n",
    "That's the basics of how Python does this \"mini-import\" when you call a class like a function. Remember that this is _not_ giving us the class, but instead is using the class as a _blueprint_ for building a copy of that type of thing.\n",
    "\n",
    "Keep in mind that the author is giving us a slightly inaccurate idea for how these work so that we can start to build up an understanding of classes based on what we already know about modules. The truth is, classes and objects suddenly diverge from modules at this point:\n",
    "\n",
    "* Classes are like _blueprints_ or definitions for creating new mini-modules.\n",
    "* Instantiation is how we make one of these mini-modules _and_ import it at the same time. \"Instantiate\" means creating an object from the class.\n",
    "* The resulting created mini-module is called an _object_ and we can then assign it to a variable to work with.\n",
    "\n",
    "At this point objects behave differently from modules and this should only serve as a way to bridge over to understanding classes and objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting Things from Things\n",
    "\n",
    "We now have TWO ways to get things from things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I AM AN APPLE!\n",
      "Living reflection of a dream\n",
      "I AM CLASSY APPLES!\n",
      "And now a thousand years between\n"
     ]
    }
   ],
   "source": [
    "# dict style not working\n",
    "# mystuff['tangerine']\n",
    "\n",
    "# module style\n",
    "mystuff.apple()\n",
    "print(mystuff.tangerine)\n",
    "\n",
    "# class style\n",
    "thing = MyStuff()\n",
    "thing.apple()\n",
    "print(thing.tangerine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A First Class Example\n",
    "\n",
    "We have seen the similarities among these three `key=value` container types and probably have a bunch of questions. Hang on with the questions, as the next exercise will hammer home our \"object-oriented vocabulary.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__Why do I need `self` when I make `__init__` or other functions for classes?\n",
    "\n",
    "If we don't have `self`, then code like `cheese = 'Frank'` is ambiguous. It isn't clear whether we meant the _instance_'s `cheese` or a local variable with the same name. With `self.cheese = 'Frank'`, it's always clear we meant the _instance attribute_ `self.cheese`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 41: Learning to Speak Object Oriented"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise we are going to learn how to speak \"object oriented.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Word Drills\n",
    "\n",
    "__`class`__ \n",
    "\n",
    "Tell Python to make a _new type_ of thing. \n",
    "\n",
    "__`object`__\n",
    "\n",
    "Two meanings: the most basic type of thing and any instances of something.\n",
    "\n",
    "__`instance`__\n",
    "\n",
    "What we get when we tell Python to create an object.\n",
    "\n",
    "__`def`__\n",
    "\n",
    "How to define a function inside a class.\n",
    "\n",
    "__`self`__\n",
    "\n",
    "Inside the functions of a class, `self` is a _variable_ for the instance/object being accessed.\n",
    "\n",
    "__inheritance__\n",
    "\n",
    "The concept that one class can _inherit traits_ from another class, much like us and our parents.\n",
    "\n",
    "__composition__\n",
    "\n",
    "The concept that a class can be composed of other classes as parts, much like how a car has wheels.\n",
    "\n",
    "__attribute__\n",
    "\n",
    "A property classes have that are from composition and are usually variables.\n",
    "\n",
    "__is-a__\n",
    "\n",
    "A phrase to say that something inherits from another, as in a \"salmon is-a fish\".\n",
    "\n",
    "__has-a__\n",
    "\n",
    "A phrase to say that something is composed of other things or has a trait, as in \"a salmon has-a mouth\".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Phrase Drills\n",
    "\n",
    "__`class X(Y)`__\n",
    "\n",
    "\"Make a class named X that is-a Y.\"\n",
    "\n",
    "__`class X(object): def \\_\\_init\\_\\_(self, J)`__\n",
    "\n",
    "\"Class X has-a \\_\\_init\\_\\_ that takes itself and J as parameters.\"\n",
    "\n",
    "__`class X(object): def M(self, J)`__\n",
    "\n",
    "\"Class X has-a function named M that takes itself and J as parameters.\"\n",
    "\n",
    "__`foo = X()`__\n",
    "\n",
    "\"Set foo to an instance of class X.\"\n",
    "\n",
    "__`foo.M(J)`__\n",
    "\n",
    "\"From foo get the M function, and call it with parameters self and J.\"\n",
    "\n",
    "__`foo.K = Q`__\n",
    "\n",
    "\"From foo get the K attribute and set it to Q.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What does `result = sentence[:]` do?__\n",
    "\n",
    "That's a Python way of _copying a list_. We are using the list slice syntax `[:]` to effectively make a _slice_ from the very _first_ element to the very _last_ one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 42: Is-A, Has-A, Objects and Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important concept that you have to understand is the difference between a class and an object. The problem is, there is no real \"difference\" between a class and an object. They are actually the same thing at different points in time. I will demonstrate by a Zen koan:\n",
    "\n",
    "`What is the difference between a Fish and a Salmon?`\n",
    "\n",
    "Now for the mind-bending idea: Fish is a class, and Salmon is a class, and Mary is an object. Think about that for a second. Let's break it down slowly and see if we get it.\n",
    "\n",
    "A Fish is a class, meaning it's not a _real_ thing, but rather a word we attach to instances of things with similar attributes. Got fins? Got gills? Lives in water? Alright it's probably a Fish.\n",
    "\n",
    "There we have it: Mary is a kind of Salmon that is a kind of Fish."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How This Looks in Code\n",
    "\n",
    "Two catch phrases \"is-a\" and \"has-a\":\n",
    "\n",
    "* We use the phrase is-a when we talk about objects and classes being related to each other by a _class_ relationship.\n",
    "* We use has-a when we talk about objects and classes that are related only because they _reference_ each other.\n",
    "\n",
    "Remember, is-a is the relationship between Fish and Salmon, while has-a is the relationship between Salmon and Gills."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### About `class` Name (`object`)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember how the author was yelling at us to always use `class Name(object)` and he couldn't tell us why? Now he can, because we just learned about the difference between a class and an object. We would have just been confused and couldn't learn to use the technology.\n",
    "\n",
    "What happened is Python's original rendering of class was broken in many serious ways. By the time they admitted the fault it was too late and they had to support it. In order to fix the problem, they needed some \"new class\" style so that the \"old classes\" would keep working but people should use the new and more correct version.\n",
    "\n",
    "This is where \"`class is-a object`\" comes in. They decided that they would use the word \"__`object`__\", **lowercased**, to be the \"_class_\" that we _inherit_ from to make a class. Confusing, right? **A `class` _inherits_ from the class named `object` to make a class.** But `object` is _not_ an object; really it's a **class**. Do _not_ forget to _inherit from `object`_.\n",
    "\n",
    "Exactly. The choice of one single word meant that the author couldn't teach us about this until now. Now we can try to understand the concept of a class that is an object if we like.\n",
    "\n",
    "However, the author would suggest just completely ignore the idea of old style versus new style classes and assume that Python always requires (`object`) when you make a class. Save our brain power for something important."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study Drills\n",
    "\n",
    "1. Research why Python added this strange object class, and what that means.\n",
    "2. Is it possible to use a class like it's an object?\n",
    "3. Fill out the animals, fish, and people in this exercise with functions that make them do things. See what happens when functions are in a \"base class\" like `Animal` versus in say `Dog`.\n",
    "4. Find other people's code and work out all the is-a and has-a relationships.\n",
    "5. Make some new relationships that are lists and dictionaries so you can also have \"has-many\" relationships.\n",
    "6. Do you think there's such thing as an \"is-many\" relationship? Read about \"multiple inheritance,\" then avoid it if you can.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Student Questions\n",
    "\n",
    "__What is the point of `self.pet = None`?__\n",
    "\n",
    "This makes sure that the `self.pet` attribute of that class is set to a default of `None`.\n",
    "\n",
    "__What does `super(Employee, self.\\_\\_init\\_\\_(name)` do?__\n",
    "\n",
    "This is how we can run the `__init__` method of a _parent_ class reliably. Search for \"python super\" and read the various advice on it being evil and good for us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 43: Basic Object-Oriented Analysis and Design"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}