Comprehensive Guide on Numpy for Beginners.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "26bf1ae0",
   "metadata": {
    "papermill": {
     "duration": 0.019038,
     "end_time": "2023-10-21T16:18:00.560488",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.541450",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Introduction**\n",
    "\n",
    "Welcome to this comprehensive guide on NumPy, the essential Python library for numerical computing. Whether you're a data scientist, machine learning enthusiast, or simply want to work with numerical data efficiently, NumPy is a foundational tool you'll want in your toolkit. In this guide, we'll cover the fundamental concepts and techniques, from creating arrays to advanced data manipulation, to help you harness the full potential of NumPy for your data-driven tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b85dd2c",
   "metadata": {
    "papermill": {
     "duration": 0.018188,
     "end_time": "2023-10-21T16:18:00.597520",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.579332",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Import Numpy\n",
    "The code imports the numpy library and assigns it an alias 'np'. Numpy is a fundamental package for scientific computing with Python. It contains among other things:\n",
    "- A powerful N-dimensional array object\n",
    "- Sophisticated (broadcasting) functions\n",
    "- Tools for integrating C/C++ and Fortran code\n",
    "- Useful linear algebra, Fourier transform, and random number capabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d14a9129",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:00.637405Z",
     "iopub.status.busy": "2023-10-21T16:18:00.636979Z",
     "iopub.status.idle": "2023-10-21T16:18:00.646460Z",
     "shell.execute_reply": "2023-10-21T16:18:00.645470Z"
    },
    "papermill": {
     "duration": 0.031825,
     "end_time": "2023-10-21T16:18:00.648579",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.616754",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Importing the numpy library and aliasing it as np\n",
    "# Numpy is a library in python that provides support to work with arrays,\n",
    "# and also provides a collection of mathematical functions to operate on these arrays.\n",
    "\n",
    "import numpy as np \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d71a3a",
   "metadata": {
    "papermill": {
     "duration": 0.01881,
     "end_time": "2023-10-21T16:18:00.686103",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.667293",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Creating an One-dimentional Array\n",
    "The variable a is assigned a numpy array containing the elements 1, 2, and 3. Numpy arrays are homogeneous in nature, i.e., they contain elements of the same data type. In this case, the elements are integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1659bb02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:00.727003Z",
     "iopub.status.busy": "2023-10-21T16:18:00.726310Z",
     "iopub.status.idle": "2023-10-21T16:18:00.732584Z",
     "shell.execute_reply": "2023-10-21T16:18:00.731882Z"
    },
    "papermill": {
     "duration": 0.029694,
     "end_time": "2023-10-21T16:18:00.734410",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.704716",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a numpy array 'a' with elements 1, 2, and 3\n",
    "a = np.array([1,2,3])\n",
    "\n",
    "# Displaying the type of object 'a' to confirm that it is a numpy array\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "17fa1da7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:00.833608Z",
     "iopub.status.busy": "2023-10-21T16:18:00.832923Z",
     "iopub.status.idle": "2023-10-21T16:18:00.838053Z",
     "shell.execute_reply": "2023-10-21T16:18:00.837357Z"
    },
    "papermill": {
     "duration": 0.086773,
     "end_time": "2023-10-21T16:18:00.840156",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.753383",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the shape of the numpy array 'a'\n",
    "# The shape is a tuple representing the dimensionality of the array.\n",
    "a.shape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bd642ab1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:00.881674Z",
     "iopub.status.busy": "2023-10-21T16:18:00.880918Z",
     "iopub.status.idle": "2023-10-21T16:18:00.886660Z",
     "shell.execute_reply": "2023-10-21T16:18:00.885423Z"
    },
    "papermill": {
     "duration": 0.028947,
     "end_time": "2023-10-21T16:18:00.889186",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.860239",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the number of dimensions of the numpy array 'a' using the 'ndim' attribute\n",
    "a.ndim "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad40204",
   "metadata": {
    "papermill": {
     "duration": 0.020029,
     "end_time": "2023-10-21T16:18:00.929231",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.909202",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Two-dimentional Array\n",
    "The code initializes a two-dimensional numpy array b. The array b is constructed using two lists [1,2,3] and [2,3,4], which act as rows in the two-dimensional array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3810ff4d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:00.969886Z",
     "iopub.status.busy": "2023-10-21T16:18:00.969276Z",
     "iopub.status.idle": "2023-10-21T16:18:00.973588Z",
     "shell.execute_reply": "2023-10-21T16:18:00.972772Z"
    },
    "papermill": {
     "duration": 0.02708,
     "end_time": "2023-10-21T16:18:00.975590",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.948510",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Creating a two-dimensional numpy array 'b'\n",
    "# The array 'b' consists of two lists [1,2,3] and [2,3,4] as its elements (rows)\n",
    "\n",
    "b = np.array([[1,2,3], [2,3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4f976581",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.016363Z",
     "iopub.status.busy": "2023-10-21T16:18:01.015979Z",
     "iopub.status.idle": "2023-10-21T16:18:01.021558Z",
     "shell.execute_reply": "2023-10-21T16:18:01.020844Z"
    },
    "papermill": {
     "duration": 0.027817,
     "end_time": "2023-10-21T16:18:01.023425",
     "exception": false,
     "start_time": "2023-10-21T16:18:00.995608",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7cb5c4b5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.064835Z",
     "iopub.status.busy": "2023-10-21T16:18:01.064163Z",
     "iopub.status.idle": "2023-10-21T16:18:01.069603Z",
     "shell.execute_reply": "2023-10-21T16:18:01.068876Z"
    },
    "papermill": {
     "duration": 0.028596,
     "end_time": "2023-10-21T16:18:01.071572",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.042976",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3), 2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the shape and number of dimensions of the two-dimensional numpy array 'b'\n",
    "# 'b.shape' returns a tuple representing the dimensionality (rows, columns) of the array 'b'\n",
    "# 'b.ndim' returns the number of dimensions of the array 'b'\n",
    "b.shape, b.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afee11b9",
   "metadata": {
    "papermill": {
     "duration": 0.018949,
     "end_time": "2023-10-21T16:18:01.110663",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.091714",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Three-dimentional Array\n",
    "The code initializes two three-dimensional numpy arrays, c and d.\n",
    "- The array c is created with one set of square brackets surrounding the matrices, making it a three-dimensional array with one element.\n",
    "- It consists of a single 3x3 matrix as its element.\n",
    "- The array d is created with two 3x3 matrices, making it a three-dimensional array with two elements.\n",
    "- Each element in d is a 3x3 matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3e546227",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.151505Z",
     "iopub.status.busy": "2023-10-21T16:18:01.150900Z",
     "iopub.status.idle": "2023-10-21T16:18:01.156189Z",
     "shell.execute_reply": "2023-10-21T16:18:01.155245Z"
    },
    "papermill": {
     "duration": 0.028512,
     "end_time": "2023-10-21T16:18:01.158563",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.130051",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Creating a three-dimensional numpy array 'c'\n",
    "# The array 'c' consists of a single matrix [[1,2,3], [2,3,4], [3,4,5]] as its element\n",
    "\n",
    "c = np.array([[\n",
    "        [1,2,3],\n",
    "        [2,3,4],\n",
    "        [3,4,5]\n",
    "            ]])\n",
    "\n",
    "# Creating another three-dimensional numpy array 'd'\n",
    "# The array 'd' consists of two matrices, each [[1,2,3], [2,3,4], [3,4,5]], as its elements\n",
    "\n",
    "d = np.array([\n",
    "    [[1,2,3],[2,3,4],[3,4,5]],\n",
    "    [[1,2,3],[2,3,4],[3,4,5]]\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a8e4e90f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.200352Z",
     "iopub.status.busy": "2023-10-21T16:18:01.199388Z",
     "iopub.status.idle": "2023-10-21T16:18:01.205394Z",
     "shell.execute_reply": "2023-10-21T16:18:01.204454Z"
    },
    "papermill": {
     "duration": 0.028892,
     "end_time": "2023-10-21T16:18:01.207463",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.178571",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of array 'c' is: (1, 3, 3)\n",
      "The shape of array 'd' is: (2, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "# Printing the shape of the three-dimensional numpy array 'c'\n",
    "# This will output a tuple representing the shape (dimensionality) of array 'c'\n",
    "print(f\"The shape of array 'c' is: {c.shape}\")\n",
    "\n",
    "# Printing the shape of the three-dimensional numpy array 'd'\n",
    "# This will output a tuple representing the shape (dimensionality) of array 'd'\n",
    "print(f\"The shape of array 'd' is: {d.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "588239fc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.250423Z",
     "iopub.status.busy": "2023-10-21T16:18:01.249255Z",
     "iopub.status.idle": "2023-10-21T16:18:01.255620Z",
     "shell.execute_reply": "2023-10-21T16:18:01.254347Z"
    },
    "papermill": {
     "duration": 0.030598,
     "end_time": "2023-10-21T16:18:01.258521",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.227923",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The data type of elements in array 'a' is: int64\n",
      "The data type of elements in array 'b' is: int64\n",
      "The data type of elements in array 'c' is: int64\n"
     ]
    }
   ],
   "source": [
    "# Printing the data types of the elements in the numpy arrays 'a', 'b', and 'c'\n",
    "# The '.dtype' attribute returns the data type of the elements in the arrays\n",
    "\n",
    "print(f\"The data type of elements in array 'a' is: {a.dtype}\")\n",
    "print(f\"The data type of elements in array 'b' is: {b.dtype}\")\n",
    "print(f\"The data type of elements in array 'c' is: {c.dtype}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f3b7f8fa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.300430Z",
     "iopub.status.busy": "2023-10-21T16:18:01.300072Z",
     "iopub.status.idle": "2023-10-21T16:18:01.305979Z",
     "shell.execute_reply": "2023-10-21T16:18:01.304851Z"
    },
    "papermill": {
     "duration": 0.02976,
     "end_time": "2023-10-21T16:18:01.308659",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.278899",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total number of elements in array 'a' is: 3\n",
      "The total number of elements in array 'b' is: 6\n",
      "The total number of elements in array 'c' is: 9\n",
      "The total number of elements in array 'd' is: 18\n"
     ]
    }
   ],
   "source": [
    "# Printing the total number of elements in the numpy arrays 'a', 'b', 'c', and 'd'\n",
    "# The '.size' attribute returns the total number of elements in the array\n",
    "\n",
    "print(f\"The total number of elements in array 'a' is: {a.size}\")\n",
    "print(f\"The total number of elements in array 'b' is: {b.size}\")\n",
    "print(f\"The total number of elements in array 'c' is: {c.size}\")\n",
    "print(f\"The total number of elements in array 'd' is: {d.size}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "123e2d0e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.351566Z",
     "iopub.status.busy": "2023-10-21T16:18:01.351207Z",
     "iopub.status.idle": "2023-10-21T16:18:01.356187Z",
     "shell.execute_reply": "2023-10-21T16:18:01.355439Z"
    },
    "papermill": {
     "duration": 0.028572,
     "end_time": "2023-10-21T16:18:01.358480",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.329908",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total bytes consumed by array 'a' is: 24 bytes\n",
      "The total bytes consumed by array 'b' is: 48 bytes\n",
      "The total bytes consumed by array 'c' is: 72 bytes\n",
      "The total bytes consumed by array 'd' is: 144 bytes\n"
     ]
    }
   ],
   "source": [
    "# Printing the total bytes consumed by the numpy arrays 'a', 'b', 'c', and 'd'\n",
    "# The '.nbytes' attribute returns the total bytes consumed by the array's elements\n",
    "\n",
    "print(f\"The total bytes consumed by array 'a' is: {a.nbytes} bytes\")\n",
    "print(f\"The total bytes consumed by array 'b' is: {b.nbytes} bytes\")\n",
    "print(f\"The total bytes consumed by array 'c' is: {c.nbytes} bytes\")\n",
    "print(f\"The total bytes consumed by array 'd' is: {d.nbytes} bytes\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "249952b9",
   "metadata": {
    "papermill": {
     "duration": 0.019849,
     "end_time": "2023-10-21T16:18:01.398366",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.378517",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Array Creation\n",
    "In this code snippet, a numpy array named myarray is created and initialized with the elements [1,2,3]. Additionally, the data type of the elements within the array is explicitly specified as integer (int) using the dtype parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7090488b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.440307Z",
     "iopub.status.busy": "2023-10-21T16:18:01.439599Z",
     "iopub.status.idle": "2023-10-21T16:18:01.443876Z",
     "shell.execute_reply": "2023-10-21T16:18:01.443154Z"
    },
    "papermill": {
     "duration": 0.027206,
     "end_time": "2023-10-21T16:18:01.445744",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.418538",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Creating a numpy array 'myarray' with specified data type\n",
    "# The array is initialized with elements [1,2,3] and the data type is set as integer ('int')\n",
    "\n",
    "myarray = np.array([1,2,3], dtype='int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "477c2a10",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.488303Z",
     "iopub.status.busy": "2023-10-21T16:18:01.487318Z",
     "iopub.status.idle": "2023-10-21T16:18:01.494090Z",
     "shell.execute_reply": "2023-10-21T16:18:01.493124Z"
    },
    "papermill": {
     "duration": 0.030277,
     "end_time": "2023-10-21T16:18:01.496181",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.465904",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a 3x3 numpy array 'zeroArray' filled with zeros\n",
    "# The dtype parameter is specified as 'float', setting the data type of the elements to floating-point numbers\n",
    "\n",
    "zeroArray = np.zeros((3,3), dtype='float')\n",
    "zeroArray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "862dab50",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.537919Z",
     "iopub.status.busy": "2023-10-21T16:18:01.537537Z",
     "iopub.status.idle": "2023-10-21T16:18:01.546248Z",
     "shell.execute_reply": "2023-10-21T16:18:01.545211Z"
    },
    "papermill": {
     "duration": 0.032198,
     "end_time": "2023-10-21T16:18:01.548421",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.516223",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a 2x3 numpy array 'oneArray' filled with ones\n",
    "# The dtype parameter is specified as 'float', setting the data type of the elements to floating-point numbers\n",
    "\n",
    "oneArray = np.ones((2,3), dtype='float')\n",
    "oneArray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5365b2a1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.590177Z",
     "iopub.status.busy": "2023-10-21T16:18:01.589823Z",
     "iopub.status.idle": "2023-10-21T16:18:01.596619Z",
     "shell.execute_reply": "2023-10-21T16:18:01.595572Z"
    },
    "papermill": {
     "duration": 0.030038,
     "end_time": "2023-10-21T16:18:01.598642",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.568604",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 5, 5],\n",
       "       [5, 5, 5]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a 2x3 numpy array 'fullArray' filled with the value 5\n",
    "# The 'np.full()' function is used with specified shape and fill value\n",
    "\n",
    "fullArray = np.full((2,3), 5)\n",
    "fullArray "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a1c9819",
   "metadata": {
    "papermill": {
     "duration": 0.020362,
     "end_time": "2023-10-21T16:18:01.639534",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.619172",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Identity Matrix\n",
    "An identity matrix, also known as a unit matrix, is a square matrix in which all diagonal elements are equal to 1 and all other elements are 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "27346072",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.681530Z",
     "iopub.status.busy": "2023-10-21T16:18:01.681148Z",
     "iopub.status.idle": "2023-10-21T16:18:01.687010Z",
     "shell.execute_reply": "2023-10-21T16:18:01.686253Z"
    },
    "papermill": {
     "duration": 0.029105,
     "end_time": "2023-10-21T16:18:01.688852",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.659747",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 1, 0],\n",
       "       [0, 0, 1]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a 3x3 identity matrix 'identity1' with integer data type\n",
    "# The 'np.identity()' function is used, specifying the size and the data type of the elements\n",
    "\n",
    "identity1 = np.identity(3, dtype='int')\n",
    "identity1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8f4eea6a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.732761Z",
     "iopub.status.busy": "2023-10-21T16:18:01.732373Z",
     "iopub.status.idle": "2023-10-21T16:18:01.737425Z",
     "shell.execute_reply": "2023-10-21T16:18:01.736682Z"
    },
    "papermill": {
     "duration": 0.029947,
     "end_time": "2023-10-21T16:18:01.739989",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.710042",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0]\n",
      " [0 1]]\n"
     ]
    }
   ],
   "source": [
    "# Creating a 2x2 identity matrix 'identity2' with integer data type\n",
    "# The 'np.identity()' function is used, specifying the size and the data type of the elements\n",
    "\n",
    "identity2 = np.identity(2, dtype='int')\n",
    "print(identity2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "230718d1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.783723Z",
     "iopub.status.busy": "2023-10-21T16:18:01.783339Z",
     "iopub.status.idle": "2023-10-21T16:18:01.789918Z",
     "shell.execute_reply": "2023-10-21T16:18:01.789092Z"
    },
    "papermill": {
     "duration": 0.030045,
     "end_time": "2023-10-21T16:18:01.791973",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.761928",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a 3x3 identity matrix 'eye1' using the 'np.eye()' function\n",
    "# The function is called with parameters defining the number of rows and columns\n",
    "\n",
    "eye1 = np.eye(3, 3)\n",
    "eye1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ddcf2ffd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.836362Z",
     "iopub.status.busy": "2023-10-21T16:18:01.835964Z",
     "iopub.status.idle": "2023-10-21T16:18:01.842580Z",
     "shell.execute_reply": "2023-10-21T16:18:01.841497Z"
    },
    "papermill": {
     "duration": 0.03185,
     "end_time": "2023-10-21T16:18:01.844767",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.812917",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0.],\n",
       "       [0., 0., 1.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eye2 = np.eye(3,3,1)\n",
    "eye2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b528f8af",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.889855Z",
     "iopub.status.busy": "2023-10-21T16:18:01.889402Z",
     "iopub.status.idle": "2023-10-21T16:18:01.896912Z",
     "shell.execute_reply": "2023-10-21T16:18:01.896149Z"
    },
    "papermill": {
     "duration": 0.032658,
     "end_time": "2023-10-21T16:18:01.898903",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.866245",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a numpy array 'arange' using the 'np.arange()' function\n",
    "# The function is called with parameters defining the start, stop, and step values\n",
    "\n",
    "arange = np.arange(1, 10, 2)\n",
    "arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "45f86163",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.942454Z",
     "iopub.status.busy": "2023-10-21T16:18:01.941661Z",
     "iopub.status.idle": "2023-10-21T16:18:01.947104Z",
     "shell.execute_reply": "2023-10-21T16:18:01.946352Z"
    },
    "papermill": {
     "duration": 0.030668,
     "end_time": "2023-10-21T16:18:01.950316",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.919648",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  7 13 19 25 31 37 43 49 55]\n"
     ]
    }
   ],
   "source": [
    "# Creating a numpy array 'linspace1' using the 'np.linspace()' function\n",
    "# The function is called with parameters defining the start value, end value, and number of values to generate\n",
    "# An additional parameter is used to set the data type of the elements to integers\n",
    "\n",
    "linspace1 = np.linspace(1, 55, 10, dtype='int')\n",
    "print(linspace1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "04db4e62",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:01.995279Z",
     "iopub.status.busy": "2023-10-21T16:18:01.994887Z",
     "iopub.status.idle": "2023-10-21T16:18:02.000452Z",
     "shell.execute_reply": "2023-10-21T16:18:01.999250Z"
    },
    "papermill": {
     "duration": 0.030359,
     "end_time": "2023-10-21T16:18:02.002853",
     "exception": false,
     "start_time": "2023-10-21T16:18:01.972494",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of linspace1 array is: (10,)\n"
     ]
    }
   ],
   "source": [
    "# Getting the shape of the 'linspace1' array and printing it\n",
    "# The shape will indicate the dimensions of the array\n",
    "\n",
    "shape_of_linspace1 = linspace1.shape\n",
    "print(f\"The shape of linspace1 array is: {shape_of_linspace1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "934ff1f6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.046661Z",
     "iopub.status.busy": "2023-10-21T16:18:02.046271Z",
     "iopub.status.idle": "2023-10-21T16:18:02.051949Z",
     "shell.execute_reply": "2023-10-21T16:18:02.050842Z"
    },
    "papermill": {
     "duration": 0.030031,
     "end_time": "2023-10-21T16:18:02.054165",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.024134",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of dimensions of linspace1 array is: 1\n"
     ]
    }
   ],
   "source": [
    "# Getting the number of dimensions of the 'linspace1' array and printing it\n",
    "# The number of dimensions indicates how many indexes are needed to access an element\n",
    "\n",
    "num_dimensions_linspace1 = linspace1.ndim\n",
    "print(f\"The number of dimensions of linspace1 array is: {num_dimensions_linspace1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4906089d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.098038Z",
     "iopub.status.busy": "2023-10-21T16:18:02.097389Z",
     "iopub.status.idle": "2023-10-21T16:18:02.103442Z",
     "shell.execute_reply": "2023-10-21T16:18:02.102320Z"
    },
    "papermill": {
     "duration": 0.030824,
     "end_time": "2023-10-21T16:18:02.106015",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.075191",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# Creating an empty numpy array 'empty1' with specified shape (1, n), where n is 3\n",
    "# The 'np.empty()' function returns a new array without initializing the elements to any particular values\n",
    "\n",
    "n = 3  # Defining the value of n\n",
    "empty1 = np.empty((1, n))  # Creating an empty array with shape (1, n)\n",
    "print(empty1)  # Printing the created empty array to inspect its content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "134b0fd0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.150847Z",
     "iopub.status.busy": "2023-10-21T16:18:02.150101Z",
     "iopub.status.idle": "2023-10-21T16:18:02.157111Z",
     "shell.execute_reply": "2023-10-21T16:18:02.156154Z"
    },
    "papermill": {
     "duration": 0.031802,
     "end_time": "2023-10-21T16:18:02.159290",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.127488",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 2.]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(n):\n",
    "    empty1[:,i] = i\n",
    "empty1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e063c53",
   "metadata": {
    "papermill": {
     "duration": 0.021135,
     "end_time": "2023-10-21T16:18:02.201565",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.180430",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Array Indexing & Slicing\n",
    "Array indexing and slicing are fundamental operations to access and manipulate array data. Below are some examples with explanations and documentation for different cases of array indexing and slicing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e14b3155",
   "metadata": {
    "papermill": {
     "duration": 0.020913,
     "end_time": "2023-10-21T16:18:02.243985",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.223072",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1:Basic Indexing**\n",
    "\n",
    "In the code snippet above, a one-dimensional numpy array array1 is created. An individual element of the array is accessed using its index. Since indexing starts from 0, array1[2] accesses the third element of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "067ff187",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.288364Z",
     "iopub.status.busy": "2023-10-21T16:18:02.287978Z",
     "iopub.status.idle": "2023-10-21T16:18:02.293761Z",
     "shell.execute_reply": "2023-10-21T16:18:02.292673Z"
    },
    "papermill": {
     "duration": 0.030972,
     "end_time": "2023-10-21T16:18:02.296529",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.265557",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accessed element: 3\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Creating a sample array\n",
    "array1 = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Accessing an element using indexing\n",
    "element = array1[2]  # This will access the third element of the array (Indexing starts from 0)\n",
    "print(f\"Accessed element: {element}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faea8a6b",
   "metadata": {
    "papermill": {
     "duration": 0.020963,
     "end_time": "2023-10-21T16:18:02.338737",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.317774",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Basic Slicing**\n",
    "\n",
    "A subarray is extracted from array1 by specifying the start and end indices. The slice array1[1:4] includes elements from index 1 up to, but not including, index 4, resulting in a subarray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0baa23a8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.382514Z",
     "iopub.status.busy": "2023-10-21T16:18:02.381571Z",
     "iopub.status.idle": "2023-10-21T16:18:02.387367Z",
     "shell.execute_reply": "2023-10-21T16:18:02.386100Z"
    },
    "papermill": {
     "duration": 0.029732,
     "end_time": "2023-10-21T16:18:02.389390",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.359658",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subarray: [2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# Slicing array to get a subarray\n",
    "subarray = array1[1:4]  # This will retrieve elements from index 1 to index 3\n",
    "print(f\"Subarray: {subarray}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76b8dcb4",
   "metadata": {
    "papermill": {
     "duration": 0.02078,
     "end_time": "2023-10-21T16:18:02.431121",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.410341",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 3: Multidimensional Array Indexing and Slicing**\n",
    "\n",
    "A two-dimensional array array2 is created, and individual elements are accessed using row and column indices. Slicing is used to extract specific rows and columns, yielding a subarray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "292acde2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.474822Z",
     "iopub.status.busy": "2023-10-21T16:18:02.474413Z",
     "iopub.status.idle": "2023-10-21T16:18:02.481106Z",
     "shell.execute_reply": "2023-10-21T16:18:02.479719Z"
    },
    "papermill": {
     "duration": 0.031105,
     "end_time": "2023-10-21T16:18:02.483281",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.452176",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accessed element: 6\n",
      "Subarray:\n",
      "[[2 3]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Creating a multidimensional array\n",
    "array2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "\n",
    "# Accessing an element\n",
    "element = array2[1, 2]  # Accessing element from the second row and third column\n",
    "print(f\"Accessed element: {element}\")\n",
    "\n",
    "# Slicing to get a subarray\n",
    "subarray = array2[0:2, 1:3]  # Getting a 2x2 subarray from the first two rows and last two columns\n",
    "print(f\"Subarray:\\n{subarray}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d47166a2",
   "metadata": {
    "papermill": {
     "duration": 0.021758,
     "end_time": "2023-10-21T16:18:02.526570",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.504812",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Manipulation of Array\n",
    "Here are some common manipulations to perform on numpy arrays such as reshaping, transposing, concatenating, and splitting."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "364d953b",
   "metadata": {
    "papermill": {
     "duration": 0.02103,
     "end_time": "2023-10-21T16:18:02.569073",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.548043",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1: Reshaping an Array**\n",
    "\n",
    "In this code, the numpy array array1 is reshaped into a 2x3 matrix using the reshape() method, resulting in reshaped_array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "17fc5b93",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.614585Z",
     "iopub.status.busy": "2023-10-21T16:18:02.614196Z",
     "iopub.status.idle": "2023-10-21T16:18:02.620549Z",
     "shell.execute_reply": "2023-10-21T16:18:02.619273Z"
    },
    "papermill": {
     "duration": 0.032421,
     "end_time": "2023-10-21T16:18:02.623054",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.590633",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped array:\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Creating a sample array\n",
    "array1 = np.array([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "# Reshaping the array\n",
    "reshaped_array = array1.reshape(2, 3)\n",
    "print(f\"Reshaped array:\\n{reshaped_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "556d4518",
   "metadata": {
    "papermill": {
     "duration": 0.021907,
     "end_time": "2023-10-21T16:18:02.667246",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.645339",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Transposing an Array**\n",
    "\n",
    "The reshaped_array is transposed, meaning its rows become columns and vice versa, resulting in transposed_array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c8cf101a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.712579Z",
     "iopub.status.busy": "2023-10-21T16:18:02.712231Z",
     "iopub.status.idle": "2023-10-21T16:18:02.718182Z",
     "shell.execute_reply": "2023-10-21T16:18:02.717082Z"
    },
    "papermill": {
     "duration": 0.032101,
     "end_time": "2023-10-21T16:18:02.720999",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.688898",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transposed array:\n",
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n"
     ]
    }
   ],
   "source": [
    "# Transposing the reshaped array\n",
    "transposed_array = reshaped_array.T\n",
    "print(f\"Transposed array:\\n{transposed_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a20dcae7",
   "metadata": {
    "papermill": {
     "duration": 0.023211,
     "end_time": "2023-10-21T16:18:02.767593",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.744382",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 3: Concatenating Arrays**\n",
    "\n",
    "Two arrays, array2 and array3, are concatenated along the first axis (vertically), resulting in a new array, concatenated_array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "03cc6be3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.815018Z",
     "iopub.status.busy": "2023-10-21T16:18:02.814633Z",
     "iopub.status.idle": "2023-10-21T16:18:02.821479Z",
     "shell.execute_reply": "2023-10-21T16:18:02.820290Z"
    },
    "papermill": {
     "duration": 0.034039,
     "end_time": "2023-10-21T16:18:02.824180",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.790141",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Concatenated array:\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Creating two arrays to concatenate\n",
    "array2 = np.array([[1, 2], [3, 4]])\n",
    "array3 = np.array([[5, 6]])\n",
    "\n",
    "# Concatenating along the first axis (vertically)\n",
    "concatenated_array = np.concatenate((array2, array3), axis=0)\n",
    "print(f\"Concatenated array:\\n{concatenated_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93804d87",
   "metadata": {
    "papermill": {
     "duration": 0.021454,
     "end_time": "2023-10-21T16:18:02.868466",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.847012",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 4: Splitting an Array**\n",
    "\n",
    "The concatenated_array is split into two arrays along the first axis (vertically), resulting in a list of new arrays, split_arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "bf7fbf3e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:02.915011Z",
     "iopub.status.busy": "2023-10-21T16:18:02.914631Z",
     "iopub.status.idle": "2023-10-21T16:18:02.922524Z",
     "shell.execute_reply": "2023-10-21T16:18:02.921251Z"
    },
    "papermill": {
     "duration": 0.034828,
     "end_time": "2023-10-21T16:18:02.924837",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.890009",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Split arrays:\n",
      "[array([[1, 2],\n",
      "       [3, 4]]), array([[5, 6]])]\n"
     ]
    }
   ],
   "source": [
    "# Splitting the concatenated array into two\n",
    "# Using np.array_split() to handle unequal splitting\n",
    "split_arrays = np.array_split(concatenated_array, 2, axis=0)\n",
    "print(f\"Split arrays:\\n{split_arrays}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b73a5262",
   "metadata": {
    "papermill": {
     "duration": 0.021576,
     "end_time": "2023-10-21T16:18:02.967938",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.946362",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Resize an Array, resize()\n",
    "\n",
    "The resize() function in numpy can be used to change the shape of an array, and it may also modify the array itself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4d99e746",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.013322Z",
     "iopub.status.busy": "2023-10-21T16:18:03.012971Z",
     "iopub.status.idle": "2023-10-21T16:18:03.019125Z",
     "shell.execute_reply": "2023-10-21T16:18:03.017920Z"
    },
    "papermill": {
     "duration": 0.031557,
     "end_time": "2023-10-21T16:18:03.021405",
     "exception": false,
     "start_time": "2023-10-21T16:18:02.989848",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array:\n",
      "[1 2 3 4]\n",
      "Resized array:\n",
      "[[1 2 3]\n",
      " [4 1 2]]\n"
     ]
    }
   ],
   "source": [
    "# Creating a sample array\n",
    "array1 = np.array([1, 2, 3, 4])\n",
    "\n",
    "# Resizing the array to shape (2, 3)\n",
    "resized_array = np.resize(array1, (2, 3))\n",
    "\n",
    "print(f\"Original array:\\n{array1}\")\n",
    "print(f\"Resized array:\\n{resized_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f01f48f",
   "metadata": {
    "papermill": {
     "duration": 0.022067,
     "end_time": "2023-10-21T16:18:03.065338",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.043271",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Flattened an Array by ravel()\n",
    "The ravel() function is used to return a flattened array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "97eca2ab",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.110837Z",
     "iopub.status.busy": "2023-10-21T16:18:03.110434Z",
     "iopub.status.idle": "2023-10-21T16:18:03.116452Z",
     "shell.execute_reply": "2023-10-21T16:18:03.115291Z"
    },
    "papermill": {
     "duration": 0.031248,
     "end_time": "2023-10-21T16:18:03.118684",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.087436",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array:\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "Flattened array:\n",
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# Creating a two-dimensional array\n",
    "array2D = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(f\"Original array:\\n{array2D}\")\n",
    "\n",
    "# Using the ravel() function to flatten the array\n",
    "flattened_array = array2D.ravel()\n",
    "print(f\"Flattened array:\\n{flattened_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b829684e",
   "metadata": {
    "papermill": {
     "duration": 0.021743,
     "end_time": "2023-10-21T16:18:03.162058",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.140315",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Flatten()\n",
    "The flatten() method in numpy is utilized to return a copy of the array collapsed into one dimension. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "352e2898",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.207410Z",
     "iopub.status.busy": "2023-10-21T16:18:03.207011Z",
     "iopub.status.idle": "2023-10-21T16:18:03.213648Z",
     "shell.execute_reply": "2023-10-21T16:18:03.212681Z"
    },
    "papermill": {
     "duration": 0.032048,
     "end_time": "2023-10-21T16:18:03.215968",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.183920",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array:\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "Flattened array:\n",
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# Creating a two-dimensional array\n",
    "array2D = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(f\"Original array:\\n{array2D}\")\n",
    "\n",
    "# Using the flatten() method to flatten the array\n",
    "flattened_array = array2D.flatten()\n",
    "print(f\"Flattened array:\\n{flattened_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0446e35a",
   "metadata": {
    "papermill": {
     "duration": 0.021234,
     "end_time": "2023-10-21T16:18:03.258681",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.237447",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Defining an Array Shape\n",
    "Defining an array shape means setting the dimensions (number of rows and columns, for example) of the array. It could be done during the creation of the array or later, by reshaping the array without changing its data. Below are examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09560700",
   "metadata": {
    "papermill": {
     "duration": 0.021054,
     "end_time": "2023-10-21T16:18:03.301273",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.280219",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1: Defining Shape During Array Creation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "12603226",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.347268Z",
     "iopub.status.busy": "2023-10-21T16:18:03.346451Z",
     "iopub.status.idle": "2023-10-21T16:18:03.352749Z",
     "shell.execute_reply": "2023-10-21T16:18:03.351705Z"
    },
    "papermill": {
     "duration": 0.032223,
     "end_time": "2023-10-21T16:18:03.354937",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.322714",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array with defined shape:\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Creating a two-dimensional array with a specific shape\n",
    "array_with_shape = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(f\"Array with defined shape:\\n{array_with_shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88da38e5",
   "metadata": {
    "papermill": {
     "duration": 0.02138,
     "end_time": "2023-10-21T16:18:03.397992",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.376612",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Reshaping an Existing Array**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "0ea18313",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.442769Z",
     "iopub.status.busy": "2023-10-21T16:18:03.442381Z",
     "iopub.status.idle": "2023-10-21T16:18:03.447990Z",
     "shell.execute_reply": "2023-10-21T16:18:03.446858Z"
    },
    "papermill": {
     "duration": 0.030341,
     "end_time": "2023-10-21T16:18:03.449917",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.419576",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reshaped array:\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Reshaping the array to a different shape\n",
    "reshaped_array = array_with_shape.reshape((3, 2))\n",
    "print(f\"Reshaped array:\\n{reshaped_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dc351e4",
   "metadata": {
    "papermill": {
     "duration": 0.021268,
     "end_time": "2023-10-21T16:18:03.493478",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.472210",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Stacking\n",
    "Stacking in NumPy refers to the action of joining a sequence of arrays along a new axis. You can perform stacking horizontally (hstack), vertically (vstack), or along a specified axis (stack). Below are examples of these different types of stacking"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "887f6377",
   "metadata": {
    "papermill": {
     "duration": 0.021192,
     "end_time": "2023-10-21T16:18:03.536332",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.515140",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example: Horizontal and Vertical Stacking**\n",
    "\n",
    "- **Horizontal Stacking (hstack):** Joins two or more arrays horizontally, meaning the arrays are joined column-wise.\n",
    "- **Vertical Stacking (vstack):** Joins two or more arrays vertically, meaning the arrays are joined row-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4c65fa80",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.581623Z",
     "iopub.status.busy": "2023-10-21T16:18:03.581252Z",
     "iopub.status.idle": "2023-10-21T16:18:03.587466Z",
     "shell.execute_reply": "2023-10-21T16:18:03.586502Z"
    },
    "papermill": {
     "duration": 0.031977,
     "end_time": "2023-10-21T16:18:03.589949",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.557972",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Horizontally Stacked Arrays:\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n",
      "Vertically Stacked Arrays:\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "# Creating two arrays\n",
    "array1 = np.array([[1, 2], [3, 4]])\n",
    "array2 = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "# Horizontal Stacking\n",
    "hstacked_array = np.hstack((array1, array2))\n",
    "print(f\"Horizontally Stacked Arrays:\\n{hstacked_array}\")\n",
    "\n",
    "# Vertical Stacking\n",
    "vstacked_array = np.vstack((array1, array2))\n",
    "print(f\"Vertically Stacked Arrays:\\n{vstacked_array}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f7e899b",
   "metadata": {
    "papermill": {
     "duration": 0.02151,
     "end_time": "2023-10-21T16:18:03.633705",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.612195",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example: Stacking Along a Specified Axis**\n",
    "\n",
    "This allows you to specify an axis to stack along. For instance, stacking along axis=0 will stack arrays in a layer-wise fashion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3cf8af23",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.679436Z",
     "iopub.status.busy": "2023-10-21T16:18:03.679061Z",
     "iopub.status.idle": "2023-10-21T16:18:03.685096Z",
     "shell.execute_reply": "2023-10-21T16:18:03.683805Z"
    },
    "papermill": {
     "duration": 0.031132,
     "end_time": "2023-10-21T16:18:03.687279",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.656147",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stacked Arrays along a new axis:\n",
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n"
     ]
    }
   ],
   "source": [
    "# Stacking along a new axis\n",
    "stacked_array = np.stack((array1, array2), axis=0)\n",
    "print(f\"Stacked Arrays along a new axis:\\n{stacked_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8f08e8a",
   "metadata": {
    "papermill": {
     "duration": 0.021624,
     "end_time": "2023-10-21T16:18:03.730811",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.709187",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example: Column Stackt**\n",
    "\n",
    "The column_stack() function in NumPy is used to stack one-dimensional arrays as columns into a two-dimensional array. It is equivalent to numpy.hstack() but makes most sense for stacking one-dimensional arrays and is more convenient for that use case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b40f2655",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.776128Z",
     "iopub.status.busy": "2023-10-21T16:18:03.775706Z",
     "iopub.status.idle": "2023-10-21T16:18:03.782042Z",
     "shell.execute_reply": "2023-10-21T16:18:03.781011Z"
    },
    "papermill": {
     "duration": 0.031778,
     "end_time": "2023-10-21T16:18:03.784367",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.752589",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stacked array using column_stack():\n",
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n"
     ]
    }
   ],
   "source": [
    "# Creating two one-dimensional arrays\n",
    "array1 = np.array([1, 2, 3])\n",
    "array2 = np.array([4, 5, 6])\n",
    "\n",
    "# Using the column_stack() function to stack arrays as columns\n",
    "stacked_array = np.column_stack((array1, array2))\n",
    "print(f\"Stacked array using column_stack():\\n{stacked_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f96d3629",
   "metadata": {
    "papermill": {
     "duration": 0.021657,
     "end_time": "2023-10-21T16:18:03.828230",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.806573",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example: Depth Stack**\n",
    "\n",
    "Depth stacking in NumPy can be accomplished using the np.dstack() function. The np.dstack() function stacks arrays in sequence along the third axis (depth). This means that it takes each slice from the input arrays and stacks them along a new third axis to form a single array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "76298213",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:03.874427Z",
     "iopub.status.busy": "2023-10-21T16:18:03.874035Z",
     "iopub.status.idle": "2023-10-21T16:18:03.881170Z",
     "shell.execute_reply": "2023-10-21T16:18:03.879724Z"
    },
    "papermill": {
     "duration": 0.032842,
     "end_time": "2023-10-21T16:18:03.883272",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.850430",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Depth Stacked Array:\n",
      "[[[1 5]\n",
      "  [2 6]]\n",
      "\n",
      " [[3 7]\n",
      "  [4 8]]]\n"
     ]
    }
   ],
   "source": [
    "# Creating two two-dimensional arrays\n",
    "array1 = np.array([[1, 2], [3, 4]])\n",
    "array2 = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "# Using the dstack() function to stack arrays along the third axis (depth)\n",
    "depth_stacked_array = np.dstack((array1, array2))\n",
    "print(f\"Depth Stacked Array:\\n{depth_stacked_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "435a006f",
   "metadata": {
    "papermill": {
     "duration": 0.022523,
     "end_time": "2023-10-21T16:18:03.928290",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.905767",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Iterating Arrays\n",
    "Iterating over arrays in NumPy can be performed in various ways, depending on the task at hand. You might iterate element-wise, row-wise, or using more complex iteration patterns. Here are some examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94b94b85",
   "metadata": {
    "papermill": {
     "duration": 0.022491,
     "end_time": "2023-10-21T16:18:03.973129",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.950638",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1: Element-wise Iteration**\n",
    "\n",
    "Using np.nditer(), you can iterate over each element of the array, regardless of the array's shape or number of dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "bfbd05e0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.019598Z",
     "iopub.status.busy": "2023-10-21T16:18:04.019225Z",
     "iopub.status.idle": "2023-10-21T16:18:04.024055Z",
     "shell.execute_reply": "2023-10-21T16:18:04.023372Z"
    },
    "papermill": {
     "duration": 0.029853,
     "end_time": "2023-10-21T16:18:04.025890",
     "exception": false,
     "start_time": "2023-10-21T16:18:03.996037",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "array = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "# Iterating over each element of the array\n",
    "for element in np.nditer(array):\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4897925",
   "metadata": {
    "papermill": {
     "duration": 0.021766,
     "end_time": "2023-10-21T16:18:04.069746",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.047980",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Row-wise Iteration**\n",
    "\n",
    "By default, iterating directly over a NumPy array will give you each row (or the first axis) as a separate array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "82fcc819",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.115977Z",
     "iopub.status.busy": "2023-10-21T16:18:04.115241Z",
     "iopub.status.idle": "2023-10-21T16:18:04.120474Z",
     "shell.execute_reply": "2023-10-21T16:18:04.119341Z"
    },
    "papermill": {
     "duration": 0.03056,
     "end_time": "2023-10-21T16:18:04.122499",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.091939",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# Iterating over each row of the array\n",
    "for row in array:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c9e65e0",
   "metadata": {
    "papermill": {
     "duration": 0.021774,
     "end_time": "2023-10-21T16:18:04.166508",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.144734",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 3: Iterating with Index**\n",
    "\n",
    "np.ndenumerate() function returns pairs containing the index and the value of each element. It’s useful when the position information is necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "79f44899",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.213082Z",
     "iopub.status.busy": "2023-10-21T16:18:04.212023Z",
     "iopub.status.idle": "2023-10-21T16:18:04.218385Z",
     "shell.execute_reply": "2023-10-21T16:18:04.216918Z"
    },
    "papermill": {
     "duration": 0.032066,
     "end_time": "2023-10-21T16:18:04.220724",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.188658",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index (0, 0) has element 1\n",
      "Index (0, 1) has element 2\n",
      "Index (0, 2) has element 3\n",
      "Index (1, 0) has element 4\n",
      "Index (1, 1) has element 5\n",
      "Index (1, 2) has element 6\n"
     ]
    }
   ],
   "source": [
    "# Iterating over each element with index using ndenumerate\n",
    "for index, element in np.ndenumerate(array):\n",
    "    print(f\"Index {index} has element {element}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a3b8b32",
   "metadata": {
    "papermill": {
     "duration": 0.022032,
     "end_time": "2023-10-21T16:18:04.265275",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.243243",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Splitting NumPy Arrays\n",
    "\n",
    "Splitting a NumPy array involves breaking it into multiple arrays along a specified axis. This can be done using various functions such as np.split(), np.hsplit(), and np.vsplit()."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2d61712",
   "metadata": {
    "papermill": {
     "duration": 0.021859,
     "end_time": "2023-10-21T16:18:04.309618",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.287759",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1: Using np.split()**\n",
    "\n",
    "Using np.split(): Generic function where the axis along which the array will be split is specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ee3c8485",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.356383Z",
     "iopub.status.busy": "2023-10-21T16:18:04.355531Z",
     "iopub.status.idle": "2023-10-21T16:18:04.362184Z",
     "shell.execute_reply": "2023-10-21T16:18:04.360988Z"
    },
    "papermill": {
     "duration": 0.032213,
     "end_time": "2023-10-21T16:18:04.364352",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.332139",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Splitted arrays:\n",
      "[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]\n"
     ]
    }
   ],
   "source": [
    "array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "\n",
    "# Splitting the array into two along the vertical axis (axis=0)\n",
    "split_arrays = np.split(array, 3, axis=0)\n",
    "print(f\"Splitted arrays:\\n{split_arrays}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b8537a7",
   "metadata": {
    "papermill": {
     "duration": 0.021965,
     "end_time": "2023-10-21T16:18:04.408821",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.386856",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Using np.hsplit()**\n",
    "\n",
    "Using np.hsplit(): Splits an array into multiple sub-arrays horizontally (column-wise)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "5de2a4fb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.455336Z",
     "iopub.status.busy": "2023-10-21T16:18:04.454703Z",
     "iopub.status.idle": "2023-10-21T16:18:04.460110Z",
     "shell.execute_reply": "2023-10-21T16:18:04.459374Z"
    },
    "papermill": {
     "duration": 0.030791,
     "end_time": "2023-10-21T16:18:04.462011",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.431220",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Horizontally splitted arrays:\n",
      "[array([[1],\n",
      "       [4],\n",
      "       [7]]), array([[2],\n",
      "       [5],\n",
      "       [8]]), array([[3],\n",
      "       [6],\n",
      "       [9]])]\n"
     ]
    }
   ],
   "source": [
    "# Horizontally splitting the array into three equal parts\n",
    "split_arrays = np.hsplit(array, 3)\n",
    "print(f\"Horizontally splitted arrays:\\n{split_arrays}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e28f6434",
   "metadata": {
    "papermill": {
     "duration": 0.021986,
     "end_time": "2023-10-21T16:18:04.506407",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.484421",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 3: Using np.vsplit()**\n",
    "\n",
    "Using np.vsplit(): Splits an array into multiple sub-arrays vertically (row-wise)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "29dd5e5c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.553276Z",
     "iopub.status.busy": "2023-10-21T16:18:04.552120Z",
     "iopub.status.idle": "2023-10-21T16:18:04.558360Z",
     "shell.execute_reply": "2023-10-21T16:18:04.557031Z"
    },
    "papermill": {
     "duration": 0.031968,
     "end_time": "2023-10-21T16:18:04.560600",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.528632",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertically splitted arrays:\n",
      "[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]\n"
     ]
    }
   ],
   "source": [
    "# Vertically splitting the array into three equal parts\n",
    "split_arrays = np.vsplit(array, 3)\n",
    "print(f\"Vertically splitted arrays:\\n{split_arrays}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1f619f5",
   "metadata": {
    "papermill": {
     "duration": 0.021908,
     "end_time": "2023-10-21T16:18:04.604865",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.582957",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Searching Arrays\n",
    "Searching within a NumPy array can be accomplished using various functions like np.where(), np.argmax(), np.argmin(), and np.nonzero(). These functions help in finding elements, indices, or positions based on specified conditions or criteria."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbdf4367",
   "metadata": {
    "papermill": {
     "duration": 0.022095,
     "end_time": "2023-10-21T16:18:04.649372",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.627277",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1: Using np.where()**\n",
    "\n",
    "Returns indices where a specified condition is met. It is a versatile function that can also be used to return elements based on conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "8ab35d02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.696911Z",
     "iopub.status.busy": "2023-10-21T16:18:04.696130Z",
     "iopub.status.idle": "2023-10-21T16:18:04.702677Z",
     "shell.execute_reply": "2023-10-21T16:18:04.701473Z"
    },
    "papermill": {
     "duration": 0.032936,
     "end_time": "2023-10-21T16:18:04.705528",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.672592",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices where value > 5: (array([1, 2, 2, 2]), array([2, 0, 1, 2]))\n"
     ]
    }
   ],
   "source": [
    "array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "\n",
    "# Finding the indices where value is greater than 5\n",
    "indices = np.where(array > 5)\n",
    "print(f\"Indices where value > 5: {indices}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8da6a7c",
   "metadata": {
    "papermill": {
     "duration": 0.022251,
     "end_time": "2023-10-21T16:18:04.751350",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.729099",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Using np.argmax() and np.argmin()**\n",
    "\n",
    "These functions return the index of the maximum and minimum elements in the array, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "7a3f3c36",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.799104Z",
     "iopub.status.busy": "2023-10-21T16:18:04.798201Z",
     "iopub.status.idle": "2023-10-21T16:18:04.804940Z",
     "shell.execute_reply": "2023-10-21T16:18:04.803675Z"
    },
    "papermill": {
     "duration": 0.033532,
     "end_time": "2023-10-21T16:18:04.807660",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.774128",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index of maximum value: 8\n",
      "Index of minimum value: 0\n"
     ]
    }
   ],
   "source": [
    "# Finding the index of the maximum value in the array\n",
    "max_index = np.argmax(array)\n",
    "print(f\"Index of maximum value: {max_index}\")\n",
    "\n",
    "# Finding the index of the minimum value in the array\n",
    "min_index = np.argmin(array)\n",
    "print(f\"Index of minimum value: {min_index}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6040eabe",
   "metadata": {
    "papermill": {
     "duration": 0.022401,
     "end_time": "2023-10-21T16:18:04.853324",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.830923",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 3: Using np.nonzero()**\n",
    "\n",
    "Returns the indices of non-zero elements in the input array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "71d14610",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:04.900112Z",
     "iopub.status.busy": "2023-10-21T16:18:04.899743Z",
     "iopub.status.idle": "2023-10-21T16:18:04.908368Z",
     "shell.execute_reply": "2023-10-21T16:18:04.903585Z"
    },
    "papermill": {
     "duration": 0.035188,
     "end_time": "2023-10-21T16:18:04.911054",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.875866",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices of non-zero elements: (array([0, 0, 0, 1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2, 0, 1, 2]))\n"
     ]
    }
   ],
   "source": [
    "# Finding the indices of non-zero elements in the array\n",
    "nonzero_indices = np.nonzero(array)\n",
    "print(f\"Indices of non-zero elements: {nonzero_indices}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b2e1170",
   "metadata": {
    "papermill": {
     "duration": 0.022494,
     "end_time": "2023-10-21T16:18:04.956728",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.934234",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Sorting Arrays\n",
    "Sorting arrays in NumPy is a common operation that can be performed using various functions like np.sort(), np.argsort(), and in-place sorting using the array method array.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35101780",
   "metadata": {
    "papermill": {
     "duration": 0.02226,
     "end_time": "2023-10-21T16:18:05.001554",
     "exception": false,
     "start_time": "2023-10-21T16:18:04.979294",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1: Using np.sort()**\n",
    "\n",
    "Returns a sorted copy of an array. By default, it sorts the elements in ascending order along the specified axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "3811fdec",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:05.048325Z",
     "iopub.status.busy": "2023-10-21T16:18:05.047934Z",
     "iopub.status.idle": "2023-10-21T16:18:05.054498Z",
     "shell.execute_reply": "2023-10-21T16:18:05.053352Z"
    },
    "papermill": {
     "duration": 0.032351,
     "end_time": "2023-10-21T16:18:05.056590",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.024239",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted array: [1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "array = np.array([3, 1, 2, 4])\n",
    "\n",
    "# Sorting the array\n",
    "sorted_array = np.sort(array)\n",
    "print(f\"Sorted array: {sorted_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "452c1174",
   "metadata": {
    "papermill": {
     "duration": 0.022765,
     "end_time": "2023-10-21T16:18:05.102265",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.079500",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Using np.argsort()**\n",
    "\n",
    " Returns the indices that would sort an array. Useful when you want to sort one array based on the values in another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "a0141629",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:05.149944Z",
     "iopub.status.busy": "2023-10-21T16:18:05.149587Z",
     "iopub.status.idle": "2023-10-21T16:18:05.155224Z",
     "shell.execute_reply": "2023-10-21T16:18:05.153711Z"
    },
    "papermill": {
     "duration": 0.032359,
     "end_time": "2023-10-21T16:18:05.157491",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.125132",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices for sorted array: [1 2 0 3]\n"
     ]
    }
   ],
   "source": [
    "# Getting the indices that would sort the array\n",
    "sort_indices = np.argsort(array)\n",
    "print(f\"Indices for sorted array: {sort_indices}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4f87779",
   "metadata": {
    "papermill": {
     "duration": 0.022669,
     "end_time": "2023-10-21T16:18:05.203009",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.180340",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 3: In-place Sorting**\n",
    "\n",
    "The array method array.sort() sorts the array in-place, meaning that the array content is sorted without maintaining the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "982537e2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:05.249772Z",
     "iopub.status.busy": "2023-10-21T16:18:05.249420Z",
     "iopub.status.idle": "2023-10-21T16:18:05.254857Z",
     "shell.execute_reply": "2023-10-21T16:18:05.254040Z"
    },
    "papermill": {
     "duration": 0.031339,
     "end_time": "2023-10-21T16:18:05.257020",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.225681",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In-place sorted array: [1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# Sorting the array in-place\n",
    "array.sort()\n",
    "print(f\"In-place sorted array: {array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a8d704f",
   "metadata": {
    "papermill": {
     "duration": 0.022691,
     "end_time": "2023-10-21T16:18:05.302848",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.280157",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Filtering Arrays\n",
    "Filtering arrays is a technique used to select and manipulate array elements based on certain conditions or criteria. In NumPy, filtering can be done using boolean indexing, np.where(), or other conditional expressions. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d079c43c",
   "metadata": {
    "papermill": {
     "duration": 0.023037,
     "end_time": "2023-10-21T16:18:05.348754",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.325717",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 1: Boolean Indexing**\n",
    "\n",
    "**Boolean Indexing:** A boolean array is created based on a condition. This boolean array can be used to index the original array, resulting in an array of elements where the condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "185454c7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:05.396431Z",
     "iopub.status.busy": "2023-10-21T16:18:05.395663Z",
     "iopub.status.idle": "2023-10-21T16:18:05.401758Z",
     "shell.execute_reply": "2023-10-21T16:18:05.400842Z"
    },
    "papermill": {
     "duration": 0.032556,
     "end_time": "2023-10-21T16:18:05.404273",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.371717",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boolean array: [False False False  True  True]\n",
      "Filtered array: [4 5]\n"
     ]
    }
   ],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Creating a boolean array based on a condition\n",
    "bool_array = array > 3\n",
    "print(f\"Boolean array: {bool_array}\")\n",
    "\n",
    "# Using the boolean array to filter elements\n",
    "filtered_array = array[bool_array]\n",
    "print(f\"Filtered array: {filtered_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7672afc4",
   "metadata": {
    "papermill": {
     "duration": 0.022502,
     "end_time": "2023-10-21T16:18:05.450752",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.428250",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: Using np.where()**\n",
    "\n",
    "This function returns the indices where a condition is true. These indices can be used to filter elements from the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ba6bfb67",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:05.499571Z",
     "iopub.status.busy": "2023-10-21T16:18:05.499195Z",
     "iopub.status.idle": "2023-10-21T16:18:05.504538Z",
     "shell.execute_reply": "2023-10-21T16:18:05.503837Z"
    },
    "papermill": {
     "duration": 0.032568,
     "end_time": "2023-10-21T16:18:05.506746",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.474178",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtered array using np.where(): [4 5]\n"
     ]
    }
   ],
   "source": [
    "# Finding indices where a condition is true, and using them to filter elements\n",
    "indices = np.where(array > 3)\n",
    "filtered_array = array[indices]\n",
    "print(f\"Filtered array using np.where(): {filtered_array}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0eab3b7",
   "metadata": {
    "papermill": {
     "duration": 0.022672,
     "end_time": "2023-10-21T16:18:05.553026",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.530354",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**More Example of Filtering**\n",
    "\n",
    "This code snippet is a demonstration of boolean indexing in NumPy. An array arr is created with four integer elements. A boolean array x is manually created, containing True and False values. This boolean array is used to index the original array arr, resulting in a new array newarr that contains the elements of arr where the corresponding value in x is True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "cc0bc97a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:05.602647Z",
     "iopub.status.busy": "2023-10-21T16:18:05.602262Z",
     "iopub.status.idle": "2023-10-21T16:18:05.607334Z",
     "shell.execute_reply": "2023-10-21T16:18:05.606539Z"
    },
    "papermill": {
     "duration": 0.033893,
     "end_time": "2023-10-21T16:18:05.610207",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.576314",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[41 43]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([41, 42, 43, 44])  # Creating a numpy array\n",
    "\n",
    "# Defining a boolean array manually\n",
    "x = [True, False, True, False]  \n",
    "\n",
    "# Filtering the array 'arr' using the boolean array 'x'\n",
    "newarr = arr[x]  \n",
    "\n",
    "print(newarr)  # Printing the filtered array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1aff48e",
   "metadata": {
    "papermill": {
     "duration": 0.022894,
     "end_time": "2023-10-21T16:18:05.658174",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.635280",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Create a filter array that will return only values higher than 42\n",
    "\n",
    "This code snippet illustrates how to manually create a filter (boolean array) to select specific elements from a NumPy array based on a condition. In this case, the condition is whether the element is greater than 42."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "07f0f2fd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-21T16:18:05.706143Z",
     "iopub.status.busy": "2023-10-21T16:18:05.705799Z",
     "iopub.status.idle": "2023-10-21T16:18:05.711457Z",
     "shell.execute_reply": "2023-10-21T16:18:05.710768Z"
    },
    "papermill": {
     "duration": 0.03195,
     "end_time": "2023-10-21T16:18:05.713653",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.681703",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False, True, True, True]\n",
      "[46 51 55]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([42, 46, 51, 55])  # Creating a numpy array\n",
    "\n",
    "filter_arr = []  # Creating an empty list to hold boolean values\n",
    "\n",
    "# Iterating over each element in 'arr'\n",
    "for element in arr:\n",
    "    # Applying the condition to each element\n",
    "    if element > 42:\n",
    "        filter_arr.append(True)  # If the condition is met, append True\n",
    "    else:\n",
    "        filter_arr.append(False)  # If the condition is not met, append False\n",
    "\n",
    "# Creating a new array by filtering 'arr' using 'filter_arr'\n",
    "newarr = arr[filter_arr]  \n",
    "\n",
    "print(filter_arr)  # Printing the boolean array\n",
    "print(newarr)  # Printing the filtered array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b2ddb3d",
   "metadata": {
    "papermill": {
     "duration": 0.023847,
     "end_time": "2023-10-21T16:18:05.761384",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.737537",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Closing Thoughts**\n",
    "\n",
    "In this document, we've explored fundamental concepts and techniques for working with arrays in NumPy, a powerful library for numerical computations in Python. From creating arrays to filtering and manipulating data, NumPy offers a versatile toolbox for data scientists, researchers, and engineers.\n",
    "\n",
    "As you continue your journey in data analysis, machine learning, or any field where numerical data plays a crucial role, mastering NumPy will be an invaluable asset. The ability to efficiently process and manipulate data is at the heart of many data-driven endeavors, and NumPy provides the tools to make it happen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a61ecab9",
   "metadata": {
    "papermill": {
     "duration": 0.023668,
     "end_time": "2023-10-21T16:18:05.809079",
     "exception": false,
     "start_time": "2023-10-21T16:18:05.785411",
     "status": "completed"
    },
    "tags": []
   },
   "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.10.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 8.858909,
   "end_time": "2023-10-21T16:18:06.152306",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2023-10-21T16:17:57.293397",
   "version": "2.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}