Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "934ea414-335e-493f-92fb-bed01b225766",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6e247349-2fcf-4001-833c-dffc81da27a8",
   "metadata": {},
   "source": [
    "## Introduction to Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e92b2bb6-88d3-4436-9f03-da7d04687633",
   "metadata": {},
   "source": [
    "NumPy is the fundamental package for scientific computing in Python. It is a Python library that provides a multidimensional array object, various derived objects (such as masked arrays and matrices), and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more.  \n",
    "### Which Language is NumPy written in?\n",
    "NumPy is a Python library and is written partially in Python, but most of the parts that require fast computation are written in C or C++.\r\n",
    "\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "198b46dc-7ac1-4f33-9391-231a0203e016",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0423807e-99a8-4401-b8d9-808e7fddd43d",
   "metadata": {},
   "source": [
    "## Why Use NumPy?\n",
    "- In Python we have lists that serve the purpose of arrays, but they are slow to process.  \n",
    "- NumPy aims to provide an array object that is up to 50x faster than traditional Python lists.\n",
    "### Why is NumPy Faster Than Lists?\n",
    "NumPy arrays are stored at one continuous place in memory unlike lists, so processes can access and manipulate them very efficiently.This behavior is called locality of reference in computer science.\n",
    "This is the main reason why NumPy is faster than lists. Also it is optimized to work with latest CPU architectures.ures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d4da4ea-fa95-4821-a512-4e321db7ef88",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "69f161bb-dc1f-435d-952f-2a446c24969e",
   "metadata": {},
   "source": [
    "### Installing Numpy\n",
    "Write `pip install numpy` in your command line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b84616e9-e3c9-4f5c-9e65-5174e2ca4aa5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a4f125b4-1624-44c4-82b3-6426ac720739",
   "metadata": {},
   "source": [
    "#### Importing NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b8c48828-8467-4d81-9fb8-ca68dc15d4ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cdecbbd-a78e-4b92-89df-bd71aa243d8a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "31794b29-82c3-41a1-81c1-e2b931ce5cbc",
   "metadata": {},
   "source": [
    "### What is array?\n",
    "In computer programming, an array is a structure for storing and retrieving data. We often talk about an array as if it were a grid in space, with each cell storing one element of the data.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "646b4ee4-1290-4da7-8d20-6c4a6086a90f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2194aa20-32f1-4180-b95d-6dc524ac6885",
   "metadata": {},
   "source": [
    "## Numpy Array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c98c780e-a10e-4508-a245-9b07c6566a2b",
   "metadata": {},
   "source": [
    "A **NumPy array** is a numerically ordered sequence of elements stored contiguously in memory, that can store elements of homogeneous types (usually numbers but can be boolians, strings, or other objects), is iterable, mutable, non-growable/shrinkable and allows duplicate elements.\n",
    "\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5ca33d1a-fbf1-4e02-8e25-74efd817356f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.array([1,2,3,4,5])\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "339931d0-a8d6-4f1b-9cf7-63223d68d785",
   "metadata": {},
   "source": [
    "#### 2d-Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d9f57ba0-a76c-4d91-9c08-0c64837655c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.array([[1,2,3],\n",
    "                  [4,5,6],\n",
    "                  [7,8,9]])\n",
    "array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f0c7d4d-a6dd-46af-a1ea-8e840705e7a7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "42dc6e39-a755-46df-9fa8-8d3242096311",
   "metadata": {},
   "source": [
    "#### N-dimensional Array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c7785c6-76ea-4b78-bf99-35592d09862d",
   "metadata": {},
   "source": [
    "The fundamental array class is called ndarray: it represents an “N-dimensional array”.\n",
    "\n",
    "Most NumPy arrays have some restrictions. For instance:\n",
    "- All elements of the array must be of the same type of data.\n",
    "- Once created, the total size of the the array can’t change.\n",
    "- The shape must be “rectangular”, not “jagged”; e.g., each row of a two-dimensional array must have the same number of columns.\n",
    "\n",
    "When these conditions are met, NumPy exploits these characteristics to make the array faster, more memory efficient, and more convenient to use than less restrictive data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ea728a8-9808-44b8-aeb5-cded0bfb017a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f0fb822c-2a3d-4340-baf5-27ec1add40d2",
   "metadata": {},
   "source": [
    "## Array Attributes\n",
    "- `ndim` It tells the number of dimensions of array.\n",
    "- `shape` The shape of an array is a tuple of non-negative integers that specify the number of elements along each dimension.\n",
    "- `size` The fixed, total number of elements in array.\n",
    "- `dtype` It tells the data type of elements of array.\n",
    "- `nbytes` Total bytes consumed by the elements of the array.\n",
    "- `itemsize` Length of one array element in bytes.\r\n",
    "\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "02ff699f-b437-4a6b-96b8-29a658c67216",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dimensions of Array:  2\n",
      "The shape of Array:  (2, 3)\n",
      "The size of Array:  6\n",
      "The datatype of Array:  int32\n",
      "Total bytes consumed by Array:  24\n",
      "Memory in bytes occupied by each element of Array:  4\n",
      "Array:  [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],\n",
    "               [4,5,6]])\n",
    "print(\"The dimensions of Array: \",arr.ndim)\n",
    "print(\"The shape of Array: \",arr.shape)\n",
    "print(\"The size of Array: \",arr.size)\n",
    "print(\"The datatype of Array: \",arr.dtype)\n",
    "print(\"Total bytes consumed by Array: \",arr.nbytes)\n",
    "print(\"Memory in bytes occupied by each element of Array: \",arr.itemsize)\n",
    "print(\"Array: \",arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13d9d2a4-4205-4b92-9b76-2ebc90099ee0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f1283853-0d4b-49d1-9707-e2ff58f32fce",
   "metadata": {},
   "source": [
    "## Creating Numpy Arrays with built-in functions:\n",
    "- `np.zeros()`\n",
    "- `np.ones()`\n",
    "- `np.empty()`\n",
    "- `np.arange`\n",
    "- `np.linspace`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77ec9c24-8aa7-47d8-9cef-237b0897022d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3769d610-3434-470b-8a36-cd02cb1f3eb9",
   "metadata": {},
   "source": [
    "### 1. np.zeros()  \n",
    "This method returns an array of given shape and type, filled with zeros.\n",
    "- np.zeros(shape, dtype=float)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "fba95bab-7198-4603-865a-98ad55cbab65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.zeros((1,5),dtype=int)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc4b27e8-8487-4e21-b594-28da1d445903",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d060c1b9-7229-45ec-9593-e39d5f0cd0c4",
   "metadata": {},
   "source": [
    "### 2. np.ones()\n",
    "This method returns an array of given shape and type, filled with ones.\n",
    "- np.ones(shape, dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "6c83ce12-385b-49e8-9ec9-93dd349abef5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.ones((1,5),dtype=int)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0693abe-7f7e-4d10-87e8-dbe06e38f692",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3156eaeb-4b93-471a-a03e-04d76757a12b",
   "metadata": {},
   "source": [
    "### 3. np.empty()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22784365-15db-400c-b0ba-3679b1f4a637",
   "metadata": {},
   "source": [
    "The function **np.empty()** creates an array whose initial content is random and depends on the state of the memory. \n",
    "- np.empty(shape, dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "c54eae4b-d720-48b9-9539-ce8153d9aa11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1223002760,       32766,           0,         584,         792],\n",
       "       [          0,         768,       32766,           0,           0]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.empty((2,5),dtype=int)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a45adb0e-2537-4c42-be42-fcbc9397bb63",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "56324b65-2e2d-4e9a-83d3-498f3eb068e3",
   "metadata": {},
   "source": [
    "### 4. np.arange()\n",
    "This function is used to get evenly spaced values within a given interval.\n",
    "- np.arange(start=,stop=)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "db849eec-a033-40f6-a647-59584a37f005",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(start=1,stop=10)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c52caa9-e6cd-4600-9262-cbf45c90b4f4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "77e95dae-11f0-42e3-8ca4-0c6a67a9ad0a",
   "metadata": {},
   "source": [
    "### np.linspace()\n",
    "You can also use np.linspace() to create an array with values that are spaced linearly in a specified interval.\n",
    "- np.linspace(start=,stop=,num=)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "7908574d-3b70-41b4-9a40-7417d6e7d259",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.        ,  3.11111111,  5.22222222,  7.33333333,  9.44444444,\n",
       "       11.55555556, 13.66666667, 15.77777778, 17.88888889, 20.        ])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.linspace(start=1,stop=20,num=10)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15aca98d-2fb4-4ad7-a61c-99c964585d3c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a43e2aa5-e110-4a12-aeb4-7827dd983448",
   "metadata": {},
   "source": [
    "### Sorting an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "8d223ef1-c205-48dc-b9aa-73465748e73e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  2,  4,  5,  6,  9, 10])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([2,9,6,4,2,5,1,10])\n",
    "np.sort(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aad5135b-b972-4d7b-8b61-d30867f5b9c2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "63d92c8b-ad10-4201-92e4-351b246774bb",
   "metadata": {},
   "source": [
    "### Concatenating Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa86d170-74a8-42e5-baa4-952c82ad435d",
   "metadata": {},
   "source": [
    "It joins two or more arrays in a single array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "eb8b4897-f108-4e5e-a618-a6633757392f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6]])\n",
    "np.concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "6fc568e5-70c5-46c1-bcae-d0b74e9b6c2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "d666f9e8-a76a-4b1e-b4d4-377fa3995bab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b), axis=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9023f355-25df-40e5-a23d-66be3308147a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5beaea7a-6bb7-411e-a9ce-4b38b9e0ad51",
   "metadata": {},
   "source": [
    "### Reshaping Array\n",
    "Using `arr.reshape()` will give a new shape to an array without changing the data. Just remember that when you use the reshape method, the array you want to produce needs to have the same number of elements as the original array. If you start with an array with 12 elements, you’ll need to make sure that your new array also has a total of 12 elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "381e6186-d612-4534-8a2f-d978e300019c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(8)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "88bc085d-5444-41b9-8872-4826b8f360e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3],\n",
       "       [4, 5, 6, 7]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.reshape(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1912107-baa6-4333-80f9-d1d1fc5abef4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "389460e0-091a-43d3-92a4-7b795e7755bc",
   "metadata": {},
   "source": [
    "### Indexing and slicing\n",
    "You can index and slice NumPy arrays in the same ways you can slice Python lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "6dd7aca7-b7b3-45ca-8394-4e7f80cea3c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3])\n",
    "arr[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "9982430a-2e1f-4204-9c18-c24d4e815881",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "addf2e82-8981-48e5-a697-49581281696f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "f07e29d4-25c7-467c-b64f-497260762b66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[-1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "dbd78273-5a42-45e9-9600-237edfb19f51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[-2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b136925-8566-45d5-aba1-857b4b1b8cac",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "51072379-48a0-4157-8ae0-0d70c097a506",
   "metadata": {},
   "source": [
    "You may want to take a section of your array or specific array elements to use in further analysis or additional operations. To do that, you’ll need to subset, slice, and/or index your arrays.\n",
    "\n",
    "If you want to select values from your array that fulfill certain conditions, it’s straightforward with NumPy.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "3077b972-2df5-4a16-a44f-a8415d6d795e",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e10e878-1269-4c6d-9c6b-bf90170427ae",
   "metadata": {},
   "source": [
    "You can easily print all of the values in the array that are less than 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "ac8c19d1-1b33-410b-b38d-bae91d5ec1ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(arr[arr < 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5403f12a-bbfe-4c4f-818e-044c49159932",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d583f10a-1668-4f3f-8784-5ddc60191d2d",
   "metadata": {},
   "source": [
    "You can select elements that are divisible by 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "915cab8f-ec23-41d8-a931-2ae80795c603",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  4  6  8 10 12]\n"
     ]
    }
   ],
   "source": [
    "divisible_by_2 = arr[arr%2==0]\n",
    "print(divisible_by_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b49100ce-6a73-457c-9364-27b151256a61",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1be6269d-90f3-4731-b3d2-904f56916e5c",
   "metadata": {},
   "source": [
    "## Creating an Array from existing Data:\n",
    "- `slicing and indexing`\n",
    "- `np.vstack()`\n",
    "- `np.hstack()`\n",
    "- `np.hsplit()`\n",
    "- `view()`\n",
    "- `copy()`\n",
    "\n",
    "You can easily create a new array from a section of an existing array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "3117b1b0-f6da-4f41-8f35-55055f8a2abb",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b004650-9cb7-4369-9f0b-d29f124c0181",
   "metadata": {},
   "source": [
    "You can create a new array from a section of your array any time by specifying where you want to slice your array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "555ce513-0734-4dfb-ad4b-16efc4c21558",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = arr[3:8]\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e973431-3f8b-42d6-9d51-4f9a78e6eb74",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "67d81de1-68bb-4d5e-adbc-903f03201690",
   "metadata": {},
   "source": [
    "You can also stack two existing arrays, both vertically and horizontally. Let’s say you have two arrays, `arr1` and `arr2`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "1705a139-ad8b-4687-95f6-ace445062481",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array([[1, 1],\n",
    "               [2, 2]])\n",
    "arr2 = np.array([[3, 3],\n",
    "               [4, 4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4baa8806-550d-47f5-b065-23253b4017c5",
   "metadata": {},
   "source": [
    "You can stack them vertically with `vstack`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "007e4464-66b9-4c1b-8494-dd25d86c275e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [2, 2],\n",
       "       [3, 3],\n",
       "       [4, 4]])"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((arr1, arr2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb847a36-ab3f-4eab-a7ce-19071467b7bb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4295c93e-32d2-4add-b918-e4ec8e5af9b2",
   "metadata": {},
   "source": [
    "You can stack them horizontally with `hstack`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "2c412af3-fbb1-412c-9816-d567fad81479",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 3, 3],\n",
       "       [2, 2, 4, 4]])"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((arr1, arr2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d57cb136-7e07-4ed6-b69c-1adf86594e73",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "629c7294-b826-40d2-8db6-fa4366a3ca16",
   "metadata": {},
   "source": [
    "You can split an array into several smaller arrays using `hsplit`. You can specify either the number of equally shaped arrays to return or the columns after which the division should occur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "72e04f81-7c45-40ad-8e08-6ee602d8eac9",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1,2,3,4,5,2],\n",
    "                [4,6,7,8,9,3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "b5797386-c5a4-470b-8284-41a3e7429f45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[1, 2, 3],\n",
       "        [4, 6, 7]]),\n",
       " array([[4, 5, 2],\n",
       "        [8, 9, 3]])]"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(arr,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db0ae29d-132d-4412-9800-9632ff37cb8d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3615e960-999f-40d0-8f06-0ec3630e97a9",
   "metadata": {},
   "source": [
    "If you wanted to split your array after the 2nd and 4th column, you’d run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "b11d2e35-cc34-4415-919c-e8a02c2a25e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[1, 2],\n",
       "        [4, 6]]),\n",
       " array([[3, 4],\n",
       "        [7, 8]]),\n",
       " array([[5, 2],\n",
       "        [9, 3]])]"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(arr,(2,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fedaadf2-2949-4e21-83ff-d8e8d3a7c278",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0c8ee1b6-9846-47ca-b576-8dabe68d1aa9",
   "metadata": {},
   "source": [
    "You can use the `view` method to create a new array object that looks at the same data as the original array (a shallow copy).\n",
    "\n",
    "Views are an important NumPy concept! NumPy functions, as well as operations like indexing and slicing, will return views whenever possible. This saves memory and is faster (no copy of the data has to be made). However it’s important to be aware of this - modifying data in a view also modifies the original array!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "3a99f843-2037-4aec-b5df-7dcb4ba8a5cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(5)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd70ffd5-541b-445b-b5b9-383e4a36dc9c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dd5fb682-d97e-44e2-9bf8-5e86bd6525c8",
   "metadata": {},
   "source": [
    "Now we create an array `arr1` by slicing `arr` and modify the first element of `arr1`. This will modify the corresponding element in `arr` as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "3d335968-ba95-446f-a2be-019bffb7ec4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = arr[0:]\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "0200d81f-eec8-484d-a4d4-be129998db0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[0] = 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "c5a84a93-4f51-45b4-956a-74902747fce7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([9, 1, 2, 3, 4]), array([9, 1, 2, 3, 4]))"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr,arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95b8aa72-bc8e-4d86-abf9-1f4201a4866c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "142d9b6c-1a05-4399-957a-fed959e513b2",
   "metadata": {},
   "source": [
    "Using the `copy` method will make a complete copy of the array and its data (a deep copy). To use this on your array, you could run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "6277fa4f-dcc6-4cb1-a81f-1e44a5756341",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(5)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bbe9e27-42d7-40bf-ba5e-9f1ce77fadc9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9a7cdfd1-8c11-4025-be85-5969c4f6a9c0",
   "metadata": {},
   "source": [
    "Now we create an array `arr1` by slicing `arr` and modify the first element of `arr1`. This will not modify the corresponding element in `arr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "d34a2046-5a90-4f86-8d46-62d158748710",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = arr.copy()\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "47268548-999b-4faf-8fab-92497265ca36",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[0] = 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "e6c530d2-2b4b-417d-bb72-037720d2281a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4]), array([9, 1, 2, 3, 4]))"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr,arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e3f04c7-80c8-4296-9e68-2d3893b07875",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4acb8e6c-365b-411a-80c8-44d76c6247d9",
   "metadata": {},
   "source": [
    "## Basic Operations\n",
    "- `addition`\n",
    "- `subtraction`\n",
    "- `multiplication`\n",
    "- `division`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "id": "24c7868e-1a27-4cba-be4c-c54c17037721",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array([1,2,3])\n",
    "arr2 = np.array([4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "id": "75fd5479-9793-4151-a73f-c702d0805547",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1+arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "id": "7b8f13b1-cae6-4764-854e-ee53e312f9a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -3, -3])"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1-arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "a89d51e0-8144-4b7a-89ea-88bbd3c7fba0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4, 10, 18])"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1*arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "id": "9057ed62-83b9-440d-806b-3263a5d017ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4. , 2.5, 2. ])"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2/arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa7580b8-ce10-4d2c-8dd7-6dd0b4a8a9f4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fe88c3ca-5177-4cfc-bcd8-38fe73b4109c",
   "metadata": {},
   "source": [
    "If you want to find the sum of the elements in an array, you’d use `sum()`. This works for 1D arrays, 2D arrays, and arrays in higher dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "id": "bd4d2412-de62-479d-b73a-9e9f88320a5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4])\n",
    "arr.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae30fdaf-4f7c-40c9-b121-c90eb10083dd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "id": "57b3914e-b1bd-4ff1-92be-463aecdad3ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([[1, 1], [2, 2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd6cec43-e0a2-41cf-b980-82e381e123dc",
   "metadata": {},
   "source": [
    "You can sum over the axis of rows with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "id": "568f1b1b-cc25-46aa-b818-7ed988e53c0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3])"
      ]
     },
     "execution_count": 300,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fc44c7a-d155-4381-9f07-fae80c7e93a1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b8afbfdc-df33-45a7-997c-c8469f6623f5",
   "metadata": {},
   "source": [
    "You can sum over the axis of columns with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "id": "85ac9ef8-b458-4500-80ea-2211865c0e22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4])"
      ]
     },
     "execution_count": 303,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbde0f3b-b86f-4858-a7e6-876ef554b0e9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6e7407ba-02e6-4b47-90ca-dfb4b3192a07",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "There are times when you might want to carry out an operation between an array and a single number (also called an operation between a vector and a scalar) or between arrays of two different sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "id": "0d1a5cb9-cd3d-47d9-b4a3-f90aa8184aac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6])"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1, 2])\n",
    "arr*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b47f396b-b312-4444-b406-53e4541200bc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fb7b3ce1-bd9b-45b3-955f-c729680298d5",
   "metadata": {},
   "source": [
    "## Basic Statistics Functions\n",
    "- maximum\n",
    "- minimum\n",
    "- sum\n",
    "- mean\n",
    "- product\n",
    "- standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "id": "f8b7d2ec-06d8-4dfc-97e4-1abbc21644ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "id": "d4dbbf79-885c-4d28-9520-8169134af9f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "id": "c8e6f1c6-c888-47fa-823f-0e0acc0cfef8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "id": "2be2c5da-f829-4403-bcc2-99c254ab9a5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 319,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "id": "ba2f4527-330d-4c4c-9b65-16f60e6f5b2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "id": "e2b1510d-76ab-4006-8d8e-113c33c35a85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.prod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "id": "d71f1106-ff50-4b47-bd2b-79ef5aa7ed47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 327,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d75c3293-856a-4979-8b3b-5e3b06f211ed",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b4a50c53-885c-44f3-be79-d885b6aed9a2",
   "metadata": {},
   "source": [
    "### Unique Elements of Array\n",
    "You can find the unique elements in an array easily with `np.unique`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "id": "1f9a2547-f296-400c-ae67-bbf0b237fc2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "id": "a54dc3c4-845e-4a7f-aa6f-71a8ce2cf404",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5baecf44-32ba-4e15-a070-57c512601e30",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4cc69d8a-91d5-42d7-9aea-459d3ec1f040",
   "metadata": {},
   "source": [
    "To get the indices of unique values in a NumPy array, just pass the `return_index` argument in `np.unique()` as well as your array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "id": "6fa3064b-d238-4c57-9e91-64ac3020c7d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20]),\n",
       " array([ 0,  2,  3,  4,  5,  6,  7, 12, 13, 14], dtype=int64))"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(arr,return_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5fb3291-2efe-4df1-aaaf-77a956ca7df6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "59ffe847-c454-4f28-8d94-b64152436535",
   "metadata": {},
   "source": [
    "You can pass the `return_counts` argument in `np.unique()` along with your array to get the frequency count of unique values in a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "id": "6d7a1ea5-64f0-440e-b4f2-e7190fc46de6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20]),\n",
       " array([3, 2, 2, 2, 1, 1, 1, 1, 1, 1], dtype=int64))"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(arr,return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c306385-ddd2-494e-be18-dbb35d397335",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e8ba7c9d-faef-481e-ae7a-d9c258d155d0",
   "metadata": {},
   "source": [
    "### Transpose of Matrix\n",
    "You can take transpose(interchange rows and columns) of a matrix with `arr.transpose()` and `arr.T`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "id": "230c380a-e03d-4740-82b9-866c88e406fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 2],\n",
    "                [3, 4],\n",
    "                [5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "id": "9ec56a45-8d8c-4f87-b503-9843a7f091e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3, 5],\n",
       "       [2, 4, 6]])"
      ]
     },
     "execution_count": 346,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "id": "c0f1e6a7-e433-4fbb-9d4f-2499870cd2a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3, 5],\n",
       "       [2, 4, 6]])"
      ]
     },
     "execution_count": 348,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94b5d572-afe1-4e15-b1e2-7f6c78206183",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0636ae28-b4af-4fb6-af46-149a843d3369",
   "metadata": {},
   "source": [
    "### Reversing an Array\n",
    "NumPy’s `np.flip()` function allows you to flip, or reverse, the contents of an array along an axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "id": "3eaf5c59-8d8a-47be-86ab-0e0b15fa3530",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "id": "ef7d0762-b12f-4baf-b496-8a319706590d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 4, 3, 2, 1])"
      ]
     },
     "execution_count": 354,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flip(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a51109fe-2cdd-4e68-b309-ddd4044f67d2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1aef803d-9576-4ac0-b092-f285c423698a",
   "metadata": {},
   "source": [
    "#### Reversing 2d-Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "id": "e70f5154-85c6-46f1-a8e0-488696e7bad3",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 2],\n",
    "                [3, 4],\n",
    "                [5, 6]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac7a0f21-863e-445f-b6e4-ab340b97b572",
   "metadata": {},
   "source": [
    "You can reverse the content in all of the rows and all of the columns with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "id": "22ec0bc3-8afa-476a-b9a0-e7981c4728a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 5],\n",
       "       [4, 3],\n",
       "       [2, 1]])"
      ]
     },
     "execution_count": 359,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flip(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "230102b9-7a7f-48a4-9943-feb4722d27dc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f617aca4-707c-4426-a053-8b73163ac25a",
   "metadata": {},
   "source": [
    "You can easily reverse only the rows with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "id": "cea22156-68bb-40e4-93ae-0409871c5b23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 6],\n",
       "       [3, 4],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 363,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flip(arr,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "432c171f-7909-4bf7-be8e-644f15a6009d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "350caace-8a60-4b7c-9588-e3ecd2d304d2",
   "metadata": {},
   "source": [
    "You can easily reverse only the columns with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "id": "957bbb7c-9954-4808-b8f0-cfe0527c43e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1],\n",
       "       [4, 3],\n",
       "       [6, 5]])"
      ]
     },
     "execution_count": 367,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flip(arr,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6a2c7f5-9538-4802-b670-c24a02f9b544",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4d2477fa-c0b1-495b-8fbf-ba9bcb5a939a",
   "metadata": {},
   "source": [
    "You can also reverse the contents of only one column or row. For example, you can reverse the contents of the row at index position 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "id": "45fa8687-6275-409b-b09c-c497a75c9cef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 5])"
      ]
     },
     "execution_count": 372,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flip(arr[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d42649ca-1298-4af1-9ad5-da1536d265fb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e1604a54-28c7-4a24-a864-97f7aab97905",
   "metadata": {},
   "source": [
    "### Flattening multidimensional arrays\n",
    "- flatten()\n",
    "- ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "id": "17601780-76dd-4a7f-ac73-095abdb6bfed",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f96ccc1-f1ff-4821-bd96-176df6004e7e",
   "metadata": {},
   "source": [
    "You can use `flatten` to flatten your array into a 1D array. When you use `flatten`, changes to your new array won’t change the parent array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "id": "cd9a6419-767e-42cb-9416-04fa0433073f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])"
      ]
     },
     "execution_count": 380,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07909f4b-cb0a-48b3-8e5b-df3f9e7afa38",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "76ca4ca4-fc1c-467b-b989-70c3ed014ec4",
   "metadata": {},
   "source": [
    "But when you use `ravel`, the changes you make to the new array will affect the parent array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "id": "caf4a002-5932-4f0f-8df6-aac75fb7c8d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])"
      ]
     },
     "execution_count": 383,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f0d1362-09e7-4c08-b168-d8042790e7b9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "65db6db4-b21b-4c2b-afa5-3a276c50e3a2",
   "metadata": {},
   "source": [
    "## Array with Random values\n",
    "Numpy allows you to use various functions to produce arrays with random values. To access these functions, first we have to access the random function itself. This is done using `np.random`, after which we specify which function we need. Here is a list of the most used random functions and their purpose:\n",
    "- `np.random.rand()`\n",
    "- `np.random.randn()`\n",
    "- `np.random.randint()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a41be75d-9d45-48bd-82fc-2c45a77837d4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "25ceee61-873f-49e0-92ae-123c7750eb44",
   "metadata": {},
   "source": [
    "**np.random.rand()** produce random values in the given shape from 0 to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "id": "a88804f2-97c5-4bbf-bd1b-a2116750bc70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.79133167931571"
      ]
     },
     "execution_count": 391,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "id": "9f447b17-c8d3-4f69-952b-cc2c47ec38ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.86793788, 0.46871584, 0.99279709])"
      ]
     },
     "execution_count": 393,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "id": "62d2e307-f6f7-4827-ac7c-9323cdc43ec3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.94933783, 0.803309  ],\n",
       "       [0.72436004, 0.67120132]])"
      ]
     },
     "execution_count": 395,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f722b8e-deb3-4b79-99d2-d3822fa601ef",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b02395f6-949d-4cde-ac40-fe4cbaa2d82c",
   "metadata": {},
   "source": [
    "**np.random.randn()** produce random values with a ‘standard normal’ distribution, from -1 to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "id": "f008fe1d-478f-4fd0-ad7e-a1b0cdcbd93d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2976753352290595"
      ]
     },
     "execution_count": 418,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "id": "b8c73f21-1ab2-4145-b1bb-f51c20221a2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.1380559 , -0.13666659,  1.12617832])"
      ]
     },
     "execution_count": 399,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "id": "db69fe97-25e4-487f-9f91-24927dcb2796",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.31048728, -1.14890978],\n",
       "       [ 1.36022365, -0.7074852 ]])"
      ]
     },
     "execution_count": 401,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3bee488-9b18-4f55-b65e-948c9a812fce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "45b05ad9-c811-489f-ad91-e776bafa19c7",
   "metadata": {},
   "source": [
    "**np.random.randint()** produce random numbers from low to high, specified as parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "id": "3018b1c8-7ac2-448d-93b3-6c3f764b6a9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 411,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(low=1, high=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "id": "0b1bc8db-1294-4aea-ac56-cb9c6b251858",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([81, 49, 18, 13, 31, 81, 21, 55,  3, 70, 38, 43, 70, 87, 44, 36, 50,\n",
       "       94, 27, 96])"
      ]
     },
     "execution_count": 409,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(low=1, high=100, size=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "id": "c2f5139a-829b-4496-a789-d874ca7a9e8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[37, 59, 21],\n",
       "       [67, 37, 21],\n",
       "       [85,  8, 15],\n",
       "       [65, 16,  6],\n",
       "       [42, 30, 27]])"
      ]
     },
     "execution_count": 405,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(low=1, high=100, size=(5,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0202691e-6381-4c12-b9c2-73a2b6c7d6dd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bba7653b-2d4d-4f37-ba11-2a262628d1ba",
   "metadata": {},
   "source": [
    "### Help()\n",
    "Python has a built-in `help()` function that can help you access the information about concise summary of the object and how to use it.  This means that nearly any time you need more information, you can use `help()` to quickly find the information that you need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "id": "6d487dfd-6a9d-4a03-a734-1def659a34e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, /, start=0)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c943734a-cb91-4c33-926f-9d2a3d2a667a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6bba83a7-551e-42b8-bf86-9336425fee69",
   "metadata": {},
   "source": [
    "You can also use `?`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "id": "91d53b51-331a-4e2a-9cc5-11f9c1d3fc9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterable\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m/\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m\n",
       "Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
       "\n",
       "When the iterable is empty, return the start value.\n",
       "This function is intended specifically for use with numeric values and may\n",
       "reject non-numeric types.\n",
       "\u001b[1;31mType:\u001b[0m      builtin_function_or_method"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55d60be1-eceb-45f0-8afc-48deec5271e2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}