NumPy-fundamentals-for-beginners.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1c4dde62",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "885d9f9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# create one dimensional array of hard coded values\n",
    "arr = np.array([1,2,3,4])\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f93ae7a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[100   2   3   4]\n"
     ]
    }
   ],
   "source": [
    "# access array element by index\n",
    "arr = np.array([1,2,3,4])\n",
    "print(arr[0])\n",
    "\n",
    "# modify array element \n",
    "arr[0] = 100\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "36d44d1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# create one dimensional array of values within the given range\n",
    "arr = np.arange(5)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "eb0e457f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [11, 12, 13, 14]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a two dimensional array \n",
    "arr = np.array([[1,2,3,4],[5,6,7,8],[11,12,13,14]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8d57a4ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.30382141, 0.46471536, 0.11619559, 0.19795021],\n",
       "       [0.92436647, 0.87635375, 0.09723231, 0.69274036],\n",
       "       [0.34688857, 0.43689242, 0.60374348, 0.63606045]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a two dimensional array with random numbers between 0 and 1\n",
    "np.random.rand(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "004ae1ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10.12788301, 10.7438313 , 10.40489251, 10.08876065],\n",
       "       [10.67175302, 10.61925441, 10.59842178, 10.7067809 ],\n",
       "       [10.3810884 , 10.39430522, 10.79904654, 10.4473923 ]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a two dimensional array with random numbers between 10 and 11\n",
    "np.random.rand(3,4) + 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "33a5df16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# array reshaping, convert 1-D array to 2-D array\n",
    "arr = np.array([1,2,3,4,5,6]).reshape(2,3)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "50db9213",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
       "       34, 35])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# flatten a multi-dimensional array into 1-D array via ravel method\n",
    "arr = np.arange(36).reshape(2,6,3)\n",
    "arr.ravel()\n",
    "\n",
    "# Cautions! : ravel method returns a flattened view of the original array, not a separate copy.\n",
    "# Hence any update on it will update the original array.\n",
    "# Rather use flatten method if you would need a complete separate copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "5de430ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
       "       34, 35])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# flatten a multi-dimensional array into 1-D array via flatten method\n",
    "arr = np.arange(36).reshape(2,6,3)\n",
    "arr.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "d6bb9dca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a + b  = [ 6  8 10 12]\n",
      "a - b  = [-4 -4 -4 -4]\n",
      "a * b  = [ 5 12 21 32]\n",
      "a / b  = [0.2        0.33333333 0.42857143 0.5       ]\n",
      "a % b  = [1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# arithematic operations on arrays\n",
    "a = np.array([1, 2, 3, 4])\n",
    "b = np.array([5, 6, 7, 8])\n",
    "print(\"a + b  =\", a + b)\n",
    "print(\"a - b  =\", a - b)\n",
    "print(\"a * b  =\", a * b)\n",
    "print(\"a / b  =\", a / b)\n",
    "print(\"a % b  =\", a % b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "391286e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True  True False False False]\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# conditional operatoin on arrays\n",
    "arr = np.array([1,2,3,4,5,6])\n",
    "\n",
    "# print true/false for each element for below condition\n",
    "print(arr <=3)\n",
    "\n",
    "# print only elements meeting below condition\n",
    "print(arr[arr<=3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2c2092fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min = 1\n",
      "max = 6\n",
      "sum = 21\n",
      "prod = 720\n",
      "std = 1.707825127659933\n",
      "var = 2.9166666666666665\n"
     ]
    }
   ],
   "source": [
    "# mathematical and statistical functions\n",
    "arr = np.array([1,2,3,4,5,6])\n",
    "\n",
    "for func in (arr.min, arr.max, arr.sum, arr.prod, arr.std, arr.var):\n",
    "    print(func.__name__, \"=\", func())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "3d52de99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 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",
      "[[12 14 16 18]\n",
      " [20 22 24 26]\n",
      " [28 30 32 34]]\n",
      "[[12 15 18 21]\n",
      " [48 51 54 57]]\n",
      "[[ 6 22 38]\n",
      " [54 70 86]]\n"
     ]
    }
   ],
   "source": [
    "# sum across depth, heigh and width\n",
    "\n",
    "arr = np.arange(24).reshape(2,3,4)\n",
    "print(arr)\n",
    "\n",
    "# sum across depth, axis=0\n",
    "print(arr.sum(axis=0))\n",
    "\n",
    "\n",
    "# sum across height, axis=1\n",
    "print(arr.sum(axis=1))\n",
    "\n",
    "# sum across width, axis=2\n",
    "print(arr.sum(axis=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "19ff295f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " absolute = [1 2 3 4 5 6]\n",
      "\n",
      " sqrt = [1.         1.41421356 1.73205081 2.         2.23606798 2.44948974]\n",
      "\n",
      " exp = [  2.71828183   7.3890561   20.08553692  54.59815003 148.4131591\n",
      " 403.42879349]\n",
      "\n",
      " log = [0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947]\n",
      "\n",
      " sign = [1 1 1 1 1 1]\n",
      "\n",
      " ceil = [1. 2. 3. 4. 5. 6.]\n",
      "\n",
      " modf = (array([0., 0., 0., 0., 0., 0.]), array([1., 2., 3., 4., 5., 6.]))\n",
      "\n",
      " isnan = [False False False False False False]\n",
      "\n",
      " cos = [ 0.54030231 -0.41614684 -0.9899925  -0.65364362  0.28366219  0.96017029]\n"
     ]
    }
   ],
   "source": [
    "# universal functions\n",
    "arr = np.array([1,2,3,4,5,6])\n",
    "\n",
    "for func in (np.abs, np.sqrt, np.exp, np.log, np.sign, np.ceil, np.modf, np.isnan, np.cos):\n",
    "    print(\"\\n\", func.__name__, \"=\", func(arr))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0b9a2344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " add = [ 7  9 11 13 15]\n",
      "\n",
      " greater = [False False False False False]\n",
      "\n",
      " maximum = [ 6  7  8  9 10]\n",
      "\n",
      " minimum = [1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "# binary functions\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([6,7,8,9,10])\n",
    "\n",
    "for func in (np.add, np.greater, np.maximum, np.minimum):\n",
    "    print(\"\\n\", func.__name__, \"=\", func(arr1, arr2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "14741611",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[2 3]\n",
      "[2 3 4]\n",
      "[1 4]\n"
     ]
    }
   ],
   "source": [
    "# index range for 1-D arrays\n",
    "arr = np.array([1,2,3,4,5])\n",
    "print(arr[:3])   ## print elements from index 0 to (3-1)\n",
    "print(arr[1:3])  ## print elements from index 1 to (3-1)\n",
    "print(arr[1:-1]) ## print elements from index 1 to (last index -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "f6558890",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[5 6 7 8 9]\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# iterate over array\n",
    "arr = np.arange(10).reshape(2,5)\n",
    "for i in arr:\n",
    "    print(i)\n",
    "\n",
    "# iterate over each individual elements of the array\n",
    "for i in arr.flat:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "2560dfa0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# stacking together different arrays\n",
    "q1 = np.array([1,2,3])\n",
    "q2 = np.array([4,5,6])\n",
    "q3 = np.array([7,8,9])\n",
    "\n",
    "# vertical stacking\n",
    "q4 = np.vstack((q1, q2, q3))\n",
    "print(q4)\n",
    "\n",
    "# horizontal stacking\n",
    "q5 = np.hstack((q1, q2, q3))\n",
    "print(q5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "3d0402b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]]\n",
      "[[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]]\n",
      "[[12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]]\n",
      "[[ 0  1  2]\n",
      " [ 6  7  8]\n",
      " [12 13 14]\n",
      " [18 19 20]]\n",
      "[[ 3  4  5]\n",
      " [ 9 10 11]\n",
      " [15 16 17]\n",
      " [21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "# split arrays\n",
    "arr = np.arange(24).reshape(4,6)\n",
    "print(arr)\n",
    "\n",
    "# vertical split\n",
    "v1,v2 = np.vsplit(arr, 2)\n",
    "print(v1)\n",
    "print(v2)\n",
    "\n",
    "# horizontal split\n",
    "v3,v4 = np.hsplit(arr,2)\n",
    "print(v3)\n",
    "print(v4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "7c611e4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix:\n",
      "[[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]]\n",
      "After transpose:\n",
      "[[ 0  6 12 18]\n",
      " [ 1  7 13 19]\n",
      " [ 2  8 14 20]\n",
      " [ 3  9 15 21]\n",
      " [ 4 10 16 22]\n",
      " [ 5 11 17 23]]\n"
     ]
    }
   ],
   "source": [
    "# matrix operations : Transpose\n",
    "\n",
    "m = np.arange(24).reshape(4,6)\n",
    "\n",
    "print(\"Original matrix:\")\n",
    "print(m)\n",
    "\n",
    "print(\"After transpose:\")\n",
    "print(m.T)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "01ce6ba6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "[[ 7  8  9]\n",
      " [10 11 12]]\n",
      "[[ 27  30  33]\n",
      " [ 61  68  75]\n",
      " [ 95 106 117]]\n"
     ]
    }
   ],
   "source": [
    "# matrix operations : Multiplication\n",
    "m1=np.array([[1,2],[3,4],[5,6]])\n",
    "print(m1)\n",
    "\n",
    "m2=np.array([[7,8,9],[10,11,12]])\n",
    "print(m2)\n",
    "\n",
    "M = m1.dot(m2)\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "36c13990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2.31818182  0.56818182  0.02272727]\n",
      " [ 1.72727273 -0.72727273  0.09090909]\n",
      " [-0.04545455  0.29545455 -0.06818182]]\n"
     ]
    }
   ],
   "source": [
    "# matrix operations : Inverse\n",
    "import numpy.linalg as linalg\n",
    "m = np.array([[1,2,3],[5,7,11],[21,29,31]])\n",
    "print(linalg.inv(m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "85ca0d3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.00000000e+00 -5.55111512e-17  0.00000000e+00]\n",
      " [-2.98372438e-16  1.00000000e+00 -5.55111512e-17]\n",
      " [ 5.78009862e-15  1.27675648e-15  1.00000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "# identity matrix\n",
    "import numpy.linalg as linalg\n",
    "m = np.array([[1,2,3],[5,7,11],[21,29,31]])\n",
    "print(m.dot(linalg.inv(m))) ## this generates identity matrix as we multiply a matrix by its inverse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "522b45c4",
   "metadata": {},
   "source": [
    "## Solving a linear equation\n",
    "* $2x + 6y = 6$\n",
    "* $5x + 3y = -9$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "348916f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.,  2.])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a  = np.array([[2, 6], [5, 3]])\n",
    "b = np.array([6, -9])\n",
    "s = linalg.solve(a, b)\n",
    "s"
   ]
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}