2_numpy/0_intro_to_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<table style=\"border:none\">\n",
    "    <tr style=\"border:none\">\n",
    "    <th style=\"border:none\">\n",
    "        <a  href='https://colab.research.google.com/github/AmirMardan/ml_course/blob/main/2_numpy/0_intro_to_numpy.ipynb'><img src='https://colab.research.google.com/assets/colab-badge.svg'></a>\n",
    "    </th>\n",
    "    <th style=\"border:none\">\n",
    "        <a  href='https://github1s.com/AmirMardan/ml_course/blob/main/2_numpy/0_intro_to_numpy.ipynb'><img src='../imgs/open_vscode.svg' height=20px width=115px></a>\n",
    "    </th>\n",
    "    </tr>\n",
    "</table>\n",
    "</center>\n",
    "\n",
    "\n",
    "This notebook is created by <a href='https://amirmardan.github.io'> Amir Mardan</a>. For any feedback or suggestion, please contact me via my <a href=\"mailto:mardan.amir.h@gmail.com\">email</a>, (mardan.amir.h@gmail.com).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src='img/numpy.png' width='300px'>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='top'></a>\n",
    "# Introdunction to NumPy\n",
    "\n",
    "This notebook will cover the following topics:\n",
    "\n",
    "- [Introduction](#introduction)\n",
    "- [NumPy vs list](#numpy_list) \n",
    "- [1. Creating a NumPy array](#creating) \n",
    "    - [Creating arrays from lists](#creating_with_list) \n",
    "    - [Special arrays](#special_array) \n",
    "- [2 Attributes of arrays](#attributes_array) \n",
    "- [3. Data Selection](#data_election) \n",
    "    - [Array indexing](#indexing) \n",
    "    - [Array slicing](#slicing) \n",
    "    - [Array view vs copy](#view_copy) \n",
    "    - [Conditional selection](#conditional) \n",
    "- [4. Array manipulation](#manipulation) \n",
    "    - [Shape of an array](#shape) \n",
    "    - [Joining arrays](#joining) \n",
    "    - [Splitting of arrays](#splitting) \n",
    "- [5. Computation on NumPy arrays ](#computation) \n",
    "- [6. Aggregations](#aggregations) \n",
    "    - [Summation](#summation) \n",
    "    - [Minimum and maximum](#min_max) \n",
    "    - [Variance and standard deviation](#var_std) \n",
    "    - [Mean and median](#mean_median) \n",
    "    - [Find index](#find_index) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='introduction'></a>\n",
    "## Introduction \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is a library for working large, multi-dimensional arrays and matrices.\n",
    "Created by **Travis Oliphant**, first time released in 1995 as *Numeric* and changed to *NumPy* in 2006.\n",
    "\n",
    "<center><img src='./img/travis.jpeg' alter='tavis' width=300px></center>\n",
    "\n",
    "The array object in NumPy is called `ndarray`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='numpy_list'></a>\n",
    "## NumPy vs list \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Advantages of using NumPy arrays over Python lists**\n",
    "\n",
    "- Numpy takes less memory\n",
    "- Numpy is faster\n",
    "- Numpy has better functionality\n",
    "\n",
    "Let's try if these statements are true. But first, we need to tell Python, that we want to use Numpy. To do so, we import this package. Generally, a Python package can be imported at the beginning of a script as\n",
    "\n",
    "```Python\n",
    " import module\n",
    "```\n",
    "To make us comfortable, Python lets us pick a nickname for a module we import using the keyword `as`,\n",
    "\n",
    "```Python\n",
    " import module as nickname\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Import numpy \n",
    "\n",
    "import numpy as np\n",
    "\n",
    "n = 1000\n",
    "\n",
    "# Make an array of zeros\n",
    "numpy_version = np.zeros(n)\n",
    "\n",
    "list_version = list(numpy_version)\n",
    "\n",
    "print(type(list_version), type(numpy_version))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Danger:</b> Please note that the addition of two lists causes concatenation!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numpy_based():\n",
    "    return  numpy_version + 5\n",
    "    \n",
    "    \n",
    "def list_based():\n",
    "    return [list_version[i] + 5 for i in range(len(list_version))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "225 µs ± 2.32 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n",
      "2.01 µs ± 41.6 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit list_based()\n",
    "%timeit numpy_based()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In lot's of material, we see the above example is used to show NumPy is fater but the truth is the function `list_based` is not implemented well. Let's write it with `map()` as we learned in introduction to Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "205 ns ± 3.08 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)\n",
      "2.02 µs ± 19 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)\n",
      "Voila, list is faster now.\n"
     ]
    }
   ],
   "source": [
    "def list_based():\n",
    "    add = lambda a: a + 5\n",
    "    return map(add, list_version)\n",
    "\n",
    "\n",
    "%timeit list_based()\n",
    "%timeit numpy_based()\n",
    "print('Voila, list is faster now.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "They're equal!\n",
      "NumPy:  (1000,) \n",
      "list:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Let's check the size and values \n",
    "\n",
    "a = numpy_based()\n",
    "b = list_based()\n",
    "\n",
    "c = list(b)\n",
    "print(\"They're equal!\\nNumPy: \", a.shape, \"\\nlist: \", np.shape(c)) if [np.all(c == a)] else print('Wrong!') \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But for sure, NumPy gives us more functionality and NumPy's methods are faster using NumPy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numpy_based():\n",
    "    return np.mean(numpy_version)\n",
    "\n",
    "\n",
    "def list_based():\n",
    "    return np.mean(list_version)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59 µs ± 2.13 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n",
      "10.1 µs ± 2.31 µs per loop (mean ± std. dev. of 7 runs, 100,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit list_based()\n",
    "%timeit numpy_based()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='creating'></a>\n",
    "## 1 . Creating a NumPy array \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`numpy.array` can be used to create a tensor\n",
    "\n",
    "<center><img src='img/Tensor_01.webp' alt='tensor' width=400px></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  2 ; shape:  0\n"
     ]
    }
   ],
   "source": [
    "# Create 0-D array\n",
    "\n",
    "a = np.array(2)\n",
    "\n",
    "print(\"a = \", a, \"; shape: \", a.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='creating_with_list'></a>\n",
    "### 1.1 Creating arrays from lists\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use `np.array()` to create an array from Python lists\n",
    "\n",
    "```Python\n",
    "np.array(list_name)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 4.3, 8. , 9. ])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create 1-D 'float' array\n",
    "\n",
    "np.array([1.0, 4.3, 8., 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the parameter `dtype` to specify the type of data,\n",
    "\n",
    "```Python\n",
    "np.array(list_name, dtype=desired_type)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 8, 9], dtype=int32)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create 1-D 'int' array\n",
    "\n",
    "np.array([1.0, 4., 8., 9], dtype=np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 4., 8., 9.],\n",
       "       [2., 4., 1., 3.]], dtype=float32)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create 2-D array\n",
    "\n",
    "np.array([[1.0, 4., 8., 9],\n",
    "          [2, 4, 1, 3]], dtype=np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='special_array'></a>\n",
    "### 1.2 Special arrays\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's better to use special methods in NumPy for larger arrays. These special arrays are:\n",
    "\n",
    "- All zero array\n",
    "- All one array\n",
    "- Identity matrix\n",
    "- Empty array\n",
    "- Full array\n",
    "- Random array\n",
    "- Arrays based on a given range\n",
    "\n",
    "These arrays are usually created with the following syntax:\n",
    "\n",
    "```Python\n",
    "np.array(shape=shape_in_tuple, dtype=type_of_data)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array of zeros\n",
    "\n",
    "np.zeros(shape=(5, 2), dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array of zeros using zeros_like\n",
    "\n",
    "np.zeros_like(np.ones(shape=(5, 2), dtype=np.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make it easier, we can let NumPy decide the type of data for the rest of this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array of ones\n",
    "\n",
    "np.ones(shape=(5, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an identity matrix\n",
    "# Note: np.eye doesn't get the sahpe as argument!\n",
    "\n",
    "np.eye(5, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an empty array\n",
    "\n",
    "np.empty(shape=(5, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an empty array using empty_like\n",
    "\n",
    "np.empty_like(np.zeros((5, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.11722769,  0.76295362],\n",
       "       [-2.17500568,  0.81683978],\n",
       "       [ 1.50041677, -0.32196711],\n",
       "       [-1.63829221,  0.57127079],\n",
       "       [ 2.63541006,  0.4626389 ]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array of random numbers (normally distributed)\n",
    "\n",
    "np.random.normal(loc=0, scale=1, size=(5,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.03419494, 0.77326372],\n",
       "       [0.78682513, 0.40468411],\n",
       "       [0.79862319, 0.01839944],\n",
       "       [0.83450445, 0.39707709],\n",
       "       [0.23809996, 0.68961533]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array of random numbers (uniformly distributed)\n",
    "\n",
    "np.random.random((5, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div>\n",
    "<span style=\"color:#151D3B; font-weight:bold\">Question: 🤔</span><p>\n",
    "Generate an array with shape of [10, 10] and values between 5 and 7\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Answer\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.4097082 , 0.80731176],\n",
       "       [0.2891896 , 0.00881332],\n",
       "       [0.26646891, 0.99539955],\n",
       "       [0.87865244, 0.17352633],\n",
       "       [0.68704688, 0.49754203]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array of random numbers\n",
    "\n",
    "np.random.rand(5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 1],\n",
       "       [2, 2],\n",
       "       [2, 3],\n",
       "       [2, 2]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array of random integer numbers\n",
    "\n",
    "np.random.randint(low=1, high=5, size=(5, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2,\n",
       "       2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5,\n",
       "       3.6, 3.7, 3.8, 3.9])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array in a range\n",
    "\n",
    "np.arange(start=1, stop=4, step=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.33333333, 1.66666667, 2.        , 2.33333333,\n",
       "       2.66666667, 3.        , 3.33333333, 3.66666667, 4.        ])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array in a range\n",
    "\n",
    "np.linspace(start=1, stop=4, num=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   10.        ,    21.5443469 ,    46.41588834,   100.        ,\n",
       "         215.443469  ,   464.15888336,  1000.        ,  2154.43469003,\n",
       "        4641.58883361, 10000.        ])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array in a range\n",
    "\n",
    "np.logspace(start=1, stop=4, num=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='attributes_array'></a>\n",
    "## 2. Attributes of arrays \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use attributes to determine some properties of the array such as shape, size, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 8  3 13]\n",
      " [ 3  9  9]\n",
      " [ 8  3  3]\n",
      " [ 8  0  4]]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.randint(14, size=(4, 3))\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimension:  2\n",
      "Shape:  (4, 3)\n",
      "Size:  12\n",
      "Type:  int64\n",
      "Element size:  8 bytes\n",
      "Array size:  96 bytes\n"
     ]
    }
   ],
   "source": [
    "print(\"Dimension: \", x.ndim) \n",
    "print(\"Shape: \", x.shape) \n",
    "print(\"Size: \", x.size) \n",
    "print(\"Type: \", x.dtype)\n",
    "print(\"Element size: \", x.itemsize, 'bytes')  # Size of each element\n",
    "print(\"Array size: \", x.nbytes, 'bytes')  # Size of the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='data_election'></a>\n",
    "## 3. Data Selection\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Indexing*** is used to select an individual element of an array\n",
    "\n",
    "***Slicing*** is used to select a part of an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='indexing'></a>\n",
    "### 3.1 Array indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note that Python counts from `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.92217528],\n",
       "       [0.79863999],\n",
       "       [0.94418079],\n",
       "       [0.82755604],\n",
       "       [0.63045452],\n",
       "       [0.88990979]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_1d = np.random.random((6, 1))\n",
    "x_1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.92217528])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access to the first element\n",
    "\n",
    "x_1d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.88990979])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access to the last element\n",
    "\n",
    "x_1d[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.33885542, 0.1597375 , 0.07806182, 0.23368214, 0.06593179],\n",
       "       [0.66934263, 0.81221089, 0.64326019, 0.01511344, 0.14241199],\n",
       "       [0.43655335, 0.53837157, 0.82013621, 0.06432384, 0.72217852],\n",
       "       [0.61336211, 0.41301832, 0.0147283 , 0.45730859, 0.03794812]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_2d = np.random.random((4, 5))\n",
    "x_2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3388554239006373"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_2d[0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3388554239006373"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_2d[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div>\n",
    "<span style=\"color:#151D3B; font-weight:bold\">Question: 🤔</span><p>\n",
    "What would be the result of <code>x_2d[0, 0]</code>?\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='slicing'></a>\n",
    "### 3.2 Array slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a 1-D slicing we use the following syntax\n",
    "\n",
    "```Python\n",
    "sliced = original[begining:end:step]\n",
    "```\n",
    "\n",
    "If `step` is not given, it will be considered as `1`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.92217528],\n",
       "       [0.79863999],\n",
       "       [0.94418079],\n",
       "       [0.82755604],\n",
       "       [0.63045452],\n",
       "       [0.88990979]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.79863999],\n",
       "       [0.94418079],\n",
       "       [0.82755604]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Specify the start and end of the desired section by number\n",
    "\n",
    "x_1d[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Tip:</b> Please consider that element 1 is included but that's not the case for element 4.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.79863999],\n",
       "       [0.94418079],\n",
       "       [0.82755604],\n",
       "       [0.63045452],\n",
       "       [0.88990979]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Specify the start or the end of the desired section that corresponds to\n",
    "the start or the end of the array\n",
    "\"\"\"\n",
    "\n",
    "x_1d[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.79863999],\n",
       "       [0.82755604],\n",
       "       [0.88990979]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing with step greater than 1\n",
    "\n",
    "x_1d[1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.88990979],\n",
       "       [0.63045452],\n",
       "       [0.82755604],\n",
       "       [0.94418079],\n",
       "       [0.79863999]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can reverse the array by indexing\n",
    "\n",
    "x_1d[-1:0:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.01511344, 0.14241199],\n",
       "       [0.06432384, 0.72217852],\n",
       "       [0.45730859, 0.03794812]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing in 2-D\n",
    "\n",
    "x_2d[1:, 3:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='view_copy'></a>\n",
    "### 3.3 Array view vs copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An extremely important thing to know is array slices return *views* of data rather than *copy*.\n",
    "This is another difference between NumPy arrays and Python lists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.92217528]\n",
      " [0.79863999]\n",
      " [0.94418079]\n",
      " [0.82755604]\n",
      " [0.63045452]\n",
      " [0.88990979]]\n",
      "======== \n",
      " [[1.84435057]\n",
      " [0.79863999]\n",
      " [0.94418079]\n",
      " [0.82755604]\n",
      " [0.63045452]\n",
      " [0.88990979]]\n"
     ]
    }
   ],
   "source": [
    "print(x_1d)\n",
    "\n",
    "x_1d_sliced = x_1d[0]\n",
    "\n",
    "x_1d_sliced *= 2\n",
    "\n",
    "print(\"======== \\n\", x_1d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To prevent any problems, you should use the method `copy()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.84435057]\n",
      " [0.79863999]\n",
      " [0.94418079]\n",
      " [0.82755604]\n",
      " [0.63045452]\n",
      " [0.88990979]]\n",
      "======== \n",
      " [[1.84435057]\n",
      " [0.79863999]\n",
      " [0.94418079]\n",
      " [0.82755604]\n",
      " [0.63045452]\n",
      " [0.88990979]]\n"
     ]
    }
   ],
   "source": [
    "print(x_1d)\n",
    "\n",
    "x_1d_sliced = x_1d[0].copy()\n",
    "\n",
    "x_1d_sliced *= 2\n",
    "\n",
    "print(\"======== \\n\", x_1d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='conditional'></a>\n",
    "### 3.4 Conditional selection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a condition to select a part of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.84435057],\n",
       "       [0.79863999],\n",
       "       [0.94418079],\n",
       "       [0.82755604],\n",
       "       [0.63045452],\n",
       "       [0.88990979]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True],\n",
       "       [ True],\n",
       "       [ True],\n",
       "       [ True],\n",
       "       [False],\n",
       "       [ True]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's create a condition\n",
    "\n",
    "cond = x_1d > 0.7\n",
    "cond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.84435057, 0.79863999, 0.94418079, 0.82755604, 0.88990979])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select the data based on the condition\n",
    "\n",
    "x_1d[cond]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9,  8,  3,  2,  1,  6],\n",
       "       [11,  9,  1, 11,  9, 10],\n",
       "       [ 8,  6,  1,  0,  8, 10],\n",
       "       [ 0,  7,  5,  2, 10,  4],\n",
       "       [ 4,  9,  1, 10,  0,  8]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's create a 2-D array\n",
    "\n",
    "x_2d_int = np.random.randint(12, size=(5, 6))\n",
    "\n",
    "x_2d_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8,  2,  6, 10,  8,  6,  0,  8, 10,  0,  2, 10,  4,  4, 10,  0,  8])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's pull out the even numbers\n",
    "\n",
    "x_2d_int[x_2d_int % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div>\n",
    "<span style=\"color:#151D3B; font-weight:bold\">Question: 🤔</span><p>\n",
    "Using conditional indexing, pull out numbers in <code>x_2d_int</code> that are divisible by both 2 and 7.\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Answer\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='manipulation'></a>\n",
    "## 4. Array manipulation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data manipulation is an important step in any study."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='shape'></a>\n",
    "### 4.1 Shape of an array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create some arrays\n",
    "\n",
    "arr_1d = np.arange(10)\n",
    "arr_2d = 5 * np.random.random((4, 5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.12494865e+00, 2.52019245e+00, 1.66512359e+00, 4.41634994e+00,\n",
       "        2.92805654e+00],\n",
       "       [3.50692316e-01, 1.00497838e+00, 3.06787794e+00, 7.90607320e-01,\n",
       "        3.09527984e+00],\n",
       "       [2.42114524e+00, 2.04947916e+00, 3.24382176e-03, 2.82234526e+00,\n",
       "        3.79200212e+00],\n",
       "       [3.46652576e+00, 1.33838524e-01, 6.33470826e-01, 4.25387286e+00,\n",
       "        4.02985249e+00]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,) (10,)\n"
     ]
    }
   ],
   "source": [
    "# Shape of an array can be obtained in 2 ways\n",
    "\n",
    "print(arr_1d.shape, np.shape(arr_1d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily reshape a NumPy array\n",
    "\n",
    "\n",
    "```Python\n",
    "\n",
    "array.reshape(rows, columns)\n",
    "\n",
    "np.reshape(array, newshape=(rows, columns))\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.12494865e+00, 2.52019245e+00, 1.66512359e+00, 4.41634994e+00],\n",
       "       [2.92805654e+00, 3.50692316e-01, 1.00497838e+00, 3.06787794e+00],\n",
       "       [7.90607320e-01, 3.09527984e+00, 2.42114524e+00, 2.04947916e+00],\n",
       "       [3.24382176e-03, 2.82234526e+00, 3.79200212e+00, 3.46652576e+00],\n",
       "       [1.33838524e-01, 6.33470826e-01, 4.25387286e+00, 4.02985249e+00]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d.reshape(5, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.12494865e+00, 2.52019245e+00, 1.66512359e+00, 4.41634994e+00],\n",
       "       [2.92805654e+00, 3.50692316e-01, 1.00497838e+00, 3.06787794e+00],\n",
       "       [7.90607320e-01, 3.09527984e+00, 2.42114524e+00, 2.04947916e+00],\n",
       "       [3.24382176e-03, 2.82234526e+00, 3.79200212e+00, 3.46652576e+00],\n",
       "       [1.33838524e-01, 6.33470826e-01, 4.25387286e+00, 4.02985249e+00]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.reshape(arr_2d, newshape=(5, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.12494865e+00, 2.52019245e+00, 1.66512359e+00, 4.41634994e+00,\n",
       "       2.92805654e+00, 3.50692316e-01, 1.00497838e+00, 3.06787794e+00,\n",
       "       7.90607320e-01, 3.09527984e+00, 2.42114524e+00, 2.04947916e+00,\n",
       "       3.24382176e-03, 2.82234526e+00, 3.79200212e+00, 3.46652576e+00,\n",
       "       1.33838524e-01, 6.33470826e-01, 4.25387286e+00, 4.02985249e+00])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can flatten an array using attribute flatten\n",
    "\n",
    "arr_2d.flatten()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Tip:</b> Reshape doesn't act in place while resize returns <code>None</code> and acts in place.</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original shape:  (4, 5)\n",
      "Shape after using reshape:  (4, 5)\n",
      "Shape after using resize:  (5, 4)\n"
     ]
    }
   ],
   "source": [
    "print(\"Original shape: \", arr_2d.shape)\n",
    "\n",
    "arr_2d.reshape(5, 4)\n",
    "\n",
    "print(\"Shape after using reshape: \", arr_2d.shape)\n",
    "\n",
    "a = arr_2d.resize(5, 4)\n",
    "\n",
    "print(\"Shape after using resize: \", arr_2d.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:red; font-weight:bold;'>Note:</span> <code>np.resize()</code> acts like <code>np.reshape()</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original shape:  (5, 4)\n",
      "Shape after using reshape:  (5, 4)\n",
      "Shape after using resize:  (5, 4)\n"
     ]
    }
   ],
   "source": [
    "print(\"Original shape: \", arr_2d.shape)\n",
    "\n",
    "np.reshape(arr_2d, (5, 4))\n",
    "\n",
    "print(\"Shape after using reshape: \", arr_2d.shape)\n",
    "\n",
    "np.resize(arr_2d, (5, 4))\n",
    "\n",
    "print(\"Shape after using resize: \", arr_2d.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='joining'></a>\n",
    "### 4.2 Joining arrays \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array([[1, 2, 0, 1]])\n",
    "\n",
    "arr2 = 6 * np.random.random((4, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr1:  (1, 4)\n",
      "arr2:  (4, 4)\n"
     ]
    }
   ],
   "source": [
    "# Check the shape\n",
    "print('arr1: ', arr1.shape)\n",
    "print('arr2: ', arr2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.39519938, 1.14490425, 1.59430489, 2.32748641],\n",
       "       [1.59774472, 4.67115618, 2.78828997, 5.98815225],\n",
       "       [5.50006861, 1.87447721, 3.72428163, 1.99962704],\n",
       "       [4.09223037, 3.72611926, 2.16547115, 5.50849331],\n",
       "       [1.        , 2.        , 0.        , 1.        ]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Joining arrays by row\n",
    "\n",
    "np.concatenate((arr2, arr1), axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For using `axis = 0`, we should have the same number of columns and for `axis = 1`, we should have the same number of rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.39519938, 1.14490425, 1.59430489, 2.32748641, 1.        ],\n",
       "       [1.59774472, 4.67115618, 2.78828997, 5.98815225, 2.        ],\n",
       "       [5.50006861, 1.87447721, 3.72428163, 1.99962704, 0.        ],\n",
       "       [4.09223037, 3.72611926, 2.16547115, 5.50849331, 1.        ]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Joining arrays by column\n",
    "# .T takes the transpose as well as np.transpose()\n",
    "np.concatenate((arr2, arr1.T), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.39519938, 1.14490425, 1.59430489, 2.32748641],\n",
       "       [1.59774472, 4.67115618, 2.78828997, 5.98815225],\n",
       "       [5.50006861, 1.87447721, 3.72428163, 1.99962704],\n",
       "       [4.09223037, 3.72611926, 2.16547115, 5.50849331],\n",
       "       [1.        , 2.        , 0.        , 1.        ]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Joining by vstack which acts as using axis = 0\n",
    "\n",
    "np.vstack((arr2, arr1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.39519938, 1.14490425, 1.59430489, 2.32748641, 1.        ],\n",
       "       [1.59774472, 4.67115618, 2.78828997, 5.98815225, 2.        ],\n",
       "       [5.50006861, 1.87447721, 3.72428163, 1.99962704, 0.        ],\n",
       "       [4.09223037, 3.72611926, 2.16547115, 5.50849331, 1.        ]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Joining by hstack which acts as using axis = 1\n",
    "\n",
    "np.hstack((arr2, arr1.T))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.39519938, 1.14490425, 1.59430489, 2.32748641, 1.        ],\n",
       "       [1.59774472, 4.67115618, 2.78828997, 5.98815225, 2.        ],\n",
       "       [5.50006861, 1.87447721, 3.72428163, 1.99962704, 0.        ],\n",
       "       [4.09223037, 3.72611926, 2.16547115, 5.50849331, 1.        ]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Joining by column_stack / row_stack which acts as using axis = 1 / 0. \n",
    "\n",
    "np.column_stack((arr2, arr1.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='splitting'></a>\n",
    "### 4.3 Splitting of arrays \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The opposite of concatenation is splitting.\n",
    " \n",
    "`np.split`, `np.hsplit`, `np.vsplit`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.39519938, 1.14490425, 1.59430489, 2.32748641],\n",
       "       [1.59774472, 4.67115618, 2.78828997, 5.98815225],\n",
       "       [5.50006861, 1.87447721, 3.72428163, 1.99962704],\n",
       "       [4.09223037, 3.72611926, 2.16547115, 5.50849331]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[4.39519938, 1.14490425, 1.59430489, 2.32748641],\n",
       "        [1.59774472, 4.67115618, 2.78828997, 5.98815225]]),\n",
       " array([[5.50006861, 1.87447721, 3.72428163, 1.99962704],\n",
       "        [4.09223037, 3.72611926, 2.16547115, 5.50849331]])]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Splitting with axis = 0\n",
    "\n",
    "np.split(arr2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[4.39519938, 1.14490425],\n",
       "        [1.59774472, 4.67115618],\n",
       "        [5.50006861, 1.87447721],\n",
       "        [4.09223037, 3.72611926]]),\n",
       " array([[1.59430489, 2.32748641],\n",
       "        [2.78828997, 5.98815225],\n",
       "        [3.72428163, 1.99962704],\n",
       "        [2.16547115, 5.50849331]])]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Splitting with axis = 1\n",
    "\n",
    "np.array_split(arr2, 2, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[4.39519938, 1.14490425],\n",
       "        [1.59774472, 4.67115618],\n",
       "        [5.50006861, 1.87447721],\n",
       "        [4.09223037, 3.72611926]]),\n",
       " array([[1.59430489, 2.32748641],\n",
       "        [2.78828997, 5.98815225],\n",
       "        [3.72428163, 1.99962704],\n",
       "        [2.16547115, 5.50849331]])]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using hsplit / vsplit\n",
    "\n",
    "np.hsplit(arr2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='computation'></a>\n",
    "## 5. Computation on NumPy arrays \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computation on NumPy arrays can be very fast if we use *vectorized* operators through *universal functions*, **ufuncs**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating two arrays\n",
    "\n",
    "arr1d_1 = np.arange(7)\n",
    "arr1d_2 = np.linspace(9, 12, len(arr1d_1))\n",
    "\n",
    "\n",
    "arr2d_1 = np.random.random((4, 5))\n",
    "arr2d_2 = 4 + 6 * np.random.random((4, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.57298148, 5.05451181, 9.30686384, 5.45030493, 6.25630425],\n",
       "       [9.88605326, 5.75480465, 7.57635189, 4.22292416, 7.44118237],\n",
       "       [6.27490308, 7.93402006, 8.47860973, 7.21057738, 5.89683428],\n",
       "       [7.29190697, 6.26982447, 4.86490874, 5.55885806, 5.31803991]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition of two arrays (equivalent of arr1d_1 + arr1d_2)\n",
    "\n",
    "np.add(arr2d_1, arr2d_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-7.41692924, -3.63845529, -7.41536096, -3.76219532, -5.53915092],\n",
       "       [-9.12633911, -3.91432114, -7.46766107, -3.9437874 , -7.16843862],\n",
       "       [-5.35673459, -7.29877831, -7.89010091, -6.30672002, -4.23985931],\n",
       "       [-7.12914617, -5.06413038, -4.49792165, -5.0431271 , -3.63105947]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtraction of two arrays (equivalent of arr1d_1 - arr1d_2)\n",
    "\n",
    "np.subtract(arr2d_1, arr2d_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5848023 , 3.07743318, 7.90753411, 3.88792755, 2.11478749],\n",
       "       [3.61099584, 4.44896665, 0.40878651, 0.56990735, 0.99617073],\n",
       "       [2.66995079, 2.41912735, 2.40828264, 3.05442721, 4.19906187],\n",
       "       [0.58679555, 3.41632062, 0.85900946, 1.36694299, 3.77423889]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication of two arrays (equivalent of arr1d_1 * arr1d_2)\n",
    "\n",
    "np.multiply(arr2d_1, arr2d_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.01041049, 0.1628968 , 0.11311311, 0.1832412 , 0.06079912],\n",
       "       [0.03995889, 0.19034642, 0.00722486, 0.03417982, 0.01866878],\n",
       "       [0.07893716, 0.04170224, 0.03595328, 0.06686672, 0.16346306],\n",
       "       [0.01128633, 0.10637894, 0.03919617, 0.04864475, 0.1885084 ]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division of two arrays (equivalent of arr1d_1 + arr1d_2)\n",
    "\n",
    "np.divide(arr2d_1, arr2d_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.10775998, -0.14994941, -0.02422299, -0.07362935, -0.44541798],\n",
       "       [-0.42037978, -0.03609806, -1.26483714, -0.85521296, -0.86527518],\n",
       "       [-0.33810761, -0.49809097, -0.53127702, -0.34493009, -0.08171405],\n",
       "       [-1.08948017, -0.21979286, -0.73637921, -0.58860679, -0.07391995]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Logarithm of an array\n",
    "\n",
    "np.log10(arr2d_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.0811509 , 2.02998471, 2.57474743, 2.32577846, 1.43129076],\n",
       "       [1.4620756 , 2.5098971 , 1.05584924, 1.14977742, 1.14610803],\n",
       "       [1.58262402, 1.3738553 , 1.34212531, 1.57133988, 2.28985268],\n",
       "       [1.08478347, 1.82731385, 1.20140721, 1.29416471, 2.32446573]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exponent of an array\n",
    "\n",
    "np.exp(arr2d_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.07794697, 0.65033721, 0.81093686, 0.74734342, 0.35094178],\n",
       "       [0.37078773, 0.79574806, 0.05431866, 0.1391157 , 0.13594958],\n",
       "       [0.44312736, 0.31230732, 0.29002639, 0.4367014 , 0.73690977],\n",
       "       [0.0812906 , 0.56698995, 0.18246557, 0.25501719, 0.74696817]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sin of an array\n",
    "\n",
    "np.sin(arr2d_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False, False],\n",
       "       [False, False, False, False, False],\n",
       "       [False, False, False, False, False],\n",
       "       [False, False, False, False, False]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison for greate, equivalent arr2d_1 > arr2d_2\n",
    "\n",
    "np.greater(arr2d_1, arr2d_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison for greate, equivalent arr2d_1 < arr2d_2\n",
    "\n",
    "np.less(arr2d_1, arr2d_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2. , 1. , 9. , 1.2])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# FInding the absolute of an array, equivalent of np.absolute\n",
    "\n",
    "np.abs([2, -1, 9, -1.2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='aggregations'></a>\n",
    "## 6. Aggregations \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before doing any operation, it's good to have a summary statistics of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='summation'></a>\n",
    "###  6.1 Summation \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create an array\n",
    "\n",
    "arr1 = np.random.random((100, 100))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5003.9501297867755"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sum of values in an array\n",
    "\n",
    "np.sum(arr1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.49 ms ± 1.1 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "72.6 µs ± 25.8 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Comparing with Python built-in function\n",
    "\n",
    "big_array = np.random.random(100000)\n",
    "\n",
    "%timeit sum(big_array)\n",
    "%timeit np.sum(big_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='min_max'></a>\n",
    "###  6.2 Minimum and maximum \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create an array\n",
    "\n",
    "arr1 = np.random.random((6, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.95454675, 0.80592209, 0.83338245, 0.77042827, 0.84348619])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Finding max along columns\n",
    "\n",
    "arr1.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.59064987, 0.93905949, 0.84348619, 0.66486399, 0.80592209,\n",
       "       0.95454675])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Finding max along rows\n",
    "arr1.max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.16122773, 0.12339998, 0.00310598, 0.10653879, 0.00182586])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Finding min\n",
    "arr1.min(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.59064987, 0.93905949, 0.84348619, 0.66486399, 0.80592209,\n",
       "       0.95454675])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can use np.max / np.min as well.\n",
    "np.max(arr1, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='var_std'></a>\n",
    "### 6.3 Variance and standard deviation \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create an array\n",
    "\n",
    "arr1 = np.random.random((6, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.34273506350237504"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calculating the standard deviation of the array\n",
    "\n",
    "np.std(arr1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.34273506350237504"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's check if std is variance^0.5\n",
    "\n",
    "arr1.std() == np.sqrt(arr1.var())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.35771294, 0.24085549, 0.26653071, 0.39025074, 0.29958713,\n",
       "       0.36384725])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# std along rows\n",
    "\n",
    "arr1.std(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.09855379, 0.0784968 , 0.06833994, 0.15192005, 0.09711345])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# variance along columns\n",
    "\n",
    "arr1.var(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='mean_median'></a>\n",
    "###  6.4 Mean and median\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create an array\n",
    "\n",
    "arr1 = np.random.random((6, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.48865834632454436"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the mean of the whole array\n",
    "\n",
    "arr1.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.53827744, 0.40127025, 0.59665278, 0.33421707, 0.33345773,\n",
       "       0.7280748 ])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the mean along an axis\n",
    "\n",
    "arr1.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.45769839591723477"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the mean of the whole array\n",
    "\n",
    "np.median(arr1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:red; font-weight:bold;'>Note: </span> An <code>ndarray</code> doesn't have method median."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='find_index'></a>\n",
    "###  6.5 Find index \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.13342196, 0.51625798, 0.21430031, 0.14102139, 0.80624634],\n",
       "       [0.9611696 , 0.47088499, 0.00758668, 0.37012156, 0.55707768],\n",
       "       [0.15327368, 0.38915331, 0.69674686, 0.08540601, 0.89252822],\n",
       "       [0.04101646, 0.62661837, 0.23546178, 0.        , 0.65122638],\n",
       "       [0.47912935, 0.26925893, 0.80557815, 0.07393885, 0.42204269],\n",
       "       [0.01963075, 0.95747755, 0.40774398, 0.4743706 , 0.72677359]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's create an array\n",
    "\n",
    "arr1 = np.random.random((6, 5))\n",
    "arr1[3, 3] = 0\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the indix of maximum value\n",
    "\n",
    "arr1.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the indix of minimum value\n",
    "\n",
    "arr1.argmin()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([3]), array([3]))"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the indix of an specific value\n",
    "\n",
    "np.where(arr1 == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [TOP ☝️](#top)\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ece4c4f9c4961c7468795d846fc72c6e00987d764e9134aaba41ea0514f48bf6"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}