01.My_own_decks/Programming_languages/Numpy/numpy_OLIVIER.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "I wanted to revise what i've learnt so far when dealing with numpy... So i've started to create a cheat-sheet. Most of what you'll find below is taken from Khalil El Mahrsi's course that you can find on his website [smellydatascience.com](https://smellydatascience.com/teaching/python-for-data-science-2021/02-numpy.html) published under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License (CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/). So all the credits goes to him. I've added few tips found here and there... \n",
    "\n",
    "I've also found a great [Visual Intro to NumPy and Data Representation\n",
    "](https://jalammar.github.io/visual-numpy/) by Jay Alammar that is really interesting ! so let's begin \n",
    "\n",
    "Let's begin :)\n",
    "\n",
    "__What is NumPy?__  \n",
    "\n",
    "A fundamental Python package for scientific computation\n",
    "\n",
    "__Which Python data science packages reliy on NumPy?__\n",
    "\n",
    "Many, among others: pandas, scikit-learn, matplotlib...\n",
    "\n",
    "__What do NumPy provide?__\n",
    "- An object type (the ndarray) for representing multidimensional arrays (vectors, matrices, tensors, ...)\n",
    "- Optimized routines and array operations\n",
    "- Shape manipulation (indexing and slicing, reshaping, ...)\n",
    "- Linear algebra and mathematical operations\n",
    "- Statistics\n",
    "- Random simulation\n",
    "- Discrete Fourier transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installing & importing Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conda install numpy\n",
    "pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.18.5'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asking For Help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data-type of the array's elements.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "None\n",
      "\n",
      "Returns\n",
      "-------\n",
      "d : numpy dtype object\n",
      "\n",
      "See Also\n",
      "--------\n",
      "numpy.dtype\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> x\n",
      "array([[0, 1],\n",
      "       [2, 3]])\n",
      ">>> x.dtype\n",
      "dtype('int32')\n",
      ">>> type(x.dtype)\n",
      "<type 'numpy.dtype'>\n"
     ]
    }
   ],
   "source": [
    "np.info(np.ndarray.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an array from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  9,  8,  7,  6,  5])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([10, 9, 8, 7, 6, 5])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np arrays are subscriptable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "slicing is also supported"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 7, 5])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  9])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np arrays are mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  10,    9,    8, 1000,    6,    5])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3] = 1000\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Why Not Just Use Lists?__  \n",
    "Lists are general-purpose sequences.\n",
    "- Efficient when it comes to insertions, deletions, appending, ...\n",
    "- No support for vectorized operations (e.g., element-wise addition or multiplication)\n",
    "- Mixed types → must store type info for every item \n",
    "\n",
    "NumPy arrays are (way) more efficient\n",
    "- Fixed type (i.e., all elements of an array have the same type)\n",
    "    - Less in-memory space  \n",
    "    - No type checking when iterating  \n",
    "- Use contiguous memory → faster access and better caching\n",
    "- Relies on highly-optimized compiled C code\n",
    "- Support of vectorization and broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np.int64   \n",
    "np.float32   \n",
    "np.complex   \n",
    "np.bool      \n",
    "np.object    \n",
    "np.string_   \n",
    "np.unicode_   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Arrays vs. Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1, l2 = [0, 1, 2, 3], [4, 5, 6, 7]\n",
    "a1, a2 = np.array(l1), np.array(l2)\n",
    "l1 + l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "adding two np arrays results in...  \n",
    "elt-wise addition :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  6,  8, 10])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 + a2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the * results in list replication  \n",
    "...but results in elt-wise multiplication for ndarrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 3, 6, 9])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * a1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "trying to multiply lists raises an exception...  \n",
    "...but is supported for ndarrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-ec7519df584c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ml1\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0ml2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'list'"
     ]
    }
   ],
   "source": [
    "l1 * l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 * a2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__What make NumPy significantly faster than built-in Python lists?__  \n",
    "Vectorization, fixed types, compiled C implementations, etc..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = list(range(10000))\n",
    "a = np.array(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "427 µs ± 11.2 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -n 10000 -r 10\n",
    "sum([2 * i for i in l])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.7 µs ± 198 ns per loop (mean ± std. dev. of 10 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -n 10000 -r 10\n",
    "(2 * a).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Basics\n",
    "\n",
    "![title](1.png)   \n",
    "Attributes of interest:\n",
    "- shape\n",
    "- ndim\n",
    "- dtype\n",
    "- itemsize\n",
    "- nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "number of dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2, 3, 4])    \n",
    "a.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "shape (length along each dimension)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "itmen size in bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "total memory size in bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "positional indexing works the same as lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "same goes for slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "arrays are mutable but beware of type coercion!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3, 12])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[4] = 12.5\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-Dimensional Arrays\n",
    "\n",
    "For the sake of simplification, examples shown here use two-dimensional arrays. The principles remains the same for arrays of higher dimensions.\n",
    "![title](2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([\n",
    "    [0, 1, 2, 3, 4],  # 1st row\n",
    "    [0, 1, 2, 3, 4]], # 2nd row\n",
    "    # type eventually specified\n",
    "    dtype=np.int16)\n",
    "\n",
    "b.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int16')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For 3D arrays:\n",
    "![title](21.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Array Indexing\n",
    "NumPy's basic array indexing and slicing are extensions of Python's indexing and slicing to N dimensions\n",
    "- One slice or index per dimension\n",
    "- Separated by a comma (,)   \n",
    "\n",
    "Similar rules apply to omitted parts of a slice\n",
    "- d_i_start omitted → 0\n",
    "- d_i_end omitted → array.shape[i]\n",
    "- d_i_step omitted → 1   \n",
    "\n",
    "If a dimension is to be fully retained, use a colon (:) as the corresponding slice\n",
    "\n",
    "Syntax (indexing)   \n",
    "array[i, j, ...]\n",
    "\n",
    "Syntax (slicing)  \n",
    "array[d_0_start: d_0_end: d_1_step, d_1_start: d_1_end: d_1_step, ...]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Array Indexing\n",
    "\n",
    "Access a single item\n",
    "![title](3.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.array([\n",
    "    [0, 1, 2, 3, 4],\n",
    "    [5, 6, 7, 8, 9]])\n",
    "d[1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access a whole row\n",
    "\n",
    "![title](4.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[0, :] # d[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asscess a whole column\n",
    "\n",
    "![title](./5.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 8])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[:, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](6.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [5, 6, 7]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[:, :3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[1, 2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](8.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [6, 8]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[:, 1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [6, 8]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[:, [1, 3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Content Modification\n",
    "- NumPy arrays are mutable   \n",
    "- Indexing and slicing can be used in assignment statements to modify items\n",
    "- Values are coerced to the array's data type (e.g., the decimal part of a float will be truncated when it is inserted in an array of integers)\n",
    "\n",
    "![title](9.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6, 12,  8,  9]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = np.array([\n",
    "    [0, 1, 2, 3, 4],\n",
    "    [5, 6, 7, 8, 9]])\n",
    "\n",
    "e[1, 2] = 12.9\n",
    "e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify multiple items through slicing\n",
    "\n",
    "![title](10.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1, -2, 42, -1],\n",
       "       [ 5,  6,  7,  8,  9]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[0, 2:] = [-2, 42, -1]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify multiple items through slicing (with broadcasting)\n",
    "\n",
    "\n",
    "![title](11.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7,  1, 13, 42, 18],\n",
       "       [ 7,  6, 13,  8, 18]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[:, ::2] = [7, 13, 18]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify multiple items through boolean filtering (will be presented later)\n",
    "\n",
    "![title](12.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7,  1, -3, -3, -3],\n",
       "       [ 7,  6, -3,  8, -3]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[d >= 13] = -3\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns copy with values appended. NOT in-place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([0,1,2,3,4])\n",
    "y = np.append(x, [5,6,7,8,9])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When dealing with arrays with higher dimensions, we use : for selecting the whole indices along each axis. We can also use … can select all indices across multiple axes. The exact number of axes expanded is inferred."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5],\n",
       "        [ 6,  7,  8],\n",
       "        [ 9, 10, 11],\n",
       "        [12, 13, 14]],\n",
       "\n",
       "       [[15, 16, 17],\n",
       "        [18, 19, 20],\n",
       "        [21, 22, 23],\n",
       "        [24, 25, 26],\n",
       "        [27, 28, 29]]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array(range(30)).reshape(2, 5, -1)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[15, 16, 17],\n",
       "       [18, 19, 20],\n",
       "       [21, 22, 23],\n",
       "       [24, 25, 26],\n",
       "       [27, 28, 29]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[1, ...] #Same as [1, :, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  5,  8, 11, 14],\n",
       "       [17, 20, 23, 26, 29]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[..., 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert an item in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0, 100,   1,   2,   3,   4])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "np.insert(a, 1, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete an item in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 3, 1, 0])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(5)[: :-1]\n",
    "np.delete(a, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arithmetic Operations and Basic Math\n",
    "- NumPy arrays support a wide range of element-wise arithmetic operations (sum, substraction, multiplication, ...)\n",
    "- NumPy also provides a wide range of mathematical functions\n",
    "    - Trigonometric and hyperbolic functions\n",
    "    - Sums, products, and differences over axes\n",
    "    - Logarithms and exponents\n",
    "    - ...\n",
    "    \n",
    "Most array operations can be vectorized. Do not use for loops unless it is absolutely necessary (very rare)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "element-wise sum of 2 arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 5, 7])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "b = np.array([3, 4, 5])\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "element-wise product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 16, 50])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "b = np.array([3, 4, 5])\n",
    "a * b * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "element-wise power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1, 32])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "b = np.array([3, 4, 5])\n",
    "a ** b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "trigonometric functions (sin, cos, tan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.84147098, 0.99999968])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 3.14/2])\n",
    "np.sin(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "hyperbolic functions (sinh, cosh, tanh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.76159416, 0.91702576])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 3.14/2])\n",
    "np.tanh(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "log and exponential functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 2.30258509, 4.60517019])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 10, 100])\n",
    "np.log(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sum all the matrix's elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([\n",
    "    [0, 1, 2, 3, 4],\n",
    "    [5, 6, 7, 8, 9]])\n",
    "\n",
    "np.sum(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sum along the rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  7,  9, 11, 13])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([\n",
    "    [0, 1, 2, 3, 4],\n",
    "    [5, 6, 7, 8, 9]])\n",
    "\n",
    "np.sum(m, axis = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sum  along the columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 35])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([\n",
    "    [0, 1, 2, 3, 4],\n",
    "    [5, 6, 7, 8, 9]])\n",
    "\n",
    "np.sum(m, axis = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "difference along the columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [1, 1, 1, 1]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([\n",
    "    [0, 1, 2, 3, 4],\n",
    "    [5, 6, 7, 8, 9]])\n",
    "\n",
    "np.diff(m, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "product along the rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  6, 14, 24, 36])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([\n",
    "    [0, 1, 2, 3, 4],\n",
    "    [5, 6, 7, 8, 9]])\n",
    "\n",
    "np.prod(m, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Element-wise comparison between 2 arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([0, 2, 0])\n",
    "a == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array-wise comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_equal(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Element-wise comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "a < 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "- Broadcasting designates how NumPy conducts arithmetic operations on arrays with different shapes\n",
    "- If the arrays have compatible dimensions\n",
    "    - The smaller array is “replicated” to match the bigger array's dimensions\n",
    "    - The operation is conducted element-wise as usual\n",
    "- If the arrays have incompatible dimensions, a ValueError is raised\n",
    "- Dimensions are compatible if\n",
    "    - They are equal, or\n",
    "    - One of them is 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Broadcasting a scalar\n",
    "![title](13.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12],\n",
       "       [13, 14, 15]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], \n",
    "             [3, 4, 5]])\n",
    "a + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Broadcasting a row\n",
    "![title](14.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 21, 32],\n",
       "       [13, 24, 35]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], \n",
    "             [3, 4, 5]])\n",
    "b = np.array([10, 20, 30])\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Broadcasting a colum\n",
    "![title](15.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 10,  11,  12],\n",
       "       [103, 104, 105]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], \n",
    "             [3, 4, 5]])\n",
    "b = np.array([[10], [100]])\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Creation Routines\n",
    "\n",
    "NumPy provides useful [routines for creating arrays (filled with constant values, from numeric ranges, ...)](https://numpy.org/doc/stable/reference/routines.array-creation.html)\n",
    "![title](16.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [1, 1],\n",
       "       [1, 1]], dtype=int32)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3, 2), dtype=np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[42, 42, 42],\n",
       "       [42, 42, 42]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full([2, 3], 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[66., 66.],\n",
       "       [66., 66.]], dtype=float16)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1], [3, 4]])\n",
    "np.full_like(a, 66, dtype=np.float16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as np.eye(4)\n",
    "np.identity(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an empty array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.0e+000, 4.9e-324],\n",
       "       [9.9e-324, 1.5e-323],\n",
       "       [2.0e-323, 2.5e-323]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0],\n",
       "       [0, 1, 0, 0],\n",
       "       [0, 0, 2, 0],\n",
       "       [0, 0, 0, 3]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(np.arange(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "creates an array from start to stop in step.  \n",
    "np.arange(start, stop, step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 1.1, 0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "given an array containing some numbers and a range, limit the numbers to that range.  \n",
    "For numbers outside the range, it returns the edge value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3, 3, 3, 4, 5, 5, 5, 5, 5])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "np.clip(a, 3, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "return an array with the evenly spaced numbers from strat to stop  \n",
    "np.linespace(start, stop, num) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  5., 10., 15., 20.])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 20, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is convenient to draw math function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "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 matplotlib.pyplot as plt\n",
    "\n",
    "def f(x): return x**2 + 2*x + 1\n",
    "\n",
    "x = np.linspace(-7, 5, 100)\n",
    "plt.plot(x, f(x))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.e+01, 1.e+03, 1.e+05])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(1, 5, num=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   1.,   10.,  100., 1000.])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.geomspace(1, 1000, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Number Generation Routines\n",
    "NumPy provides useful [random number generation and sampling routines](https://numpy.org/doc/stable/reference/random/index.html)\n",
    "![title](17.png)\n",
    "*These are the legacy operations that you will see the most in code examples. NumPy also provides updated routines (recommended)\n",
    "\n",
    "** __distribution__ is to be replaced by the distribution's name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "generates random numbers uniformly distributed between 0 to 1 in a given shape.  \n",
    "rand() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.09073019, 0.81433141, 0.86814649, 0.54149361, 0.8167305 ])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.37454012, 0.95071431],\n",
       "       [0.73199394, 0.59865848],\n",
       "       [0.15601864, 0.15599452]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fix seed\n",
    "np.random.seed(42)\n",
    "np.random.rand(3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "generates an array (size=size) of random integers in the range (low — high).  \n",
    "randint(low, high, size) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([71, 34, 91, 80, 40])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "np.random.randint(20, 100, size=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "randomly choose samples from a given array. It is also possible to pass a probability.  \n",
    "random.choice()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 2, 2, 4, 3, 2, 5, 4, 1])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [0, 1, 2, 3, 4, 5]\n",
    "np.random.choice(x, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 3, 7, 4, 6])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "np.random.seed(42)\n",
    "\n",
    "# default w/replacement\n",
    "np.random.choice(a, size=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "np.random.binomial(n=1, p=0.5, size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "generates random numbers in a normal distribution.  \n",
    "randn() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "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": [
    "plt.hist(np.random.randn(10000))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra\n",
    "NumPy provides [optimized implementations of linear algebra functions](https://numpy.org/doc/stable/reference/routines.linalg.html)\n",
    "![title](18.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "b = np.array([3, 4, 5])\n",
    "np.dot(a, b)\n",
    "# equivalent to np.sum(a * b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dot product (or more generally matrix multiplication) is done with a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 1],\n",
       "       [9, 7]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "b = np.array([[0, 1], [1, 1], [1, 0]])\n",
    "np.dot(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python 3.5, the @ operator was added as an infix operator for matrix multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0],\n",
       "       [0, 1, 0, 0],\n",
       "       [0, 0, 4, 0],\n",
       "       [0, 0, 0, 9]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.diag(np.arange(4))\n",
    "x@x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2],\n",
    "              [3, 4, 5],\n",
    "              [7, 8, 9]])\n",
    "\n",
    "np.trace(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.7416573867739413"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "# equivalent: np.sqrt(np.dot(a, a))\n",
    "np.linalg.norm(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.881943016134134"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3],\n",
    "              [4, 5, 6],\n",
    "              [7, 8, 9]])\n",
    "\n",
    "# matrix's Frobenius norm\n",
    "np.linalg.norm(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 468,  576,  684],\n",
       "       [1062, 1305, 1548],\n",
       "       [1656, 2034, 2412]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3],\n",
    "              [4, 5, 6],\n",
    "              [7, 8, 9]])\n",
    "\n",
    "# matrix's Frobenius norm\n",
    "np.linalg.matrix_power(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 3, 6],\n",
       "       [1, 4, 7],\n",
       "       [2, 5, 8]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(9).reshape(3, -1)\n",
    "# same as a.T\n",
    "np.transpose(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistics\n",
    "NumPy provides multiple [routines for statistics](https://numpy.org/doc/stable/reference/routines.statistics.html)\n",
    "![title](19.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 4, -3],\n",
    "              [0, 7, 2],\n",
    "              [9, 3, 4]])\n",
    "\n",
    "np.mean(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.5, 3.5, 6. ])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 4],\n",
    "              [0, 7],\n",
    "              [9, 3]])\n",
    "\n",
    "np.mean(a, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 4.])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 4, -3],\n",
    "              [0, 7, 2],\n",
    "              [9, 3, 4]])\n",
    "\n",
    "np.median(a, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 7, 4])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 4, -3],\n",
    "              [0, 7, 2],\n",
    "              [9, 3, 4]])\n",
    "\n",
    "# np.max(a, axis=0) also works\n",
    "np.amax(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3,  0,  3])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 4, -3],\n",
    "              [0, 7, 2],\n",
    "              [9, 3, 4]])\n",
    "\n",
    "np.min(a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "returns the indices of the max values along an axis.  \n",
    "useful in object classification and detection to find the object with the highest probability.  \n",
    "There are also similar functions like argmin() , argwhere() , argpartition()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 1])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 4, -3],\n",
    "              [0, 7, 2],\n",
    "              [9, 3, 4]])\n",
    "\n",
    "# index of min along each col\n",
    "np.argmin(a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For an array arr, np.argmax(arr), np.argmin(arr), and np.argwhere(condition(arr)) return the indices of maximum values, minimum values, and values that satisfy a user-defined condition respectively. While these arg functions are widely used, we often overlook the function np.argsort() that returns the indices that would sort an array.\n",
    "   \n",
    "We can use np.argsort to sort values of arrays according to another array. Here is an example of sorting student names using their exam scores. The sorted name array can also be transformed back to its original order using np.argsort(np.argsort(score))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Danny', 'Fanny', 'Charlie', 'Ben', 'Ada', 'George', 'Eden'],\n",
       "      dtype='<U7')"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score = np.array([70, 60, 50, 10, 90, 40, 80])\n",
    "name = np.array(['Ada', 'Ben', 'Charlie', 'Danny', 'Eden', 'Fanny', 'George'])\n",
    "\n",
    "# # an array of names in ascending order of their scores\n",
    "sorted_names = name[np.argsort(score)]\n",
    "sorted_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Ada', 'Ben', 'Charlie', 'Danny', 'Eden', 'Fanny', 'George'],\n",
       "      dtype='<U7')"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_names[np.argsort(np.argsort(score))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping Arrays\n",
    "[Array manipulation routines](https://numpy.org/doc/stable/reference/routines.array-manipulation.html) can be used to change array shapes, join arrays, ...\n",
    "![title](20.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "reshape a multidimensional array to 1D array  \n",
    "flatten a into a 1-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "reshape the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "\n",
    "a.reshape(3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can use -1 , numpy calculates the dimension for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2, 3, 4, 5])\n",
    "\n",
    "a.reshape((2, -1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "stack arrays horizontally   \n",
    "(arrays are provided as tuples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  0, 10, 20],\n",
       "       [ 3,  4,  5, 30, 40, 50]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "b = np.array([[0, 10, 20], [30, 40, 50]])\n",
    "np.hstack((a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "stack arrays horizontally   \n",
    "(arrays are provided as tuples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 0, 10, 20],\n",
       "       [30, 40, 50]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "b = np.array([[0, 10, 20], [30, 40, 50]])\n",
    "c = np.vstack((a, b))\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "split array vertically into 4 arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[0, 1, 2]]),\n",
       " array([[3, 4, 5]]),\n",
       " array([[ 0, 10, 20]]),\n",
       " array([[30, 40, 50]])]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "b = np.array([[0, 10, 20], [30, 40, 50]])\n",
    "c = np.vstack((a, b))\n",
    "\n",
    "np.vsplit(c, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "how to insert a new axis at a user-defined axis position ?  \n",
    "\n",
    "with np.newaxis, this operation expands the shape of an array by one unit of dimension. While this can also be done by np.expand_dims(), using np.newaxis is much more readable and arguably more elegant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5, 4, 25)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array(range(1000)).reshape(2,5,4,-1)\n",
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1, 5, 4, 25)"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[..., np.newaxis, :, :, :].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove single-dimensional entries from the shape of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0],\n",
       "        [1],\n",
       "        [2]]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[[0], [1], [2]]])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.squeeze(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.squeeze(x, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced Indexing\n",
    "In addition to standard (basic) Python indexing, NumPy supports a more advanced indexing syntax\n",
    "- Using integer array indexing\n",
    "- With boolean “masking”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "an example of advanced integer array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23, 20, -7])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([\n",
    "    [-2, 50, 23, 30],\n",
    "    [42, -7, -8, 11],\n",
    "    [40, 20, 15, 17]\n",
    "])\n",
    "\n",
    "a[[0, 2, 1], [2, 1, 1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "positions to retain on each row using the a boolean ndarray to mask / filter values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 42, -7, -8, 20, 17])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([\n",
    "    [-2, 50, 23, 30],\n",
    "    [42, -7, -8, 11],\n",
    "    [40, 20, 15, 17]\n",
    "])\n",
    "\n",
    "filter = np.array([\n",
    "    [False, False, False, True ],\n",
    "    [True,  True,  True,  False],\n",
    "    [False, True,  False, True ]\n",
    "])\n",
    "\n",
    "a [filter]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "conducts elt-wise truth value testing -> result used as filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2, -7, -8])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([\n",
    "    [-2, 50, 23, 30],\n",
    "    [42, -7, -8, 11],\n",
    "    [40, 20, 15, 17]\n",
    "])\n",
    "\n",
    "a[a < 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "boolean ndarrays can be combined with & (and) and | (or)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23, 30, 11, 20, 15, 17])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([\n",
    "    [-2, 50, 23, 30],\n",
    "    [42, -7, -8, 11],\n",
    "    [40, 20, 15, 17]\n",
    "])\n",
    "\n",
    "a[(a > 10) & (a < 40)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2, 50, 42, -7, -8])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[(a < 0) | (a > 40)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "advanced indexes can be used to modify elts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[99, 99, 23, 30],\n",
       "       [99, 99, 99, 11],\n",
       "       [40, 20, 15, 17]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([\n",
    "    [-2, 50, 23, 30],\n",
    "    [42, -7, -8, 11],\n",
    "    [40, 20, 15, 17]\n",
    "])\n",
    "\n",
    "a[(a < 0) | (a > 40)] = 99\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy has a submodule numpy.ma that supports data arrays __with masks__. A masked array contains an ordinary numpy array and a mask that __indicates the position of invalid entries__.  \n",
    "\n",
    "np.ma.MaskedArray(data=arr, mask=invalid_mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "masked_array(data=[1, 2, 3, --, 5],\n",
       "             mask=[False, False, False,  True, False],\n",
       "       fill_value=999999)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy.ma as ma\n",
    "x = np.array([1, 2, 3, -1, 5])\n",
    "\n",
    "mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])\n",
    "mx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other tips and tricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "returns the values in an array that are not in another array.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "b = np.array([4, 5, 6, 7, 8, 9])\n",
    "np.setdiff1d(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.setdiff1d(b, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "returns the intersection of 2 arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "b = np.array([4, 5, 6, 7, 8, 9])\n",
    "np.intersect1d(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "returns elements chosen from x or y depending on condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['fail', 'pass', 'pass', 'fail'], dtype='<U4')"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exam_scores = np.array([40, 80, 90, 20])\n",
    "np.where(exam_scores > 60, 'pass', 'fail')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the x and y are not passed to the np.where , the index position of the elements that meet the condition will be returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 2]),)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(exam_scores > 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "how to sort an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([3, 2, 1])\n",
    "a.sort()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 2, 1],\n",
       "       [9, 8, 6]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([\n",
    "    [9, 8, 6],\n",
    "    [3, 2, 1]\n",
    "])\n",
    "a.sort(axis=0)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "a[ : :-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a copy, change the original array, and display both arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([42,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "c = arr.copy()\n",
    "arr[0] = 42\n",
    "\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a view, change the original array, and display both arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([42,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "v = arr.view()\n",
    "arr[0] = 42\n",
    "\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([42,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a view, change the view, and display both arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([31,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "v = arr.view()\n",
    "v[0] = 31\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([31,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check if an array owns the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "x = arr.copy()\n",
    "y = arr.view()\n",
    "\n",
    "print(x.base)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "print(y.base)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Views vs Copies: The main differences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Modifying a view modifies the base (original) array, whereas modifying a copy does not modify the base array.\n",
    "- Making a copy takes more time, often 1.5x-2x longer.\n",
    "- A view has the same base as its base array. A copy does not.\n",
    "(See section above ‘Checking if something is a copy’ for what this means.)\n",
    "- A view also shares memory with the base array, whereas a copy does not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking if something is a copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "b = np.random.randn(5,2)\n",
    " \n",
    "# view\n",
    "v = b[:3, :]  \n",
    "print(v.base is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# copy\n",
    "c = b[[0,1,2],:]  \n",
    "print(c.base is b)"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}