numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NUMPY "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NumPy is a Python library.\n",
    "# NumPy is used for working with arrays.\n",
    "# NumPy is short for \"Numerical Python\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#use numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.26.4\n"
     ]
    }
   ],
   "source": [
    "# check numpy version\n",
    "import numpy as np\n",
    "\n",
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# create array and check array\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "print(arr)\n",
    "\n",
    "print(type(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.]])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy array with zero\n",
    "import numpy as np\n",
    "n1 = np.zeros((1,2))\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "n1 = np.zeros((5,5))\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "\n",
      "42\n",
      "[1 2 3 4 5]\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[[1 2 3]\n",
      "  [4 5 6]]\n",
      "\n",
      " [[1 2 3]\n",
      "  [4 5 6]]]\n"
     ]
    }
   ],
   "source": [
    "# Check ARRAY DIMENSION\n",
    "import numpy as np\n",
    "a = np.array(42)\n",
    "b = np.array([1, 2, 3, 4, 5])\n",
    "c = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
    "\n",
    "print(a.ndim)\n",
    "print(b.ndim)\n",
    "print(c.ndim)\n",
    "print(d.ndim)\n",
    "print('\\n')\n",
    "\n",
    "print(a) #0 dimensi\n",
    "print(b) #1 dimensi\n",
    "print(c) #2 dimensi\n",
    "print(d) #3 dimensi "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ARRAY INDEXING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[[1 2 3 4]]]]]\n",
      "number of dimensions : 5\n"
     ]
    }
   ],
   "source": [
    "# array dimensi 5\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4], ndmin=5)\n",
    "\n",
    "print(arr)\n",
    "print('number of dimensions :', arr.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# array index\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4])\n",
    "\n",
    "print(arr[0])\n",
    "print(arr[1])\n",
    "print(arr[2] + arr[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2nd element on 1st row:  2\n",
      "2nd element on 2nd row:  7\n"
     ]
    }
   ],
   "source": [
    "# Access 2-D Arrays\n",
    "import numpy as np\n",
    "arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])\n",
    "\n",
    "print('2nd element on 1st row: ', arr[0, 1])\n",
    "print('2nd element on 2nd row: ', arr[1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5th element on 2nd row:  10\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])\n",
    "\n",
    "print('5th element on 2nd row: ', arr[1, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# Access 3-D Arrays\n",
    "import numpy as np\n",
    "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
    "\n",
    "print(arr[0, 1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last element from 2nd dim:  10\n"
     ]
    }
   ],
   "source": [
    "# Negative Indexing\n",
    "import numpy as np\n",
    "\n",
    "arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])\n",
    "\n",
    "print('Last element from 2nd dim: ', arr[1, -1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "print(arr[1:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "print(arr[4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "print(arr[-3:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "print(arr[1:5:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "print(arr[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 8 9]\n"
     ]
    }
   ],
   "source": [
    "#SLICING 2D ARRAY\n",
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
    "\n",
    "print(arr[1, 1:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 8]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
    "\n",
    "print(arr[0:2, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3 4]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
    "\n",
    "print(arr[0:2, 1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4])\n",
    "\n",
    "print(arr.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<U6\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array(['apple', 'banana', 'cherry'])\n",
    "\n",
    "print(arr.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4], dtype='i4')\n",
    "\n",
    "print(arr)\n",
    "print(arr.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "# Converting Data Type on Existing Arrays\n",
    "\n",
    "import numpy as np\n",
    "arr = np.array([1.1, 2.1, 3.1])\n",
    "\n",
    "newarr = arr.astype('i')\n",
    "\n",
    "print(newarr)\n",
    "print(newarr.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1.1, 2.1, 3.1])\n",
    "\n",
    "newarr = arr.astype(int)\n",
    "\n",
    "print(newarr)\n",
    "print(newarr.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False  True]\n",
      "bool\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 0, 3])\n",
    "\n",
    "newarr = arr.astype(bool)\n",
    "\n",
    "print(newarr)\n",
    "print(newarr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Copy vs View"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[42  2  3  4  5]\n",
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "x = arr.copy()\n",
    "arr[0] = 42\n",
    "\n",
    "print(arr)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[31  2  3  4  5]\n",
      "[31  2  3  4  5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "x = arr.view()\n",
    "x[0] = 31\n",
    "\n",
    "print(arr)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "x = arr.copy()\n",
    "y = arr.view()\n",
    "\n",
    "print(x.base)\n",
    "print(y.base)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Shape\n",
    "The shape of an array is the number of elements in each dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "\n",
    "print(arr.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[[1 2 3 4]]]]]\n",
      "shape of array : (1, 1, 1, 1, 4)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4], ndmin=5)\n",
    "\n",
    "print(arr)\n",
    "print('shape of array :', arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Reshaping\n",
    "\n",
    "Reshaping means changing the shape of an array.\n",
    "\n",
    "The shape of an array is the number of elements in each dimension.\n",
    "\n",
    "By reshaping we can add or remove dimensions or change number of elements in each dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "#Reshape From 1-D to 2-D\n",
    "\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
    "\n",
    "newarr = arr.reshape(4, 3)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2]\n",
      "  [ 3  4]\n",
      "  [ 5  6]]\n",
      "\n",
      " [[ 7  8]\n",
      "  [ 9 10]\n",
      "  [11 12]]]\n"
     ]
    }
   ],
   "source": [
    "#Reshape From 1-D to 3-D\n",
    "\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
    "\n",
    "newarr = arr.reshape(2, 3, 2)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "#Returns Copy or View?\n",
    "\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "print(arr.reshape(2, 4).base)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n"
     ]
    }
   ],
   "source": [
    "# Unknown Dimension\n",
    "\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "newarr = arr.reshape(2, 2, -1)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# Flattening the arrays\n",
    "\n",
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "newarr = arr.reshape(-1)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Iterating\n",
    "Iterating means going through elements one by one.\n",
    "\n",
    "As we deal with multi-dimensional arrays in numpy, we can do this using basic for loop of python.\n",
    "\n",
    "If we iterate on a 1-D array it will go through each element one by one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3]) #1 dimensi\n",
    "\n",
    "for x in arr:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6]]) #2 dimensi\n",
    "\n",
    "for x in arr:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6]]) #2 dimensi\n",
    "\n",
    "for x in arr:\n",
    "  for y in x:\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) #3 dimensi\n",
    "\n",
    "for x in arr:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) #3 dimensi\n",
    "\n",
    "for x in arr:\n",
    "  for y in x:\n",
    "    for z in y:\n",
    "      print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# Iterating Arrays Using nditer()\n",
    "#The function nditer() is a helping function that can be used from very basic to very advanced iterations. \n",
    "#It solves some basic issues which we face in iteration, lets go through it with examples.\n",
    "\n",
    "import numpy as np\n",
    "arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\n",
    "\n",
    "for x in np.nditer(arr):\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'1'\n",
      "b'2'\n",
      "b'3'\n"
     ]
    }
   ],
   "source": [
    "# We can use op_dtypes argument and pass it the expected datatype to change the datatype of elements while iterating.\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3])\n",
    "\n",
    "for x in np.nditer(arr, flags=['buffered'], op_dtypes=['S']):\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# Iterating With Different Step Size\n",
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "\n",
    "for x in np.nditer(arr[:, ::2]):\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0,) 1\n",
      "(1,) 2\n",
      "(2,) 3\n"
     ]
    }
   ],
   "source": [
    "# Enumerated Iteration Using ndenumerate()\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3])\n",
    "\n",
    "for idx, x in np.ndenumerate(arr):\n",
    "  print(idx, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0) 1\n",
      "(0, 1) 2\n",
      "(0, 2) 3\n",
      "(0, 3) 4\n",
      "(1, 0) 5\n",
      "(1, 1) 6\n",
      "(1, 2) 7\n",
      "(1, 3) 8\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "\n",
    "for idx, x in np.ndenumerate(arr):\n",
    "  print(idx, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Joining Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr1 = np.array([1, 2, 3])\n",
    "\n",
    "arr2 = np.array([4, 5, 6])\n",
    "\n",
    "arr = np.concatenate((arr1, arr2))\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr1 = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "arr2 = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "arr = np.concatenate((arr1, arr2), axis=1)\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n"
     ]
    }
   ],
   "source": [
    "# Stacking is same as concatenation, the only difference is that stacking is done along a new axis.\n",
    "\n",
    "import numpy as np\n",
    "arr1 = np.array([1, 2, 3])\n",
    "\n",
    "arr2 = np.array([4, 5, 6])\n",
    "\n",
    "arr = np.stack((arr1, arr2), axis=1)\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr1 = np.array([1, 2, 3])\n",
    "\n",
    "arr2 = np.array([4, 5, 6])\n",
    "\n",
    "arr = np.hstack((arr1, arr2))\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr1 = np.array([1, 2, 3])\n",
    "\n",
    "arr2 = np.array([4, 5, 6])\n",
    "\n",
    "arr = np.vstack((arr1, arr2))\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 4]\n",
      "  [2 5]\n",
      "  [3 6]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr1 = np.array([1, 2, 3])\n",
    "\n",
    "arr2 = np.array([4, 5, 6])\n",
    "\n",
    "arr = np.dstack((arr1, arr2))\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Splitting Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([1, 2]), array([3, 4]), array([5, 6])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "newarr = np.array_split(arr, 3)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([1, 2]), array([3, 4]), array([5]), array([6])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "newarr = np.array_split(arr, 4)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n",
      "[3 4]\n",
      "[5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "newarr = np.array_split(arr, 3)\n",
    "\n",
    "print(newarr[0])\n",
    "print(newarr[1])\n",
    "print(newarr[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[1, 2],\n",
      "       [3, 4]]), array([[5, 6],\n",
      "       [7, 8]]), array([[ 9, 10],\n",
      "       [11, 12]])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])\n",
    "\n",
    "newarr = np.array_split(arr, 3)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[1, 2, 3],\n",
      "       [4, 5, 6]]), array([[ 7,  8,  9],\n",
      "       [10, 11, 12]]), array([[13, 14, 15],\n",
      "       [16, 17, 18]])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])\n",
    "\n",
    "newarr = np.array_split(arr, 3)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[ 1],\n",
      "       [ 4],\n",
      "       [ 7],\n",
      "       [10],\n",
      "       [13],\n",
      "       [16]]), array([[ 2],\n",
      "       [ 5],\n",
      "       [ 8],\n",
      "       [11],\n",
      "       [14],\n",
      "       [17]]), array([[ 3],\n",
      "       [ 6],\n",
      "       [ 9],\n",
      "       [12],\n",
      "       [15],\n",
      "       [18]])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])\n",
    "\n",
    "newarr = np.array_split(arr, 3, axis=1)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[ 1],\n",
      "       [ 4],\n",
      "       [ 7],\n",
      "       [10],\n",
      "       [13],\n",
      "       [16]]), array([[ 2],\n",
      "       [ 5],\n",
      "       [ 8],\n",
      "       [11],\n",
      "       [14],\n",
      "       [17]]), array([[ 3],\n",
      "       [ 6],\n",
      "       [ 9],\n",
      "       [12],\n",
      "       [15],\n",
      "       [18]])]\n"
     ]
    }
   ],
   "source": [
    "# the hsplit() method to split the 2-D array into three 2-D arrays along rows.\n",
    "import numpy as np\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])\n",
    "\n",
    "newarr = np.hsplit(arr, 3)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Searching Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([3, 5, 6], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "# To search an array, use the where() method\n",
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 4, 4])\n",
    "\n",
    "x = np.where(arr == 4)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([1, 3, 5, 7], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "x = np.where(arr%2 == 0)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 2, 4, 6], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "x = np.where(arr%2 == 1)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# The searchsorted() method is assumed to be used on sorted arrays.\n",
    "import numpy as np\n",
    "arr = np.array([6, 7, 8, 9])\n",
    "\n",
    "x = np.searchsorted(arr, 7)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([6, 7, 8, 9])\n",
    "\n",
    "x = np.searchsorted(arr, 7, side='right')\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 3, 5, 7])\n",
    "\n",
    "x = np.searchsorted(arr, [2, 4, 6])\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Sorting Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# The NumPy ndarray object has a function called sort(), that will sort a specified array.\n",
    "import numpy as np\n",
    "arr = np.array([3, 2, 0, 1])\n",
    "\n",
    "print(np.sort(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple' 'banana' 'cherry']\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array(['banana', 'cherry', 'apple'])\n",
    "\n",
    "print(np.sort(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False  True  True]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([True, False, True])\n",
    "\n",
    "print(np.sort(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3 4]\n",
      " [0 1 5]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[3, 2, 4], [5, 0, 1]])\n",
    "\n",
    "print(np.sort(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Filter Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[41 43]\n"
     ]
    }
   ],
   "source": [
    "# A boolean index list is a list of booleans corresponding to indexes in the array.\n",
    "import numpy as np\n",
    "arr = np.array([41, 42, 43, 44])\n",
    "\n",
    "x = [True, False, True, False]\n",
    "\n",
    "newarr = arr[x]\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False, False, True, True]\n",
      "[43 44]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([41, 42, 43, 44])\n",
    "\n",
    "# Create an empty list\n",
    "filter_arr = []\n",
    "\n",
    "# go through each element in arr\n",
    "for element in arr:\n",
    "  # if the element is higher than 42, set the value to True, otherwise False:\n",
    "  if element > 42:\n",
    "    filter_arr.append(True)\n",
    "  else:\n",
    "    filter_arr.append(False)\n",
    "\n",
    "newarr = arr[filter_arr]\n",
    "\n",
    "print(filter_arr)\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False, True, False, True, False, True, False]\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "# Create an empty list\n",
    "filter_arr = []\n",
    "\n",
    "# go through each element in arr\n",
    "for element in arr:\n",
    "  # if the element is completely divisble by 2, set the value to True, otherwise False\n",
    "  if element % 2 == 0:\n",
    "    filter_arr.append(True)\n",
    "  else:\n",
    "    filter_arr.append(False)\n",
    "\n",
    "newarr = arr[filter_arr]\n",
    "\n",
    "print(filter_arr)\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False  True  True]\n",
      "[43 44]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([41, 42, 43, 44])\n",
    "\n",
    "filter_arr = arr > 42\n",
    "\n",
    "newarr = arr[filter_arr]\n",
    "\n",
    "print(filter_arr)\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False  True False  True False  True False]\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "filter_arr = arr % 2 == 0\n",
    "\n",
    "newarr = arr[filter_arr]\n",
    "\n",
    "print(filter_arr)\n",
    "print(newarr)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}