numpy/Numpy_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8073f788-d167-4025-87bb-14c5da2b1bec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accessing : 2\n",
      "\n",
      "Shape of array : (1, 5)\n",
      "\n",
      "Data type : int8\n",
      "\n",
      "INDEX of max element : 4\n",
      "\n",
      "INDEX of min element : 0\n",
      "\n",
      "sorted array INDICES : [[0 1 2 3 4]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#Creating a numpy array\n",
    "myarr = np.array([[1, 2, 3, 4, 5]], np.int8)\n",
    "\n",
    "#Accessing individual elements\n",
    "print(f\"Accessing : {myarr[0, 1]}\\n\")\n",
    "\n",
    "#details on the array\n",
    "print(f\"Shape of array : {myarr.shape}\\n\")\n",
    "print(f\"Data type : {myarr.dtype}\\n\")\n",
    "print(f\"INDEX of max element : {myarr.argmax()}\\n\")\n",
    "print(f\"INDEX of min element : {myarr.argmin()}\\n\")\n",
    "print(f\"sorted array INDICES : {myarr.argsort()}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a3639d40-ae82-45a6-ab9a-ec0b800880d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2-D array : \n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "Object type array : {32, 23, 55} \n",
      "\n",
      "Data Type : object\n"
     ]
    }
   ],
   "source": [
    "#Array creation by Conversion from other Python structures\n",
    "listarray = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], np.int8)\n",
    "print(f\"2-D array : \\n{listarray}\")\n",
    "\n",
    "objectarray = np.array({32, 23, 55})\n",
    "print(f\"\\nObject type array : {objectarray} \\n\\nData Type : {objectarray.dtype}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3d7c3c88-4732-409d-bbad-7dc1c1692e51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zeros : \n",
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "Data Type : float64\n",
      "Shape : (2, 5)\n",
      "\n",
      "Arange : [0 1 2 3 4 5 6 7 8 9]\n",
      "\n",
      "Linspace : \n",
      "[1.         1.36363636 1.72727273 2.09090909 2.45454545 2.81818182\n",
      " 3.18181818 3.54545455 3.90909091 4.27272727 4.63636364 5.        ] \n",
      "\n",
      "Empty : \n",
      "[[6.23042070e-307 4.67296746e-307 1.69121096e-306 1.11260755e-306\n",
      "  1.89146896e-307 7.56571288e-307]\n",
      " [3.11525958e-307 1.24610723e-306 1.37962320e-306 1.29060871e-306\n",
      "  2.22518251e-306 1.33511969e-306]\n",
      " [1.78022342e-306 1.05700345e-307 3.11525958e-307 1.69118108e-306\n",
      "  8.06632139e-308 1.20160711e-306]\n",
      " [1.69119330e-306 1.29062229e-306 6.89804133e-307 9.34609790e-307\n",
      "  9.34609790e-307 1.60219035e-306]] \n",
      "\n",
      "Identity Matrix : \n",
      "[[1. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0.]\n",
      " [0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "#Array creation using \"Zeros\"\n",
    "zeros = np.zeros((2, 5))\n",
    "print(f\"Zeros : \\n{zeros}\")\n",
    "print(f\"Data Type : {zeros.dtype}\")\n",
    "print(f\"Shape : {zeros.shape}\\n\")\n",
    "\n",
    "#Array creation using \"arange\"\n",
    "rng = np.arange(10)\n",
    "print(f\"Arange : {rng}\\n\")\n",
    "\n",
    "#Array creation using \"linspace\"\n",
    "lspace = np.linspace(1, 5, 12)\n",
    "print(f\"Linspace : \\n{lspace} \\n\")\n",
    "\n",
    "#Empty array of given dimensions\n",
    "emp = np.empty((4, 6))\n",
    "print(f\"Empty : \\n{emp} \\n\")\n",
    "\n",
    "#Identity Matrix\n",
    "ide = np.identity(5)\n",
    "print(f\"Identity Matrix : \\n{ide}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "475dec12-acd5-4177-8292-9bec926342a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arange \n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n",
      " 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71\n",
      " 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95\n",
      " 96 97 98]\n",
      "\n",
      "Reshape \n",
      "[[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      "  24 25 26 27 28 29 30 31 32]\n",
      " [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56\n",
      "  57 58 59 60 61 62 63 64 65]\n",
      " [66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89\n",
      "  90 91 92 93 94 95 96 97 98]]\n",
      "\n",
      "Ravel \n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n",
      " 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71\n",
      " 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95\n",
      " 96 97 98]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Creating array using \"arange\"\n",
    "arr = np.arange(99)\n",
    "print(f\"Arange \\n{arr}\\n\")\n",
    "\n",
    "#Changing shape/dimensions\n",
    "arr = arr.reshape(3, 33)\n",
    "print(f\"Reshape \\n{arr}\\n\")\n",
    "\n",
    "#Returns the flattened array(1D)\n",
    "arr = arr.ravel()\n",
    "print(f\"Ravel \\n{arr}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b0d9fc38-6fca-42b8-9e62-e7ecae593d10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The matrix X is : \n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 1 0]]\n",
      "\n",
      "MAX : 7\n",
      "\n",
      "MIN : 0\n",
      "\n",
      "Sum of all elements : 29\n",
      "\n",
      "Sum of axis = 0 : [12  8  9]\n",
      "\n",
      "Sum of axis = 1 : [ 6 15  8]\n",
      "\n",
      "Transpose : \n",
      "[[1 4 7]\n",
      " [2 5 1]\n",
      " [3 6 0]]\n",
      "\n",
      "ar.flat :\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "1\n",
      "0\n",
      "\n",
      "Number of dimensions : 2\n",
      "\n",
      "Size of array : 9\n",
      "\n",
      "Bytes consumed : 72\n",
      "\n",
      "argmin for 2D array : 8\n",
      "\n",
      "argmax for 2D array : 6\n",
      "\n",
      "argmax for axis = 0 : [2 1 1]\n",
      "\n",
      "argmax for axis = 1 : [2 2 0]\n",
      "\n",
      "ravel : \n",
      "[1 2 3 4 5 6 7 1 0]\n",
      "\n",
      "3*3 array reshaped to 9*1 :\n",
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]\n",
      " [5]\n",
      " [6]\n",
      " [7]\n",
      " [1]\n",
      " [0]]\n"
     ]
    }
   ],
   "source": [
    "x = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 1, 0]\n",
    "]\n",
    "\n",
    "ar = np.array(x)\n",
    "print(f\"The matrix X is : \\n{ar}\\n\")\n",
    "\n",
    "#Max(returns actual value)\n",
    "print(f\"MAX : {ar.max()}\\n\")\n",
    "\n",
    "#Min(returns actual value)\n",
    "print(f\"MIN : {ar.min()}\\n\")\n",
    "\n",
    "#Sum of all elements\n",
    "print(f\"Sum of all elements : {ar.sum()}\\n\")\n",
    "\n",
    "#Sum of elements for axis = 0\n",
    "print(f\"Sum of axis = 0 : {ar.sum(axis = 0)}\\n\")\n",
    "\n",
    "#Sum of elements for axis = 1\n",
    "print(f\"Sum of axis = 1 : {ar.sum(axis = 1)}\\n\")\n",
    "\n",
    "#Transpose of a matrix\n",
    "print(f\"Transpose : \\n{ar.T}\\n\")\n",
    "\n",
    "#Returns a flattened array\n",
    "print(\"ar.flat :\")\n",
    "for item in ar.flat:\n",
    "    print(item)\n",
    "\n",
    "#Number of dimensions\n",
    "print(f\"\\nNumber of dimensions : {ar.ndim}\\n\")\n",
    "\n",
    "#Size of array\n",
    "print(f\"Size of array : {ar.size}\\n\")\n",
    "\n",
    "#Bytes consumed\n",
    "print(f\"Bytes consumed : {ar.nbytes}\\n\")\n",
    "\n",
    "#\"argmin\" for 2D array\n",
    "print(f\"argmin for 2D array : {ar.argmin()}\\n\")\n",
    "\n",
    "#\"argmax for 2D array\"\n",
    "print(f\"argmax for 2D array : {ar.argmax()}\\n\")\n",
    "\n",
    "#argmax for axis = 0\n",
    "print(f\"argmax for axis = 0 : {ar.argmax(axis = 0)}\\n\")\n",
    "\n",
    "#argmax for axis = 1\n",
    "print(f\"argmax for axis = 1 : {ar.argmax(axis = 1)}\\n\")\n",
    "\n",
    "#ravel(flatten the 2D array)\n",
    "print(f\"ravel : \\n{ar.ravel()}\\n\")\n",
    "\n",
    "#reshape to 9*1 array\n",
    "print(f\"3*3 array reshaped to 9*1 :\\n{ar.reshape(9,1)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "91206442-8e5c-4160-8263-2f278f1a2c34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of metrices : \n",
      "[[ 2  4  4]\n",
      " [ 8  5 12]\n",
      " [15  2  0]]\n",
      "\n",
      "Multiplication of metrices : \n",
      "[[ 1  4  3]\n",
      " [16  0 36]\n",
      " [56  1  0]]\n",
      "\n",
      "Element-wise sqrt : \n",
      "[[1.         1.41421356 1.73205081]\n",
      " [2.         2.23606798 2.44948974]\n",
      " [2.64575131 1.         0.        ]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Matrix Operations\n",
    "\n",
    "ar1 = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 1, 0]\n",
    "])\n",
    "\n",
    "ar2 = np.array([\n",
    "    [1, 2, 1],\n",
    "    [4, 0, 6],\n",
    "    [8, 1, 0]\n",
    "])\n",
    "\n",
    "#Sum of metrices\n",
    "print(f\"Sum of metrices : \\n{ar1 + ar2}\\n\")\n",
    "\n",
    "#Multiplication of metrices\n",
    "print(f\"Multiplication of metrices : \\n{ar1 * ar2}\\n\")\n",
    "\n",
    "#element-wise sqrt\n",
    "print(f\"Element-wise sqrt : \\n{np.sqrt(ar1)}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5cdbd540-d9fb-4ae7-9a2d-35c9ad0ad231",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INDICES of nos > 3 in ar1 : \n",
      "(array([1, 1, 1, 2]), array([0, 1, 2, 0]))\n",
      "\n",
      "<class 'tuple'>\n",
      "\n",
      "no of non-zero elements : 8\n",
      "\n",
      "non-zero elements : \n",
      "(array([0, 0, 0, 1, 1, 1, 2, 2]), array([0, 1, 2, 0, 1, 2, 0, 1]))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Searching in the 2D array\n",
    "\n",
    "#make pairs using each array\n",
    "#(1, 0), (1, 1), (1, 2), (2, 0)\n",
    "print(f\"INDICES of nos > 3 in ar1 : \\n{np.where(ar1 > 3)}\\n\")\n",
    "\n",
    "print(f\"{type(np.where(ar1 > 3))}\\n\")\n",
    "\n",
    "#count non-zero elements in ar1\n",
    "print(f\"no of non-zero elements : {np.count_nonzero(ar1)}\\n\")\n",
    "\n",
    "#returns a tuple for each axis\n",
    "print(f\"non-zero elements : \\n{np.nonzero(ar1)}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6f23088e-6291-41e9-895c-0224ab354216",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "storage consumed by py_ar : 112\n",
      "storage consumed by np_ar : 32\n"
     ]
    }
   ],
   "source": [
    "#Storage Efficient\n",
    "import sys\n",
    "\n",
    "py_ar = [0, 55, 14, 2]\n",
    "np_ar = np.array(py_ar)\n",
    "\n",
    "print(f\"storage consumed by py_ar : {sys.getsizeof(1) * len(py_ar)}\")\n",
    "print(f\"storage consumed by np_ar : {np_ar.itemsize * np_ar.size}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3165cb3f-8965-4810-a3e1-008cc88837e3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}