005_Python_NumPy_Array_Part4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-27T18:42:32.348446Z",
     "start_time": "2021-05-27T18:42:32.329894Z"
    }
   },
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/09_Python_NumPy_Module)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays reorganizing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `asarray()`\n",
    "\n",
    "The **`asarray()`** function is used when you want to convert an input to an array. The input could be a lists, tuple, ndarray, etc.\n",
    "\n",
    "**Syntax:**\n",
    "```python\n",
    "numpy.asarray(data, dtype=None, order=None)[source]\n",
    "```\n",
    "\n",
    "* **`data`**: Data that you want to convert to an array\n",
    "\n",
    "* **`dtype`**: This is an optional argument. If not specified, the data type is inferred from the input data\n",
    "\n",
    "* **`Order`**: Default is **`C`** which is an essential row style. Other option is **`F`** (Fortan-style)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:01.557209Z",
     "start_time": "2021-07-06T15:01:01.242760Z"
    }
   },
   "outputs": [],
   "source": [
    "# Consider the following 2-D matrix with four rows and four columns filled by 1\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "a = np.matrix(np.ones((4,4)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to change the value of the matrix, you cannot. The reason is, it is not possible to change a copy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:01.604081Z",
     "start_time": "2021-07-06T15:01:01.570882Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "np.array(a)[2]=3\n",
    "print(a)  # value won't change in result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix is immutable. You can use asarray if you want to add modification in the original array. Let's see if any change occurs when you want to change the value of the third rows with the value 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:01.763262Z",
     "start_time": "2021-07-06T15:01:01.607988Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [2. 2. 2. 2.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "np.asarray(a)[2]=2 # np.asarray(A): converts the matrix A to an array\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `arange()`\n",
    "\n",
    "The **`arange()`** is an inbuilt numpy function that returns an ndarray object containing evenly spaced values within a defined interval. For instance, you want to create values from 1 to 10; you can use **`arange()`** function.\n",
    "\n",
    "**Syntax:**\n",
    "```python\n",
    "numpy.arange(start, stop,step) \n",
    "```\n",
    "* **`start`**: Start of interval\n",
    "* **`stop`**: End of interval\n",
    "* **`step`**: Spacing between values. Default step is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:01.958575Z",
     "start_time": "2021-07-06T15:01:01.772054Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "import numpy as np\n",
    "np.arange(1, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to change the step, you can add a third number in the parenthesis. It will change the step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.126052Z",
     "start_time": "2021-07-06T15:01:01.965409Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  5,  9, 13])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "import numpy as np\n",
    "np.arange(1, 14, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.211013Z",
     "start_time": "2021-07-06T15:01:02.130937Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0,11,2)   # even no by adding a step size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.304274Z",
     "start_time": "2021-07-06T15:01:02.214922Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,11,2)   # odd no"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshape Data\n",
    "\n",
    "In some occasions, you need to reshape the data from wide to long. You can use the reshape function for this. \n",
    "\n",
    "**Syntax:** \n",
    "```python\n",
    "numpy.reshape(a, newShape, order='C')\n",
    "```\n",
    "* **`a: Array`** that you want to reshape\n",
    "* **`newShape`**: The new desires shape\n",
    "* **`order`**: Default is **`C`** which is an essential row style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.411696Z",
     "start_time": "2021-07-06T15:01:02.315015Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "e  = np.array([(1,2,3), (4,5,6)])\n",
    "print(e)\n",
    "e.reshape(3,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Broadcasting with array reorganizing \n",
    "\n",
    "It's super cool and super useful. The one-line explanation is that when doing elementwise operations, things expand to the \"correct\" shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.503980Z",
     "start_time": "2021-07-06T15:01:02.417556Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x:   [0 1 2 3 4]\n",
      "x+1: [1 2 3 4 5]\n",
      "\n",
      "y:  \n",
      "[[0.20040757 0.96248829 0.29534113 0.14204329 0.00786338]\n",
      " [0.68572271 0.22357762 0.88618684 0.91174698 0.87380356]]\n",
      "y+1:\n",
      "[[1.20040757 1.96248829 1.29534113 1.14204329 1.00786338]\n",
      " [1.68572271 1.22357762 1.88618684 1.91174698 1.87380356]]\n"
     ]
    }
   ],
   "source": [
    "# add a scalar to a 1-d array\n",
    "x = np.arange(5)\n",
    "print('x:  ', x)\n",
    "print('x+1:', x + 1, end='\\n\\n')\n",
    "\n",
    "y = np.random.uniform(size=(2, 5))\n",
    "print('y:  ', y,  sep='\\n')\n",
    "print('y+1:', y + 1, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since `x` is shaped `(5,)` and `y` is shaped `(2,5)` we can do operations between them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.628979Z",
     "start_time": "2021-07-06T15:01:02.509842Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.96248829, 0.59068226, 0.42612988, 0.03145352],\n",
       "       [0.        , 0.22357762, 1.77237368, 2.73524094, 3.49521424]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without broadcasting we'd have to manually reshape our arrays, which quickly gets annoying."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.753491Z",
     "start_time": "2021-07-06T15:01:02.634841Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.96248829, 0.59068226, 0.42612988, 0.03145352],\n",
       "       [0.        , 0.22357762, 1.77237368, 2.73524094, 3.49521424]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.reshape(1, -1).repeat(2, axis=0) * y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.862866Z",
     "start_time": "2021-07-06T15:01:02.757399Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "before = np.array([[1,2,3,4],[5,6,7,8]])\n",
    "print(before)\n",
    "\n",
    "after = before.reshape((2,4))\n",
    "print(after)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flatten Data\n",
    "\n",
    "When you deal with some neural network like convnet, you need to flatten the array. You can use **`flatten()`**.\n",
    "\n",
    "**Syntax:** \n",
    "```python\n",
    "numpy.flatten(order='C')\n",
    "```\n",
    "* **`a: Array`** that you want to reshape\n",
    "* **`newShape`**: The new desires shape\n",
    "* **`order`**: Default is **`C`** which is an essential row style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.955151Z",
     "start_time": "2021-07-06T15:01:02.867751Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.flatten()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is `hstack`?\n",
    "\n",
    "With **`hstack`** you can appened data horizontally. This is a very convinient function in Numpy. Lets study it with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:02.970776Z",
     "start_time": "2021-07-06T15:01:02.958081Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Horizontal Append: [1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "## Horitzontal Stack\n",
    "\n",
    "import numpy as np\n",
    "f = np.array([1,2,3])\n",
    "g = np.array([4,5,6])\n",
    "\n",
    "print('Horizontal Append:', np.hstack((f, g)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.094802Z",
     "start_time": "2021-07-06T15:01:02.973707Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 0., 0.],\n",
       "       [1., 1., 1., 1., 0., 0.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Horizontal  stack\n",
    "\n",
    "h1 = np.ones((2,4))\n",
    "h2 = np.zeros((2,2))\n",
    "\n",
    "np.hstack((h1,h2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is `vstack`?\n",
    "\n",
    "With **`vstack`** you can appened data vertically. Lets study it with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.203200Z",
     "start_time": "2021-07-06T15:01:03.097730Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertical Append: [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "## Vertical Stack\n",
    "\n",
    "import numpy as np\n",
    "f = np.array([1,2,3])\n",
    "g = np.array([4,5,6])\n",
    "\n",
    "print('Vertical Append:', np.vstack((f, g)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.328195Z",
     "start_time": "2021-07-06T15:01:03.206127Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8],\n",
       "       [1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Vertically stacking vectors\n",
    "\n",
    "v1 = np.array([1,2,3,4])\n",
    "v2 = np.array([5,6,7,8])\n",
    "\n",
    "np.vstack([v1,v2,v1,v2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate Random Numbers\n",
    "\n",
    "To generate random numbers for Gaussian distribution use:\n",
    "\n",
    "**Syntax:**\n",
    "```python\n",
    "numpy.random.normal(loc, scale, size)\n",
    "```\n",
    "* **`loc`**: the mean. The center of distribution\n",
    "* **`scale`**: standard deviation.\n",
    "* **`size`**: number of returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.482980Z",
     "start_time": "2021-07-06T15:01:03.334057Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.73370838 5.02319487 5.03247675 4.63238643 5.20491465 4.23379671\n",
      " 4.65235094 4.03461004 4.81788758 5.40603744]\n"
     ]
    }
   ],
   "source": [
    "## Generate random number from normal distribution\n",
    "\n",
    "normal_array = np.random.normal(5, 0.5, 10)\n",
    "print(normal_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linspace\n",
    "\n",
    "Linspace gives evenly spaced samples.\n",
    "\n",
    "**Syntax:**\n",
    "```python\n",
    "numpy.linspace(start, stop, num, endpoint)\n",
    "```\n",
    "* **`start`**: Start of sequence\n",
    "* **`stop`**: End of sequence\n",
    "* **`num`**: Number of samples to generate. Default is 50\n",
    "* **`endpoint`**: If **`True`** (default), stop is the last value. If **`False`**, stop value is not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.594308Z",
     "start_time": "2021-07-06T15:01:03.488351Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  2.,  4.,  6.,  8., 10.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "import numpy as np\n",
    "np.linspace(0,10,6) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.713934Z",
     "start_time": "2021-07-06T15:01:03.605053Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.44444444, 1.88888889, 2.33333333, 2.77777778,\n",
       "       3.22222222, 3.66666667, 4.11111111, 4.55555556, 5.        ])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example: For instance, it can be used to create 10 values from 1 to 5 evenly spaced.\n",
    "\n",
    "import numpy as np\n",
    "np.linspace(1.0, 5.0, num=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not want to include the last digit in the interval, you can set endpoint to **`False`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.821847Z",
     "start_time": "2021-07-06T15:01:03.719799Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.8, 2.6, 3.4, 4.2])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1.0, 5.0, num=5, endpoint=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LogSpace\n",
    "\n",
    "LogSpace returns even spaced numbers on a log scale. Logspace has the same parameters as **`np.linspace`**.\n",
    "\n",
    "**Syntax:**\n",
    "```python\n",
    "numpy.logspace(start, stop, num, endpoint)\n",
    "```\n",
    "* **`start`**: Start of sequence\n",
    "* **`stop`**: End of sequence\n",
    "* **`num`**: Number of samples to generate. Default is 50\n",
    "* **`endpoint`**: If **`True`** (default), stop is the last value. If **`False`**, stop value is not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:03.962961Z",
     "start_time": "2021-07-06T15:01:03.824777Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1000.        ,  2154.43469003,  4641.58883361, 10000.        ])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "np.logspace(3.0, 4.0, num=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finaly, if you want to check the memory size of an element in an array, you can use **`.itemsize`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.070380Z",
     "start_time": "2021-07-06T15:01:03.972725Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1,2,3], dtype=np.complex128)\n",
    "x.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistics\n",
    "\n",
    "NumPy has quite a few useful statistical functions for finding minimum, maximum, percentile standard deviation and variance, etc from the given elements in the array. The functions are explained as follows −"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is equipped with the robust statistical function as listed below:\n",
    "\n",
    "| Function | Numpy |\n",
    "|:----: |:---- |\n",
    "| **`Min`**                | **np.min()** | \n",
    "| **`Max`**                | **np.max()** | \n",
    "| **`Mean`**               | **np.mean()** | \n",
    "| **`Median`**             | **np.median()** | \n",
    "| **`Standard deviation`** | **np.std()** | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.196356Z",
     "start_time": "2021-07-06T15:01:04.076241Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.57057605 5.76249894 4.09935016 5.38336447 4.96652011 5.29402596\n",
      " 4.79025614 6.00232788 5.49574452 5.60059908]\n"
     ]
    }
   ],
   "source": [
    "# Consider the following Array\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "normal_array = np.random.normal(5, 0.5, 10)\n",
    "print(normal_array)\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.366276Z",
     "start_time": "2021-07-06T15:01:04.200262Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.099350157876355\n",
      "6.002327879593869\n",
      "5.196526332130161\n",
      "5.338695217273813\n",
      "0.5550161930871431\n"
     ]
    }
   ],
   "source": [
    "# Example:Statistical function\n",
    "\n",
    "### Min \n",
    "print(np.min(normal_array))\n",
    "\n",
    "### Max \n",
    "print(np.max(normal_array))\n",
    "\n",
    "### Mean \n",
    "print(np.mean(normal_array))\n",
    "\n",
    "### Median\n",
    "print(np.median(normal_array))\n",
    "\n",
    "### Sd\n",
    "print(np.std(normal_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.460025Z",
     "start_time": "2021-07-06T15:01:04.369208Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats = np.array([[1,2,3],[4,5,6]])\n",
    "stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.553777Z",
     "start_time": "2021-07-06T15:01:04.462957Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.666079Z",
     "start_time": "2021-07-06T15:01:04.559638Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(stats, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.772523Z",
     "start_time": "2021-07-06T15:01:04.673896Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(stats, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Miscellaneous"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Data from File\n",
    "\n",
    "you can download the \"data.txt\" from **[here](https://github.com/milaan9/09_Python_NumPy_Module/blob/main/data.txt)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:04.975650Z",
     "start_time": "2021-07-06T15:01:04.779363Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  13  21  11 196  75   4   3  34   6   7   8   0   1   2   3   4   5]\n",
      " [  3  42  12  33 766  75   4  55   6   4   3   4   5   6   7   0  11  12]\n",
      " [  1  22  33  11 999  11   2   1  78   0   1   2   9   8   7   1  76  88]]\n"
     ]
    }
   ],
   "source": [
    "filedata = np.genfromtxt('data.txt', delimiter=',')\n",
    "filedata = filedata.astype('int32') # you can also change type to 'int64'\n",
    "print(filedata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Masking and Advanced Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:05.039125Z",
     "start_time": "2021-07-06T15:01:04.982484Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False,  True,  True, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False],\n",
       "       [False, False, False, False,  True,  True, False,  True, False,\n",
       "        False, False, False, False, False, False, False, False, False],\n",
       "       [False, False, False, False,  True, False, False, False,  True,\n",
       "        False, False, False, False, False, False, False,  True,  True]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filedata >50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:05.162172Z",
     "start_time": "2021-07-06T15:01:05.045963Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  13  21  11 196  75   4   3  34   6   7   8   0   1   2   3   4   5]\n",
      " [  3  42  12  33 766  75   4  55   6   4   3   4   5   6   7   0  11  12]\n",
      " [  1  22  33  11 999  11   2   1  78   0   1   2   9   8   7   1  76  88]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([196,  75, 766,  75,  55, 999,  78,  76,  88])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(filedata)\n",
    "filedata[filedata >50] # '[]' will display the value of data point from the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:05.271545Z",
     "start_time": "2021-07-06T15:01:05.173893Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  13  21  11 196  75   4   3  34   6   7   8   0   1   2   3   4   5]\n",
      " [  3  42  12  33 766  75   4  55   6   4   3   4   5   6   7   0  11  12]\n",
      " [  1  22  33  11 999  11   2   1  78   0   1   2   9   8   7   1  76  88]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False,  True,  True, False,  True,  True,\n",
       "       False, False, False, False, False, False, False,  True,  True])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(filedata)\n",
    "np.any(filedata > 50, axis = 0) # axis=0 refers to columns and axis=1 refers to rows in this dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:05.380922Z",
     "start_time": "2021-07-06T15:01:05.274476Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  13  21  11 196  75   4   3  34   6   7   8   0   1   2   3   4   5]\n",
      " [  3  42  12  33 766  75   4  55   6   4   3   4   5   6   7   0  11  12]\n",
      " [  1  22  33  11 999  11   2   1  78   0   1   2   9   8   7   1  76  88]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False,  True, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(filedata)\n",
    "np.all(filedata > 50, axis = 0) # '.all' refers to all the data points in row/column (based on axis=0 or axis=1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:05.521545Z",
     "start_time": "2021-07-06T15:01:05.389709Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  13  21  11 196  75   4   3  34   6   7   8   0   1   2   3   4   5]\n",
      " [  3  42  12  33 766  75   4  55   6   4   3   4   5   6   7   0  11  12]\n",
      " [  1  22  33  11 999  11   2   1  78   0   1   2   9   8   7   1  76  88]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False, False,  True, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False],\n",
       "       [False, False, False, False, False,  True, False,  True, False,\n",
       "        False, False, False, False, False, False, False, False, False],\n",
       "       [False, False, False, False, False, False, False, False,  True,\n",
       "        False, False, False, False, False, False, False,  True,  True]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(filedata)\n",
    "(((filedata > 50) & (filedata < 100)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:05.664124Z",
     "start_time": "2021-07-06T15:01:05.526429Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  13  21  11 196  75   4   3  34   6   7   8   0   1   2   3   4   5]\n",
      " [  3  42  12  33 766  75   4  55   6   4   3   4   5   6   7   0  11  12]\n",
      " [  1  22  33  11 999  11   2   1  78   0   1   2   9   8   7   1  76  88]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True,  True, False,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True, False,  True, False,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True, False,\n",
       "         True,  True,  True,  True,  True,  True,  True, False, False]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(filedata)\n",
    "(~((filedata > 50) & (filedata < 100)))  # '~' means not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-06T15:01:05.820861Z",
     "start_time": "2021-07-06T15:01:05.672914Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 9])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### You can index with a list in NumPy\n",
    "a = np.array([1,2,3,4,5,6,7,8,9])\n",
    "a [[1,2,8]] #indexes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Documentation\n",
    "\n",
    "This brief overview has touched on many of the important things that you need to know about numpy, but is far from complete. Check out the **[numpy reference](https://numpy.org/doc/stable/reference/)** to find out much more about numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "208px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}