fix snippets

Author: rsokl

Python/Module2_EssentialsOfPython/Itertools.ipynb

@@ -12,15 +12,15 @@
     "#### `range`\n",
     "generate a sequence of integers in the specified \"range\":\n",
     "```python\n",
-    ">>> range(10)\n",
     "# will generate 0.. 1.. 2.. ... 8.. 9\n",
+    "range(10)\n",
     "```\n",
     "\n",
     "#### `enumerate`\n",
     "\"enumerate\" the items in an iterable:\n",
     "```python\n",
-    ">>> enumerate([\"apple\", \"banana\", \"cat\", \"dog\"])\n",
     "# will generate (0, 'apple').. (1, 'banana').. (2, 'cat').. (3, 'dog')]\n",
+    "enumerate([\"apple\", \"banana\", \"cat\", \"dog\"])\n",
     "```\n",
     "\n",
     "#### `zip`\n",
@@ -30,8 +30,9 @@
     ">>> exam_1_scores = [90, 82, 79, 87]\n",
     ">>> exam_2_scores = [95, 84, 72, 91]\n",
     "\n",
-    ">>> zip(names, exam_1_scores, exam_2_scores)\n",
     "# will generate ('Angie', 90, 95).. ('Brian', 82, 84).. ('Cassie', 79, 72).. ('David', 87, 91)]\n",
+    ">>> zip(names, exam_1_scores, exam_2_scores)\n",
+    "<zip at 0x20de1082608>\n",
     "```\n",
     "***\n",
     "The following are some of the many useful tools provided by the `itertools` module:\n",
@@ -45,16 +46,19 @@
     ">>> iter_3 = [\"moo\", \"cow\"]\n",
     ">>> iter_4 = \"him\"\n",
     "\n",
-    ">>>  chain(gen_1, gen_2, iter_3, iter_4)\n",
     "# will generate: 0.. 2.. 4.. 9.. 16.. 25.. 'moo'.. 'cow'.. 'h'.. 'i'.. 'm'\n",
+    ">>> chain(gen_1, gen_2, iter_3, iter_4)\n",
+    "<itertools.chain at 0x20de109ec18>\n",
     "```\n",
     "\n",
     "#### `itertools.combinations`\n",
     "Generate all length-n \"combinations\" from an iterable:\n",
     "```python\n",
     ">>> from itertools import combinations\n",
-    ">>> combinations([0, 1, 2, 3], 3)  # generate all length-3 combinations from [0, 1, 2, 3]\n",
+    "\n",
     "# will generate: (0, 1, 2).. (0, 1, 3).. (0, 2, 3).. (1, 2, 3)\n",
+    ">>> combinations([0, 1, 2, 3], 3)  # generate all length-3 combinations from [0, 1, 2, 3]\n",
+    "<itertools.combinations at 0x20de10a7728>\n",
     "```"
    ]
   }
@@ -76,7 +80,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,

Python/Module2_EssentialsOfPython/SequenceTypes.ipynb

@@ -340,7 +340,7 @@
     "\n",
     "# start: 0, stop: 7, step: 1 \n",
     ">>> seq[:]  # equivalent: `seq[None:None]`\n",
-    ">>> seq = \"abcdefg\"\n",
+    "'abcdefg'\n",
     "\n",
     "# start: 0, stop: 7, step: 2\n",
     ">>> seq[::2]\n",
@@ -356,18 +356,18 @@
     "'gfedcba'\n",
     "\n",
     ">>> seq[-2:]\n",
-    "\"fg\"\n",
+    "'fg'\n",
     "\n",
     ">>> seq[:-2]\n",
-    "\"abcde\"\n",
+    "'abcde'\n",
     "```\n",
     "\n",
     "Although the colon-syntax for slicing, `seq[start:stop:step]`, appears nearly ubiquitously in Python code, it is important to know that there is a built-in `slice` object that Python uses to form slices. It accepts the same start, stop, and step values, and produces the same sort of slicing behavior:\n",
     "```python\n",
     "# using the `slice` object explicitly\n",
     ">>> seq = \"abcdefg\"\n",
     ">>> seq[slice(0, 3, 1)]\n",
-    "\"abc\"\n",
+    "'abc'\n",
     "```\n",
     "\n",
     "This gives you the ability to work with slices in more creative ways in your code, since it allows you to assign a variable to a slice.\n",
@@ -568,7 +568,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,

Python/Module2_EssentialsOfPython/Variables_and_Assignment.ipynb

@@ -133,6 +133,7 @@
     "# shorthand for: x = x + (4, 5)\n",
     "# this creates a new tuple\n",
     ">>> x += (4, 5)\n",
+    ">>> x \n",
     "(1, 2, 3, 4, 5)\n",
     "\n",
     "# y still references the original tuple\n",

Python/Module3_IntroducingNumpy/AccessingDataAlongMultipleDimensions.ipynb

@@ -35,12 +35,14 @@
     "\n",
     "Similar to Python's sequences, we use 0-based indices and slicing to access the content of an array. However, we must specify an index/slice for *each* dimension of an array:\n",
     "```python\n",
+    ">>> import numpy as np\n",
+    "\n",
     "# A 3-D array\n",
     ">>> x = np.array([[[0, 1],\n",
-    "                   [2, 3]],\n",
-    "              \n",
-    "                  [[4, 5],\n",
-    "                   [6, 7]]])\n",
+    "...                [2, 3]],\n",
+    "...           \n",
+    "...               [[4, 5],\n",
+    "...                [6, 7]]])\n",
     "\n",
     "# get: sheet-0, both rows, flip order of columns\n",
     ">>> x[0, :, ::-1]\n",
@@ -57,7 +59,7 @@
     "Let's being our discussion by constructing a simple ND-array containing three floating point numbers. \n",
     "\n",
     "```python\n",
-    "simple_array = np.array([2.3, 0.1, -9.1])\n",
+    ">>> simple_array = np.array([2.3, 0.1, -9.1])\n",
     "```\n",
     "This array supports the same indexing scheme as Python's sequences (lists, tuples, and strings):\n",
     "\n",
@@ -122,9 +124,9 @@
     "\n",
     "```python\n",
     "# using a 2-dimensional array to store the grades\n",
-    "grades = np.array([[93,  95], \n",
-    "                   [84, 100], \n",
-    "                   [99,  87]])\n",
+    ">>> grades = np.array([[93,  95], \n",
+    "...                    [84, 100], \n",
+    "...                    [99,  87]])\n",
     "```\n",
     "\n",
     "NumPy is able to see the repeated structure among the list-of-lists-of-numbers passed to `np.array`, and resolve the two dimensions of data, which we deem the 'student' dimension and the 'exam' dimension, respectively. \n",
@@ -195,6 +197,7 @@
     "```python\n",
     "# using a negative index and a slice\n",
     ">>> grades[:, -1]  # Latest exam scores (Exam 2), for all students\n",
+    "array([ 95, 100,  87])\n",
     "```\n",
     "Note the value of using the negative index is that it will always provide you with the latest exam score - you need not check how many exams the students have taken.\n",
     "\n",
@@ -235,10 +238,11 @@
     "## N-dimensional Arrays\n",
     "Let's build up some intuition for arrays with a dimensionality higher than 2. The following code creates a 3-dimensional array:\n",
     "```python\n",
-    "d3_array = np.array([[[0, 1],\n",
-    "                      [2, 3]],\n",
-    "                     [[4, 5],\n",
-    "                      [6, 7]]])\n",
+    "# a 3D array\n",
+    ">>> d3_array = np.array([[[0, 1],\n",
+    "...                       [2, 3]],\n",
+    "...                      [[4, 5],\n",
+    "...                       [6, 7]]])\n",
     "```\n",
     "You can think of axis-0 denoting which of the 2x2 \"sheets\" to select from. Then axis-1 specifies the row along the sheets, and axis-2 the column within the row:\n",
     "\n",

Python/Module3_IntroducingNumpy/BasicArrayAttributes.ipynb

@@ -10,14 +10,15 @@
     "We will use the following array to provide context for our discussion:\n",
     " \n",
     "```python\n",
+    ">>> import numpy as np\n",
     ">>> example_array = np.array([[[ 0,  1,  2,  3],\n",
-    "                               [ 4,  5,  6,  7]],\n",
-    "\n",
-    "                              [[ 8,  9, 10, 11],\n",
-    "                               [12, 13, 14, 15]],\n",
-    "\n",
-    "                              [[16, 17, 18, 19],\n",
-    "                               [20, 21, 22, 23]]])\n",
+    "...                            [ 4,  5,  6,  7]],\n",
+    "...\n",
+    "...                           [[ 8,  9, 10, 11],\n",
+    "...                            [12, 13, 14, 15]],\n",
+    "...\n",
+    "...                           [[16, 17, 18, 19],\n",
+    "...                            [20, 21, 22, 23]]])\n",
     "```\n",
     "According to the preceding discussion, it is a 3-dimensional array structured such that:\n",
     "\n",

Python/Module3_IntroducingNumpy/Broadcasting.ipynb

@@ -242,12 +242,12 @@
     "# axis-0 (rows):    student\n",
     "# axis-1 (columns): exams \n",
     ">>> import numpy as np\n",
-    ">>> grades = array([[ 0.79,  0.84,  0.84],\n",
-    "...                 [ 0.87,  0.93,  0.78],\n",
-    "...                 [ 0.77,  1.  ,  0.87],\n",
-    "...                 [ 0.66,  0.75,  0.82],\n",
-    "...                 [ 0.84,  0.89,  0.76],\n",
-    "...                 [ 0.83,  0.71,  0.85]])\n",
+    ">>> grades = np.array([[ 0.79,  0.84,  0.84],\n",
+    "...                    [ 0.87,  0.93,  0.78],\n",
+    "...                    [ 0.77,  1.  ,  0.87],\n",
+    "...                    [ 0.66,  0.75,  0.82],\n",
+    "...                    [ 0.84,  0.89,  0.76],\n",
+    "...                    [ 0.83,  0.71,  0.85]])\n",
     "```\n",
     "\n",
     "We might be interested to see how each of these scores compare to the mean score for that specific exam. Based on our discussion from the last section, we can easily compute the mean-score for each exam (rounded to 2 decimal places):\n",
@@ -787,14 +787,15 @@
     ">>> x = np.array([[[ 0,  1,  2,  3],\n",
     "...                [ 4,  5,  6,  7],\n",
     "...                [ 8,  9, 10, 11]],\n",
-    "\n",
+    "...\n",
     "...               [[12, 13, 14, 15],\n",
     "...                [16, 17, 18, 19],\n",
     "...                [20, 21, 22, 23]]])\n",
     "\n",
     "\n",
     "# sum over each row, within a sheet\n",
     ">>> summed_rows = x.sum(axis=1)\n",
+    ">>> summed_rows\n",
     "array([[12, 15, 18, 21],\n",
     "       [48, 51, 54, 57]])\n",
     "\n",

Python/Module3_IntroducingNumpy/FunctionsForCreatingNumpyArrays.ipynb

@@ -39,7 +39,6 @@
     "You can create an array from a Python `list` or `tuple` by using NumPy's `array` function. NumPy will interpret the structure of the data it receives to determine the dimensionality and shape of the array. For example, a single list of numbers will be used to create a 1-dimensional array: \n",
     "\n",
     "```python\n",
-    ">>> import numpy as np\n",
     "# a list of numbers will become a 1D-array\n",
     ">>> np.array([1., 2., 3.])  # shape: (3,)\n",
     "array([ 1.,  2.,  3.])\n",

Python/Module3_IntroducingNumpy/IntroducingTheNDarray.ipynb

@@ -45,7 +45,7 @@
     "Let's take the mean value over the three distinct columns in our data:\n",
     "```python\n",
     ">>> np.mean(x, axis=1)\n",
-    "array([ 3.,  4.,  5.])\n",
+    "array([ 1.,  4.,  7.])\n",
     "```\n",
     "\n",
     "We can use broadcasting to raise each column of `x` to a different power:\n",

Python/Module3_IntroducingNumpy/ReshapingArrays.ipynb

@@ -58,10 +58,10 @@
     "Because the size of an input array and the resulting reshaped array must agree, you can specify *one* of the dimension-sizes in the reshape function to be -1, and this will cue NumPy to compute that dimension's size for you. For example, if you are reshaping a shape-(36,) array into a shape-(3, 4, 3) array. The following are valid:\n",
     "```python\n",
     "# Equivalent ways of specifying a reshape\n",
-    ">>> np.arange(36).reshape(3, 4, 3)   # (36,) --reshape--> (3, 4, 3) \n",
-    ">>> np.arange(36).reshape(3, 4, -1)  # NumPy replaces -1 with 36/(3*4) -> 3\n",
-    ">>> np.arange(36).reshape(3, -1, 3)  # NumPy replaces -1 with 36/(3*3) -> 4\n",
-    ">>> np.arange(36).reshape(-1, 4, 3)  # NumPy replaces -1 with 36/(3*4) -> 3\n",
+    "np.arange(36).reshape(3, 4, 3)   # (36,) --reshape--> (3, 4, 3) \n",
+    "np.arange(36).reshape(3, 4, -1)  # NumPy replaces -1 with 36/(3*4) -> 3\n",
+    "np.arange(36).reshape(3, -1, 3)  # NumPy replaces -1 with 36/(3*3) -> 4\n",
+    "np.arange(36).reshape(-1, 4, 3)  # NumPy replaces -1 with 36/(3*4) -> 3\n",
     "```\n",
     "\n",
     "You can use -1 to specify only one dimension: \n",