numpy_op.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector: 1-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "#Create a vector as a Row\n",
    "vector_row = np.array([1,2,3])\n",
    "print(vector_row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "#Create vector as a Column\n",
    "vector_column = np.array([[1],[2],[3]])\n",
    "print(vector_column)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#arange([start],stop,[step]) \n",
    "np.arange(0,10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.   2.5  5.   7.5 10. ]\n"
     ]
    }
   ],
   "source": [
    "lin_arr = np.linspace(0, 10, 5)  #start, stop, number of points evenly spaced\n",
    "print(lin_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.70236102 0.13153759 0.91758206 0.5472845 ]\n"
     ]
    }
   ],
   "source": [
    "my_rand = np.random.rand(4)\n",
    "print(my_rand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix: 2-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[1,2,3],[4,5,6]])\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros((2,2))   # Create an array of all zeros\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "b = np.ones((3,2))    # Create an array of all ones\n",
    "print(b) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 8]\n",
      " [8 8]\n",
      " [8 8]]\n"
     ]
    }
   ],
   "source": [
    "c = np.full((3,2), 8)  # Create a constant array\n",
    "print(c) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": [
    "d = np.eye(4)         # Create a 2x2 identity matrix\n",
    "print(d) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.77571651 0.77016212]\n",
      " [0.53253959 0.0984232 ]]\n"
     ]
    }
   ],
   "source": [
    "e = np.random.random((2,2))  # Create an array filled with random values\n",
    "print(e) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "#Create a vector as a Row\n",
    "vector_row = np.array([ 1,2,3,4,5,6 ])\n",
    "print(vector_row)\n",
    "#Create a Matrix\n",
    "matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [4, 5],\n",
       "       [7, 8]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix[2][1]\n",
    "matrix[:,0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_row[1:3:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_row[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_row[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_row[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n",
      "[1 2 3 4 5 6]\n",
      "[1 2 3]\n",
      "[4 5 6]\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#Select 3rd element of Vector\n",
    "print(vector_row[2])\n",
    "\n",
    "#Select 2nd row 2nd column\n",
    "print(matrix[1,1])\n",
    "#Select all elements of a vector\n",
    "print(vector_row[:])\n",
    "#Select everything up to and including the 3rd element\n",
    "print(vector_row[:3])\n",
    "#Select the everything after the 3rd element\n",
    "print(vector_row[3:])\n",
    "#Select the last element\n",
    "print(vector_row[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[2]\n",
      " [5]\n",
      " [8]]\n"
     ]
    }
   ],
   "source": [
    "#Select the first 2 rows and all the columns of the matrix\n",
    "print(matrix[:2,:])\n",
    "#Select all rows and the 2nd column of the matrix\n",
    "print(matrix[:,1:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "(3, 3)\n",
      "9\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(matrix)\n",
    "print(matrix.shape)\n",
    "\n",
    "print(matrix.size)\n",
    "#View the number of Dimensions(2 in this case)\n",
    "print(matrix.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix.argmax() #index of the highest value in the array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix.argmin() #index of the lowest value in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "9\n",
      "1\n",
      "[7 8 9]\n",
      "[3 6 9]\n",
      "sum:\n",
      "[12 15 18]\n",
      "[ 6 15 24]\n"
     ]
    }
   ],
   "source": [
    "print(matrix)\n",
    "print(np.max(matrix))  \n",
    "print(np.min(matrix))\n",
    "\n",
    "print(np.max(matrix,axis=0)) #max in each column \n",
    "print(np.max(matrix,axis=1)) #max in each row\n",
    "\n",
    "print('sum:')\n",
    "print( np.sum(matrix,axis=0) )  # sum along the cols\n",
    "print( np.sum(matrix,axis=1) )  #sum along the rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 6 9]\n"
     ]
    }
   ],
   "source": [
    "print(np.max(matrix,axis=1)) #max in each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n",
      "2.581988897471611\n",
      "6.666666666666667\n"
     ]
    }
   ],
   "source": [
    "#Mean\n",
    "print(np.mean(matrix))\n",
    "#Standard Dev.\n",
    "print(np.std(matrix))\n",
    "#Variance\n",
    "print(np.var(matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]\n",
      " [5]\n",
      " [6]\n",
      " [7]\n",
      " [8]\n",
      " [9]]\n",
      "[[1 2 3 4 5 6 7 8 9]]\n",
      "[1 2 3 4 5 6 7 8 9]\n",
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "#Reshape\n",
    "print(matrix.reshape(9,1))\n",
    "#Here -1 says as many columns as needed and 1 row\n",
    "print(matrix.reshape(1,-1))\n",
    "#If we provide only 1 value Reshape would return a 1-d array of that length\n",
    "print(matrix.reshape(9))\n",
    "#We can also use the Flatten method to convert a matrix to 1-d array\n",
    "print(matrix.flatten())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4 7]\n",
      " [2 5 8]\n",
      " [3 6 9]]\n"
     ]
    }
   ],
   "source": [
    "#Transpose the matrix\n",
    "print(matrix.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#Calculate the Determinant\n",
    "print(np.linalg.det(matrix))\n",
    "#Calculate the Rank\n",
    "print(np.linalg.matrix_rank(matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]\n",
      "[[-0.23197069 -0.78583024  0.40824829]\n",
      " [-0.52532209 -0.08675134 -0.81649658]\n",
      " [-0.8186735   0.61232756  0.40824829]]\n"
     ]
    }
   ],
   "source": [
    "# Calculate the Eigenvalues and Eigenvectors of that Matrix\n",
    "eigenvalues ,eigenvectors=np.linalg.eig(matrix)\n",
    "print(eigenvalues)\n",
    "print(eigenvectors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n",
      "32\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "#Create vector-1\n",
    "vector_1 = np.array([ 1,2,3 ])\n",
    "#Create vector-2\n",
    "vector_2 = np.array([ 4,5,6 ])\n",
    "#Calculate Dot Product\n",
    "print(np.dot(vector_1,vector_2))\n",
    "#Alternatively you can use @ to calculate dot products\n",
    "print(vector_1 @ vector_2)\n",
    "print(vector_1.dot(vector_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 8 10 12]\n",
      " [ 8 10 12]\n",
      " [ 8 10 12]]\n",
      "[[-6 -6 -6]\n",
      " [ 0  0  0]\n",
      " [ 6  6  6]]\n",
      "[[ 7 16 27]\n",
      " [16 25 36]\n",
      " [ 7 16 27]]\n"
     ]
    }
   ],
   "source": [
    "#Create Matrix-1\n",
    "matrix_1 = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "#Create Matrix-2\n",
    "matrix_2 = np.array([[7,8,9],[4,5,6],[1,2,3]])\n",
    "#Add the 2 Matrices\n",
    "print(np.add(matrix_1,matrix_2))\n",
    "#Subtraction\n",
    "print(np.subtract(matrix_1,matrix_2))\n",
    "#Multiplication(Element wise, not Dot Product)\n",
    "print(matrix_1*matrix_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 2]]\n",
      "[[-1.80952381  0.95238095 -0.14285714]\n",
      " [ 1.61904762 -0.9047619   0.28571429]\n",
      " [-0.14285714  0.28571429 -0.14285714]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[1,2,3],[4,5,6],[7,8,2]])\n",
    "print(matrix)\n",
    "#Calculate its inverse\n",
    "print(np.linalg.inv(matrix))"
   ]
  },
  {
   "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": []
  },
  {
   "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": "markdown",
   "metadata": {},
   "source": [
    "### Ref.\n",
    "\n",
    "1. https://becominghuman.ai/an-essential-guide-to-numpy-for-machine-learning-in-python-5615e1758301\n",
    "2. http://cs231n.github.io/python-numpy-tutorial/\n",
    "3. https://hackernoon.com/introduction-to-numpy-1-an-absolute-beginners-guide-to-machine-learning-and-data-science-5d87f13f0d51\n",
    "4. https://towardsdatascience.com/lets-talk-about-numpy-for-datascience-beginners-b8088722309f"
   ]
  },
  {
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}