Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "##NumPy , which stands for Numerical python\n",
    "import numpy as np #import numpy , np is an alias , we can use anything , it is just used to call numpy lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing the list in list format [2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Printing the datatype list format <class 'list'>\n",
      "[2 3 4 5 6 7 8 9]\n",
      "<class 'numpy.ndarray'>\n",
      "(8,)\n"
     ]
    }
   ],
   "source": [
    "#creating list\n",
    "lis=[2,3,4,5,6,7,8,9]\n",
    "print(\"Printing the list in list format\",end=\" \")\n",
    "print(lis)\n",
    "print(\"Printing the datatype list format\",end=\" \")\n",
    "print(type(lis)) \n",
    "new_list = np.array(lis)  #typecasting list into numpy array, using np variable to call numpy lib and store it into the new variable\n",
    "print(new_list)           #printing numpyarray\n",
    "print(type(new_list))     #checking data type of the newly created variable of numpy array\n",
    "print(new_list.shape)    #checking shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8]\n",
      "1\n",
      "(9,)\n",
      "[0. 1. 2. 3. 4. 5. 6. 7. 8.]\n",
      "[0 1 2 3 4 5 6 7 8]\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "sq = np.arange(9)       #creating an array arange is used to create an array from 0-8 , 9 elements\n",
    "print(sq)               #printing array\n",
    "print(sq.ndim)          #telling dimension of array using ndim function\n",
    "print(sq.shape)         #it will give the shape of array , we use shape function\n",
    "print(sq.astype(float)) #we are typecasting array type to float type (elements of array get typecasted into float type), using astype function\n",
    "print(sq.astype(int))   #we are typecasting array type to intt type (elements of array get typecasted into int type), using astype function\n",
    "print(len(sq))          #len is used to count length of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#linspace function\n",
    "\"\"\"start : starting value of sequence\n",
    "stop : end value of sseq\n",
    "num : number of samples/elements to be generated. Default is 50\n",
    "Endpoint = if true(default) , stop value is last value.if false , stop value is not last value\n",
    "\"\"\"       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 2.33333333, 3.66666667, 5.        ])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1.0,5.0, num=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.66666667, 1.33333333, 2.        ])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.8, 2.6, 3.4, 4.2])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1.0,5.0,num = 5,endpoint =False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The temp list is : \n",
      "[25.3, 55.3, 98.5, 50]\n",
      "The data type of list is : \n",
      "<class 'list'>\n",
      "The temp array after typecast is : \n",
      "[25.3 55.3 98.5 50. ]\n",
      "The type of temp array is : \n",
      "<class 'numpy.ndarray'>\n",
      "The converted array is : \n",
      "[ 77.54 131.54 209.3  122.  ]\n",
      "The type of converted array is : \n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "#temp conversion using numpy array\n",
    "temp = [25.3,55.3,98.5,50]\n",
    "print(\"The temp list is : \")\n",
    "print(temp)\n",
    "print(\"The data type of list is : \")\n",
    "print(type(temp))\n",
    "newarray = np.array(temp)\n",
    "print(\"The temp array after typecast is : \")\n",
    "print(newarray)\n",
    "print(\"The type of temp array is : \")\n",
    "print(type(newarray))\n",
    "\n",
    "carray = newarray*9/5 +32\n",
    "print(\"The converted array is : \")\n",
    "print(carray)\n",
    "print(\"The type of converted array is : \")\n",
    "print(type(carray))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[77.54, 131.54, 209.3, 122.0]\n"
     ]
    }
   ],
   "source": [
    "#without using numpy array\n",
    "fvalues = [x*9/5 + 32 for x in temp] #this is list format\n",
    "print(fvalues)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n",
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]]]\n"
     ]
    }
   ],
   "source": [
    "sq = np.arange(24) #creating an array of 24 elements\n",
    "print(sq) #printing\n",
    "b = sq.reshape(2,3,4) #reshape is used to convert single dim array into 2 dim array - here (2 - number of matrix that needs to be created from 24 elements, 4 - number of rows,3 - number of columns)\n",
    "print(b) #printing those matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31]\n",
      "[[[ 0  1  2  3  4  5  6  7]\n",
      "  [ 8  9 10 11 12 13 14 15]\n",
      "  [16 17 18 19 20 21 22 23]\n",
      "  [24 25 26 27 28 29 30 31]]]\n",
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]\n",
      "  [12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]\n",
      "  [24 25 26 27]\n",
      "  [28 29 30 31]]]\n",
      "[[[ 560  588  616  644]\n",
      "  [1456 1548 1640 1732]\n",
      "  [2352 2508 2664 2820]\n",
      "  [3248 3468 3688 3908]]]\n"
     ]
    }
   ],
   "source": [
    "sq = np.arange(32) #creating an array of 32 elements\n",
    "print(sq) #printing\n",
    "d = sq.reshape(1,4,8) #reshape is used to convert single dim array into 2 dim array - here (1 - number of matrix that needs to be created from 32 elements, 8 - number of rows,4 - number of columns)\n",
    "print(d) #printing those matrix\n",
    "e = sq.reshape(1,8,4)\n",
    "print(e)\n",
    "print(np.matmul(d,e)) #to multiply matrix in conventional form number of columns 1st matrix = number of rows of the 2nd matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31]\n",
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]\n",
      "  [12 13 14 15]]\n",
      "\n",
      " [[16 17 18 19]\n",
      "  [20 21 22 23]\n",
      "  [24 25 26 27]\n",
      "  [28 29 30 31]]]\n",
      "[[[ 0  2  4  6]\n",
      "  [ 8 10 12 14]\n",
      "  [16 18 20 22]\n",
      "  [24 26 28 30]]\n",
      "\n",
      " [[32 34 36 38]\n",
      "  [40 42 44 46]\n",
      "  [48 50 52 54]\n",
      "  [56 58 60 62]]]\n"
     ]
    }
   ],
   "source": [
    "sq = np.arange(32) #creating an array of 32 elements\n",
    "print(sq) #printing\n",
    "c = sq.reshape(2,4,4) #reshape is used to convert single dim array into 2 dim array - here (2 - number of matrix that needs to be created from 32 elements, 4 - number of rows,4 - number of columns)\n",
    "print(c) #printing those matrix\n",
    "print(c+c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5 8]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "[[ 4 10 24]\n",
      " [16 25 48]\n",
      " [28 40 72]]\n"
     ]
    }
   ],
   "source": [
    "#how to add values to a matrix\n",
    "know = np.array([4,5,8])\n",
    "print(know)\n",
    "how = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(how)\n",
    "print(know*how)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "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",
      " [1 1 1 1]\n",
      " [1 1 1 1]]\n",
      "[[0.58163479 0.67186697 0.71775816]\n",
      " [0.22858556 0.98124281 0.36249169]\n",
      " [0.05250998 0.48526589 0.93323032]\n",
      " [0.86826646 0.76228356 0.98669891]]\n",
      "[[0.42662227 0.86348596 0.61812455]\n",
      " [0.61247613 0.28163184 0.99408158]\n",
      " [0.01716972 0.34750798 0.343606  ]\n",
      " [0.60766638 0.0490193  0.46945032]]\n",
      "[[1.00825706 1.53535293 1.33588272]\n",
      " [0.84106169 1.26287466 1.35657327]\n",
      " [0.06967969 0.83277386 1.27683633]\n",
      " [1.47593285 0.81130286 1.45614923]]\n",
      "[[ 0.15501253 -0.19161898  0.09963361]\n",
      " [-0.38389058  0.69961097 -0.63158989]\n",
      " [ 0.03534026  0.13775791  0.58962432]\n",
      " [ 0.26060008  0.71326426  0.51724858]]\n"
     ]
    }
   ],
   "source": [
    "W = np.ones((3,4)) #it will create matrix of ones\n",
    "print(W)\n",
    "m = np.ones([3,4]) # it will work for list type array also ie square brackets\n",
    "#we can also change the data type of ones matrix\n",
    "l = np.ones((3,4) , dtype = int) #dtype will convert the by default float type to int type but for random matrix it doesn't work random matrix will always be in float\n",
    "print(l)\n",
    "X = np.random.random([4,3]) #random function will randomly create a 4*3 matrix with random flaot elements\n",
    "print(X)  \n",
    "Y = np.random.random([4,3]) #it will throw error when number of rows and columns that needs to be added are different\n",
    "print(Y)\n",
    "s = np.add(X,Y) # we can also us X+Y\n",
    "print(s)\n",
    "print(X-Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 4 0 8 8 9 6 7 8 2]\n",
      "5.7\n",
      "9\n",
      "0\n",
      "2.794637722496424\n",
      "6.5\n",
      "7.81\n"
     ]
    }
   ],
   "source": [
    "data= np.array([5,4,0,8,8,9,6,7,8,2])\n",
    "print(data)\n",
    "print(data.mean())\n",
    "print(np.max(data))\n",
    "print(np.min(data))\n",
    "print(np.std(data)) #standard deviation\n",
    "print(np.median(data))\n",
    "print(np.var(data)) #variance\n",
    "#mode is not supported"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#dot product\n",
    "f= np.array([1,2])\n",
    "g= np.array([4,5])\n",
    "np.dot(f,g) #1*4 +2*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#min dimension\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "#resize - resize is not transpose\n",
    "a = np.array([[1,2,3],[4,5,6]])\n",
    "b = a.reshape(3,2)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int16\n",
      "[[  3   8   9]\n",
      " [  1  -7   0]\n",
      " [  4 123   4]]\n"
     ]
    }
   ],
   "source": [
    "##create a new data type\n",
    "i16=np.dtype(np.int16) #like int16 , there are int32, int64 we can increase the bit size\n",
    "#i16\n",
    "print(i16)\n",
    "\n",
    "##creating a list\n",
    "fst = [[3.4,8.7,9.9],[1.1,-7.8,-0.7],[4.1,123,4.8]]\n",
    "\n",
    "#create a array with input list n datatype the newly created one\n",
    "A=np.array(fst,dtype=i16)\n",
    "#A=np.array(fst,dtype=np.int16) - this will also give the same result - we can use this directly\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('name', 'S10'), ('age', '<i8'), ('marks', '<f8')]\n",
      "[(b'abc', 21, 50.) (b'xyz', 18, 75.)]\n",
      "[b'abc' b'xyz']\n"
     ]
    }
   ],
   "source": [
    "student = np.dtype([('name','S10'),('age','i8'),('marks','f8')])\n",
    "print(student)\n",
    "\n",
    "a=np.array([('abc',21,50),('xyz',18,75)],dtype=student)\n",
    "print(a)\n",
    "\n",
    "print(a['name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [3 4 5]\n",
      " [4 5 6]]\n",
      "\n",
      "\n",
      "The items in the second column are \n",
      "[2 4 5]\n",
      "\n",
      "\n",
      "The items in the second row are \n",
      "[3 4 5]\n",
      "\n",
      "\n",
      "The items in the column 1 onwards are \n",
      "[[2 3]\n",
      " [4 5]\n",
      " [5 6]]\n",
      "\n",
      "\n",
      "The items in the row 1 onwards are \n",
      "[[3 4 5]\n",
      " [4 5 6]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3],[3,4,5],[4,5,6]])\n",
    "print(a)\n",
    "print('\\n')\n",
    "print('The items in the second column are ')\n",
    "print(a[..., 1])\n",
    "print('\\n')\n",
    "\n",
    "print('The items in the second row are ')\n",
    "print(a[1,...])\n",
    "print('\\n')\n",
    "print('The items in the column 1 onwards are ')\n",
    "print(a[...,1:])\n",
    "print('\\n')\n",
    "print('The items in the row 1 onwards are ')\n",
    "print(a[1:,...]) #or (a[1:,:]) will also give the same answer\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matrix a :\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "matrix b : \n",
      "[1 2]\n",
      "multiplication with broadcasting : \n",
      "[[1 4]\n",
      " [3 8]]\n",
      "now addition using broadcasting\n",
      "[[2 4]\n",
      " [4 6]]\n"
     ]
    }
   ],
   "source": [
    "#broadcasting\n",
    "A= np.array([(1,2),(3,4)])\n",
    "B= np.array([1,2])\n",
    "print(\"matrix a :\")\n",
    "print(A)\n",
    "\n",
    "print(\"matrix b : \")\n",
    "print(B)\n",
    "\n",
    "print(\"multiplication with broadcasting : \")\n",
    "print(A*B)\n",
    "\n",
    "print(\"now addition using broadcasting\")\n",
    "print(A+B)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#flatten\n",
    "A.flatten() # it will flatten the 2d array into one dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "horizontal append  [1 2 3 4 5 6]\n",
      "vertical append \n",
      "  [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "#stack n vstack\n",
    "f= np.array([1,2,3])\n",
    "g=np.array([4,5,6])\n",
    "\n",
    "print(\"horizontal append \", np.hstack((f,g)))\n",
    "print(\"vertical append \\n \", np.vstack((f,g)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "6\n",
      "median is :  4.5\n"
     ]
    }
   ],
   "source": [
    "def med(lis):\n",
    "    \n",
    "    ls=sorted(lis)\n",
    "    print(ls)\n",
    "    n=len(ls)\n",
    "    print(n)\n",
    "    h=n//2\n",
    "##print(h)\n",
    "##hh=(n/2)+1\n",
    "##m = int(ls[h])\n",
    "#print(m)\n",
    "    if(n%2 ==0):\n",
    "            med=(ls[h]+ls[h+1])/2\n",
    "            print(\"median is : \" , med)\n",
    "    else:\n",
    "            med=ls[h+1]\n",
    "            print(\"median is : \" , med)\n",
    "\n",
    "lis = [3,2,5,1,6,4]\n",
    "med(lis)\n",
    "            \n",
    "          \n",
    "        \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 40, 60, 80, 86]\n",
      "the 3 central values are : \n",
      "40\n",
      "60\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "def central(ls):\n",
    " \n",
    "    sot=sorted(ls)\n",
    "    print(sot)\n",
    "    n=len(sot)\n",
    "    mid=n//2\n",
    "    print(\"the 3 central values are : \")\n",
    "    print(sot[mid-1])\n",
    "    print(sot[mid])\n",
    "    print(sot[mid+1])\n",
    "\n",
    "ls=[40,20,60,80,86]\n",
    "central(ls)"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}