0C_Python_Prerequisites.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Programming Refresher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook provides a quick refresher of some Python concepts and packages useful for numerical computation.\n",
    "If you feel comfortable using Python, NumPy, and Matplotlib, feel free to skim through or skip this notebook entirely. \n",
    "\n",
    "## Python \n",
    "Python, first released in 1991, is a programming language of increasing popularity and the one that shall be used throughout this course. \n",
    "Later, you'll learn about a framework called PyTorch, which allows us to easily implement neural networks in Python. \n",
    "In addition to this practical consideration, Python boasts such benefits as code-readability, easy semantics,  interactivity (i.e., you don't have to recompile all the time!), and it supports such common programming paradigms as object-oriented and functional programming.\n",
    "\n",
    "This walk-through provides an overview of aspects of the Python programming language you'll need to know for the course, including: lists, tuples, dictionaries, for-loops, if-statements, NumPy, and MatPlotLib. \n",
    "We recommend that you are comfortable with all of these before proceeding with the course.\n",
    "\n",
    "For those unfamiliar with Python, this will likely not be sufficient to bring you fully up-to-speed. \n",
    "Instead, the free e-book [Python Like You Mean It](https://www.pythonlikeyoumeanit.com/intro.html), by Ryan Soklaski, will provide an more comprehensive introduction to Python for scientific computing. \n",
    "Additionally, to further learn about the programming language's features and to view its documentation, the website <http://www.python.org> is a great resource. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables and Assignments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, we store all pieces of data -- numbers, characters, strings, [*everything*](http://www.diveintopython.net/getting_to_know_python/everything_is_an_object.html) -- as objects, and we refer to these objects using variables.  As a simple case, we can *assign* a variable a value using the assignment operator, which is the \"equals\" sign:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "y = 5\n",
    "z = x + y\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we can perform assignment using specific values -- as in assigning 4 to variable *x* and 5 to variable *y* -- and we can also assign a value with respect to other variables -- as in assigning the variable *z* the sum of *x* and *y*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python collections allow us to put multiple data items into a single object that we may then access or operate on all together.  There are several built-in types of collections, and we shall discuss three of them: lists, tuples, and dictionaries.  Later, we'll introduce an additional way to collect data using arrays from a library called *numpy*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list comprises a sequence of objects, usually represented using square brackets with commas between the items in the sequence as is done below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['a', 'b', 'c', 'd']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, *my_list* contains a sequence of character objects.  Lists, however, accomodate items of varying types of objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "varied_list = ['a', 1, 'b', 3.14159] # a list with elements of char, integer, and float types\n",
    "nested_list = ['hello', 'governor', [1.618, 42]] # a list within a list!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists allow for what is called *indexing*, in which a specified element of the list may be obtained.  For instance, say you wanted to grab the second element of *varied_list* above. Then you could index the list as so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "second_element = varied_list[1] # Grab second element of varied_list\n",
    "print(second_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now is a good time to mention that Python is what's called a *zero-indexed* programming language.  This simply means that the \"first\" element in a list or other collection of data items is indexed using \"0\" (zero) rather than \"1\". This is why, above, we grab the second element of *varied_list* using the integer index \"1\" instead of \"2\" as some might expect from a *one-indexed* language (like MATLab)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another feature of python indexing that comes in handy is the use of *negative indexing*.  As we discussed above, the \"first\" element of a python list is denoted by index \"0\"; thus, it is almost natural to consider the last element of the list as being indexed by \"-1\". Observe the following examples of negative indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "last_element = my_list[-1] # the last element of my_list\n",
    "last_element_2 = my_list[len(my_list)-1] # also the last element of my_list, obtained differently\n",
    "second_to_last_element = my_list[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to indexing is list slicing, in which a contiguous section of list may be accessed.  The colon (:) is used to perform slicing, with integers denoting the positions at which to begin and end the slice. Below, we show that the beginning or ending integer for a slice may be omited when one is slicing from the beginning or to the end of the list. Also note below that the index for slice beginning is included in the slice, but the index for the slice end is not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "NFL_list = [\"Chargers\", \"Broncos\", \"Raiders\", \"Chiefs\", \"Panthers\", \"Falcons\", \"Cowboys\", \"Eagles\"]\n",
    "AFC_west_list = NFL_list[:4] # Slice to grab list indices 0, 1, 2, 3 -- \"Chargers\", \"Broncos\", \"Raiders\", \"Chiefs\"\n",
    "NFC_south_list = NFL_list[4:6] # Slice list indices 4, 5 -- \"Panthers\", \"Falcons\"\n",
    "NFC_east_list = NFL_list[6:] # Slice list indices 6, 7 -- \"Cowboys\", \"Eagles\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple is a Python collection that is extremely similar to a list, with some subtle differences.  For starters, tuples are indicated using parentheses instead of square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "coordinates = (x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable *coordinates* above is a tuple containing the variables *x* and *y*. This example was chosen to also demonstrate a difference between the typical usage of tuples versus lists. Whereas lists are frequently used to contain objects whose values are similar in some sense, tuples are frequently used to contain attributes of a coherent unit. For instance, as above, it makes sense to treat the coordinates of a point as a single unit. As another example, consider the following tuple and list concerning dates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "year1 = 2011\n",
    "month1 = \"May\"\n",
    "day1 = 18\n",
    "date1 = (month1, day1, year1)\n",
    "year2 = 2017\n",
    "month2 = \"June\"\n",
    "day2 = 13\n",
    "date2 = (month2, day2, year2)\n",
    "years_list = [year1, year2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice above that we have collected the attributes of a single date into one tuple: those pieces of information all describe a single \"unit\".  By contrast, in the years list we have collected the different years in the code-snippet: the values in the list have a commonality (they are both years), but they do not describe the same unit. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The distinction I've drawn between tuples and lists here is one that many Python programmers recognize in practice, but not one that is strictly enforced (i.e., you won't get any errors if you break this convention!).  Another subtle way in which tuples and lists differ involves what is called *mutability* of Python variables.  Mutability is a more complex concept that we need not discuss in our Python introduction, but interested students are encouraged to [read further](https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747) if they like!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since you've seen parenthesis (for tuples) and square brackets (for lists), you may be wondering what curly braces are used for in Python. The answer: Python dictionaries.  The defining feature of a Python dictionary is that it has **keys** and **values** that are associated with each other.  When defining a dictionary, this association may be accomplished using the color (:) as is done below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mary Shelley\n"
     ]
    }
   ],
   "source": [
    "book_dictionary = {\"Title\": \"Frankenstein\", \"Author\": \"Mary Shelley\", \"Year\": 1818}\n",
    "print(book_dictionary[\"Author\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, the keys of the *book_dictionary* are \"Title\", \"Author\", and \"Year\", and each of these keys has a corresponding value associated with it. Notice that the key-value pairs are separated by a comma. Using keys allows us to access a piece of the dictionary by its name, rather than needing to know the index of the piece that we want, as is the case with lists and tuples. For instance, above we could get the author of Frankenstein using the \"Author\" key, rather than using an index. In fact, unlike in a list or tuple, the order of elements in a dictionary doesn't matter, and dictionaries cannot be indexed using integers, which we see below when we try to access the second element of the dictionary using an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "1",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m-------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                    Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-43bbaea82a52>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbook_dictionary\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 1"
     ]
    }
   ],
   "source": [
    "print(book_dictionary[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with most of the popular programming languages, Python offers several ways to control the flow of execution within a program. Here, we'll introduce looping and conditional statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, it is important to make you aware of a unique aspect of the Python language: indentation. While a language like C uses curly braces to contain code statements within loops or conditionals, Python indicates these statements through indentation.  This feature lends Python code readability, as you will see in the examples below. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For-Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looping statements allow for the repeated execution of a section of code. For instance, suppose we wanted to add up all of the integers between zero (0) and ten (10), not including ten. We could, of course, do this in one line, but we could also use a loop to add each integer one at a time. Below is the code for a simple accumulator that accomplishes this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "for i in range(10):\n",
    "    sum = sum + i\n",
    "print(sum)\n",
    "alternative_sum = 0+1+2+3+4+5+6+7+8+9\n",
    "print(alternative_sum==sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *range*() built-in function generates the sequence of values that we loop over, and notice that range(10) does not include 10 itself. In addition to looping over a sequence of integers using the range() function, we can also loop over the elements in a list, which is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "flour\n",
      "sugar\n",
      "eggs\n",
      "oil\n",
      "baking soda\n"
     ]
    }
   ],
   "source": [
    "ingredients = [\"flour\", \"sugar\", \"eggs\", \"oil\", \"baking soda\"]\n",
    "for ingredient in ingredients:\n",
    "    print(ingredient)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, the for-loop iterates over the elements of the list *ingredients*, and within the loop each of those elements is referred to as *ingredient*. The use of singular/plural nouns to handle this iteration is a common Python motif, but is by no means necessary to use in your own programming. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oftentimes while programming, one will want to only execute portions of code when certain conditions are met, for instance, when a variable has a certain value.  This is accomplished using conditional statements: **if**, **elif**, and **else**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is even\n",
      "1 is odd\n",
      "2 is even\n",
      "3 is odd\n",
      "4 is even\n",
      "5 is odd\n",
      "6 is even\n",
      "7 is odd\n",
      "8 is even\n",
      "9 is odd\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i % 2 == 0: # % -- modulus operator -- returns the remainder after division\n",
    "        print(\"{} is even\".format(i))\n",
    "    else:\n",
    "        print(\"{} is odd\".format(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In the Northern Hemisphere: \n",
      "\n",
      "Month 1 is in Winter\n",
      "Month 2 is in Winter\n",
      "Month 3 is in Spring\n",
      "Month 4 is in Spring\n",
      "Month 5 is in Spring\n",
      "Month 6 is in Summer\n",
      "Month 7 is in Summer\n",
      "Month 8 is in Summer\n",
      "Month 9 is in Fall\n",
      "Month 10 is in Fall\n",
      "Month 11 is in Fall\n",
      "Month 12 is in Winter\n"
     ]
    }
   ],
   "source": [
    "# Example using elif as well\n",
    "# Print the meteorological season for each month (loosely, of course, and in the Northern Hemisphere)\n",
    "print(\"In the Northern Hemisphere: \\n\")\n",
    "month_integer = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] # i.e., January is 1, February is 2, etc...\n",
    "for month in month_integer:\n",
    "    if month < 3:\n",
    "        print(\"Month {} is in Winter\".format(month))\n",
    "    elif month < 6:\n",
    "        print(\"Month {} is in Spring\".format(month))\n",
    "    elif month < 9:\n",
    "        print(\"Month {} is in Summer\".format(month))\n",
    "    elif month < 12:\n",
    "        print(\"Month {} is in Fall\".format(month))\n",
    "    else: # This will put 12 (i.e., December) into Winter\n",
    "        print(\"Month {} is in Winter\".format(month))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows for list comprehension in which the elements of a list are iterated over all in one line of code.  Say, for example, that you wanted to add 1 to each element in a list of integers. You could do so using list comprehension as so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "even_list = [2, 4, 6, 8]\n",
    "odd_list = [even+1 for even in even_list]\n",
    "print(odd_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note from above the similarities between list comprehension and a for-loop; Python has list comprehension as a compact, \"pythonic\" way of performing operations that could be done within a for-loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [NumPy](http://www.numpy.org/) library endows Python with a host of scientific computing capabilities. Chief among these is the Array object, which provides a multidimensional way to organize values of the same type. Numpy arrays allow slicing and indexing similar to lists. Most importantly, Numpy has a formidable number of mathematical operations that can be used to transform arrays and perform computations between arrays.  For those familiar with MATLab, these operations should be reminiscent of many matrix operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A: \n",
      "\n",
      "[[1 3 5]\n",
      " [2 4 6]]\n",
      "\n",
      "Matrix B: \n",
      "\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "\n",
    "x = np.array([2, 4, 6]) # create a rank 1 array\n",
    "A = np.array([[1, 3, 5], [2, 4, 6]]) # create a rank 2 array\n",
    "B = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "print(\"Matrix A: \\n\")\n",
    "print(A)\n",
    "\n",
    "print(\"\\nMatrix B: \\n\")\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5]\n",
      "6\n",
      "[3 4]\n"
     ]
    }
   ],
   "source": [
    "# Indexing/Slicing examples\n",
    "print(A[0, :]) # index the first \"row\" and all columns\n",
    "print(A[1, 2]) # index the second row, third column entry\n",
    "print(A[:, 1]) # index entire second column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Matrix E (the transpose of B): \n",
      "\n",
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n",
      "\n",
      " Matrix F (result of matrix multiplication A x E): \n",
      "\n",
      "[[22 49]\n",
      " [28 64]]\n",
      "\n",
      " Matrix G (result of matrix-vector multiplication A*x): \n",
      "\n",
      "[44 56]\n"
     ]
    }
   ],
   "source": [
    "# Arithmetic Examples\n",
    "C = A * 2 # multiplies every elemnt of A by two\n",
    "D = A * B # elementwise multiplication rather than matrix multiplication\n",
    "E = np.transpose(B)\n",
    "F = np.matmul(A, E) # performs matrix multiplication -- could also use np.dot()\n",
    "G = np.matmul(A, x) # performs matrix-vector multiplication -- again could also use np.dot()\n",
    "\n",
    "print(\"\\n Matrix E (the transpose of B): \\n\")\n",
    "print(E)\n",
    "\n",
    "print(\"\\n Matrix F (result of matrix multiplication A x E): \\n\")\n",
    "print(F)\n",
    "\n",
    "print(\"\\n Matrix G (result of matrix-vector multiplication A*x): \\n\")\n",
    "print(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2 12 30]\n",
      " [ 4 16 36]]\n",
      "[[ 3  6  9]\n",
      " [ 6  9 12]]\n"
     ]
    }
   ],
   "source": [
    "# Broadcasting Examples\n",
    "H = A * x # \"broadcasts\" x for element-wise multiplication with the rows of A\n",
    "print(H)\n",
    "J = B + x # broadcasts for addition, again across rows\n",
    "print(J)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix X: \n",
      "\n",
      "[[ 3  9  4]\n",
      " [10  2  7]\n",
      " [ 5 11  8]]\n",
      "\n",
      " Maximum value in X: \n",
      "\n",
      "11\n",
      "\n",
      " Column-wise max of X: \n",
      "\n",
      "[10 11  8]\n",
      "\n",
      " Indices of column max: \n",
      "\n",
      "[1 2 2]\n",
      "\n",
      " Row-wise max of X: \n",
      "\n",
      "[ 9 10 11]\n"
     ]
    }
   ],
   "source": [
    "# max operation examples\n",
    "\n",
    "X = np.array([[3, 9, 4], [10, 2, 7], [5, 11, 8]])\n",
    "all_max = np.max(X) # gets the maximum value of matrix X\n",
    "column_max = np.max(X, axis=0) # gets the maximum in each column -- returns a rank-1 array [10, 11, 8]\n",
    "row_max = np.max(X, axis=1) # gets the maximum in each row -- returns a rank-1 array [9, 10, 11]\n",
    "\n",
    "# In addition to max, can similarly do min. Numpy also has argmax to return indices of maximal values\n",
    "column_argmax = np.argmax(X, axis=0) # note that the \"index\" here is actually the row the maximum occurs for each column\n",
    "\n",
    "print(\"Matrix X: \\n\")\n",
    "print(X)\n",
    "print(\"\\n Maximum value in X: \\n\")\n",
    "print(all_max)\n",
    "print(\"\\n Column-wise max of X: \\n\")\n",
    "print(column_max)\n",
    "print(\"\\n Indices of column max: \\n\")\n",
    "print(column_argmax)\n",
    "print(\"\\n Row-wise max of X: \\n\")\n",
    "print(row_max)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix X: \n",
      "\n",
      "[[ 3  9  4]\n",
      " [10  2  7]\n",
      " [ 5 11  8]]\n",
      "\n",
      " Sum over all elements of X: \n",
      "\n",
      "59\n",
      "\n",
      " Column-wise sum of X: \n",
      "\n",
      "[18 22 19]\n",
      "\n",
      " Row-wise sum of X: \n",
      "\n",
      "[16 19 24]\n"
     ]
    }
   ],
   "source": [
    "# Sum operation examples\n",
    "# These work similarly to the max operations -- use the axis argument to denote if summing over rows or columns\n",
    "\n",
    "\n",
    "total_sum = np.sum(X)\n",
    "column_sum = np.sum(X, axis=0)\n",
    "row_sum = np.sum(X, axis=1)\n",
    "\n",
    "print(\"Matrix X: \\n\")\n",
    "print(X)\n",
    "print(\"\\n Sum over all elements of X: \\n\")\n",
    "print(total_sum)\n",
    "print(\"\\n Column-wise sum of X: \\n\")\n",
    "print(column_sum)\n",
    "print(\"\\n Row-wise sum of X: \\n\")\n",
    "print(row_sum)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rank-1 array X: \n",
      "\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]\n",
      "\n",
      " Reshaped into a square matrix: \n",
      "\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n",
      "\n",
      " Reshaped into a rank-3 array with dimensions 2 x 2 x 4: \n",
      "\n",
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]]\n",
      "\n",
      " [[ 8  9 10 11]\n",
      "  [12 13 14 15]]]\n"
     ]
    }
   ],
   "source": [
    "# Matrix reshaping\n",
    "\n",
    "X = np.arange(16) # makes a rank-1 array of integers from 0 to 15\n",
    "X_square = np.reshape(X, (4, 4)) # reshape X into a 4 x 4 matrix\n",
    "X_rank_3 = np.reshape(X, (2, 2, 4)) # reshape X to be 2 x 2 x 4 --a rank-3 array\n",
    "                                    # consider as two rank-2 arrays with 2 rows and 4 columns\n",
    "print(\"Rank-1 array X: \\n\")\n",
    "print(X)\n",
    "print(\"\\n Reshaped into a square matrix: \\n\")\n",
    "print(X_square)\n",
    "print(\"\\n Reshaped into a rank-3 array with dimensions 2 x 2 x 4: \\n\")\n",
    "print(X_rank_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much of plotting you'll do will be through the [Matplotlib](https://matplotlib.org/) library, specifically within the Pyplot module.  Aptly named, the *plot* function is used to plot 2-D data, as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# We'll start with a parabola\n",
    "# Compute the parabola's x and y coordinates\n",
    "x = np.arange(-5, 5, 0.1)\n",
    "y = np.square(x)\n",
    "\n",
    "# Use matplotlib for the plot\n",
    "plt.plot(x, y, 'b') # specify the color blue for the line\n",
    "plt.xlabel('X-Axis Values')\n",
    "plt.ylabel('Y-Axis Values')\n",
    "plt.title('First Plot: A Parabola')\n",
    "plt.show() # required to actually display the plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Another Matplotlib function you'll encounter is *imshow* which is used to display images. Recall that an image may be considered as an array, with array elements indicating image pixel values. As a simple example, here is the identity matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X = np.identity(10)\n",
    "identity_matrix_image = plt.imshow(X, cmap=\"Greys_r\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now plot a random matrix, with a different colormap\n",
    "A = np.random.randn(10, 10)\n",
    "random_matrix_image = plt.imshow(A)\n",
    "plt.show()"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}