a little more explaination for slicing lab.

Author: PythonCHB

source/exercises/slicing.rst

@@ -20,6 +20,8 @@ Write some functions that take a sequence as an argument, and return a copy of t
 * with the elements reversed (just with slicing).
 * with the last third, then first third, then the middle third in the new order.
 
+  - Example:   ``(1,2,3,4,5,6)`` should return: ``(5,6,1,2,3,4)`` (start with a length that's a multiple of three, but make sure it doesn't crash for other lengths)
+
 **NOTE:** These should work with ANY sequence -- but you can use strings to test, if you like.
 
 Your functions should look like:

source/modules/Sequences.rst

@@ -771,39 +771,75 @@ Other Gotchas
 
 Easy container setup, or deadly trap?
 
-(note: you can nest lists to make a 2D-ish array)
+Say you want something like sort of like a 2D array -- one way to do that is to nest lists -- make a list of lists.
+
+ONe seemingobvious way to create an empty list of lists would be to use multiplcation of lists -- make a list with one list in it, and then multiply it by the number of lists you want:
 
 .. code-block:: ipython
 
-    In [13]: bins = [ [] ] * 5
+    In [12]: bins = [ [] ] * 5
 
-    In [14]: bins
-    Out[14]: [[], [], [], [], []]
+    In [13]: bins
+    Out[13]: [[], [], [], [], []]
 
-    In [15]: words = ['one', 'three', 'rough', 'sad', 'goof']
+OK -- that worked -- you have a list with five empty lists in it. So let's try using that. This is a very contrived example, but say you have list of words:
 
-    In [16]: for word in words:
-       ....:     bins[len(word)-1].append(word)
-       ....:
+.. code-block:: ipython
 
-So, what is going to be in ``bins`` now?
+    In [14]: words = ['one', 'three', 'rough', 'sad', 'goof']
+
+and you want to put one in each of the "inside" lists:
+
+.. code-block:: ipython
+
+
+    In [15]: # loop five times
+        ...: for i in range(5):
+        ...:     # add a word to the corresponding bin
+        ...:     bins[i].append(words[i])
+
+So, what is going to be in ``bins`` now? Think for a bit first -- you added one word to each bin, yes? But are those "sublists" independent? 
 
 There is only **One** bin
 -------------------------
 
 .. code-block:: ipython
 
-    In [65]: bins
-    Out[65]:
+    In [16]: bins
+    Out[16]: 
     [['one', 'three', 'rough', 'sad', 'goof'],
      ['one', 'three', 'rough', 'sad', 'goof'],
      ['one', 'three', 'rough', 'sad', 'goof'],
      ['one', 'three', 'rough', 'sad', 'goof'],
      ['one', 'three', 'rough', 'sad', 'goof']]
 
-We multiplied a sequence containing a single *mutable* object.
+Whoa! So we don't have 5 lists -- we have five *references* to the same list. Remember that in Python you can have any number of names "bound" to any object -- and any object can be contained in any number of containers, or multiple times in one container.
 
-We got a list containing five references to a single *mutable* object.
+So when we multiplied a sequence containing a single *mutable* object. We got a list containing five references to a single *mutable* object.
+
+Since it's mutable -- you can change it "in place", and when you change it -- the change shows everywhere that list is referenced.
+
+So how to make a list of independent lists? You need to loop and call that code that makes an empty list each time in the loop, something like this:
+
+.. code-block:: ipython
+
+    In [21]: bins = []
+
+    In [22]: for i in range(5):
+        ...:     bins.append([])
+        ...: 
+
+    In [23]: bins
+    Out[23]: [[], [], [], [], []]
+
+    In [24]: # loop five times
+        ...: for i in range(5):
+        ...:     # add a word to the corresponding bin
+        ...:     bins[i].append(words[i])
+        ...: 
+
+    In [25]: bins
+    Out[25]: [['one'], ['three'], ['rough'], ['sad'], ['goof']]
 
 
 Mutable Default Argument
@@ -858,12 +894,13 @@ This will ensure that a new list will be created if one is not passed-in.
 Mutable Sequence Methods
 ========================
 
-In addition to all the methods supported by sequences we've seen above, mutable sequences (the List), have a number of other methods that are used to change it in place.
+In addition to all the methods supported by sequences we've seen above, mutable sequences (the list), have a number of other methods that are used to change it in place.
 
 You can find all these in the Standard Library Documentation:
 
 https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
 
+
 Assignment
 -----------
 
@@ -913,11 +950,11 @@ You can pass any sequence to ``.extend()``:
     ['beans', 'spam', 'eggs', 'ham', 'sushi', 'bread', 'water',
      's', 'p', 'a', 'g', 'h', 'e', 't', 't', 'i']
 
-So be careful -- a string is a single object --but also a sequence of characters.
+So be careful -- a string is a single object -- but also a sequence of characters (technically a sequence of length-1 strings).
 
 
-Shrinking the List
-------------------
+Shrinking a list
+----------------
 
 ``.pop()``, ``.remove()``
 
@@ -1130,8 +1167,8 @@ Otherwise ... taste and convention.
 Convention
 ----------
 
-Lists are homogeneous collections:
--- they alway contain values of the same type
+Lists are typically homogeneous collections:
+-- they always contain values of the same type
 -- they simplify iterating, sorting, etc
 
 Tuples are mixed types:

source/modules/StaticAndClassMethods.rst

@@ -8,8 +8,7 @@ Static and Class Methods
 You've seen how methods of a class are *bound* to an instance when it is
 created.
 
-And you've seen how the argument ``self`` is then automatically passed to
-the method when it is called.
+And you've seen how the argument ``self`` is then automatically passed to the method when it is called.
 
 And you've seen how you can call *unbound* methods on a class object so
 long as you pass an instance of that class as the first argument.
@@ -36,9 +35,6 @@ A *static method* is a method that doesn't get self:
     Out[37]: 9
 
 
-.. [demo: :download:`static_method.py <../../Examples/Session08/static_method.py>`]
-
-
 Where are static methods useful?
 
 Usually they aren't.  It is often better just to write a module-level function.
@@ -80,9 +76,6 @@ argument
     Out[42]: 16
 
 
-.. [demo: :download:`class_method.py <../../Examples/Session08/class_method.py>`]
-
-
 Why?
 ----
 
@@ -102,6 +95,9 @@ Consider this:
     in a class method:  <class '__main__.SubClassy'>
     Out[45]: 64
 
+``a_class_method`` is defined in the ``Classy`` class (see above).
+And it prints the class that it is called on. But despite being defined in ``Classy``, it gets the ``SubClassy`` class object as the first parameter (``cls``).
+So a classmethod will "do the right thing" when used in a subclass.
 
 Alternate Constructors
 -----------------------
@@ -123,7 +119,6 @@ keys:
     TypeError: cannot convert dictionary update sequence element #0 to a sequence
 
 
-
 The stock constructor for a dictionary won't work this way. So the dict object
 implements an alternate constructor that *can*.
 
@@ -144,8 +139,7 @@ implements an alternate constructor that *can*.
 See also ``datetime.datetime.now()``, etc....
 
 
-Properties, Static Methods and Class Methods are powerful features of Python's
-OO model.
+Properties, Static Methods and Class Methods are powerful features of Python's OO model.
 
 They are implemented using an underlying structure called *descriptors*
 

source/modules/Unicode.rst

@@ -26,7 +26,7 @@ What the heck is Unicode anyway?
 * First there was chaos...
 
   * Different machines used different encodings -- different ways of mapping
-    binary data that the computer stores to letters.
+    the binary data that the computer stores to letters.
 
 * Then there was ASCII -- and all was good (7 bit), 127 characters
 
@@ -84,7 +84,7 @@ http://www.joelonsoftware.com/articles/Unicode.html
 
 Actually, dealing with numbers rather than bytes is big
 
--- but we take that for granted
+-- but we take that for granted.
 
 
 Mechanics
@@ -98,11 +98,11 @@ Py2 strings were simply sequences of bytes.  When text was one per character tha
 Py3 strings (or Unicode strings in py2) are sequences of "platonic characters".
 
 It's almost one code point per character -- there are complications
-with combined characters: accents, etc -- but we can mostly ignore those -- you will get far thiking of a code point as a character.
+with combined characters: accents, etc -- but we can mostly ignore those -- you will get far thinking of a code point as a character.
 
 Platonic characters cannot be written to disk or network!
 
-(ANSI: one character == one byte -- so easy!)
+(ANSI: one character == one byte -- it was so easy!)
 
 
 Strings vs Unicode
@@ -132,7 +132,7 @@ And two ways to work with binary data:
 py3 is more clear:
 
   ``str`` for text
-  ``byte`` for binary data
+  ``bytes`` for binary data
 
 Unicode
 --------
@@ -154,12 +154,12 @@ If you need to deal with the actual bytes for some reason, you may need to conve
 
 And can get even more confusing with py2 strings being *both* text and bytes!
 
-This is actually one of the biggest differences between Python 2 and Python 3. As an ordinary user (particularly one that used English...), you may not notice -- text is text, and things generally "just work", but under the hood it is very different, and folks writing libraries for things like Internet protocols struggle with the differences.
+This is actually one of the biggest differences between Python 2 and Python 3. As an ordinary user (particularly one that used English...), you may not notice -- text is text, and things generally "just work", but under the hood it is very different, and folks writting libraries for things like Internet protocols struggled with the differences.
 
 Using Unicode in Py2
----------------------
+--------------------
 
-If you do need to write Python2 code, you really should use Unicode.
+If you do need to write Python2 code, you really should use Unicode. If you don't -- skip ahead to "Unicode Literals".
 
 Here are the basics:
 
@@ -214,7 +214,9 @@ Encoding and Decoding
 
 
 Unicode Literals
-------------------
+----------------
+
+How do you get text that isn't plain English text?
 
 1) Use Unicode in your source files:
 
@@ -226,6 +228,8 @@ Unicode Literals
 
 2) Escape the Unicode characters:
 
+Either by its hexadecimal value, or its name:
+
 .. code-block:: python
 
   print u"The integral sign: \u222B"
@@ -239,7 +243,7 @@ One example:  http://inamidst.com/stuff/unidata/
 
 
 Using Unicode
---------------
+-------------
 
 Use ``unicode`` objects in all your code
 
@@ -251,14 +255,17 @@ Many packages do this for you: *XML processing, databases, ...*
 
 **Gotcha:**
 
-Python has a default encoding (usually ascii)
+Python has a default encoding. On Mac and Unix systems, it's usually utf-8 -- Windows? not nearly as consistent.
 
 .. code-block:: ipython
 
-  In [2]: sys.getdefaultencoding()
-  Out[2]: 'ascii'
+ In [7]: sys.getdefaultencoding()
+ Out[7]: 'utf-8'
+
+Try this on your machine, and see what you get.
 
-The default encoding will get used in unexpected places!
+The default encoding will get used in unexpected places! 
+Notably in text files by default.
 
 Using Unicode Everywhere
 -------------------------
@@ -329,12 +336,13 @@ UTF-16
 
 Kind of like UTF-8, except it uses at least 16bits (2 bytes) for each character: NOT ASCII compatible.
 
-But is still needs more than two bytes for some code points, so you still can't process it as two bytes per character.
+But it still needs more than two bytes for some code points, so you still can't simply process it as two bytes per character.
 
-In C/C++ held in a "wide char" or "wide string".
+In C/C++, it is held in a "wide char" or "wide string".
 
 MS Windows uses UTF-16, as does (I think) Java.
 
+
 UTF-16 criticism
 -----------------
 
@@ -362,7 +370,7 @@ A 1-byte per char encoding.
 
 * The most common one-byte per char encoding for European text.
 
-* Nice property -- every byte value from 0 to 255 is a valid character ( at least in Python )
+* Nice property -- every byte value from 1 to 255 is a valid character ( at least in Python )
 
 * You will never get an UnicodeDecodeError if you try to decode arbitrary bytes with latin-1.
 
@@ -384,27 +392,25 @@ http://docs.python.org/howto/unicode.html
 
 "Reading Unicode from a file is therefore simple"
 
-use io.open:
+use plain old open:
 
 .. code-block:: python
 
-  from io import open
-  io.open('unicode.rst', encoding='utf-8')
+  open('unicode.rst', encoding='utf-8')
   for line in f:
       print repr(line)
 
-(https://docs.python.org/2/library/io.html#module-interface)
-
-.. note: This is all for Python 2 -- the built in ``open`` in Py3 does utf-8 by default.
 
 Encodings Built-in to Python:
-  http://docs.python.org/2/library/codecs.html#standard-encodings
+  http://docs.python.org/3/library/codecs.html#standard-encodings
 
 
 Gotchas in Python 2
---------------------
+-------------------
 
-file names, etc:
+(Probaly do'nt need to worry about this anymore!)
+
+File names, etc:
 
 If you pass in unicode, you get unicode
 
@@ -438,7 +444,7 @@ Exception messages:
 :download:`exception_test.py  <../examples/unicode/exception_test.py>`.
 
 Unicode in Python 3
-----------------------
+-------------------
 
 The "string" object **is** Unicode (always).
 
@@ -456,7 +462,8 @@ It's all much cleaner.
 (by the way, the recent implementations are very efficient...)
 
 So you can pretty much ignore encodings and all that for most basic text processing.
-If you do find yourself needing to deal with binary data, you ay need to encode/decode stuff yourself.  IN which case, Python provides an ``.encode()`` method on strings that encode the string to a bytes object with the encoding you select:
+If you do find yourself needing to deal with binary data, you ay need to encode/decode stuff yourself.
+In which case, Python provides an ``.encode()`` method on strings that encode the string to a bytes object with the encoding you select:
 
 .. code-block:: ipython
 
@@ -477,7 +484,7 @@ It's all quite simple an robust.
 
   But there are a couple key points to remember:
 
-  * The primary people struggling were those that wrote (or wored with) libraries that had to deal with protocols that used both binary and text data in the same data stream.
+  * The primary people struggling were those that wrote (or worked with) libraries that had to deal with protocols that used both binary and text data in the same data stream.
 
   * As of Python 3.4 or so, the python string object had grown the features it needed to support even those ugly binary+text use cases.