numpy_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Tutorial\n",
    "\n",
    "NumPy is one of the most used package in Python. It provides multidimenional array object and all sorts of routine for operations on arrays. \n",
    "We will only scratch the surface of what NumPy is capable of in this tutorial. You can check out [their website](https://docs.scipy.org/doc/numpy/index.html) for more information.\n",
    "\n",
    "A good amount of the material in this notebook comes from:\n",
    "* [CS231n Python & NumPy Tutorial by Justin Johnson](http://cs231n.github.io/python-numpy-tutorial/)\n",
    "* [NumPy Quickstart Tutorial](https://docs.scipy.org/doc/numpy/user/quickstart.html)\n",
    "\n",
    "## For those that are familiar with Matlab\n",
    "\n",
    "Matlab and NumPy/SciPy have a lot in common. But there also many differences. We recommend you read the [Numpy for Matlab users webpage](https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html).\n",
    "\n",
    "## Prequisite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Basics\n",
    "\n",
    "The main object in NumPy is `ndarray`. It is a table of elements (usually numbers), all of the same type. In NumPy dimensions are called _axes_. Here are some important attributes of `ndarray`:\n",
    "\n",
    "* ndarray.ndim: The number of dimensions of the array.\n",
    "* ndarray.shape: The dimensions of the array.\n",
    "* ndarray.size: The total number of elements of the array.\n",
    "* ndarray.dtype: The type of the elements in the array.\n",
    "\n",
    "Here is an exmaple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "(2, 3)\n",
      "2\n",
      "int64\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3],[4, 5, 6]])\n",
    "print(a)\n",
    "print(a.shape)\n",
    "print(a.ndim)\n",
    "print(a.dtype)\n",
    "print(a.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array creation\n",
    "\n",
    "There are various ways to create NumPy arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]] \n",
      "\n",
      "[[0. 0.]\n",
      " [0. 0.]] \n",
      "\n",
      "[1. 1. 1.] \n",
      "\n",
      "[0 2 4 6 8] \n",
      "\n",
      "[[0.26456932 0.55416868 0.31622063]\n",
      " [0.12763405 0.88360159 0.59699571]\n",
      " [0.28773449 0.49498605 0.88727801]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3],[4, 5, 6]])    # Create by lists\n",
    "b = np.zeros((2, 2))    # Create an array full of zeros with dimension (2, 2)\n",
    "c = np.ones((3, ))    # Create an array full of ones with dimension (3, )\n",
    "d = np.arange(0, 10, 2)   # Create 1-d array from 0 to 10 spaced with 2\n",
    "e = np.random.random((3, 3))    # Create an array full of random numbers with dimension (3, 3)\n",
    "print(a, '\\n')\n",
    "print(b, '\\n')\n",
    "print(c, '\\n')\n",
    "print(d, '\\n')\n",
    "print(e, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array operation/math\n",
    "\n",
    "NumPy performs element-wise operation on default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6  8]\n",
      " [10 12]] \n",
      "\n",
      "[[-4 -4]\n",
      " [-4 -4]] \n",
      "\n",
      "[[ 5 12]\n",
      " [21 32]] \n",
      "\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]] \n",
      "\n",
      "[[ 1  4]\n",
      " [ 9 16]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2], [3, 4]])\n",
    "y = np.array([[5, 6], [7, 8]])\n",
    "print(x + y, '\\n')\n",
    "print(x - y, '\\n')\n",
    "print(x * y, '\\n')\n",
    "print(x / y, '\\n')\n",
    "print(x ** 2, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix/Vector inner product is perform by `np.dot()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22]\n",
      " [43 50]]\n",
      "9\n",
      "[ 9 27]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2], [3, 4]])\n",
    "y = np.array([[5, 6], [7, 8]])\n",
    "a = np.array([9, 0])\n",
    "b = np.array([1, 2])\n",
    "print(np.dot(x, y))\n",
    "print(np.dot(a, b))\n",
    "print(np.dot(x, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many other useful function in NumPy, to name a few:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "[5 7 9]\n",
      "[ 6 15] \n",
      "\n",
      "[3 6]\n",
      "[3 6] \n",
      "\n",
      "[1 4]\n",
      "[2.5 3.5 4.5] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3], \n",
    "              [4, 5, 6]])\n",
    "print(np.sum(x))          # Compute sum of all elements\n",
    "print(np.sum(x, axis=0))  # Compute sum of each column\n",
    "print(np.sum(x, axis=1), '\\n')  # Compute sum of each row\n",
    "\n",
    "print(np.max(x, axis=1))  # Compute max of each row\n",
    "print(x.max(1), '\\n')    # Same as the line above\n",
    "\n",
    "print(np.min(x, axis=-1))  # Compute min according to last dimension\n",
    "print(np.mean(x, axis=0), '\\n')  # Compute mean according of each column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the axis you apply the operation will have its dimension removed from the shape. This is useful to keep in mind when you're trying to figure out what axis corresponds to what.\n",
    "\n",
    "How can we compute the index of the max value of each row?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3], \n",
    "              [4, 5, 6]])\n",
    "print(np.argmax(x, axis=1)) # Compute index of max of each row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we want to convert dtype of an entire array, we can:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3], \n",
    "              [4, 5, 6]])\n",
    "print(x.astype('float'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many more usefule NumPy functions. We don't need to memorize all of them, because we can always google it! :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing, Slicing\n",
    "\n",
    "NumPy arrays can be indexed, sliced much like lists in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n",
      " 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71\n",
      " 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95\n",
      " 96 97 98 99]\n",
      "2\n",
      "99\n",
      "[2 3 4]\n",
      "[0 1 2 3 4]\n",
      "[90 91 92 93 94 95 96 97 98 99]\n",
      "[ 0 10 20 30 40]\n",
      "[99 89 79 69 59 49 39 29 19  9]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(100)\n",
    "print(a)\n",
    "print(a[2])\n",
    "print(a[-1])    # Retrieve last element\n",
    "print(a[2:5])\n",
    "print(a[:5])\n",
    "print(a[90:])\n",
    "print(a[:50:10])    # Retrieve from a[0:50], but sample every 10 elements\n",
    "print(a[::-10])    # Sample every 10 elements, but in reverse order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same method applys to multidimensional arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 0 0 3 3]\n",
      " [5 0 2 3 8]\n",
      " [9 4 8 8 6]\n",
      " [4 3 0 1 0]\n",
      " [0 5 4 0 9]]\n",
      "3\n",
      "[3 3 8 1 0]\n",
      "[[5 0 2 3 8]\n",
      " [9 4 8 8 6]]\n",
      "[7 0 0 3 3]\n"
     ]
    }
   ],
   "source": [
    "b = np.random.randint(0, 10, (5, 5))\n",
    "print(b)\n",
    "print(b[0, 3])\n",
    "print(b[:, 3])\n",
    "print(b[1:3, :])\n",
    "print(b[0])    # Indexing first dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes the array dimension is large. The __dots__ (`...`) represent as many colons as needed to produce a complete indexing tuple. For example, if x is an array with 5 axes, then\n",
    "* `x[1, 2, ...]` is equivalent to `x[1,2,:,:,:]`\n",
    "* `x[...,3]` to `x[:,:,:,:,3]`\n",
    "* `x[4,...,5,:]` to `x[4,:,:,5,:]`\n",
    "\n",
    "NumPy also supports indexing with ndarray, in two fashion: integer array, boolean array. This is also called fancy indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0]\n",
      " [5 1 0 6 9]\n",
      " [0 0 0 0 0]\n",
      " [3 4 2 1 4]\n",
      " [0 0 0 0 0]] \n",
      "\n",
      "[[False False False False False]\n",
      " [False False False  True  True]\n",
      " [False False False False False]\n",
      " [False False False False False]\n",
      " [False False False False False]] \n",
      "\n",
      "[[ 0  0  0  0  0]\n",
      " [ 5  1  0 10 10]\n",
      " [ 0  0  0  0  0]\n",
      " [ 3  4  2  1  4]\n",
      " [ 0  0  0  0  0]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(0, 10, (5, 5))\n",
    "b = [0, 2, 4]\n",
    "a[b, :] = 0    # Index with integer array\n",
    "print(a, '\\n')\n",
    "c = a > 5     \n",
    "a[c] = 10    # Index with boolean array\n",
    "print(c, '\\n')\n",
    "print(a, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shape manimulation\n",
    "\n",
    "There are also functions that manipulate shape of an array in NumPy. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 0 2 4]\n",
      " [3 2 8 6]\n",
      " [5 3 6 5]]\n",
      "(3, 4) \n",
      "\n",
      "[5 0 2 4 3 2 8 6 5 3 6 5] \n",
      "\n",
      "[[5 0]\n",
      " [2 4]\n",
      " [3 2]\n",
      " [8 6]\n",
      " [5 3]\n",
      " [6 5]] \n",
      "\n",
      "[[5 0]\n",
      " [2 4]\n",
      " [3 2]\n",
      " [8 6]\n",
      " [5 3]\n",
      " [6 5]] \n",
      "\n",
      "[[5 3 5]\n",
      " [0 2 3]\n",
      " [2 8 6]\n",
      " [4 6 5]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(10, size=(3, 4))\n",
    "print(a)\n",
    "print(a.shape, '\\n')\n",
    "\n",
    "print(a.flatten(), '\\n')    # Flatten the array\n",
    "print(a.reshape(6, 2), '\\n')    # Reshape the array to shape (6, 2)\n",
    "print(a.reshape(6, -1), '\\n')    # If a dimension is given as -1 in a reshaping operation, the other dimensions are automatically calculated:\n",
    "print(a.T, '\\n')    # Transpose the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy can also stack/concatenate arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 4)\n",
      "(3, 8)\n",
      "(2, 3, 4)\n",
      "(3, 4, 2)\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(10, size=(3, 4))\n",
    "b = np.random.randint(10, size=(3, 4))\n",
    "print(np.concatenate((a, b), axis=0).shape)    # Concatenate arrays on the first dimension\n",
    "print(np.concatenate((a, b), axis=-1).shape)    # Concatenate arrays on the last dimension\n",
    "print(np.stack((a, b), axis=0).shape)    # Prepends array dimension, then concatenate arrays on the first dimension\n",
    "print(np.stack((a, b), axis=-1).shape)    # Append array dimension, then concatenate arrays on the last dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, there are quick ways to expand an array with a dummy dimension or reduce an array's dummy dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 5, 6)\n",
      "(1, 5, 6, 1)\n",
      "(5, 6)\n",
      "(5, 6, 1)\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(10, size=(5, 6))\n",
    "a = np.expand_dims(a, axis=0)\n",
    "print(a.shape)    # Expand array dimension by prepending a dimension\n",
    "a = np.expand_dims(a, axis=-1)\n",
    "print(a.shape)    # Expand array dimension by appending a dimension\n",
    "\n",
    "print(np.squeeze(a).shape)    # Reduce all dummy dimensions\n",
    "print(np.squeeze(a, axis=0).shape)    # Reduce a specific dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "Many of the operations we've looked at above involved arrays of the same rank.\n",
    "However, many times we might have a smaller array and use that multiple times to update an array of a larger rank.\n",
    "For example, consider the below example of shifting the mean of each column from the elements of the corresponding column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "[2.  3.5 5. ]\n",
      "(3,)\n",
      "\n",
      " [[-1.  -1.5 -2. ]\n",
      " [ 1.   1.5  2. ]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [3, 5, 7]])\n",
    "print(x.shape)\n",
    "\n",
    "col_means = x.mean(axis=0)\n",
    "print(col_means)\n",
    "print(col_means.shape)    # col_means has a smaller rank than x!\n",
    "\n",
    "mean_shifted = x - col_means    # col_means automatically expands dimension\n",
    "print('\\n', mean_shifted)\n",
    "print(mean_shifted.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or even just multiplying a matrix by 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  6]\n",
      " [ 6 10 14]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [3, 5, 7]])\n",
    "print(x * 2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Broadcasting two arrays together follows these rules:\n",
    "1. If the arrays do not have the same rank, __prepend__ the shape of the lower rank array with __1s__ until both shapes have the same length.\n",
    "2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension, or __if one of the arrays has size 1 in that dimension__.\n",
    "3. The arrays can be broadcast together if they are compatible in all dimensions.\n",
    "4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of shapes of the two input arrays.\n",
    "5. In any dimension where one array had size 1 and the other array had size greater than 1, the first array behaves as if it were __copied along that dimension__.\n",
    "\n",
    "For example, when subtracting the columns above, we had arrays of shape (2, 3) and (3,).\n",
    "1. These arrays do not have same rank, so we prepend the shape of the lower rank one to make it (1, 3).\n",
    "2. (2, 3) and (1, 3) are compatible (have the same size in the dimension, or if one of the arrays has size 1 in that dimension).\n",
    "3. Can be broadcast together!\n",
    "4. After broadcasting, each array behaves as if it had shape equal to (2, 3).\n",
    "5. The smaller array will behave as if it were copied along dimension 0.\n",
    "\n",
    "Let's try to subtract the mean of each row!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 5.]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (2,3) (2,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-9f7214ab90e7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mrow_means\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow_means\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mmean_shifted\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mrow_means\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3) (2,) "
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [3, 5, 7]])\n",
    "row_means = x.mean(axis=1)\n",
    "print(row_means)\n",
    "mean_shifted = x - row_means"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happened?\n",
    "\n",
    "Answer: If we following broadcasting rule 1, then we'd prepend a 1 to the smaller rank array ot get (1, 2). However, the last dimensions don't match now between (2, 3) and (1, 2), and so we can't broadcast.\n",
    "\n",
    "Take 2, reshaping the row means to get the desired behavior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "[[2.]\n",
      " [5.]]\n",
      "(2, 1)\n",
      "[[-1.  0.  1.]\n",
      " [-2.  0.  2.]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [3, 5, 7]])\n",
    "print(x.shape)\n",
    "\n",
    "row_means = x.mean(axis=1).reshape((-1, 1))\n",
    "print(row_means)\n",
    "print(row_means.shape)\n",
    "\n",
    "mean_shifted = x - row_means\n",
    "print(mean_shifted)\n",
    "print(mean_shifted.shape) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Views vs. Copies\n",
    "\n",
    "Unlike a copy, in a **view** of an array, the data is shared between the view and the array. Sometimes, our results are copies of arrays, but other times they can be views. Understanding when each is generated is important to avoid any unforeseen issues.\n",
    "\n",
    "Views can be created from a slice of an array, changing the dtype of the same data area (using arr.view(dtype), not the result of arr.astype(dtype)), or even both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original:\n",
      " [0 1 2 3 4]\n",
      "Array After Modified View:\n",
      " [ 0  1 -1  3  4]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(5)\n",
    "print('Original:\\n', x)\n",
    "\n",
    "# Modifying the view will modify the array\n",
    "view = x[1:3]\n",
    "view[1] = -1\n",
    "print('Array After Modified View:\\n', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if we use fancy indexing, the result will actually be a copy and not a view:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original:\n",
      " [0 1 2 3 4]\n",
      "Copy:\n",
      " [ 1 -1]\n",
      "Array After Modified Copy:\n",
      " [0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(5)\n",
    "print('Original:\\n', x)\n",
    "\n",
    "# Modifying the result of the selection due to fancy indexing\n",
    "# will not modify the original array.\n",
    "copy = x[[1, 2]]\n",
    "copy[1] = -1\n",
    "print('Copy:\\n', copy)\n",
    "print('Array After Modified Copy:\\n', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original:\n",
      " [0 1 2 3 4]\n",
      "Copy:\n",
      " [2 3 4]\n",
      "Modified Array:\n",
      " [ 0  1  2 10  4]\n",
      "Copy After Modified Array:\n",
      " [2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# Another example involving fancy indexing\n",
    "x = np.arange(5)\n",
    "print('Original:\\n', x)\n",
    "\n",
    "copy = x[x >= 2]\n",
    "print('Copy:\\n', copy)\n",
    "x[3] = 10\n",
    "print('Modified Array:\\n', x)\n",
    "print('Copy After Modified Array:\\n', copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Speed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shrink(array):\n",
    "    output = np.empty(len(array))\n",
    "    for i in range(len(array)):\n",
    "        output[i] = array[i] / 2\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "454 ms ± 4.19 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "1.79 ms ± 25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "FPS : 2 / 427\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "W,H = 1920,1080\n",
    "array = np.random.rand(W*H)\n",
    "\n",
    "%timeit shrink(array)\n",
    "%timeit array/2\n",
    "\n",
    "t0 = time.time()\n",
    "shrink(array)\n",
    "t1 = time.time()\n",
    "array/2\n",
    "t2 = time.time()\n",
    "print('FPS :', int(1/(t1-t0)),'/',int(1/(t2-t1)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Last Tips\n",
    "\n",
    "* NumPy is an incredibly powerful library for computation providing both massive efficiency gains and convenience.\n",
    "* There still lots of NumPy functions not covered in this tutorial. So don't afraid to consult Google!\n",
    "* Always keep track of array shapes. Especially, NumPy automatically squeeze arrays after most functions.\n",
    "* Watch out for views & copies.\n",
    "* The speed of fancy indexing (integer array indexing vs. boolean array indexing) can differs a lot when processing large arrays."
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}