@@ -29,14 +29,16 @@ All of programming is really about manipulating values.
 Literals for the Basic Value types:
 ------------------------------------
 
+A "literal" is something you can put in your code to directly get a value. Python has literals for the key built in types.
+
 Numbers:
   - floating point: ``3.4``
   - integers: ``456``
 
 Text:
   -  ``"a bit of text"``
   -  ``'a bit of text'``
-  - (either single or double quotes work -- why? If you don't know try looking it up in one of the referenced sources!)
+  - (either single or double quotes work -- why? If you don't know, try looking it up in one of the referenced sources!)
 
 Boolean values:
   -  ``True``
@@ -51,15 +53,18 @@ The nothing object:
 Code structure
 --------------
 
-Each line is a piece of code.
+Each line is a unit of code. Each line is made up of these components:
 
-Comments:
+**Comments:**
 
 .. code-block:: ipython
 
     In [3]: # everything after a '#' is a comment
 
-Expressions:
+
+**Expressions:**
+
+An expression is a unit of code that evaluates to a value:
 
 .. code-block:: ipython
 
@@ -69,8 +74,9 @@ Expressions:
     Out[5]: 7
 
 
-Statements:
-statements carry out an action, but do not evaluate to a value, that is you can't assign to them (or put them in a lamda, or...)
+**Statements:**
+
+statements carry out an action, but do not evaluate to a value, that is, you can't assign to them (or put them in a lamda, or...)
 
 .. code-block:: ipython
 
@@ -80,9 +86,10 @@ statements carry out an action, but do not evaluate to a value, that is you can'
 
     In [8]: return something
 
+Statements include function (and class) definitions (``def``), loop constructs (``for``, ``while``), code forking constructs (``if``), exception handling (``try``, ``except``), and a handful of other more advanced constructs.
 
 
-It is somewhat obvious, but handy when playing with code:
+The ``print()`` function does what you'd expect, and is very handy when playing with code:
 
 .. code-block:: ipython
 
@@ -97,7 +104,6 @@ You can print multiple things:
     the value is 5
 
 
-
 Any Python object can be printed (though it might not be pretty...)
 
 .. code-block:: ipython
@@ -109,9 +115,10 @@ Any Python object can be printed (though it might not be pretty...)
     In [2]: print(bar)
     <class '__main__.bar'>
 
+Code Blocks
+...........
 
-
-Blocks of code are delimited by a colon and indentation:
+Separate blocks of code are delimited by a colon and indentation. Everything indented after a colon is "inside" that block. It can be a function definition, or a loop construct, or a handful of other more advanced constructs.
 
 .. code-block:: python
 
@@ -170,9 +177,8 @@ But they are not:
     for i in range(100):
     \tprint i**2
 
-**ALWAYS INDENT WITH 4 SPACES**
-
 
+.. centered:: **ALWAYS INDENT WITH 4 SPACES**
 
 
 Make sure your editor is set to use spaces only --
@@ -195,14 +201,38 @@ An *expression* is made up of values and operators.
 * Integer vs. float arithmetic
 
   * (Python 3 smooths this out).
-  * Always use ``/`` when you want division with float results, ``//`` when you want floored (integer) results (no remainder).
+  * Always use ``/`` when you want division with float results, ``//`` when you want floored (integer) results (no remainder):
+
 
-* Type conversions.
+.. code-block:: ipython
 
-  * This is the source of many errors, especially in handling text.
+    In [1]: 3 / 4
+    Out[1]: 0.75
 
-* Type errors - checked at run time only.
+    In [2]: 3 // 4
+    Out[2]: 0
 
+* Type conversions: You usually need to convert types explicitly:
+
+.. code-block:: ipython
+
+    In [4]: 3 * "4"
+    Out[4]: '444'
+
+    In [5]: 3 * int("4")
+    Out[5]: 12
+
+* Type errors - checked at run time only:
+
+.. code-block:: ipython
+
+    In [10]: '3' * '4'
+    ---------------------------------------------------------------
+    TypeError                     Traceback (most recent call last)
+    <ipython-input-10-1e6fdc328f08> in <module>
+    ----> 1 '3' * '4'
+
+    TypeError: can't multiply sequence by non-int of type 'str'
 
 Symbols
 -------
@@ -213,13 +243,13 @@ Symbols are how we give names to values (objects).
 * Symbols must begin with an underscore or letter.
 * Symbols can contain any number of underscores, letters and numbers.
 
-  * this_is_a_symbol
-  * this_is_2
-  * _AsIsThis
-  * 1butThisIsNot
-  * nor-is-this
+  * ``this_is_a_symbol``
+  * ``this_is_2``
+  * ``_AsIsThis``
+  * ``1butThisIsNot``
+  * ``nor-is-this``
 
-* Symbols don't have a type; values do.
+* Symbols (names) don't have a type; values do.
 
   * This is why Python is "Dynamic".
 
@@ -250,7 +280,7 @@ it is bound.
     In [26]: type(a)
     Out[26]: float
 
-*wait!* ``a`` has a different type?!? -- yes, because it's the type of the value: "3.14", names don't actually have a type, the same name can refer to any type.
+*wait!* ``a`` has a different type?!? -- yes, because it's the type of the value: ``3.1``, names don't actually have a type, the same name can refer to any type.
 
 
 Assignment
@@ -282,6 +312,7 @@ Evaluating the name will return the value to which it is bound
     In [31]: a_float
     Out[31]: 3.14
 
+
 Variables?
 ----------
 
@@ -300,6 +331,7 @@ Variables?
 * A name can be bound to a value -- but that has nothing to do with a
   location in memory.
 
+
 In-Place Assignment
 -------------------
 
@@ -536,7 +568,7 @@ To check if a name is bound to one of these, you use ``is``:
 
     x is None
 
-Note that in contrast to English -- "is" is asking a question, not making an assertion -- ``a is True`` means "is a set to the value True?"
+Note that in contrast to English -- "is" is asking a question, not making an assertion -- ``a is True`` means "is a set to the True object?"
 
 
 Operator Precedence
@@ -554,6 +586,7 @@ To force statements to be evaluated out of order, use parentheses -- expressions
 
 Python follows the "usual" rules of algebra.
 
+
 Python Operator Precedence
 --------------------------
 
 
@@ -30,11 +30,11 @@ Defining a function:
 
 
 Local vs. Global
-----------------
+................
 
 Names bound in Python have a *scope*
 
-That *scope* determines where a symbol is visible, and what value it has in a
+That *scope* determines where a name is visible, and what value it has in a
 given block.
 
 .. code-block:: ipython
@@ -64,6 +64,8 @@ No -- they did not. The "y" and "z" names *inside* the function are completely s
 
 The ones outside the function are "global" names.
 
+When you use a name in Python, it first checks if it's a local name. Then, if that name is not in the local scope, it will look in the global scope for it.
+
 **NOTE:** "global" in Python means global to the module (generally a single file), not global to an entire program. Which is really good, as you have little way of knowing what names are being used in packages you are using, but are not writing yourself!
 
 In general, you should use global names mostly for constants.
@@ -81,7 +83,7 @@ This is just a convention, but it's a good one to follow.
 
 
 Global Gotcha
--------------
+.............
 
 Take a look at this function definition:
 
@@ -128,6 +130,12 @@ the global value already bound. So in the line that caused the error:
 Python knows that x is a local name, as it is assigned on the next line.  But on this line,  x has not yet been given a value -- hence the error.
 
 
+Globals are "read only"
+.......................
+
+While you have access to the global names in side a function, you can't change what those names are bound to. Take a look at the previous examples -- when we set a new value to a name (using the equal sign), that makes the name local -- so it will not change what the global name refers to.
+
+
 Parameters
 ----------
 
@@ -143,6 +151,9 @@ These types of parameters are called *positional*
 When you call a function, you **must** provide arguments for all *positional*
 parameters *in the order they are listed*.
 
+Defaults for parameters:
+........................
+
 You can provide *default values* for parameters in a function definition:
 
 .. code-block:: ipython
@@ -177,6 +188,11 @@ Or, you can use the parameter name as a *keyword* to indicate which you mean:
     In [29]: fun(y=4, x=1)
     1 4 3
 
+
+This allows you to specify only those optional parameters that you need to, and keep using the defaults for the rest.
+This is a very powerful feature of Python -- you'll find it's common to have a pretty long optional parameter list to functions.
+It allows a lot of flexibility (the hard stuff is possible), while in common use, it's easy to use (the easy stuff is easy).
+
 Once you've provided a *keyword* argument in this way, you can no longer
 provide any *positional* arguments:
 
@@ -187,6 +203,7 @@ provide any *positional* arguments:
         fun(x=5, 6)
     SyntaxError: non-keyword arg after keyword arg
 
+
 Recursion
 ---------