Python (Tutorial of Numpy 100% practical complete).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A complete tutorial of Numpy 100% useful for machine learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "#To install library\n",
    "#pip install numpy\n",
    "# To call into program\n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------\n",
      "[1 5 9]\n",
      "---------------------------------------------------------------\n",
      "[[2]\n",
      " [7]\n",
      " [8]]\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#Creating a Vector\n",
    "\n",
    "#Problem : Create a vector by using numpy\n",
    "row=np.array([1,5,9])\n",
    "col=np.array([[2],\n",
    "             [7],\n",
    "             [8]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "# To get output use print command\n",
    "print(row)\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(col)\n",
    "print(\"---------------------------------------------------------------\")\n",
    "#Numpy's main data structure is he multi-dimensional array .To create a vector we simply create a one-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3]\n",
      " [3 7]\n",
      " [5 8]]\n",
      "-----------------------------------------------------------\n",
      "[[1 3 3]\n",
      " [7 5 8]]\n"
     ]
    }
   ],
   "source": [
    "# Reshape Arrays\n",
    "#problem:change shape of matrix without changing elements\n",
    "x=np.array([[1,3],\n",
    "              [3,7],\n",
    "               [5,8]])\n",
    "print(x)\n",
    "print(\"-----------------------------------------------------------\")\n",
    "print(x.reshape(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-12.999999999999995\n"
     ]
    }
   ],
   "source": [
    "# calculate Deteminant\n",
    "#problem:find  Deteminant of matrix\n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "print(np.linalg.det(x))# .det() is used to calculate determinant of matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------\n",
      "[[1 3]\n",
      " [3 7]\n",
      " [5 8]]\n",
      "---------------------------------------------------------------\n",
      "---------------------------------------------------------------\n",
      "[[1 3]\n",
      " [3 7]\n",
      " [5 8]]\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#creating a matrix\n",
    "\n",
    "#Problem:Create a matrix\n",
    "\n",
    "#solution:\n",
    "\n",
    "matrix=np.array([[1,3],\n",
    "              [3,7],\n",
    "               [5,8]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(matrix)\n",
    "print(\"---------------------------------------------------------------\")\n",
    "#or \n",
    "\n",
    "matrix_1=np.mat([[1,3],\n",
    "              [3,7],\n",
    "               [5,8]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(matrix_1)\n",
    "print(\"---------------------------------------------------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "#Rank of matrix\n",
    "#rank is dimensions of matrix\n",
    "#problem:find rank of matrix\n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "print(np.linalg.matrix_rank(x))#To find rank of matrix we use .matrix_rank() \n",
    "#here matrix is 3D "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3 5]\n",
      " [2 7 8]\n",
      " [3 9 2]]\n"
     ]
    }
   ],
   "source": [
    "#transposing a vector or matrix\n",
    "#transpose means swapped row into columns or columns into rows\n",
    "#problem: find transpose \n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "print(x.T)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (0, 0)\t3\n",
      "  (0, 2)\t5\n",
      "  (1, 1)\t8\n",
      "  (2, 0)\t1\n",
      "  (2, 2)\t6\n"
     ]
    }
   ],
   "source": [
    "#creating spare matrix\n",
    "\n",
    "#Problem:Given data with very few nonzeros values ,you want to efficiently represent it..\n",
    "\n",
    "# solution:Create a sparse matrix\n",
    "from scipy import sparse\n",
    "x=np.array([[3,0,5],\n",
    "           [0,8,0],\n",
    "           [1,0,6]])\n",
    "x_sparse=sparse.csr_matrix(x)\n",
    "print(x_sparse)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "#       (0[0],0[1],0[2]\n",
    "#       1[0],1[1],1[2]\n",
    "#       2[0],2[1],2[2])\n",
    "\n",
    "\n",
    "# Here in (0,0) we get 3.\n",
    "# means in row 0 and column's element 0 we have value 3.\n",
    "# In (1,1) we get 8\n",
    "# Here row 2 with column's element 1 we get 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------\n",
      "6\n",
      "---------------------------------------------------------------\n",
      "8\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# SELECTING ELEMENTS\n",
    "# PROBLEM: TO SELECT ONE OR MORE ELEMENTS IN MATRIX\n",
    "# To create row vector\n",
    "nv=np.array([1,6,5,3,8,9,11,24,33,23])\n",
    "#to create a matrix \n",
    "nv_1=np.array([[1,3,4],\n",
    "              [3,7,9],\n",
    "               [5,8,21]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv[1])# to select vector with position 1 ([0,1,,2,3,4,5,6,7,8,9,10])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv_1[2,1])# to select matrix element (2,1) i.e row 2 with element of colmun 1 \n",
    "                                                        #       (0[0],0[1],0[2]\n",
    "                                                        #       1[0],1[1],1[2]\n",
    "                                                        #       2[0],2[1],2[2])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------\n",
      "(3, 3)\n",
      "---------------------------------------------------------------\n",
      "2\n",
      "---------------------------------------------------------------\n",
      "9\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Describing a matrix\n",
    "# problem: find shape ,size and dimensions\n",
    "nv=np.array([[1,3,4],\n",
    "              [3,7,9],\n",
    "               [5,8,21]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv.shape)# to get shape we use .shape \n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv.ndim)# to get dimensions we use .ndim\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv.size)#to get Size we use .size\n",
    "print(\"---------------------------------------------------------------\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "#(3,3) means 3 rows with 3 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------\n",
      "[[101 103 104]\n",
      " [103 107 109]\n",
      " [105 108 121]]\n",
      "---------------------------------------------------------------\n",
      "[[ 0  2  3]\n",
      " [ 2  6  8]\n",
      " [ 4  7 20]]\n",
      "---------------------------------------------------------------\n",
      "[[ 2  6  8]\n",
      " [ 6 14 18]\n",
      " [10 16 42]]\n",
      "---------------------------------------------------------------\n",
      "[[ 0.5  1.5  2. ]\n",
      " [ 1.5  3.5  4.5]\n",
      " [ 2.5  4.  10.5]]\n",
      "---------------------------------------------------------------\n",
      "[[1 1 0]\n",
      " [1 1 1]\n",
      " [1 0 1]]\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#Applying operation to elements\n",
    "# problem:apply some operation to elements\n",
    "nv=np.array([[1,3,4],\n",
    "              [3,7,9],\n",
    "               [5,8,21]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv+100)# add 100 to matrix\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv-1)#subtract by1\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv*2)#multiply by 2\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv/2)#divide by 2\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(nv%2)#mod by 2\n",
    "print(\"---------------------------------------------------------------\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------\n",
      "1\n",
      "---------------------------------------------------------------\n",
      "21\n",
      "---------------------------------------------------------------\n",
      "[ 5  8 21]\n",
      "---------------------------------------------------------------\n",
      "[1 3 4]\n",
      "---------------------------------------------------------------\n",
      "[ 4  9 21]\n",
      "---------------------------------------------------------------\n",
      "[1 3 5]\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#finding min and max values\n",
    "#problem:find min and max values\n",
    "x=np.array([[1,3,4],\n",
    "              [3,7,9],\n",
    "               [5,8,21]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(x.min())\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(x.max())\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(np.max(x,axis=0))# find max element in each columns\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(np.min(x,axis=0))# find min element in each columns\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(np.max(x,axis=1))# find max element in each row\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(np.min(x,axis=1))# find min element in each row\n",
    "print(\"---------------------------------------------------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------\n",
      "6.777777777777778\n",
      "---------------------------------------------------------------\n",
      "31.28395061728395\n",
      "---------------------------------------------------------------\n",
      "5.593205754956986\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#calculate the average ,varience  and standard diversion\n",
    "#problem:calculate statistics about array\n",
    "x=np.array([[1,3,4],\n",
    "              [3,7,9],\n",
    "               [5,8,21]])\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(x.mean())# use mean()to calculate average.\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(x.var())# use .var() to calculate varience\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(x.std())# use .std() to calculate standard diversion\n",
    "print(\"---------------------------------------------------------------\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5488135  0.71518937 0.60276338 0.54488318]\n",
      "---------------------------------------------------------------\n",
      "[10 19  5  7]\n",
      "---------------------------------------------------------------\n",
      "[-0.05503512 -0.10731045  1.36546718 -0.09769572 -2.42595457]\n",
      "---------------------------------------------------------------\n",
      "[ 1.62933678 -0.67491949  0.61101311 -0.53976806  3.10638027]\n",
      "---------------------------------------------------------------\n",
      "[1.14035078 1.87008726 1.47360805 1.80091075]\n"
     ]
    }
   ],
   "source": [
    "# Generating random values \n",
    "#problem:Generate pesudo-random value\n",
    "#to set seed\n",
    "np.random.seed(0)\n",
    "#Generate four random floats \n",
    "x=np.random.random(4)\n",
    "#Generate four random int between 1,20\n",
    "y=np.random.randint(1,20,4)\n",
    "print(x)# to get random floats of seed 0\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(y)# to get output of  four random int between 1,20\n",
    "print(\"---------------------------------------------------------------\")\n",
    "x_1=np.random.normal(0.0,1.0,5)#Draw  five number from normal distribution with mean 0.0 and standard deviation of 1.0\n",
    "print(x_1)\n",
    "print(\"---------------------------------------------------------------\")\n",
    "x_2=np.random.logistic(0.0,1.0,5)#Draw  five number from logistic distribution with mean 0.0 and scale of 1.0\n",
    "print(x_2)\n",
    "print(\"---------------------------------------------------------------\")\n",
    "x_3=np.random.uniform(1.0,2.0,4)#Draw four number greater than r equal to1.0 and less than 2.0\n",
    "print(x_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4.5 -2.5]\n",
      " [-2.5  1.5]]\n",
      "---------------------------------------------------------------\n",
      "[[ 1.0000000e+00 -8.8817842e-16]\n",
      " [ 0.0000000e+00  1.0000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "# inverting a matrix\n",
    "#problem:calculate the inverse of square matrix\n",
    "x=np.array([[3,5],[5,9]])\n",
    "print(np.linalg.inv(x))# we use .linalg to calculate invere.\n",
    "#inverse of square matrix ,A is second matrix A' such that\n",
    "#  A*A'=I\n",
    "#where I is identity matrix\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(x@np.linalg.inv(x))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2 12 12]\n",
      " [ 9 14 18]\n",
      " [15 48  2]]\n"
     ]
    }
   ],
   "source": [
    "#multiply matrices\n",
    "#problem:multiply two matrices\n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "y=np.array([[2,6,4],\n",
    "              [3,2,2],\n",
    "               [3,6,1]])\n",
    "print((x*y))# to get multiplication of matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3  8  7]\n",
      " [ 6  9 11]\n",
      " [ 8 14  3]]\n",
      "---------------------------------------------------------------\n",
      "[[-1 -4 -1]\n",
      " [ 0  5  7]\n",
      " [ 2  2  1]]\n"
     ]
    }
   ],
   "source": [
    "#addition and subtraction of matrices\n",
    "#problem:calculate addition and subtraction of  two matrices\n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "y=np.array([[2,6,4],\n",
    "              [3,2,2],\n",
    "               [3,6,1]])\n",
    "print(np.add(x,y))\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(np.subtract(x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[17 28 11]\n",
      " [54 86 35]\n",
      " [40 58 38]]\n",
      "---------------------------------------------------------------\n",
      "26\n"
     ]
    }
   ],
   "source": [
    "#calculate Dot product\n",
    "#problem:find dot product of two matrices\n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "y=np.array([[2,6,4],\n",
    "              [3,2,2],\n",
    "               [3,6,1]])\n",
    "print(np.dot(x,y))\n",
    "\n",
    "\n",
    "print(\"---------------------------------------------------------------\")\n",
    "#problem:find dot product of two vectors\n",
    "x=np.array([1,2,3])\n",
    "y=np.array([2,6,4])\n",
    "print(np.dot(x,y))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[14.70132599  0.18111316 -4.88243915]\n",
      "---------------------------------------------\n",
      "[[-0.24095623 -0.82508529 -0.22189122]\n",
      " [-0.77562773  0.54745221 -0.55251079]\n",
      " [-0.58338814 -0.13975098  0.80342773]]\n"
     ]
    }
   ],
   "source": [
    "# Eigenvalues and Eigenvectors\n",
    "#problem:find eigenvalues and eigenvectors of square matrix\n",
    "#use linalg.eig\n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "x_eigenvalue,x_eigenvector=np.linalg.eig(x)\n",
    "print(x_eigenvalue)\n",
    "print(\"---------------------------------------------\")\n",
    "print(x_eigenvector)\n",
    "#eigenvalues and eigenvectors are used in machine learning libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 7 2]\n",
      "---------------------------------------------\n",
      "[2 9]\n",
      "---------------------------------------------\n",
      "[1 7 2]\n",
      "---------------------------------------------\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "#calculating the trace of matrix\n",
    "#the trace of matrix is sum of diagonal of elements of matrix.\n",
    "#problem:calculate trace of matrix\n",
    "x=np.array([[1,2,3],\n",
    "              [3,7,9],\n",
    "               [5,8,2]])\n",
    "print(x.diagonal())#return Diagonal values\n",
    "print(\"---------------------------------------------\")\n",
    "print(x.diagonal(offset=1))#return Diagonal values one above the main Diagonal\n",
    "print(\"---------------------------------------------\")\n",
    "print(x.diagonal(offset=0))#return Diagonal values one below the main Diagonal\n",
    "print(\"---------------------------------------------\")\n",
    "print(x.trace())# sum of diagonal elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}