Basic Numpy Operation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8ba30257",
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing Numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0923d3ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import process_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ca028e70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.125\n"
     ]
    }
   ],
   "source": [
    "# time taken by list\n",
    "list1 = [i for i in range(10000000)]\n",
    "start_time = process_time()\n",
    "list1 = [i+10 for i in list1] #adding five to each number\n",
    "end_time = process_time()\n",
    "print(end_time-start_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f8840a39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.015625\n"
     ]
    }
   ],
   "source": [
    "array1 = np.array([i for i in range(10000000)])\n",
    "start_time = process_time()\n",
    "array1 += 10\n",
    "end_time = process_time()\n",
    "print(end_time-start_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6e352f9",
   "metadata": {},
   "source": [
    "#### Conclusion :--> required time for operation with array is very less thats why we prefer to array against list or tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "98cda7f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "list1=[1,2,3,4,5]\n",
    "print(list1)\n",
    "print(type(list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "724e32ec",
   "metadata": {},
   "source": [
    "- numeber are seperated by commas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d453dfcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "Array1 = np.array([1,2,3,4,5])\n",
    "print(Array1)\n",
    "print(type(Array1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "344ff3fe",
   "metadata": {},
   "source": [
    "- number of are not seperated by commas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9f76320",
   "metadata": {},
   "source": [
    "## Built in function in Numpy Array\n",
    "## Creating one dimentional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a6e0215d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7 9]\n"
     ]
    }
   ],
   "source": [
    "# arange function\n",
    "x = np.arange(1,10,2) # from 1 to 10 with step size 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "18b86815",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.07300832 0.88391953 0.04772143 0.34838327 0.75961367]\n"
     ]
    }
   ],
   "source": [
    "# five random values from zero to one\n",
    "x=np.random.rand(5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ccacdd0",
   "metadata": {},
   "source": [
    "## Creating two dimentional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ee19463",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "list1=[[1,2,3],[4,5,6],[7,8,9]]\n",
    "my_matrix=np.array(list1)\n",
    "print(my_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "be94ab96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.47253113 0.36158816 0.84992541]\n",
      " [0.08635288 0.36864389 0.03840046]]\n"
     ]
    }
   ],
   "source": [
    "# 2*3 matrix contain from zero to one\n",
    "x=np.random.rand(2,3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f79824cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.03988239 -0.24766981  1.71029175  0.37764059 -1.25006353]\n"
     ]
    }
   ],
   "source": [
    "#random values follows std normal distribution means whose mean is zero and std dev is 1\n",
    "x = np.random.randn(5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "873c0f48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.10485501 -0.09636671 -0.66343729  0.07111683]\n",
      " [ 0.94049366  0.42332458  1.36966485  0.2110586 ]\n",
      " [-0.00739175 -0.0062378   0.12665587 -0.19373729]]\n"
     ]
    }
   ],
   "source": [
    "# random values follows std normal distribution means whose mean is zero and std dev is 1\n",
    "x=np.random.randn(3,4)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f4abcd2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[16 41 35 35]\n",
      " [72 92 55 53]\n",
      " [71 88 30 76]]\n"
     ]
    }
   ],
   "source": [
    "#np.random.randint\n",
    "x=np.random.randint(10,100,(3,4))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d8d341d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3. 4.]\n",
      " [5. 6. 7. 8.]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2, 4)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now create two dimentional array (with defining values at float values)\n",
    "array2=np.array([(1,2,3,4),(5,6,7,8)],dtype=float)\n",
    "print(array2)\n",
    "array2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49dbe83",
   "metadata": {},
   "source": [
    "## Three dimentional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a61b926e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2 3]\n",
      "  [4 5 6]]\n",
      "\n",
      " [[1 2 3]\n",
      "  [4 5 6]]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60bfde06",
   "metadata": {},
   "source": [
    "## higher Dimentional arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "630df9c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[[1 2 3 4]]]]]\n",
      "number of dimensions : 5\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4], ndmin=5)\n",
    "print(arr)\n",
    "print('number of dimensions :', arr.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "583e161c",
   "metadata": {},
   "source": [
    "In this array the innermost dimension (5th dim) has 4 elements, the 4th dim has 1 element that is the vector,\n",
    "the 3rd dim has 1 element that is the matrix with the vector, the 2nd dim has 1 element that is 3D array and\n",
    "1st dim has 1 element that is a 4D array."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b921e427",
   "metadata": {},
   "source": [
    "## intial placeholder in numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d814c2b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# create numpy array with all the values are zero\n",
    "x=np.zeros((4,5))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6468e780",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# create numpy array with all the values are one\n",
    "x=np.ones((4,5))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "80b871cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 5 5 5]\n",
      " [5 5 5 5]\n",
      " [5 5 5 5]\n",
      " [5 5 5 5]]\n"
     ]
    }
   ],
   "source": [
    "# array of perticular values\n",
    "x=np.full((4,4),5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c37a6c6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# creating identity matrix- all the diogonal element will be one and rest all the values \n",
    "x=np.eye(4)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "873842bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.26047351 0.59713824 0.15616444 0.41672586]\n",
      " [0.4232413  0.1188952  0.74494826 0.79226738]\n",
      " [0.70899618 0.11672829 0.54877322 0.40710021]]\n"
     ]
    }
   ],
   "source": [
    "# create array with random values\n",
    "x=np.random.random((3,4))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecfde415",
   "metadata": {},
   "source": [
    "- All the values you will get here will be in the range of 0 to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ee02f928",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[65 95 74 61]\n",
      " [26 89 77 16]\n",
      " [95 94 54 72]]\n"
     ]
    }
   ],
   "source": [
    "# create random int values\n",
    "x=np.random.randint(10,100,(3,4))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8f2ab324",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10. 15. 20. 25. 30.]\n"
     ]
    }
   ],
   "source": [
    "# creating array of evenly spaced values\n",
    "x=np.linspace(10,30,5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1a017e9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40 50]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# converting list to array\n",
    "list1=[10,20,30,40,50]\n",
    "array1=np.asarray(list1)\n",
    "print(array1)\n",
    "type(array1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8b563e98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40 50]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# converting tuple to array\n",
    "tuple1=(10,20,30,40,50)\n",
    "array1=np.asarray(tuple1)\n",
    "print(array1)\n",
    "type(array1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9349bf02",
   "metadata": {},
   "source": [
    "## Analysing numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "889ca9e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[71 94 83 34 16]\n",
      " [26 84 49 24 88]\n",
      " [48 19 79 23 97]\n",
      " [41 76 34 21 46]]\n",
      "Shape of the array:\n",
      " (4, 5)\n"
     ]
    }
   ],
   "source": [
    "# shape of the array\n",
    "x=np.random.randint(10,99,(4,5))\n",
    "print(x)\n",
    "print(f\"Shape of the array:\\n {x.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b3e190ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dimenation of the array\n",
    "x.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "5c1b8331",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# number of the element present in the array\n",
    "x.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "899a3a34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#checking the datatype of the element in the array\n",
    "x.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d97130d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17 11 19 11 16 11 14 12 14 10]\n"
     ]
    }
   ],
   "source": [
    "myarr=np.random.randint(10,20,10)\n",
    "print(myarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2fb462c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "39cbd6f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# index location of max value\n",
    "myarr.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "995ca729",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "1bc19630",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#index location of min value\n",
    "myarr.argmin()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55189b7d",
   "metadata": {},
   "source": [
    "## Mathematical Opearation with NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c09ce61a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1=[1,2,3,4,5]\n",
    "list2=[6,7,8,9,10]\n",
    "list1+list2 #==> instead of adding this PLus operator will concatenate the two list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b25d7e77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 11 17]\n",
      " [13 14 18]\n",
      " [17 19 15]]\n",
      "[[23 24 23]\n",
      " [27 29 27]\n",
      " [24 27 20]]\n"
     ]
    }
   ],
   "source": [
    "a=np.random.randint(10,20,(3,3))\n",
    "b=np.random.randint(20,30,(3,3))\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "590835b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[33 35 40]\n",
      " [40 43 45]\n",
      " [41 46 35]]\n"
     ]
    }
   ],
   "source": [
    "# let do some basic Mathematic Operations\n",
    "print(a+b) #==> same result could be obtained by np.add(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2dc7b4ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-13 -13  -6]\n",
      " [-14 -15  -9]\n",
      " [ -7  -8  -5]]\n"
     ]
    }
   ],
   "source": [
    "print(a-b) #==> same result could be obtained by np.substract(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "fd793616",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[230 264 391]\n",
      " [351 406 486]\n",
      " [408 513 300]]\n"
     ]
    }
   ],
   "source": [
    "print(a*b) #==> same result could be obtained by np.multiply(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1efbf9f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.43478261 0.45833333 0.73913043]\n",
      " [0.48148148 0.48275862 0.66666667]\n",
      " [0.70833333 0.7037037  0.75      ]]\n"
     ]
    }
   ],
   "source": [
    "print(a/b) #==> same result could be obtained by np.division(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "babdbe0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr=np.arange(0,11)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "419b000b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr+arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "146d78cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Admin\\AppData\\Local\\Temp\\ipykernel_9992\\1862401812.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  arr/arr\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([nan,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr/arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1a91cc2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "72067340",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 1.        , 1.41421356, 1.73205081, 2.        ,\n",
       "       2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ,\n",
       "       3.16227766])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "88a14d21",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,\n",
       "       -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849,\n",
       "       -0.54402111])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "98177418",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Admin\\AppData\\Local\\Temp\\ipykernel_9992\\3120950136.py:1: RuntimeWarning: divide by zero encountered in log\n",
      "  np.log(arr)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([      -inf, 0.        , 0.69314718, 1.09861229, 1.38629436,\n",
       "       1.60943791, 1.79175947, 1.94591015, 2.07944154, 2.19722458,\n",
       "       2.30258509])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3671a9db",
   "metadata": {},
   "source": [
    "- Since log of zero is infinity but still it giving result "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "59c1663a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "1858a247",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "f65074a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "89122457",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "f13eaedd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1622776601683795"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1a46c8c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "3ccc4e29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3, 9, 8, 3],\n",
       "       [4, 1, 1, 1, 5],\n",
       "       [1, 4, 4, 8, 8],\n",
       "       [9, 1, 9, 2, 8],\n",
       "       [7, 1, 3, 8, 3]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr=np.random.randint(1,10,(5,5))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "4112bbeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([22, 10, 26, 27, 27])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# summation across the rows\n",
    "arr.sum(axis=0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "046d41b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([24, 12, 25, 29, 22])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# summation across the column\n",
    "arr.sum(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e27f305",
   "metadata": {},
   "source": [
    "## Array Manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "20f691a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 10 15]\n",
      " [19 11 16]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1=np.random.randint(10,20,(2,3))\n",
    "print(array1)\n",
    "array1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "c9b30833",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 19]\n",
      " [10 11]\n",
      " [15 16]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transpose\n",
    "trans=np.transpose(array1)\n",
    "print(trans)\n",
    "trans.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "0f2af74d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[25 16 29]\n",
      " [12 18 27]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "# reshaping array\n",
    "a=np.random.randint(10,30,(2,3))\n",
    "print(a)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "fc76fcb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[25 16]\n",
      " [29 12]\n",
      " [18 27]]\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "b=a.reshape(3,2)\n",
    "print(b)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c7d6271",
   "metadata": {},
   "source": [
    "## Numpy Indexing and selection\n",
    "- Grabbing single element\n",
    "- Grabbing a slice of element\n",
    "- Brodcasting selection\n",
    "- Indexing and selection in two dimentions\n",
    "- Condition Selection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0396fa00",
   "metadata": {},
   "source": [
    "## Grabbing single element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "bc03bd3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "myarr=np.arange(0,11)\n",
    "print(myarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "675e48df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "72b27818",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr[3:5] #==> five is excluding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "fd8a7ef2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f73659f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr[5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1c03727",
   "metadata": {},
   "source": [
    "## Brodcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "4cc1f4bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "ba030952",
   "metadata": {},
   "outputs": [],
   "source": [
    "# it means you can reassign multiple values simultaneously\n",
    "myarr[0:5]=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "d273c698",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100, 100, 100, 100, 100,   5,   6,   7,   8,   9,  10])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "afd52272",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr=np.arange(0,11)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0651966c",
   "metadata": {},
   "source": [
    "## slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "f9feaf75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing section of array and setting it to new variable\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "2627e00a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slice_of_array=arr[0:5]\n",
    "slice_of_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "8192a241",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([99, 99, 99, 99, 99])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slice_of_array[:]=99\n",
    "slice_of_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "d3b8eea8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([99, 99, 99, 99, 99,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "388156b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_copy=arr.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "516aa5e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_copy[:]=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "b8a8908a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "e564938e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([99, 99, 99, 99, 99,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "793259b0",
   "metadata": {},
   "source": [
    "## slicing 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "607b8955",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 8 9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
    "print(arr[1, 1:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "22565534",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6]\n"
     ]
    }
   ],
   "source": [
    "#negative slicing\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "print(arr[-3:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a89c32c",
   "metadata": {},
   "source": [
    "## indexing and selection in two dimentional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "2e5ac465",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[21, 87, 18],\n",
       "       [49, 92, 85],\n",
       "       [29, 17, 83]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d=np.random.randint(10,99,(3,3))\n",
    "arr_2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "adb9c4c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "8243cbd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21, 87, 18])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to grab first row\n",
    "arr_2d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "042e12c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to grab third element in the first row\n",
    "arr_2d[0][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "f65a4684",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[21, 87, 18],\n",
       "       [49, 92, 85],\n",
       "       [29, 17, 83]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to get some slice or subsection of matrix\n",
    "arr_2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "593f57d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[87, 18],\n",
       "       [92, 85]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d[:2,1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "837b3f17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2nd element on 1st row: 2\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])\n",
    "print(f'2nd element on 1st row: {arr[0, 1]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dac91554",
   "metadata": {},
   "source": [
    "## Indexing in 3D array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "c2f67cf4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
    "print(arr[0, 1, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bc70674",
   "metadata": {},
   "source": [
    "## Condition and selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "a6b5edfc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr=np.arange(0,11)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "59eb2338",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False,  True,  True,  True,  True,\n",
       "        True,  True])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "710f9a3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_arr = arr > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "6954eda9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[bool_arr] #==> filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "b154eb07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same result can be obtained by following code\n",
    "arr[arr > 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "a538a979",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================================================================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"=\"*100)"
   ]
  }
 ],
 "metadata": {
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}