Preliminaries_Numpy_Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions, Conditionals, and Iteration in Python\n",
    "\n",
    "Let us create a Python function, and call it from a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World, x was < 10\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def HelloWorldXY(x, y):\n",
    "    if (x < 10):\n",
    "        print(\"Hello World, x was < 10\")\n",
    "    elif (x < 20):\n",
    "        print(\"Hello World, x was >= 10 but < 20\")\n",
    "    else:\n",
    "        print(\"Hello World, x was >= 20\")\n",
    "    return x + y\n",
    "\n",
    "print(HelloWorldXY(1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us call the function `HelloWorldXY()` from a loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Now running with i: 8\n",
      "Hello World, x was < 10\n",
      "Result from HelloWorld: 16\n",
      "\n",
      "--- Now running with i: 13\n",
      "Hello World, x was >= 10 but < 20\n",
      "Result from HelloWorld: 26\n",
      "\n",
      "--- Now running with i: 18\n",
      "Hello World, x was >= 10 but < 20\n",
      "Result from HelloWorld: 36\n",
      "\n",
      "--- Now running with i: 23\n",
      "Hello World, x was >= 20\n",
      "Result from HelloWorld: 46\n"
     ]
    }
   ],
   "source": [
    "for i in range(8, 25, 5): # i=8, 13, 18, 23 (start, stop, step)\n",
    "    print(\"\\n--- Now running with i: {}\".format(i))\n",
    "    r = HelloWorldXY(i,i)\n",
    "    print(\"Result from HelloWorld: {}\".format(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want a loop starting at 0 to 2 (exclusive) you could do any of the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterate over the items. `range(2)` is like a list [0,1].\n",
      "0\n",
      "1\n",
      "Iterate over an actual list.\n",
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(\"Iterate over the items. `range(2)` is like a list [0,1].\")\n",
    "for i in range(2):\n",
    "    print(i)\n",
    "\n",
    "print(\"Iterate over an actual list.\")\n",
    "for i in [0,1]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "While works\n",
      "0\n",
      "1\n",
      "Python supports standard key words like continue and break\n",
      "Entered while\n",
      "while broken\n"
     ]
    }
   ],
   "source": [
    "print(\"While works\")\n",
    "i = 0\n",
    "while i < 2:\n",
    "    print(i)\n",
    "    i += 1\n",
    "    \n",
    "print(\"Python supports standard key words like continue and break\")\n",
    "while True:\n",
    "    print(\"Entered while\")\n",
    "    break\n",
    "print(\"while broken\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy\n",
    "\n",
    "### Introducing NumPy\n",
    "\n",
    "Python is convenient, but it can also be slow. However, it does \n",
    "allow you to access libraries that execute faster code written in \n",
    "languages like C. NumPy is one such library: it provides fast alternatives \n",
    "to math operations in Python and is designed to work efficiently with \n",
    "groups of numbers - like matrices.\n",
    "\n",
    "NumPy is a large library and we are only going to scratch the surface \n",
    "of it here. If you plan on doing much math with Python, you should \n",
    "definitely spend some time exploring its documentation to learn more.\n",
    "\n",
    "### Importing Numpy\n",
    "\n",
    "When importing the NumPy library, the convention you will see \n",
    "used most often - including here - is to name it `np`, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can use the library by prefixing the names of functions and \n",
    "types with `np`, which you will see in the following examples.\n",
    "\n",
    "### Data Types and Shapes\n",
    "\n",
    "The most common way to work with numbers in NumPy is through `ndarray` \n",
    "objects. They are similar to Python lists, but can have any number of \n",
    "dimensions. Also, `ndarray` supports fast math operations, which \n",
    "is just what we want.\n",
    "\n",
    "Since it can store any number of dimensions, you can use `ndarrays` \n",
    "to represent any of the data types : scalars, vectors, \n",
    "matrices, or tensors. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalars\n",
    "\n",
    "Scalars in NumPy are a bit more involved than in Python. Instead of \n",
    "Python's basic types like `int`, `float`, etc., NumPy lets \n",
    "you specify signed and unsigned types, as well as different sizes.\n",
    "So instead of Python's `int`, you have access to types \n",
    "like `uint8`, `int8`, `uint16`, `int16`, and so on.\n",
    "\n",
    "These types are important because every object you make \n",
    "(vectors, matrices, tensors) eventually stores scalars. And when you \n",
    "create a NumPy array, you can specify the type - _but every item in the \n",
    "array must have the same type_. In this regard, NumPy arrays are more \n",
    "like C arrays than Python lists.\n",
    "\n",
    "If you want to create a NumPy array that holds a scalar, you do so \n",
    "by passing the value to NumPy's `array` function, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(5)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Scalar\n",
    "s = np.array(5)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can display the number of axes of a NumPy `array` via the `ndim` attribute;\n",
    "a scalar array has $0$ axes (`ndim` == 0). The number of axes of an array is also\n",
    "called its _rank_. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see the shape of your arrays by checking their `shape` attribute. So if \n",
    "you executed this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "it would print out the result, an empty pair of parenthesis, `()`. This \n",
    "indicates that it has zero dimensions.\n",
    "\n",
    "Even though scalars are inside arrays, you still use them like a normal scalar. \n",
    "So you could type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = s + 3\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and $x$ would now equal $8$. If you were to check the type of \n",
    "$x$, you would find it is probably `numPy.int64`, because \n",
    "it is working with NumPy types, not Python types.\n",
    "\n",
    "By the way, even scalar types support most of the array functions. \n",
    "So you can call `x.shape` and it would return `()` because \n",
    "it has zero dimensions, even though it is not an array. If you tried \n",
    "that with a normal Python scalar, you would get an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectors\n",
    "\n",
    "To create a vector, you would pass a Python list to the `array` function, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([1,2,3])\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This vector has three entries and so is called a 3-dimensional vector. If you check a vector's `shape` attribute, it will return a single number representing the \n",
    "vector's one-dimensional length. In the above example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don’t confuse a 3D vector with a 3D array. A 3D vector has only one axis and has three dimensions along its axis, whereas a 3D array has three axes (and may have any number of dimensions along each axis). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dimensionality can denote either the number of entries along a specific\n",
    "axis (as in the case of our 3D vector) or the number of axes in an array (such as a\n",
    "3D array), which can be confusing at times.\n",
    "\n",
    "You can access an element within the vector using indices, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy also supports advanced indexing techniques. For example, to access the items from the \n",
    "second element onward, you would say:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy slicing is quite powerful, \n",
    "allowing you to access any combination of items in an `ndarray`. But it can also be a bit complicated, \n",
    "so you should read up on it in the documentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices\n",
    "\n",
    "You create matrices using `NumPy`'s array function, just you did for vectors. However, instead \n",
    "of just passing in a list, you need to supply a list of lists, where each list represents \n",
    "a row. So to create a $3\\times 3$ matrix containing the numbers one through nine, you could \n",
    "do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The entries from the first axis are called the _rows_, and the entries from \n",
    "the second axis are called the _columns_. A matrix thus has two axes or _rank_ 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking its shape attribute would return the tuple `(3, 3)` to indicate it has two dimensions, each length $3$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access elements of matrices just like vectors, but using additional index values. So to find \n",
    "the number $6$ in the above matrix, you would access"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[1][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensors\n",
    "\n",
    "Tensors are just like vectors and matrices, but they can have more dimensions. For example, to \n",
    "create a $3\\times 3\\times 2\\times 1$ tensor, you could do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[ 1],\n",
       "         [ 2]],\n",
       "\n",
       "        [[ 3],\n",
       "         [ 4]],\n",
       "\n",
       "        [[ 5],\n",
       "         [ 6]]],\n",
       "\n",
       "\n",
       "       [[[ 7],\n",
       "         [ 8]],\n",
       "\n",
       "        [[ 9],\n",
       "         [10]],\n",
       "\n",
       "        [[11],\n",
       "         [12]]],\n",
       "\n",
       "\n",
       "       [[[13],\n",
       "         [14]],\n",
       "\n",
       "        [[15],\n",
       "         [16]],\n",
       "\n",
       "        [[17],\n",
       "         [17]]]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = np.array([[[[1],[2]],[[3],[4]],[[5],[6]]],[[[7],[8]],\\\n",
    "    [[9],[10]],[[11],[12]]],[[[13],[14]],[[15],[16]],[[17],[17]]]])\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And `t.shape` returns `(3, 3, 2, 1)` and `t.ndim` indicates that we are dealing with a rank 4 tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3, 2, 1)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access items just like with matrices, but with more indices. So "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[2][1][1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing Shapes\n",
    "\n",
    "Sometimes you will need to change the shape of your data without actually changing \n",
    "its contents. For example, you may have a vector, which is one-dimensional, but need \n",
    "a matrix, which is two-dimensional. There are two ways you can do that.\n",
    "\n",
    "Let's say you have the following vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([1,2,3,4])\n",
    "v.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling `v.shape` would return `(4,)`. But what if you want a $1\\times 4$ matrix? \n",
    "You can accomplish that with the `reshape` function, like so:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = v.reshape(1,4)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling `x.shape` would return `(1,4)`. If you wanted a $4\\times 1$ matrix, you \n",
    "could do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = v.reshape(4,1)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `reshape` function works for more than just adding a dimension of size $1$. Check out its \n",
    "documentation for more examples.\n",
    "\n",
    "One more thing about reshaping NumPy arrays: if you see code from experienced NumPy users, you \n",
    "will often see them use a special slicing syntax instead of calling `reshape`. Using this \n",
    "syntax, the previous two examples would look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = v[None, :]\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 1)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = v[:, None]\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 1)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Those lines create a slice that looks at all of the items of `v` but asks NumPy to add a new dimension \n",
    "of size $1$ for the associated axis. It may look strange to you now, but it's a common technique so \n",
    "it's good to be aware of it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise Operations\n",
    "\n",
    "#### The Python Way\n",
    "\n",
    "Suppose you had a list of numbers, and you wanted to add $5$ to every item in the list. \n",
    "Without NumPy, you might do something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "853 ns ± 38.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "values = [1,2,3,4,5]\n",
    "for i in range(len(values)):\n",
    "    values[i] += 5\n",
    "    \n",
    "values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That makes sense, but it's a lot of code to write and it runs slowly because \n",
    "it's pure Python.\n",
    "\n",
    "__Note:__ Just in case you aren't used to using operators like `+=`, that just \n",
    "means _add these two items and then store the result in the left item._ It is a more \n",
    "succinct way of writing `values[i] = values[i] + 5`. The code you see in these examples \n",
    "makes use of such operators whenever possible."
   ]
  },
  {
   "cell_type": "markdown",