numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "successful-stadium",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bright-palestine",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10)\n",
    "#it generates array from 0 to 9 (always exclude upper limit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "wireless-chemistry",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,10)\n",
    "#can also specify starting number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "weighted-privacy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,10,2)\n",
    "#can also specify steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "modular-boating",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. ,\n",
       "       7.5, 8. , 8.5, 9. , 9.5])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,10,0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "aware-dodge",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#now as we can see we are only generating integers but what if we want to generate floats\n",
    "np.arange(1,10,dtype='float64') #dtype refers to data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "white-apparatus",
   "metadata": {},
   "outputs": [],
   "source": [
    "#storing the generated array in array\n",
    "arr = np.arange(1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "located-swimming",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.ndim\n",
    "#this gives the dimention of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "logical-potter",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9,)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape\n",
    "#it gives us shape of array i.e., 9 for 9 elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "prescription-geometry",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.size\n",
    "#gives the size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "liable-synthesis",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.dtype\n",
    "#gives type of data stored in array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "electronic-elder",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.itemsize\n",
    "#gives the size of one item in array (in bytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "minor-cleanup",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#calculating the memeory usage for arrays (in bytes)\n",
    "arr.itemsize*arr.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "floating-publisher",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "126 ns ± 0.786 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n",
      "605 ns ± 5.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "#Why is numpy used?\n",
    "#Apart from many usely function in the numpy library numpy does vectorized calculations (i.e., numpy does all the\n",
    "#different calculations on matrices or 2d 3d arrays in a vectorized manner) so that you get faster output compared\n",
    "#to normal list based operations\n",
    "#Example:\n",
    "%timeit list1 = range(1,1000)  #timeit function just time the operations\n",
    "%timeit list2 = np.arange(1,1000)\n",
    "#so here in case of list 1 we have to execute more loops than while using numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "resident-craps",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "#asarray function convert any python list into a numpy array\n",
    "print(np.asarray([1,2,3,4,5]))\n",
    "list2d =[[1,2,3],[4,5,6]]\n",
    "arr2d = np.asarray(list2d)\n",
    "print(arr2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "stuck-lover",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "#this will give a 3*4 numpy array of zeroes\n",
    "listofzeros = np.zeros((3,4),dtype='int32') #passing 3,4 as tuple\n",
    "print(listofzeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "exterior-caribbean",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4.])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Linspace\n",
    "np.linspace(1,4,num=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "relevant-short",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.42857143, 1.85714286, 2.28571429, 2.71428571,\n",
       "       3.14285714, 3.57142857, 4.        ])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1,4,num=8)\n",
    "#this will generate any amount of number in a given range so here num=8 means it will generate 8 numbers within the\n",
    "#range of (1,4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "rural-costume",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.   , 1.375, 1.75 , 2.125, 2.5  , 2.875, 3.25 , 3.625])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1,4,num=8,endpoint=False) #remember False in python starts with capital letter\n",
    "#if we use endpoint = False 4 is excluded from list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "integral-tobago",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.12523163, 0.98076502, 0.61549035, 0.40614452],\n",
       "       [0.71135075, 0.15173963, 0.05998674, 0.13877801],\n",
       "       [0.80638169, 0.27083348, 0.66804508, 0.69802804]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Random generator\n",
    "np.random.random((3,4))\n",
    "#this way we will get a 3*4 matrix with random values between 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "specified-whale",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.995919   0.64934539 0.48093762 0.27534529]\n",
      " [0.73401241 0.44567063 0.49891889 0.14168418]\n",
      " [0.89596722 0.86080143 0.72309068 0.21747493]]\n"
     ]
    }
   ],
   "source": [
    "rarr = np.random.random((3,4))\n",
    "#storing random array in 3*6 matrix\n",
    "print(rarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "executive-brunswick",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.995919  , 0.86080143, 0.72309068, 0.27534529])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#to calculate max from each column\n",
    "np.max(rarr,axis=0)  #note axis=0 is column use axis=1 for row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "architectural-worth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.27534529, 0.14168418, 0.21747493])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#to calculate min from each row\n",
    "np.min(rarr,axis=1) #note axis=1 is row use axis=0 for column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "local-genre",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9959190018068892"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#to calculate max from whole matrix don't pass any axis\n",
    "np.max(rarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "verified-pittsburgh",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.89596722, 0.64934539, 0.49891889, 0.21747493])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#similarly to calculate median\n",
    "np.median(rarr,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "painted-canberra",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.995919   0.64934539 0.48093762 0.27534529 0.73401241 0.44567063\n",
      " 0.49891889 0.14168418 0.89596722 0.86080143 0.72309068 0.21747493]\n"
     ]
    }
   ],
   "source": [
    "#Reshaping\n",
    "#this reshapes the array i.e., changes the dimention of array\n",
    "new_arr = np.reshape(rarr,(12,)) #(12,) means single dimention array of 12 size (tuple format)\n",
    "print(new_arr)\n",
    "\n",
    "#general format np.reshape(array, newshape, order='C') here order is index ordering read more in numpy documentations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "married-cartridge",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Slicing in numpy\n",
    "#creating array rarr of 4*5 dimentions and storing random numbers in it\n",
    "rarr = np.random.random((4,5))\n",
    "#note slicing means generating new matrices from given matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "proved-beast",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.59240594, 0.74283254, 0.75769391, 0.15455023, 0.93904328],\n",
       "       [0.98676453, 0.31889405, 0.0097815 , 0.90026196, 0.3142765 ],\n",
       "       [0.53282773, 0.37547214, 0.53315197, 0.66002389, 0.20759679],\n",
       "       [0.22974081, 0.14280759, 0.36496336, 0.83159365, 0.22128509]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rarr[:,:] #basic format of slicing first : is for rows and second : is for columns\n",
    "#now :,: means all rows and all columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "black-radio",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.98676453, 0.31889405, 0.0097815 , 0.90026196, 0.3142765 ],\n",
       "       [0.53282773, 0.37547214, 0.53315197, 0.66002389, 0.20759679]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rarr[1:3,:] #to select only 2nd and 3rd rows and all columns \n",
    "#note upper limit is always excluded in python also note the index based numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "prompt-gates",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.74283254, 0.75769391, 0.15455023, 0.93904328],\n",
       "       [0.31889405, 0.0097815 , 0.90026196, 0.3142765 ],\n",
       "       [0.37547214, 0.53315197, 0.66002389, 0.20759679],\n",
       "       [0.14280759, 0.36496336, 0.83159365, 0.22128509]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rarr[:,1:] #this will take all rows and columns from 1 till last (here 1 is index based)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "buried-pressing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.31889405, 0.0097815 ],\n",
       "       [0.37547214, 0.53315197]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rarr[1:3,1:3] #just another example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "electric-engineering",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.59240594, 0.74283254, 0.75769391, 0.15455023, 0.93904328],\n",
       "       [0.98676453, 0.31889405, 0.0097815 , 0.90026196, 0.3142765 ],\n",
       "       [0.53282773, 0.37547214, 0.53315197, 0.66002389, 0.20759679]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#special notations in slicing i.e., using -1\n",
    "rarr[:-1,:]\n",
    "#this means all columns but excluding last row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "portable-nightlife",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.22974081, 0.14280759, 0.36496336, 0.83159365, 0.22128509]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rarr[-1:,:] \n",
    "#selecting all columns and only first row\n",
    "#these special notations can be used to slice out np arrays whose size are unknown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "conventional-alert",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.22974081, 0.14280759, 0.36496336, 0.83159365, 0.22128509])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rarr[-1,:] #this also works the same way as above example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "saved-german",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.93904328, 0.3142765 , 0.20759679, 0.22128509])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rarr[:,-1] #selecting only last column"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}