numpy_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load in NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a NumPy Array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7 9]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,3,5,7,9])\n",
    "print(arr)\n",
    "print(type(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a Python List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "li = [1,3,5,7,9]\n",
    "print(li)\n",
    "print(type(li))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate the execution time in NumPy Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.94 µs ± 494 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.arange(1,7)**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate the execution time in Python List "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "641 ns ± 84.6 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [i**3 for i in range(1,7)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get the Dimension "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6 8]\n",
      "1\n",
      "\n",
      "[[2 4 6 8]\n",
      " [1 3 5 7]]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([2,4,6,8])\n",
    "print(arr1)\n",
    "print(arr1.ndim)\n",
    "\n",
    "print()\n",
    "\n",
    "arr2 = np.array([[2,4,6,8],[1,3,5,7]])\n",
    "print(arr2)\n",
    "print(arr2.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a three dimensional array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2 3 4]\n",
      "  [3 4 5 6]\n",
      "  [5 6 7 8]]]\n",
      "\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[[1,2,3,4],[3,4,5,6],[5,6,7,8]]])\n",
    "print(arr)\n",
    "print()\n",
    "print(arr.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a ten dimensional array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[[[[[[[10 20 30 40]]]]]]]]]]\n",
      "\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([10,20,30,40], ndmin = 10)\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "print(arr.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an array filled with zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0.]\n",
      "\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "arr_z = np.zeros(5)\n",
    "arr_z1 = np.zeros((3,3))\n",
    "\n",
    "print(arr_z)\n",
    "print()\n",
    "print(arr_z1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an array filled with ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1.]\n",
      "\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "arr_o = np.ones(5)\n",
    "arr_o1 = np.ones((4,3))\n",
    "\n",
    "print(arr_o)\n",
    "print()\n",
    "print(arr_o1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an empty array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "arr_e = np.empty(5)\n",
    "print(arr_e)\n",
    "# the empty array automatically recalls the previous memory's data ! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an ordered array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange((8))\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an array containing ones in diagonal "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": [
    "arr = np.eye(4,4)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use of linspace in an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  5. 10. 15. 20.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.linspace(0,20, num=5)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create NumPy Arrays with Random Numbers "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### rand() function :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.21933283 0.42752796 0.50934277]\n",
      "\n",
      "[[0.37673894 0.69257678 0.98383443 0.1043133 ]\n",
      " [0.68785731 0.45597751 0.56118119 0.37773989]\n",
      " [0.80939989 0.01654748 0.86589597 0.73857801]\n",
      " [0.49660164 0.72882691 0.25732292 0.63485474]]\n"
     ]
    }
   ],
   "source": [
    "# this function is used to generate random values between 0 & 1 \n",
    "\n",
    "arr1 = np.random.rand(3)\n",
    "print(arr1)\n",
    "\n",
    "print()\n",
    "\n",
    "arr2 = np.random.rand(4,4)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### randn() function :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.31248816 -0.48909605 -1.53464343]\n",
      "\n",
      "[[-2.61828225 -0.99027256 -0.52117754  1.1578355 ]\n",
      " [-1.36971347 -0.19100443 -0.66948324 -2.80905532]\n",
      " [-1.46919414 -0.11249011 -0.80580932  0.484686  ]\n",
      " [ 0.31937136 -2.05794183 -0.9450014  -0.30440535]]\n"
     ]
    }
   ],
   "source": [
    "# this function is used to generate random values close to zero (this may return both positive & negative)\n",
    "\n",
    "arr1 = np.random.randn(3)\n",
    "print(arr1)\n",
    "\n",
    "print()\n",
    "\n",
    "arr2 = np.random.randn(4,4)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ranf() function :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.30682371 0.71906295 0.63502538 0.05144118 0.96224881]\n"
     ]
    }
   ],
   "source": [
    "# this function is used for doing random sampling in numpy\n",
    "# It returns an array of specified shape and fills it with random floats in the half-open interval [0.0, 1.0)\n",
    "\n",
    "arr1 = np.random.ranf(5)\n",
    "print(arr1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### randint() function : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 5 5 3]\n"
     ]
    }
   ],
   "source": [
    "# this function is used to generate a random number between any particular given range\n",
    "\n",
    "arr2 = np.random.randint(1,7,4) # np.random.randint(min_value, max_value, total_values_between_them)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Data Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data Type :  int32\n",
      "Data Type :  int64\n",
      "Data Type :  float64\n",
      "Data Type :  <U1\n",
      "Data Type :  <U32\n"
     ]
    }
   ],
   "source": [
    "# integer datatype\n",
    "arr1 = np.array([1,2,3,4,5,6])\n",
    "print(\"Data Type : \", arr1.dtype)\n",
    "\n",
    "arr_1 = np.array([21548956412,54896874654,4587651684])\n",
    "print(\"Data Type : \", arr_1.dtype)\n",
    "\n",
    "# float datatype\n",
    "arr2 = np.array([0.1, 1.1, 2.1, 3.3])\n",
    "print(\"Data Type : \", arr2.dtype)\n",
    "\n",
    "# string datatype\n",
    "arr3 = np.array(['m','a','r','d','a','v'])\n",
    "print(\"Data Type : \", arr3.dtype)\n",
    "\n",
    "# mixed (LGTV HD+)\n",
    "arr4 = np.array(['i', 13, \"punch\", 52.3])\n",
    "print(\"Data Type : \", arr4.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data Type of [1 2 3 4 5] : int32\n",
      "Data Type of [1 2 3 4 5] : int16\n",
      "Data type of [1 2 3 4 5] : int64\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1,2,3,4,5])\n",
    "print(\"Data Type of\",arr1,\":\", arr1.dtype)\n",
    "\n",
    "arr2 = np.array([1,2,3,4,5], dtype = np.int16)\n",
    "print(\"Data Type of\",arr2,\":\", arr2.dtype)\n",
    "\n",
    "arr3 = np.array([1,2,3,4,5], dtype = np.int64)\n",
    "print(\"Data type of\",arr3,\":\", arr3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting integer to float values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12.  2. 13.  5.  7.]\n",
      "Data Type : float32\n",
      "\n",
      "[b'1' b'3' b'5' b'7' b'9']\n",
      "Data Type :  |S1\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([12,2,13,5,7], dtype = \"f\")\n",
    "print(arr)\n",
    "print(\"Data Type :\", arr.dtype)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,3,5,7,9], dtype = \"S\")\n",
    "print(arr1)\n",
    "print(\"Data Type : \", arr1.dtype)\n",
    "\n",
    "# List of characters that are used to represent dtype :\n",
    "\n",
    "# b - boolean\n",
    "# c - complex float\n",
    "# f - float  \n",
    "# i - integer  \n",
    "# m - timedelta\n",
    "# M - datetime\n",
    "# O - object \n",
    "# S - string\n",
    "# u - unsigned integer\n",
    "# U - Unicode string "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting using functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7 9]\n",
      "Data Type : int32\n",
      "\n",
      "[1. 3. 5. 7. 9.]\n",
      "Data Type : float32\n",
      "\n",
      "[ True  True  True  True  True]\n",
      "Data Type : bool\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,3,5,7,9])\n",
    "new_arr = np.float32(arr)\n",
    "new_new_arr = np.bool_(arr)\n",
    "\n",
    "print(arr)\n",
    "print(\"Data Type :\", arr.dtype)\n",
    "\n",
    "print()\n",
    "\n",
    "print(new_arr)\n",
    "print(\"Data Type :\", new_arr.dtype)\n",
    "\n",
    "print()\n",
    "\n",
    "print(new_new_arr)\n",
    "print(\"Data Type :\", new_new_arr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic Operations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Addition (a+b) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5 6 7 8]\n",
      "\n",
      "[ 2  4  6  8 10]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "add = arr + 3 \n",
    "print(add)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([1,2,3,4,5])\n",
    "adds = np.add(arr1, arr2) \n",
    "print(adds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Subtraction (a-b) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2 -1  0  1  2]\n",
      "\n",
      "[0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "sub = arr - 3 \n",
    "print(sub)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([1,2,3,4,5])\n",
    "subs = np.subtract(arr1, arr2) \n",
    "print(subs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiplication (a*b) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3  6  9 12 15]\n",
      "\n",
      "[ 1  4  9 16 25]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "mul = arr * 3 \n",
    "print(mul)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([1,2,3,4,5])\n",
    "mult = np.multiply(arr1, arr2) \n",
    "print(mult)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Division (a/b) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5 1.  1.5 2.  2.5]\n",
      "\n",
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "div = arr / 2 \n",
    "print(div)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([1,2,3,4,5])\n",
    "divs = np.divide(arr1, arr2) \n",
    "print(divs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modulus (a%b) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 1 0 1]\n",
      "\n",
      "[0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "mod = arr % 2 \n",
    "print(mod)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([1,2,3,4,5])\n",
    "mods = np.mod(arr1, arr2) \n",
    "print(mods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Power (a**b) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  4  9 16 25]\n",
      "\n",
      "[   1    4   27  256 3125]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "pow = arr ** 2 \n",
    "print(pow)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([1,2,3,4,5])\n",
    "pows = np.power(arr1, arr2) \n",
    "print(pows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reciprocal (1/a) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         0.5        0.33333333 0.25       0.2       ]\n",
      "\n",
      "[1 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "rec = 1 / arr \n",
    "print(rec)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1 = np.array([1,2,3,4,5])\n",
    "recp = np.reciprocal(arr1) \n",
    "print(recp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic Functions "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Minimum (min) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum number: 1\n",
      "Position : 6\n",
      "\n",
      "Minimum numbers from each column : [2 1 3 5 7]\n",
      "Minimum numbers from each row : [2 1]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[2,4,6,8,13],[5,1,3,5,7]])\n",
    "\n",
    "print(\"Minimum number:\", np.min(arr))\n",
    "print(\"Position :\", np.argmin(arr))\n",
    "\n",
    "print() \n",
    "\n",
    "print(\"Minimum numbers from each column :\", np.min(arr, axis = 0)) # for column\n",
    "print(\"Minimum numbers from each row :\", np.min(arr, axis = 1)) # for row "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Maximum (max) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum number: 13\n",
      "Position : 4\n",
      "\n",
      "Maximum numbers from each column : [ 5  4  6  8 13]\n",
      "Maximum numbers from each row : [13  7]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[2,4,6,8,13],[5,1,3,5,7]])\n",
    "\n",
    "print(\"Maximum number:\", np.max(arr))\n",
    "print(\"Position :\", np.argmax(arr))\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"Maximum numbers from each column :\", np.max(arr, axis = 0)) # for column \n",
    "print(\"Maximum numbers from each row :\", np.max(arr, axis = 1)) # for row "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Square root (sqrt) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square root : [ 2.  3.  8. 12. 15. 30.]\n"
     ]
    }
   ],
   "source": [
    "arr = ([4,9,64,144,225,900])\n",
    "\n",
    "print(\"Square root :\", np.sqrt(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sin & cos values : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sin values : [ 0.          0.84147098 -0.2794155   0.41211849  0.42016704]\n",
      "\n",
      "cos values : [-0.65364362 -0.91113026  0.39185723  0.8711474   0.36731937  0.0662467 ]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([0,1,6,9,13])\n",
    "print(\"sin values :\", np.sin(arr1))\n",
    "\n",
    "print() \n",
    "\n",
    "arr2 = np.array([0,1,3,7,11])\n",
    "print(\"cos values :\", np.cos(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cumulative Sum (cumsum) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cumulative sum : [ 1  3  6 10 15]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5]) # cumsum process - [1, 1+2, 1+2+3, 1+2+3+4, 1+2+3+4+5]\n",
    "\n",
    "print(\"Cumulative sum :\", np.cumsum(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Shape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [2 4 6]]\n",
      "(2, 3)\n",
      "\n",
      "[[[1 2 3]\n",
      "  [2 4 6]\n",
      "  [7 8 9]]]\n",
      "(1, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[2,4,6]])\n",
    "print(arr)\n",
    "print(arr.shape)\n",
    "\n",
    "print()\n",
    "\n",
    "arr1= np.array([[[1,2,3],[2,4,6],[7,8,9]]])\n",
    "print(arr1)\n",
    "print(arr1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshape function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  3  7  9 11 13 15 17 19]\n",
      "1\n",
      "\n",
      "[[ 1  3  7]\n",
      " [ 9 11 13]\n",
      " [15 17 19]]\n",
      "2\n",
      "\n",
      "[ 1  3  7  9 11 13 15 17 19]\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1,3,7,9,11,13,15,17,19])\n",
    "print(arr1)\n",
    "print(arr1.ndim)\n",
    "\n",
    "print() \n",
    "\n",
    "# reshaping the one dimensional array into two dimensional array.\n",
    "re = arr1.reshape(3,3) # reshape(no. of rows, no. of columns)\n",
    "print(re)\n",
    "print(re.ndim)\n",
    "\n",
    "print()\n",
    "\n",
    "# reshaping again into one dimensional array \n",
    "new = re.reshape(-1)\n",
    "print(new)\n",
    "print(new.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing in 1D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,3,5,7,9])\n",
    "\n",
    "# positive indexing\n",
    "print(arr[2])\n",
    "\n",
    "# negative indexing\n",
    "print(arr[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing in 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[9,8,7,6],[5,4,3,2]])\n",
    "\n",
    "print(arr[0,2]) # positive indexing (here 0 is the index of first array and 2 is the index number of 7 inside that array.)\n",
    "print()\n",
    "print(arr[0,-2]) # negative indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing in 3D array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "\n",
      "1\n",
      "\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[[1,2,3],[4,5,6],[7,8,9]]])\n",
    "\n",
    "print(arr[0,2,0]) # positive indexing \n",
    "print()\n",
    "print(arr[0,0,0]) # positive indexing\n",
    "print()\n",
    "print(arr[0,1,-3]) # negative indexing "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing in an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10]\n",
      "\n",
      "Get numbers from 3 to 7 : [3 4 5 6 7]\n",
      "Get all numbers after 3 : [ 4  5  6  7  8  9 10]\n",
      "Get all numbers till 3 : [0 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([0,1,2,3,4,5,6,7,8,9,10])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"Get numbers from 3 to 7 :\", arr[3:8])\n",
    "print(\"Get all numbers after 3 :\", arr[4:])\n",
    "print(\"Get all numbers till 3 :\", arr[:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "\n",
      "Get all Odd numbers : [1 3 5 7 9]\n",
      "Get all even numbers : [2 4 6 8]\n",
      "Skip 2 numbers between 3 to 8 : [3 6 9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5,6,7,8,9])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"Get all Odd numbers :\", arr[::2]) # [start:stop:step]\n",
    "print(\"Get all even numbers :\", arr[1::2]) # [1:_:2] -> 1 is index number running till end & here 2 represents skipping 1/jumping 2\n",
    "print(\"Skip 2 numbers between 3 to 8 :\", arr[2:9:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing in 2D array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4  5 11]\n",
      " [ 6  7  8  9 13 20]]\n",
      "Get numbers from 1 to 4 : [1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3,4,5,11],[6,7,8,9,13,20]])\n",
    "print(arr)\n",
    "\n",
    "print(\"Get numbers from 1 to 4 :\", arr[0,:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration of 1D array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From first method :\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "\n",
      "From second method :\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "\n",
    "# first method \n",
    "print(\"From first method :\")\n",
    "for i in arr :\n",
    "    print(i)\n",
    "    \n",
    "print()\n",
    "\n",
    "# second method\n",
    "print(\"From second method :\")\n",
    "for j in np.nditer(arr):\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration of 2D array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n",
      "[4 5]\n",
      "[7 8]\n",
      "\n",
      "From first method :\n",
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "7\n",
      "8\n",
      "\n",
      "From second method :\n",
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2],[4,5],[7,8]])\n",
    "\n",
    "for i in arr :\n",
    "    print(i)\n",
    "\n",
    "print() \n",
    "\n",
    "# first method \n",
    "print(\"From first method :\")\n",
    "for j in arr :\n",
    "    for k in j :\n",
    "        print(k)\n",
    "        \n",
    "print()        \n",
    "\n",
    "# second method \n",
    "print(\"From second method :\")\n",
    "for l in np.nditer(arr):\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration of 3D array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [5 6 7]]\n",
      "\n",
      "From first method :\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "6\n",
      "7\n",
      "\n",
      "From second method :\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[[1,2,3],[5,6,7]]])\n",
    "\n",
    "for i in arr:\n",
    "    print(i)\n",
    "    \n",
    "print() \n",
    "\n",
    "# first method \n",
    "print(\"From first method :\")\n",
    "for j in arr:\n",
    "    for k in j:\n",
    "        for l in k:\n",
    "            print(l)\n",
    "            \n",
    "print()\n",
    "\n",
    "# second method \n",
    "print(\"From second method :\")\n",
    "for m in np.nditer(arr):\n",
    "    print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration with respect to indexing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0) 1\n",
      "(0, 1) 2\n",
      "(0, 2) 3\n",
      "(1, 0) 4\n",
      "(1, 1) 5\n",
      "(1, 2) 6\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "\n",
    "for i,j in np.ndenumerate(arr): # ndenumerate function will pass 2 values both for indexing as well as iterate data. \n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy function vs View function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Similarity : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Array : [2 4 6 8]\n",
      "\n",
      "Copied Array : [2 4 6 8]\n",
      "Viewed Array : [2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([2,4,6,8])\n",
    "copy = arr.copy()\n",
    "view = arr.view()\n",
    "\n",
    "print(\"Original Array :\", arr)\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"Copied Array :\", copy)\n",
    "print(\"Viewed Array :\", view)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Difference : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Array : [ 9  7 60  3  1]\n",
      "\n",
      "Copied Array : [9 7 5 3 1]\n",
      "Viewed Array : [ 9  7 60  3  1]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([9,7,5,3,1])\n",
    "copy = arr.copy()\n",
    "view = arr.view()\n",
    "\n",
    "arr[2] = 60\n",
    "\n",
    "print(\"Original Array :\", arr)\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"Copied Array :\", copy) # it copies the data to the new location resulting in a new array.\n",
    "print(\"Viewed Array :\", view) # if original data is changed than the viewed one changes too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Joining the Array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1,2,3,4,5])\n",
    "arr2 = np.array([6,7,8,9,10])\n",
    "\n",
    "new = np.concatenate((arr1,arr2))\n",
    "print(new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]\n",
      " [5 7 3]]\n",
      "\n",
      "[[1 2 3 7 8 9]\n",
      " [4 5 6 5 7 3]]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([[1,2,3],[4,5,6]])\n",
    "arr2 = np.array([[7,8,9],[5,7,3]])\n",
    "\n",
    "new1 = np.concatenate((arr1,arr2), axis=0) #columns \n",
    "print(new1)\n",
    "\n",
    "print()\n",
    "\n",
    "new2 = np.concatenate((arr1,arr2), axis=1) #rows\n",
    "print(new2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting the Array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([1, 2, 3, 4, 5]), array([ 6,  7,  8,  9, 10])]\n",
      "\n",
      "[array([1, 2]), array([3, 4]), array([5, 6]), array([7, 8]), array([ 9, 10])]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1,2,3,4,5,6,7,8,9,10])\n",
    "\n",
    "new1 = np.array_split(arr1,2)\n",
    "print(new1)\n",
    "\n",
    "print()\n",
    "\n",
    "new2 = np.array_split(arr1,5)\n",
    "print(new2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Array Functions "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Search :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([ 1,  9, 16], dtype=int64),)\n",
      "\n",
      "(array([ 0,  3,  5,  8, 11, 12, 13, 18], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([2,3,5,4,9,8,7,1,2,3,5,4,6,2,5,1,3,5,4])\n",
    "\n",
    "new = np.where(arr == 3)\n",
    "print(new)\n",
    "\n",
    "print()\n",
    "\n",
    "new1 = np.where(arr%2 == 0)\n",
    "print(new1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sort :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  4  8  9 13 19 21 25 41 52 65 78]\n",
      "\n",
      "['a' 'a' 'd' 'm' 'r' 'v']\n",
      "\n",
      "[[ 7  8  9]\n",
      " [ 2  5 11]\n",
      " [ 0 13 89]]\n"
     ]
    }
   ],
   "source": [
    "# Integers\n",
    "arr = np.array([52,2,65,8,41,13,4,9,78,19,1,25,21])\n",
    "new = np.sort(arr)\n",
    "print(new)\n",
    "\n",
    "print()\n",
    "\n",
    "# String\n",
    "arr1 = np.array(['m','a','r','d','a','v'])\n",
    "new1 = np.sort(arr1)\n",
    "print(new1)\n",
    "\n",
    "print()\n",
    "\n",
    "# 2D Array \n",
    "arr2 = np.array([[8,9,7],[11,2,5],[13,0,89]])\n",
    "new2 = np.sort(arr2)\n",
    "print(new2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Filter :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  4  6 52]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([2,99,4,6,8,52,13])\n",
    "filter = [True, False, True, True, False, True, False]\n",
    "\n",
    "new = arr[filter]\n",
    "print(new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Shuffle :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[60 10 40 50 20 70 30]\n",
      "\n",
      "['e' 'd' 'g' 'b' 'c' 'f' 'h' 'a' 'i']\n"
     ]
    }
   ],
   "source": [
    "# 1D Array\n",
    "arr = np.array([10,20,30,40,50,60,70])\n",
    "np.random.shuffle(arr)\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "# String\n",
    "arr2 = np.array(['a','b','c','d','e','f','g','h','i'])\n",
    "np.random.shuffle(arr2)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unique :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "\n",
      "['a' 'd' 'j' 'm' 'n' 'r' 'u' 'v']\n"
     ]
    }
   ],
   "source": [
    "# Integers\n",
    "arr = np.array([1,2,1,2,1,2,3,4,5,6])\n",
    "uni = np.unique(arr)\n",
    "print(uni)\n",
    "\n",
    "print()\n",
    "\n",
    "# String\n",
    "arr1 = np.array(['m','a','r','d','a','v','j','a','d','a','u','n'])\n",
    "uni2 = np.unique(arr1)\n",
    "print(uni2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Resize :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4,5,6])\n",
    "re = np.resize(arr,(3,2))\n",
    "print(re)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Insert :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "\n",
      "[ 1  2 30  3  4  5]\n",
      "[30  1  2 30  3  4  5]\n"
     ]
    }
   ],
   "source": [
    "# Inserting data in 1D array.\n",
    "\n",
    "arr = np.array([1,2,3,4,5])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "ins = np.insert(arr, 2 , 30)\n",
    "print(ins)\n",
    "\n",
    "ins1 = np.insert(arr, (0,2), 30.5) # cannot insert float or string values in an array containing integers.\n",
    "print(ins1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [30 30 30]]\n",
      "\n",
      "[[ 1  2  3 30]\n",
      " [ 4  5  6 40]]\n"
     ]
    }
   ],
   "source": [
    "# Inserting data in 2D array.\n",
    "\n",
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "ins1 = np.insert(arr, 2, 30, axis=0)\n",
    "print(ins1)\n",
    "\n",
    "print()\n",
    "\n",
    "ins2 = np.insert(arr, 3, [30,40], axis=1)\n",
    "print(ins2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[ 1  2  3  4 30]\n",
      "\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [30 31 32]]\n"
     ]
    }
   ],
   "source": [
    "# Inserting data through append function.\n",
    "\n",
    "# 1D Array\n",
    "arr = np.array([1,2,3,4])\n",
    "print(arr)\n",
    "\n",
    "app = np.append(arr, 30)\n",
    "print(app)\n",
    "\n",
    "print()\n",
    "\n",
    "#2D Array\n",
    "arr1 = np.array([[1,2,3],[4,5,6]])\n",
    "print(arr1)\n",
    "\n",
    "app1 = np.append(arr1, [[30,31,32]], axis=0)\n",
    "print(app1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Delete :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13 23 33 43 53  2 63]\n",
      "[13 23 33 43 53 63]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([13,23,33,43,53,2,63])\n",
    "print(arr)\n",
    "\n",
    "dele = np.delete(arr, -2)\n",
    "print(dele)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix vs Array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "<class 'numpy.ndarray'>\n",
      "\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "<class 'numpy.matrix'>\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([[1,2,3],[4,5,6]])\n",
    "print(arr1)\n",
    "print(type(arr1))\n",
    "\n",
    "print()\n",
    "\n",
    "arr2 = np.matrix([[1,2,3],[4,5,6]])\n",
    "print(arr2)\n",
    "print(type(arr2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Matrix Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Transpose :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Matrix :\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "Transpose Matrix :\n",
      "[[1 4 7]\n",
      " [2 5 8]\n",
      " [3 6 9]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.matrix([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(\"Original Matrix :\")\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "trs = np.transpose(arr)\n",
    "print(\"Transpose Matrix :\")\n",
    "print(trs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Swapaxes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 5]\n",
      " [2 4]]\n",
      "\n",
      "[[3 2]\n",
      " [5 4]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.matrix([[3,5],[2,4]])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "swp = np.swapaxes(arr, 0, 1)\n",
    "print(swp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inverse :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20]\n",
      " [30 40]]\n",
      "\n",
      "[[-0.2   0.1 ]\n",
      " [ 0.15 -0.05]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.matrix([[10,20],[30,40]])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "inv = np.linalg.inv(arr)\n",
    "print(inv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Power :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20]\n",
      " [30 40]]\n",
      "\n",
      "[[ 700 1000]\n",
      " [1500 2200]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.matrix([[10,20],[30,40]])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "pow = np.linalg.matrix_power(arr, 2)\n",
    "print(pow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinate :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20]\n",
      " [30 40]]\n",
      "\n",
      "-200.0000000000001\n"
     ]
    }
   ],
   "source": [
    "arr = np.matrix([[10,20],[30,40]])\n",
    "print(arr)\n",
    "\n",
    "print()\n",
    "\n",
    "det = np.linalg.det(arr)\n",
    "print(det)"
   ]
  },
  {
   "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}