Numpy ADSP Jan 1 (3).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "344c0dd3-ddeb-407f-9f05-bc2766d233f3",
   "metadata": {},
   "source": [
    "# Numpy\n",
    "\n",
    "## Agenda\n",
    "- Fundamentals of numpy\n",
    "  - Advantages\n",
    "  - Numpy Installation and import\n",
    "- Arrays\n",
    "  - Creating Numpy arrays\n",
    "- Attributes\n",
    "- Array Functions\n",
    "  - Arithmetic\n",
    "  - Statistical\n",
    "  - String\n",
    "  - Miscellaneous\n",
    "- Array Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "461e188b-2da7-4a79-aded-9682fdb601ad",
   "metadata": {},
   "source": [
    "## Fundamentals of Numpy\n",
    "Numpy (Numerical Python) is a free, open source python library which is primrily used for mathematical computations. it is prefered over the traditional math module in python for math computation as numpy process the data if a faster way than traditional python. Numpy achieves this by utilizing the arrays (Collection of data arranged in a contiguos memory )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d5da23b9-589c-403a-9369-96a1d219e8cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "25d6f2ed-e0a7-4e11-aaba-8ec9db9702cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1736433015.9258747"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.time()  # gives the time elapsed since epoch(1-1-1970, 00:00:00) in seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "01945478-2b94-4232-b04f-23b55cc1c1a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1736433015.9484406"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.time() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cb96c991-916d-475f-a789-41939915e9d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "X =  np.random.rand(100000000)   # Generated random floating point numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b8d34b96-d674-402b-8ada-22a32780aa93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.696895599365234\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "m =  sum(X)/100000000  # mean using traditional python\n",
    "stop = time.time()\n",
    "print(stop- start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f4577d52-07bd-4dda-8034-a0eb31219272",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.30915045738220215\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "m =  np.mean(X)  # mean calculation using numpy library\n",
    "stop = time.time()\n",
    "print(stop- start)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a20b1f8-1e42-4411-abad-2ad86ae7b329",
   "metadata": {},
   "source": [
    "Dated -  08-01-2025"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "42b35d59-3c86-44b3-96c7-86535768f6c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install numpy\n",
    "# pip(prefered python installer) install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e5e38319-a686-49cf-8daf-0505ed54031c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in c:\\users\\slp12264\\appdata\\local\\anaconda3\\lib\\site-packages (1.26.4)Note: you may need to restart the kernel to use updated packages.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "302230ef-b12a-4652-94ce-73d6d91af0ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "## import the library - it allows to use the library and its content for the current file.\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4f6e780-1869-4af0-836b-ad96575a39d3",
   "metadata": {},
   "source": [
    "### Creation of arrays using numpy.\n",
    "There are two ways by which arrays can be formed using numpy\n",
    "- using the inbulit array() function  - converts other sequential  data structure to form array\n",
    "- using miscellaneous functions - generates arrays using some conditions.\n",
    "  \n",
    "#### Arrays \n",
    "arrays is a collection of homogeneous data elements arranged in contiguos manner. These are represented as space seperated values enclosed within square brackets in python. arrays can attain any number of dimensions i.e. an array is python can be 0 dimensional, 1 dimensional, 2 dimensional, n-dimensional. The numpy arrays are often termed as ndarray.\n",
    "\n",
    "#### creating arrays using array function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7cbd7e47-aeed-42ad-b80f-cfb5fecc2af7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "<class 'numpy.ndarray'>\n",
      "The Number of dimensions is 0\n",
      "The shape of the array is ()\n",
      "The Size of the array is 1\n",
      "Elements data type in the array is int32\n"
     ]
    }
   ],
   "source": [
    "# creating a zero dimensional array\n",
    "## we can create a 0darray by passing a scalar value inside the numpy array function\n",
    "\n",
    "zero_d_array =  np.array(5)\n",
    "print(zero_d_array)\n",
    "print(type(zero_d_array))\n",
    "## ndarray attributes\n",
    "print(f'The Number of dimensions is {zero_d_array.ndim}')  # gives the number of dimensions of the array\n",
    "print(f'The shape of the array is {zero_d_array.shape}') # The number of elements in each dimension\n",
    "print(f'The Size of the array is {zero_d_array.size}') # Total number of elements in the array\n",
    "print(f'Elements data type in the array is {zero_d_array.dtype}') # Datatype of the elements of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7a0d79e0-6c29-40eb-8f1d-6d114071640c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n",
      "The Number of dimensions is 1\n",
      "The shape of the array is (5,)\n",
      "The Size of the array is 5\n",
      "Elements data type in the array is int32\n"
     ]
    }
   ],
   "source": [
    "# creating a One dimensional array\n",
    "## we can create a 1darray by passing a list of values inside the numpy array function\n",
    "\n",
    "one_d_array =  np.array([1,2,3,4,5])\n",
    "print(one_d_array)\n",
    "print(type(one_d_array))\n",
    "## ndarray attributes\n",
    "print(f'The Number of dimensions is {one_d_array.ndim}')  # 1\n",
    "print(f'The shape of the array is {one_d_array.shape}') # (5,)\n",
    "print(f'The Size of the array is {one_d_array.size}') # 5\n",
    "print(f'Elements data type in the array is {one_d_array.dtype}') # int32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3e18dd60-edd2-4ebb-9fb3-8ef351f384d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4  5]\n",
      " [11 12 13 14 15]\n",
      " [21 22 23 24 25]]\n",
      "<class 'numpy.ndarray'>\n",
      "The Number of dimensions is 2\n",
      "The shape of the array is (3, 5)\n",
      "The Size of the array is 15\n",
      "Elements data type in the array is int32\n"
     ]
    }
   ],
   "source": [
    "# creating a Two dimensional array\n",
    "## we can create a 2darray by passing a list of lists of values inside the numpy array function\n",
    "\n",
    "two_d_array =  np.array([[1,2,3,4,5], [11,12,13,14,15], [21,22, 23, 24, 25]])\n",
    "print(two_d_array)\n",
    "print(type(two_d_array))\n",
    "## ndarray attributes\n",
    "print(f'The Number of dimensions is {two_d_array.ndim}')  # 2\n",
    "print(f'The shape of the array is {two_d_array.shape}') # (3,5)\n",
    "print(f'The Size of the array is {two_d_array.size}') # 15\n",
    "print(f'Elements data type in the array is {two_d_array.dtype}') # int32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c3ac5095-a6a3-4265-ad13-ef70c1bca31b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[list([1, 2, 3, 4, 5]) list([11, 12, 13, 14]) list([21, 22, 23, 24, 25])]\n",
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "## For unequal number of elements in lists\n",
    "\n",
    "example = np.array([[1,2,3,4,5], [11,12,13,14], [21,22, 23, 24, 25]], dtype = 'object')\n",
    "print(example)\n",
    "print(example.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5d73acef-1eb4-4da8-af19-90d7720a5f1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2  3  4]\n",
      "  [ 4  5  6  4]\n",
      "  [ 7  8  9  4]]\n",
      "\n",
      " [[10 11 12  4]\n",
      "  [13 14 15  4]\n",
      "  [16 17 18  4]]]\n",
      "<class 'numpy.ndarray'>\n",
      "The Number of dimensions is 3\n",
      "The shape of the array is (2, 3, 4)\n",
      "The Size of the array is 24\n",
      "Elements data type in the array is int32\n"
     ]
    }
   ],
   "source": [
    "# creating a Three dimensional array\n",
    "## we can create a 3darray by passing a list of lists of lists of values inside the numpy array function\n",
    "\n",
    "three_d_array =  np.array([[[1, 2, 3,4], [4, 5, 6,4], [7, 8, 9,4]],\n",
    "                         [[10, 11, 12,4], [13, 14, 15,4], [16, 17, 18,4]]])\n",
    "print(three_d_array)\n",
    "print(type(three_d_array))\n",
    "## ndarray attributes\n",
    "print(f'The Number of dimensions is {three_d_array.ndim}')  # 3\n",
    "print(f'The shape of the array is {three_d_array.shape}') # (2,3,4)\n",
    "print(f'The Size of the array is {three_d_array.size}') # 24\n",
    "print(f'Elements data type in the array is {three_d_array.dtype}') # int32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f1c0a887-5b76-4537-aef6-908581c1b9a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "example =  np.array([[1,2,3], [4,5,6], [7,8,9], [11, 12, 13]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4b03fdde-640c-49c8-9649-c5155d76ef27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1f56bab2-9552-4c09-95df-237fe885c838",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(example.itemsize) # it gives the memory alloted to one value in the array in bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7ffa54e9-5774-443d-989e-e9e943fce541",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<memory at 0x000002AA32E73850>\n"
     ]
    }
   ],
   "source": [
    "print(example.data) # gives the memory address of the array block"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12133e8d-c7c4-4e52-b764-8e4efba1f02b",
   "metadata": {},
   "source": [
    "### Basic Array functions\n",
    "- transpose\n",
    "- reshape\n",
    "- flatten\n",
    "- ravel\n",
    "- argmin\n",
    "- argmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f325a017-8c45-4e5d-abe5-32a14dc20981",
   "metadata": {},
   "outputs": [],
   "source": [
    "example =  np.array([728, 482, 564, 926, 285, 156, 434,  22, 807, 719, 472, 999, 531,\n",
    "       336, 325, 444, 456,  62, 567, 826])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a0987597-1218-4351-9ce2-9432404707b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# reshape() -  allows to modify the dimensions of the array with a constraint the new array with modified\n",
    "# dimensions will have same size as original array\n",
    "## syntax -  <arrayname>.reshape(<new_shape>). it a creates a modified copy of the array in the\n",
    "## memory and doesnot alter the original array untill reassigned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "58134ef8-7955-419e-8acf-c633f03e5040",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(20,)\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "print(example.ndim)\n",
    "print(example.shape)\n",
    "print(example.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ae1258e4-cf05-4098-9445-4ac0f9014613",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[728, 482],\n",
       "        [564, 926],\n",
       "        [285, 156],\n",
       "        [434,  22],\n",
       "        [807, 719]],\n",
       "\n",
       "       [[472, 999],\n",
       "        [531, 336],\n",
       "        [325, 444],\n",
       "        [456,  62],\n",
       "        [567, 826]]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example.reshape(2,5,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "697dbef6-51e5-4589-9aa2-8d52cc5c004a",
   "metadata": {},
   "outputs": [],
   "source": [
    "example2d = example.reshape(4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "53a739fa-0cb5-4c0f-a6c4-2099ae969981",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[728 482 564 926 285]\n",
      " [156 434  22 807 719]\n",
      " [472 999 531 336 325]\n",
      " [444 456  62 567 826]]\n"
     ]
    }
   ],
   "source": [
    "print(example2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8218299e-628c-41dd-973d-e3eeddb3ee81",
   "metadata": {},
   "outputs": [],
   "source": [
    "## transpose() -  it is used to take transpose of the array similar to matrix i.e. \n",
    "# rows are converted to columns and vice versa . it a creates a modified copy of the array in the\n",
    "# memory and doesnot alter the original array untill reassigned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b057330c-c0f6-4002-8ad2-77672112e8db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[728 482 564 926 285]\n",
      " [156 434  22 807 719]\n",
      " [472 999 531 336 325]\n",
      " [444 456  62 567 826]]\n",
      "(4, 5)\n"
     ]
    }
   ],
   "source": [
    "print(example2d)\n",
    "print(example2d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "04647432-ec20-46cd-84b8-0d9a484fb75b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[728 156 472 444]\n",
      " [482 434 999 456]\n",
      " [564  22 531  62]\n",
      " [926 807 336 567]\n",
      " [285 719 325 826]]\n",
      "(5, 4)\n"
     ]
    }
   ],
   "source": [
    "print(example2d.transpose())\n",
    "print(example2d.transpose().shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e8e08bcb-6401-4fba-a07e-f0a5eb9e7382",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([728, 482, 564, 926, 285, 156, 434,  22, 807, 719, 472, 999, 531,\n",
       "       336, 325, 444, 456,  62, 567, 826])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## flatten() -  used to convert any dimensional array to 1d array\n",
    "example2d.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d7305587-b756-4b79-af29-15d20b86db6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## ravel() -  used to convert any dimensional array to 1 dimensional array. it also allow to read the array in \n",
    "# either row major or column major form\n",
    "## syntax -  np.ravel(<arrayname>, order = <'F','C','A','K'>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f38b7f04-080d-413a-a487-bb85844a3244",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr =  np.array([1,2,3,4,5,6]).reshape(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "733032f4-bef2-4eda-b386-2cba0033eaf0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "a4094199-5f24-47df-aafb-65522bf2fe86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 2, 5, 3, 6])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ravel(arr, order =  'F') # 'F' stands for FORTRAN -  column major traversal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c36de9ca-d3b5-4a3d-8b9a-6f0af55bc42f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ravel(arr, order =  'C') # 'C' stands for C Languange -  row major traversal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "d6a4f2f9-9daf-4aba-b7b3-bcf15e3130db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ravel(arr, order =  'A')  # As per current memory allocation - fortran "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "325b3ee1-b34b-4434-951b-bf679342edc5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ravel(arr, order =  'K') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "105aeb79-a377-448c-979f-f05d01c8b905",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 2, 5, 3, 6])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.transpose().flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "00407b0d-d840-404f-9a72-58120bee0383",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 2, 5, 3, 6])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "686dc46a-bdcc-4290-9898-8b6962646935",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8601c0e4-7ecc-4498-9499-594dac8562cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 2, 5, 3, 6])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87899863-d247-43d0-9fe9-b6cd97900164",
   "metadata": {},
   "source": [
    "## Practice Q"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6535e53-829a-466a-aca0-defbdbf8eed0",
   "metadata": {},
   "source": [
    "As a data scientist, your task is to create a Python project that explores NumPy arrays' attributes and functions. This project will deepen your understanding of NumPy arrays, including accessing their attributes and performing common operations using NumPy functions. Use the dataset containing daily temperature records for a week.\n",
    "\n",
    "temperatures = [ 75.2, 77.1, 74.5, 79.3, 82.6, 81.2, 77.8 ]\n",
    "\n",
    "Steps to Perform:\n",
    "\n",
    "Explore the key attributes of NumPy arrays, including ndim, shape, size, dtype, itemsize, and data.\n",
    "Demonstrate important NumPy array functions such as reshape, flatten, and transpose."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f5ef87e-29ff-4204-8a0f-73470a4de544",
   "metadata": {},
   "source": [
    "**Dated -  09-01-2025**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3f20387f-79cb-4ccf-902c-aecaf91172a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = [ 75.2, 77.1, 74.5, 79.3, 82.6, 81.2, 77.8 ]\n",
    "arr = np.array(temperatures)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "a2dc6b8c-5bb0-4e54-b2d9-68dbad79cc77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "74.5\n",
      "82.6\n"
     ]
    }
   ],
   "source": [
    "print(arr.argmin()) # it gives the index of the minimum value in the array\n",
    "print(arr.argmax()) # it gives the index of the maximum value in the array\n",
    "print(arr.min()) # it gives the minimum value in the array\n",
    "print(arr.max()) # it gives the maximum value in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "61c9999a-3bf1-4af1-aff7-7eceeb80b84e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arithmetic functions -  \n",
    "\n",
    "a1 = np.array([1,2,3])\n",
    "a2 = np.array([2,8,9])\n",
    "b1 = np.array([1,5,7])\n",
    "b2 = np.array([8,9])\n",
    "c1 = np.array([1,2,6])\n",
    "c2 = np.array([3,7,17])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "4f64e61b-12c2-4635-8f8d-c5ce78b6f6b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3 10 12]\n",
      "[ 3 10 12]\n"
     ]
    }
   ],
   "source": [
    "## Addition - Element wise \n",
    "print(a1+a2) # using  addition operator of python\n",
    "print(np.add(a1,a2))  # using the numpy add function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "6231cadd-5028-4988-ad64-2457bd6b2309",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1 -6 -6]\n",
      "[-1 -6 -6]\n"
     ]
    }
   ],
   "source": [
    "## Subtraction - Element wise \n",
    "print(a1 - a2) # using  subtraction operator of python\n",
    "print(np.subtract(a1,a2))  # using the numpy subtract function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "c8b48e4d-bc2d-408b-b818-436ea79b90a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2 16 27]\n",
      "[ 2 16 27]\n"
     ]
    }
   ],
   "source": [
    "## multiplication - Element wise \n",
    "print(a1 * a2) # using  multiplication operator of python\n",
    "print(np.multiply(a1,a2))  # using the numpy multiply function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "e4c7ff5c-c86b-4edb-b312-4515f3eb0fc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5        0.25       0.33333333]\n",
      "[0.5        0.25       0.33333333]\n"
     ]
    }
   ],
   "source": [
    "## division - Element wise \n",
    "print(a1 / a2) # using  Division operator of python\n",
    "print(np.divide(a1,a2))  # using the numpy divide function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "b1416ba4-9e6c-4123-a2ed-c230bb75d4e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "## modulus/remainder - Element wise \n",
    "print(a1%a2) # using  modulus operator of python\n",
    "print(np.mod(a1,a2))  # using the numpy mod function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "cf4fe2d2-7832-42b3-9f3e-c4bf3093c6ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[    1   256 19683]\n",
      "[    1   256 19683]\n"
     ]
    }
   ],
   "source": [
    "## Power - Element wise \n",
    "print(a1**a2) # using  Exponential operator of python\n",
    "print(np.power(a1,a2))  # using the numpy power function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "81aac60f-12a1-44f8-ac26-28b33dcd9407",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 5])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mod(c2, c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "3c676785-7111-46d3-aef7-e9b18c4e0fd5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0]\n",
      "[0 0 0]\n"
     ]
    }
   ],
   "source": [
    "## Floor Division - Element wise \n",
    "print(a1//a2) # using  Floor Division operator of python(the nearest integer value moving towrds negative infinity)\n",
    "print(np.floor_divide(a1,a2))  # using the numpy floor_divide function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9dac254a-0984-41a2-92b9-5c7fc0142740",
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = np.array(['Hello', 'Welcome'])\n",
    "d2 = np.array([' World', ' Learners'])\n",
    "str1 =  'Simpli LeaRN'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ba063de7-4bb5-4ef9-9f6c-a447c36eb929",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello World' 'Welcome Learners']\n",
      "SIMPLI LEARN\n",
      "simpli learn\n",
      "Simpli learn\n",
      "Simpli Learn\n",
      "Simpli LearN\n"
     ]
    }
   ],
   "source": [
    "# Numpy String Functions\n",
    "\n",
    "print(np.char.add(d1,d2))  # Element wise conactenation of strng array\n",
    "print(np.char.upper(str1))\n",
    "print(np.char.lower(str1))\n",
    "print(np.char.capitalize(str1)) # make first character of string as upper case and remaining lower\n",
    "print(np.char.title(str1))  # make first character of each word in string as upper case and remaining lower\n",
    "print(np.char.replace(str1, 'R', 'r'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "c2529986-2f48-4a6e-b1ee-de9444953e43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HelloSimpli LeaRN' 'WelcomeSimpli LeaRN']\n"
     ]
    }
   ],
   "source": [
    "print(np.char.add(d1, str1)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "1a38a8a0-16d3-4065-b427-2222cf2fe68b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.e   # euler's number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "a4b46e31-5c5c-47bf-ad59-e53362387937",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Statistical Functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "781bbe45-7f24-4089-8652-7c7eb181c377",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2 = np.array([11,22,33,44,55, 13,7,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "dfb1e363-bb01-48a7-9b5b-cb5998d90809",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188\n",
      "23.5\n",
      "23.5\n",
      "17.5\n",
      "17.5\n",
      "35.75\n",
      "10.0\n",
      "[ 11  33  66 110 165 178 185 188]\n",
      "17.549928774784245\n",
      "308.0\n",
      "[[ 7. 19.]\n",
      " [19. 52.]]\n",
      "[[1.         0.99587059]\n",
      " [0.99587059 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(arr2)) # sum of all elements in the array\n",
    "print(np.mean(arr2)) # average of the values in the array. \n",
    "print(np.average(arr2)) # average of the values in the array. \n",
    "print(np.median(arr2)) # central value in the sorted array\n",
    "print(np.percentile(arr2, 50)) # gives the 50th percentile(median value)\n",
    "print(np.percentile(arr2, 75)) # gives the 75th percentile(Q3)\n",
    "print(np.percentile(arr2, 25)) # gives the 25th percentile(Q1)\n",
    "print(np.cumsum(arr2)) # gives the cumulative sum\n",
    "print(np.std(arr2)) # gives the standard Deviation\n",
    "print(np.var(arr2)) # gives the variance - Square of std\n",
    "\n",
    "print(np.cov(c1,c2)) # gives the covariance matrix of array\n",
    "print(np.corrcoef(c1,c2)) # gives the correlation matrix of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "8371da21-b8ca-412b-b2f5-c8b9ae8e2a1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indexing - indexing is used to access, modify elements in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "fea3a7fd-4216-4843-9414-67265b6707cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(0,20).reshape(4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "9bfb9565-3814-4e7d-9a2d-085a3dc93021",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]\n",
      " [15 16 17 18 19]]\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "8bfd5c8d-57a4-4f98-8aab-cf92d6954a0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "13\n",
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "print(a[2,3])\n",
    "print(a[-2,-2])\n",
    "print(a[-2,3])\n",
    "print(a[2,-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "57c4dcb8-e150-4e22-bd6c-ce28ba8bd8a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3] [4]\n"
     ]
    }
   ],
   "source": [
    "print(np.where(a==19)[0], np.where(a==19)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "49a482cd-d5aa-40dd-ad0e-136829239c8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2,3] = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "0f7c4fb0-1f54-429d-b4f7-13a6222bb2a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0   1   2   3   4]\n",
      " [  5   6   7   8   9]\n",
      " [ 10  11  12 100  14]\n",
      " [ 15  16  17  18  19]]\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "7749b3a9-a622-408b-8ac5-51bf2ed55ce0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  6,   7,   8],\n",
       "       [ 11,  12, 100]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing\n",
    "\n",
    "a[[1,2],1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "97859ba8-beb5-4505-9483-941fb244127d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  2  4]\n",
      " [10 12 14]]\n"
     ]
    }
   ],
   "source": [
    "print(a[0:3:2, 0:5:2])"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b764304f-52b4-4093-81eb-be169df013ca",
   "metadata": {},
   "source": [
    "Positive Index- left to right or top to bottom\n",
    "Negative Index- right to left or bottom to top"
   ]
  }
 ],
 "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}