numpy-quick-start-guide-and-cheat-sheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0e5fac08",
   "metadata": {
    "papermill": {
     "duration": 0.012929,
     "end_time": "2023-12-09T09:22:27.811638",
     "exception": false,
     "start_time": "2023-12-09T09:22:27.798709",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Table of Contents\n",
    "1. [Introduction to NumPy](#1)\n",
    "   * [1.1. What is NumPy?](#1.1)\n",
    "   * [1.2. NumPy Installation](#1.2)\n",
    "\n",
    "\n",
    "2. [NumPy Arrays](#2)\n",
    "   * [2.1. Basics of NumPy Arrays](#2.1)\n",
    "   * [2.2. Key Advantages of NumPy Arrays](#2.2)\n",
    "   * [2.3. Creating Arrays from Lists](#2.3)\n",
    "   * [2.4. Using NumPy Functions to Create Arrays](#2.4)\n",
    "\n",
    "\n",
    "3. [Array Indexing and Slicing](#3)\n",
    "   * [3.1. Indexing and Slicing Basics](#3.1)\n",
    "   * [3.2. Multidimensional Array Indexing](#3.2)\n",
    "\n",
    "\n",
    "4. [Array Shape and Reshaping](#4)\n",
    "   * [4.1. Reshaping Arrays](#4.1)\n",
    "   \n",
    "   \n",
    "5. [Array Data Types](#5)\n",
    "   * [5.1. Data Types in NumPy](#5.1)\n",
    "   * [5.2. Specifying Data Types](#5.2)\n",
    "\n",
    "\n",
    "6. [Array Operations](#6)\n",
    "   * [6.1. Basic Arithmetic Operations](#6.1)\n",
    "   * [6.2. Element-Wise Operations](#6.2)\n",
    "   * [6.3. Mathematical Functions in NumPy](#6.3)\n",
    "   * [6.4. Broadcasting in Mathematical Operations](#6.4)\n",
    "   \n",
    "   \n",
    "7. [Aggregation Functions](#7)\n",
    "   * [7.1. Sum, Mean, Median, etc.](#7.1)\n",
    "   * [7.2. Aggregation Along Specified Axes](#7.2)\n",
    "   * [7.3. Custom Functions on Arrays](#7.3)\n",
    "\n",
    "\n",
    "8. [Sorting and Searching](#8)\n",
    "   * [8.1. Sorting Arrays](#8.1)\n",
    "   * [8.2. Searching for Elements](#8.2)\n",
    "\n",
    "9. [Boolean Indexing](#9)\n",
    "   * [9.1. Filtering with Boolean Conditions](#9.1)\n",
    "   * [9.2. Combining Conditions](#9.2)\n",
    "\n",
    "\n",
    "10. [Element-Wise Conditional Operations](#10)\n",
    "   * [10.1. Conditional Operations using NumPy](#10.1)\n",
    "   * [10.2. Replacing Values Based on Conditions](#10.2)\n",
    "\n",
    "\n",
    "11. [Array Manipulation](#11)\n",
    "   * [11.1. Joining Arrays](#11.1)\n",
    "   * [11.2. Splitting Arrays](#11.2)\n",
    "   * [11.3. Adding and Removing Elements from Arrays](#11.3)\n",
    "\n",
    "\n",
    "12. [Transposing Arrays](#12)\n",
    "   * [12.1. Transposing for Data Transformations](#12.1)\n",
    "   * [12.2. Transposing for Matrix Multiplication](#12.2)\n",
    "\n",
    "\n",
    "13. [File I/O](#13)\n",
    "   * [13.1. Loading and Saving Data](#13.1)\n",
    "   * [13.2. CSV and Text Files](#13.2)\n",
    "   \n",
    "   \n",
    "14. [Binary Files](#14)\n",
    "   * [14.1. Reading and Writing Binary Files](#14.1)\n",
    "\n",
    "\n",
    "15. [Linear Algebra with NumPy](#15)\n",
    "   * [15.1. Matrix Multiplication](#15.1)\n",
    "   * [15.2. Determinants and Inverses](#15.2)\n",
    "   * [15.3. Eigenvalues and Eigenvectors](#15.3)\n",
    "\n",
    "\n",
    "16. [Random Number Generation](#16)\n",
    "   * [16.1. Random Sampling](#16.1)\n",
    "   * [16.2. Seed and Reproducibility](#16.2)\n",
    "\n",
    "\n",
    "17. [Advanced NumPy Topics](#17)\n",
    "   * [17.1. Structured Arrays](#17.1)\n",
    "   * [17.2. Memory Views](#17.2)\n",
    "   * [17.3. Universal Functions (Ufuncs)](#17.3)\n",
    "   * [17.4. Custom Data Types](#17.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef3b7967",
   "metadata": {
    "papermill": {
     "duration": 0.012147,
     "end_time": "2023-12-09T09:22:27.836311",
     "exception": false,
     "start_time": "2023-12-09T09:22:27.824164",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "<a id = \"1\"></a>\n",
    "# 1. Introduction to NumPy\n",
    "\n",
    "<a id = \"1.1\"></a>\n",
    "### 1.1. What is NumPy?\n",
    "NumPy is the fundamental library for scientific computing in Python. It provides support for arrays and matrices as well as a large collection of high-level mathematical functions to operate on these arrays. NumPy is open-source and is widely used in various scientific and engineering disciplines.\n",
    "\n",
    "<a id = \"1.2\"></a>\n",
    "### 1.2. NumPy Installation\n",
    "To install NumPy, you can use pip. Open the terminal or command prompt and enter the following command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f1a9ba2",
   "metadata": {
    "_kg_hide-output": true,
    "execution": {
     "iopub.execute_input": "2023-12-09T09:22:27.863083Z",
     "iopub.status.busy": "2023-12-09T09:22:27.862696Z",
     "iopub.status.idle": "2023-12-09T09:22:27.872779Z",
     "shell.execute_reply": "2023-12-09T09:22:27.871652Z"
    },
    "papermill": {
     "duration": 0.025176,
     "end_time": "2023-12-09T09:22:27.873998",
     "exception": true,
     "start_time": "2023-12-09T09:22:27.848822",
     "status": "failed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "pip install numpy\n",
    "\n",
    "import numpy as np    \n",
    "print(np.__version__) # This line of code will print the version of NumPy if the installation was successful."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8031f6c4",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"2\"></a>\n",
    "# 2. NumPy Arrays\n",
    "\n",
    "<a id = \"2.1\"></a>\n",
    "### 2.1. Basics of NumPy Arrays\n",
    "NumPy arrays are homogeneous, multidimensional data structures that allow to store and manipulate large datasets efficiently. They are similar to Python lists but have some key advantages.\n",
    "\n",
    "<a id = \"2.2\"></a>\n",
    "### 2.2. Key Advantages of NumPy Arrays\n",
    "- Efficiency: NumPy arrays are more memory-efficient and faster for numerical operations than Python lists.\n",
    "- Homogeneity: NumPy arrays contain elements of the same data type which allows for better optimization.\n",
    "- Multidimensionality: NumPy supports multi-dimensional arrays, making it ideal for scientific computations.\n",
    "\n",
    "<a id = \"2.3\"></a>\n",
    "### 2.3. Creating Arrays from Lists\n",
    "You can create NumPy arrays from Python lists using the `array()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b78844d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.441671Z",
     "iopub.status.busy": "2023-10-28T16:08:55.440895Z",
     "iopub.status.idle": "2023-10-28T16:08:55.453813Z",
     "shell.execute_reply": "2023-10-28T16:08:55.453106Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.441641Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_array = np.array(my_list)\n",
    "\n",
    "print(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d406fd39",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"2.4\"></a>\n",
    "### 2.4. Using NumPy Functions to Create Arrays\n",
    "NumPy provides various functions for creating arrays such as `np.zeros()`, `np.ones()` and `np.arange()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9630993b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.455282Z",
     "iopub.status.busy": "2023-10-28T16:08:55.454971Z",
     "iopub.status.idle": "2023-10-28T16:08:55.465893Z",
     "shell.execute_reply": "2023-10-28T16:08:55.464997Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.455254Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "zeros_array = np.zeros(5)\n",
    "ones_array = np.ones(5)\n",
    "range_array = np.arange(1, 11)\n",
    "\n",
    "print(zeros_array, ones_array, range_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fb5313d",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"3\"></a>\n",
    "# 3. Array Indexing and Slicing\n",
    "\n",
    "<a id = \"3.1\"></a>\n",
    "### 3.1. Indexing and Slicing Basics\n",
    "NumPy arrays can be accessed using square brackets similar to Python lists. Indexing starts at 0 and negative indices count from the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10fdc0d6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.467980Z",
     "iopub.status.busy": "2023-10-28T16:08:55.467021Z",
     "iopub.status.idle": "2023-10-28T16:08:55.477286Z",
     "shell.execute_reply": "2023-10-28T16:08:55.476211Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.467946Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_array = np.array([0, 1, 2, 3, 4, 5])\n",
    "\n",
    "first_element = my_array[0]  # Access the first element\n",
    "last_element = my_array[-1]  # Access the last element\n",
    "\n",
    "print(first_element, last_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90118a35",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"3.2\"></a>\n",
    "### 3.2. Multidimensional Array Indexing\n",
    "You can index multi-dimensional arrays using multiple indices separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8be4d22",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.480839Z",
     "iopub.status.busy": "2023-10-28T16:08:55.480509Z",
     "iopub.status.idle": "2023-10-28T16:08:55.490177Z",
     "shell.execute_reply": "2023-10-28T16:08:55.489170Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.480811Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "element = my_matrix[1, 2]  # Access the element in the second row, third column\n",
    "\n",
    "print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10638342",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"4\"></a>\n",
    "# 4. Array Shape and Reshaping\n",
    "The shape of a NumPy array is a tuple indicating the size of each dimension. You can access the shape using the `.shape` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8d9659e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.492077Z",
     "iopub.status.busy": "2023-10-28T16:08:55.491585Z",
     "iopub.status.idle": "2023-10-28T16:08:55.501326Z",
     "shell.execute_reply": "2023-10-28T16:08:55.500193Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.492038Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_array = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "shape = my_array.shape\n",
    "\n",
    "print(shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c95d6129",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"4.1\"></a>\n",
    "### 4.1. Reshaping Arrays\n",
    "You can change the shape of an array using the `.reshape()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4f8d65b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.502900Z",
     "iopub.status.busy": "2023-10-28T16:08:55.502590Z",
     "iopub.status.idle": "2023-10-28T16:08:55.513609Z",
     "shell.execute_reply": "2023-10-28T16:08:55.512429Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.502872Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_array = np.array([1, 2, 3, 4, 5, 6])\n",
    "reshaped_array = my_array.reshape(2, 3)\n",
    "\n",
    "print(reshaped_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09cc2e8b",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"5\"></a>\n",
    "# 5. Array Data Types\n",
    "\n",
    "<a id = \"5.1\"></a>\n",
    "### 5.1. Data Types in NumPy\n",
    "NumPy arrays are homogeneous, meaning all elements have the same data type. Common data types include `int`, `float` and `complex`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2385ed17",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.515804Z",
     "iopub.status.busy": "2023-10-28T16:08:55.515293Z",
     "iopub.status.idle": "2023-10-28T16:08:55.524078Z",
     "shell.execute_reply": "2023-10-28T16:08:55.523017Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.515756Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "integer_array = np.array([1, 2, 3], dtype=int)\n",
    "float_array = np.array([1.0, 2.0, 3.0], dtype=float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba477244",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"5.2\"></a>\n",
    "### 5.2. Specifying Data Types\n",
    "You can explicitly specify the data type when creating an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df608973",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.526359Z",
     "iopub.status.busy": "2023-10-28T16:08:55.525949Z",
     "iopub.status.idle": "2023-10-28T16:08:55.535793Z",
     "shell.execute_reply": "2023-10-28T16:08:55.534889Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.526319Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_array = np.array([1, 2, 3], dtype=float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dd473df",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"6\"></a>\n",
    "# 6. Array Operations\n",
    "\n",
    "<a id = \"6.1\"></a>\n",
    "### 6.1. Basic Arithmetic Operations\n",
    "NumPy arrays support basic arithmetic operations like addition, subtraction, multiplication and division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a1fbee4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.537392Z",
     "iopub.status.busy": "2023-10-28T16:08:55.537127Z",
     "iopub.status.idle": "2023-10-28T16:08:55.547072Z",
     "shell.execute_reply": "2023-10-28T16:08:55.546377Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.537368Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array1 = np.array([1, 2, 3])\n",
    "array2 = np.array([4, 5, 6])\n",
    "\n",
    "sum_array = array1 + array2    \n",
    "difference_array = array1 - array2\n",
    "product_array = array1 * array2\n",
    "quotient_array = array1 / array2\n",
    "\n",
    "print(sum_array)\n",
    "print(difference_array)\n",
    "print(product_array)\n",
    "print(quotient_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4972f002",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"6.2\"></a>\n",
    "### 6.2. Element-Wise Operations\n",
    "Arithmetic operations on NumPy arrays are performed element-wise, meaning each element is operated on individually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93e56c34",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.677707Z",
     "iopub.status.busy": "2023-10-28T16:08:55.677273Z",
     "iopub.status.idle": "2023-10-28T16:08:55.685283Z",
     "shell.execute_reply": "2023-10-28T16:08:55.683982Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.677671Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3])\n",
    "\n",
    "square_root_array = np.sqrt(array)\n",
    "square_array = np.square(array)  \n",
    "absolute_array = np.abs(array)  \n",
    "\n",
    "print(square_root_array)\n",
    "print(square_array)\n",
    "print(absolute_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3b85e65",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"6.3\"></a>\n",
    "### 6.3. Mathematical Functions in NumPy\n",
    "NumPy provides a wide range of mathematical functions for arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9164349",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.688482Z",
     "iopub.status.busy": "2023-10-28T16:08:55.687957Z",
     "iopub.status.idle": "2023-10-28T16:08:55.698826Z",
     "shell.execute_reply": "2023-10-28T16:08:55.697590Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.688438Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3])\n",
    "\n",
    "mean_value = np.mean(array)\n",
    "standard_deviation = np.std(array)\n",
    "logarithm = np.log(array)\n",
    "exponential = np.exp(array)\n",
    "\n",
    "print(mean_value)\n",
    "print(standard_deviation)\n",
    "print(logarithm)\n",
    "print(exponential)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81a86fbb",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"6.4\"></a>\n",
    "### 6.4. Broadcasting in Mathematical Operations\n",
    "NumPy automatically broadcasts arrays of different shapes during arithmetic operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a64f0f3f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.700767Z",
     "iopub.status.busy": "2023-10-28T16:08:55.700426Z",
     "iopub.status.idle": "2023-10-28T16:08:55.715022Z",
     "shell.execute_reply": "2023-10-28T16:08:55.714239Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.700736Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array1 = np.array([1, 2, 3])\n",
    "array2 = np.array([2])\n",
    "\n",
    "result = array1 + array2  # Broadcasting: [1+2, 2+2, 3+2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c60cc8fd",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"7\"></a>\n",
    "# 7. Aggregation Functions\n",
    "\n",
    "<a id = \"7.1\"></a>\n",
    "### 7.1. Sum, Mean, Median, etc.\n",
    "NumPy offers aggregation functions for summarizing array data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d3eeb97",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.716567Z",
     "iopub.status.busy": "2023-10-28T16:08:55.716274Z",
     "iopub.status.idle": "2023-10-28T16:08:55.729411Z",
     "shell.execute_reply": "2023-10-28T16:08:55.728296Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.716541Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "total_sum = np.sum(array)\n",
    "mean_value = np.mean(array)\n",
    "median_value = np.median(array)\n",
    "\n",
    "print(total_sum)\n",
    "print(mean_value)\n",
    "print(median_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2d9510",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"7.2\"></a>\n",
    "### 7.2. Aggregation Along Specified Axes\n",
    "You can aggregate along specific axes in multi-dimensional arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d2701ec",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.733895Z",
     "iopub.status.busy": "2023-10-28T16:08:55.733418Z",
     "iopub.status.idle": "2023-10-28T16:08:55.744074Z",
     "shell.execute_reply": "2023-10-28T16:08:55.743054Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.733846Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "matrix = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "row_sum = np.sum(matrix, axis=1)  # Sum along rows\n",
    "column_mean = np.mean(matrix, axis=0)  # Mean along columns\n",
    "\n",
    "print(row_sum)\n",
    "print(column_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86ceb9b4",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"7.3\"></a>\n",
    "### 7.3. Custom Functions on Arrays\n",
    "You can also apply custom functions element-wise using `np.vectorize()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71c070a9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.745648Z",
     "iopub.status.busy": "2023-10-28T16:08:55.745239Z",
     "iopub.status.idle": "2023-10-28T16:08:55.756562Z",
     "shell.execute_reply": "2023-10-28T16:08:55.755424Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.745606Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3])\n",
    "\n",
    "# Define a custom function\n",
    "def custom_function(x):\n",
    "    return x * 2\n",
    "\n",
    "custom_function_vectorized = np.vectorize(custom_function)\n",
    "result = custom_function_vectorized(array)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d124ac48",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"8\"></a>\n",
    "# 8. Sorting and Searching\n",
    "\n",
    "<a id = \"8.1\"></a>\n",
    "### 8.1. Sorting Arrays\n",
    "NumPy provides functions for sorting arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a90cf665",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.758032Z",
     "iopub.status.busy": "2023-10-28T16:08:55.757628Z",
     "iopub.status.idle": "2023-10-28T16:08:55.769318Z",
     "shell.execute_reply": "2023-10-28T16:08:55.768169Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.757990Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([3, 1, 2, 5, 4])\n",
    "\n",
    "sorted_array = np.sort(array)  # Sort in ascending order\n",
    "argsort_array = np.argsort(array)  # Get indices that would sort the array\n",
    "\n",
    "print(sorted_array)\n",
    "print(argsort_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62707e74",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"8.2\"></a>\n",
    "### 8.2. Searching for Elements\n",
    "You can search for elements in arrays using functions like `np.where()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d10582bd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.770973Z",
     "iopub.status.busy": "2023-10-28T16:08:55.770588Z",
     "iopub.status.idle": "2023-10-28T16:08:55.779677Z",
     "shell.execute_reply": "2023-10-28T16:08:55.778698Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.770943Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "indices = np.where(array == 3)  # Find indices where value is 3\n",
    "\n",
    "print(indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c77a8e8",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"9\"></a>\n",
    "# 9. Boolean Indexing\n",
    "\n",
    "<a id = \"9.1\"></a>\n",
    "### 9.1. Filtering with Boolean Conditions\n",
    "Boolean indexing enables you to filter an array based on a condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03077c2a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.780952Z",
     "iopub.status.busy": "2023-10-28T16:08:55.780659Z",
     "iopub.status.idle": "2023-10-28T16:08:55.791900Z",
     "shell.execute_reply": "2023-10-28T16:08:55.790675Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.780925Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "condition = array > 2\n",
    "filtered_array = array[condition]  # Get elements greater than 2\n",
    "\n",
    "print(filtered_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2f8b7ff",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"9.2\"></a>\n",
    "### 9.2. Combining Conditions\n",
    "You can combine multiple conditions using logical operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8fd930a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.793610Z",
     "iopub.status.busy": "2023-10-28T16:08:55.793283Z",
     "iopub.status.idle": "2023-10-28T16:08:55.802523Z",
     "shell.execute_reply": "2023-10-28T16:08:55.801596Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.793580Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "condition1 = array > 2\n",
    "condition2 = array < 5\n",
    "\n",
    "combined_condition = np.logical_and(condition1, condition2)\n",
    "filtered_array = array[combined_condition]  # Get elements between 2 and 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d6e8b4a",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"10\"></a>\n",
    "# 10. Element-wise Conditional Operations\n",
    "\n",
    "<a id = \"10.1\"></a>\n",
    "### 10.1. Conditional operations using NumPy\n",
    "NumPy supports conditional operations to create arrays based on specified conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4531108c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.804292Z",
     "iopub.status.busy": "2023-10-28T16:08:55.803884Z",
     "iopub.status.idle": "2023-10-28T16:08:55.815214Z",
     "shell.execute_reply": "2023-10-28T16:08:55.814190Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.804263Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "condition = array > 2\n",
    "result = np.where(condition, array, 0)  # Replace elements greater than 2 with 0\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04b3bb41",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"10.2\"></a>\n",
    "### 10.2. Replacing Values Based on Conditions\n",
    "You can replace elements in an array based on conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f768feb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.817671Z",
     "iopub.status.busy": "2023-10-28T16:08:55.816590Z",
     "iopub.status.idle": "2023-10-28T16:08:55.827519Z",
     "shell.execute_reply": "2023-10-28T16:08:55.826528Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.817629Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "array[array > 2] = 0  # Replace elements greater than 2 with 0\n",
    "\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4261b46a",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"11\"></a>\n",
    "# 11. Array Manipulation\n",
    "NumPy provides functions to join and split arrays efficiently.\n",
    "\n",
    "<a id = \"11.1\"></a>\n",
    "### 11.1. Joining Arrays\n",
    "You can concatenate or stack arrays using functions like `np.concatenate()`, `np.vstack()`, and `np.hstack()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34b4c20f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.829087Z",
     "iopub.status.busy": "2023-10-28T16:08:55.828702Z",
     "iopub.status.idle": "2023-10-28T16:08:55.839595Z",
     "shell.execute_reply": "2023-10-28T16:08:55.838491Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.829049Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array1 = np.array([1, 2, 3])\n",
    "array2 = np.array([4, 5, 6])\n",
    "\n",
    "concatenated_array = np.concatenate((array1, array2))\n",
    "vertical_stack = np.vstack((array1, array2))\n",
    "horizontal_stack = np.hstack((array1, array2))\n",
    "\n",
    "print(concatenated_array)\n",
    "print(vertical_stack)\n",
    "print(horizontal_stack)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6944d146",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"11.2\"></a>\n",
    "### 11.2. Splitting Arrays\n",
    "You can split arrays using `np.split()` and related functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a66ade4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.844624Z",
     "iopub.status.busy": "2023-10-28T16:08:55.844214Z",
     "iopub.status.idle": "2023-10-28T16:08:55.853893Z",
     "shell.execute_reply": "2023-10-28T16:08:55.852810Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.844592Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5, 6])\n",
    "split_arrays = np.split(array, 3)  # Split into 3 equal parts\n",
    "\n",
    "print(split_arrays)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff91b05c",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"11.3\"></a>\n",
    "### 11.3. Adding and Removing Elements from Arrays\n",
    "You can add and remove elements from arrays using functions like `np.append()`, `np.insert()` and `np.delete()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "572497e2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.855988Z",
     "iopub.status.busy": "2023-10-28T16:08:55.855570Z",
     "iopub.status.idle": "2023-10-28T16:08:55.869188Z",
     "shell.execute_reply": "2023-10-28T16:08:55.867858Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.855956Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])   \n",
    "print(\"Original Array = \", array)\n",
    "\n",
    "array = np.append(array, [6, 7])    # Add elements to the end of the array\n",
    "print(array)\n",
    "\n",
    "array = np.insert(array, 2, [8, 9]) # Insert elements at specific positions\n",
    "print(array)\n",
    "\n",
    "array = np.delete(array, [0, 1])    # Delete elements at specific positions\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98838932",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"12\"></a>\n",
    "# 12. Transposing Arrays\n",
    "\n",
    "<a id = \"12.1\"></a>\n",
    "### 12.1. Transposing for Data Transformations\n",
    "You can transpose arrays to exchange rows with columns or reshape data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0a153e5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.870976Z",
     "iopub.status.busy": "2023-10-28T16:08:55.870618Z",
     "iopub.status.idle": "2023-10-28T16:08:55.882346Z",
     "shell.execute_reply": "2023-10-28T16:08:55.881216Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.870947Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "matrix = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "transposed_matrix = np.transpose(matrix)\n",
    "\n",
    "print(transposed_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "000f2f6d",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"12.2\"></a>\n",
    "### 12.2. Transposing for Matrix Multiplication\n",
    "Transposing is often used for matrix multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64f9521b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.884606Z",
     "iopub.status.busy": "2023-10-28T16:08:55.883827Z",
     "iopub.status.idle": "2023-10-28T16:08:55.893939Z",
     "shell.execute_reply": "2023-10-28T16:08:55.892979Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.884570Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "matrix1 = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "matrix2 = np.array([[7, 8], [9, 10], [11, 12]])\n",
    "\n",
    "result_matrix = np.dot(matrix1, matrix2)\n",
    "\n",
    "print(result_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "681b240a",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"13\"></a>\n",
    "# 13. File I/O\n",
    "\n",
    "<a id = \"13.1\"></a>\n",
    "### 13.1. Loading and Saving Data\n",
    "NumPy provides functions to read and write arrays from/to files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3381a69",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.895406Z",
     "iopub.status.busy": "2023-10-28T16:08:55.895069Z",
     "iopub.status.idle": "2023-10-28T16:08:55.904697Z",
     "shell.execute_reply": "2023-10-28T16:08:55.903966Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.895379Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])      \n",
    "np.savetxt('data.txt', array)   # Save an array to a text file\n",
    "\n",
    "loaded_array = np.loadtxt('data.txt')  # Load an array from a text file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8de7859",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"13.2\"></a>\n",
    "### 13.2. CSV and Text Files\n",
    "You can also read and write data in CSV and text file formats using NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ee06b38",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.906890Z",
     "iopub.status.busy": "2023-10-28T16:08:55.905922Z",
     "iopub.status.idle": "2023-10-28T16:08:55.917807Z",
     "shell.execute_reply": "2023-10-28T16:08:55.916791Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.906857Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([[1, 2, 3], [4, 5, 6]])     \n",
    "np.savetxt('data.csv', array, delimiter=',')  # Save an array to a CSV file\n",
    "\n",
    "loaded_array = np.genfromtxt('data.csv', delimiter=',')   # Load an array from a CSV file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56795939",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"14\"></a>\n",
    "# 14. Binary Files\n",
    "\n",
    "<a id = \"14.1\"></a>\n",
    "### 14.1. Reading and Writing Binary Files\n",
    "NumPy supports saving and loading arrays in binary format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d576fddf",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.920289Z",
     "iopub.status.busy": "2023-10-28T16:08:55.919275Z",
     "iopub.status.idle": "2023-10-28T16:08:55.929798Z",
     "shell.execute_reply": "2023-10-28T16:08:55.928875Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.920248Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])    # Save an array to a binary file\n",
    "np.save('data.npy', array)\n",
    "\n",
    "loaded_array = np.load('data.npy')   # Load an array from a binary file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1459d4c",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"15\"></a>\n",
    "# 15. Linear Algebra with NumPy\n",
    "\n",
    "<a id = \"15.1\"></a>\n",
    "### 15.1. Matrix Multiplication\n",
    "NumPy provides efficient matrix multiplication using the `np.dot()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecdeb751",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.931448Z",
     "iopub.status.busy": "2023-10-28T16:08:55.931051Z",
     "iopub.status.idle": "2023-10-28T16:08:55.943140Z",
     "shell.execute_reply": "2023-10-28T16:08:55.942317Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.931415Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "matrix1 = np.array([[1, 2], [3, 4]])\n",
    "matrix2 = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "result_matrix = np.dot(matrix1, matrix2)\n",
    "\n",
    "print(result_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5e3d91d",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"15.2\"></a>\n",
    "### 15.2. Determinants and Inverses\n",
    "You can compute the determinant and inverse of a matrix using NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18d67315",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.945077Z",
     "iopub.status.busy": "2023-10-28T16:08:55.944590Z",
     "iopub.status.idle": "2023-10-28T16:08:55.956846Z",
     "shell.execute_reply": "2023-10-28T16:08:55.955669Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.945049Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "matrix = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "determinant = np.linalg.det(matrix)\n",
    "inverse_matrix = np.linalg.inv(matrix)\n",
    "\n",
    "print(determinant)\n",
    "print(inverse_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d58bbc2c",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"15.3\"></a>\n",
    "### 15.3. Eigenvalues and Eigenvectors\n",
    "NumPy allows you to calculate eigenvalues and eigenvectors of a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53b53a24",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.958427Z",
     "iopub.status.busy": "2023-10-28T16:08:55.958065Z",
     "iopub.status.idle": "2023-10-28T16:08:55.967110Z",
     "shell.execute_reply": "2023-10-28T16:08:55.965988Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.958397Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "matrix = np.array([[1, 2], [2, 1]])\n",
    "\n",
    "eigenvalues, eigenvectors = np.linalg.eig(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae5165f9",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"16\"></a>\n",
    "# 16. Random Number Generation\n",
    "\n",
    "<a id = \"16.1\"></a>\n",
    "### 16.1. Random Sampling\n",
    "NumPy provides functions for generating random numbers and samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bbd615b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.969105Z",
     "iopub.status.busy": "2023-10-28T16:08:55.968485Z",
     "iopub.status.idle": "2023-10-28T16:08:55.980693Z",
     "shell.execute_reply": "2023-10-28T16:08:55.979819Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.969069Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "random_integers = np.random.randint(1, 100, size=5)  # Generate random integers within a range\n",
    "random_uniform = np.random.uniform(0, 1, size=5)     # Generate random numbers from a uniform distribution\n",
    "random_normal = np.random.normal(0, 1, size=5)       # Generate random numbers from a normal distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea300f7d",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"16.2\"></a>\n",
    "### 16.2. Seed and Reproducibility\n",
    "You can set a seed to ensure reproducibility of random number generation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b807027a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.982541Z",
     "iopub.status.busy": "2023-10-28T16:08:55.981988Z",
     "iopub.status.idle": "2023-10-28T16:08:55.996440Z",
     "shell.execute_reply": "2023-10-28T16:08:55.995654Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.982510Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "random_numbers = np.random.rand(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4afe0af1",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"17\"></a>\n",
    "# 17. Advanced NumPy Topics\n",
    "\n",
    "<a id = \"17.1\"></a>\n",
    "### 17.1. Structured Arrays\n",
    "Structured arrays allow you to work with heterogeneous data types within a single array. This is useful for handling structured data like CSV files or database records."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6eb29953",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:55.998805Z",
     "iopub.status.busy": "2023-10-28T16:08:55.997588Z",
     "iopub.status.idle": "2023-10-28T16:08:56.011901Z",
     "shell.execute_reply": "2023-10-28T16:08:56.010797Z",
     "shell.execute_reply.started": "2023-10-28T16:08:55.998762Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "data = np.array([(1, 'Alice', 25), (2, 'Bob', 30)], dtype=[('id', 'i4'), ('name', 'U10'), ('age', 'i4')])\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66b728cc",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"17.2\"></a>\n",
    "### 17.2. Memory Views\n",
    "Memory views provide a way to access and manipulate the memory of an array without making a copy of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cc2fac6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:56.015294Z",
     "iopub.status.busy": "2023-10-28T16:08:56.014057Z",
     "iopub.status.idle": "2023-10-28T16:08:56.023723Z",
     "shell.execute_reply": "2023-10-28T16:08:56.022712Z",
     "shell.execute_reply.started": "2023-10-28T16:08:56.015250Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "memory_view = memoryview(array)\n",
    "\n",
    "print(memory_view)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0719e322",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"17.3\"></a>\n",
    "### 17.3. Universal Functions (Ufuncs)\n",
    "Universal functions (ufuncs) are functions that operate element-wise on arrays, making them efficient for numerical operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc89100c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:56.026201Z",
     "iopub.status.busy": "2023-10-28T16:08:56.025089Z",
     "iopub.status.idle": "2023-10-28T16:08:56.038323Z",
     "shell.execute_reply": "2023-10-28T16:08:56.036756Z",
     "shell.execute_reply.started": "2023-10-28T16:08:56.026157Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "square_array = np.square(array)\n",
    "log_array = np.log(array)\n",
    "\n",
    "print(square_array)\n",
    "print(log_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1dbff2c",
   "metadata": {
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "<a id = \"17.4\"></a>\n",
    "### 17.4. Custom Data Types\n",
    "You can create custom data types for NumPy arrays to handle specialized data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbd2cd58",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-28T16:08:56.043591Z",
     "iopub.status.busy": "2023-10-28T16:08:56.042729Z",
     "iopub.status.idle": "2023-10-28T16:08:56.050049Z",
     "shell.execute_reply": "2023-10-28T16:08:56.049313Z",
     "shell.execute_reply.started": "2023-10-28T16:08:56.043561Z"
    },
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "custom_dtype = np.dtype([('name', 'U10'), ('age', 'i4')])\n",
    "data = np.array([('Alice', 25), ('Bob', 30)], dtype=custom_dtype)\n",
    "\n",
    "print(data)"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "none",
   "dataSources": [],
   "dockerImageVersionId": 30558,
   "isGpuEnabled": false,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "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": 3.662893,
   "end_time": "2023-12-09T09:22:28.204666",
   "environment_variables": {},
   "exception": true,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2023-12-09T09:22:24.541773",
   "version": "2.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}