Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-21T21:56:12.709196Z",
     "start_time": "2020-10-21T21:56:12.703196Z"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Python version: 3.8.5\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import sys\n",
    "print('Python version: ' + sys.version[:5])"
   ]
  },
  {
   "source": [
    "# Learning Numpy\n",
    "\n",
    "## Basics"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[1 2 3]\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([1., 2., 3.], dtype=float32)"
      ]
     },
     "metadata": {},
     "execution_count": 2
    }
   ],
   "source": [
    "# Initialization\n",
    "a = np.array([1, 2, 3], dtype=\"int16\")\n",
    "print(a)\n",
    "a.astype('float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[9. 8. 7.]\n [6. 5. 4.]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[9.0, 8.0, 7.0], [6.0, 5.0, 4.0]])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Dimension of a: 1\nDimension of b: 2\n"
     ]
    }
   ],
   "source": [
    "# Get Dimension\n",
    "print(\"Dimension of a:\", a.ndim)\n",
    "print(\"Dimension of b:\", b.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Shape of a: (3,)\nShape of b: (2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Get Shape\n",
    "print(\"Shape of a:\", a.shape)\n",
    "print(\"Shape of b:\", b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Type of a: int16\nType of b: float64\nType of a items size(bytes): 2\nType of b items size(bytes): 8\n"
     ]
    }
   ],
   "source": [
    "# Get DataType and Size\n",
    "print(\"Type of a:\", a.dtype)\n",
    "print(\"Type of b:\", b.dtype)\n",
    "print(\"Type of a items size(bytes):\", a.itemsize)\n",
    "print(\"Type of b items size(bytes):\", b.itemsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Size of a(bytes): 6\nSize of b(bytes): 48\nSize of a(bytes): 6\nSize of b(bytes): 48\n"
     ]
    }
   ],
   "source": [
    "# Get total size\n",
    "print(\"Size of a(bytes):\", a.size * a.itemsize)\n",
    "print(\"Size of b(bytes):\", b.size * b.itemsize)\n",
    "# a.size * a.itemsize = a.nbytes\n",
    "print(\"Size of a(bytes):\", a.nbytes)\n",
    "print(\"Size of b(bytes):\", b.nbytes)"
   ]
  },
  {
   "source": [
    "## Accessing  "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(2, 7)"
      ]
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "source": [
    "a = np.array([[1,2,3,4,5,6,7],[8,9,10,11,12,13,14]])\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "metadata": {},
     "execution_count": 9
    }
   ],
   "source": [
    "#Get a specific element [r, c]\n",
    "a[1, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "metadata": {},
     "execution_count": 10
    }
   ],
   "source": [
    "#Get a specific row\n",
    "a[0, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([ 3, 10])"
      ]
     },
     "metadata": {},
     "execution_count": 11
    }
   ],
   "source": [
    "#Get a specific column\n",
    "a[:, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[2 4 6]\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "# Getting a little more fancy [startindex:endindex:step]\n",
    "print(a[0, 1:6:2])\n",
    "print(a[0, 1:-1:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11, 12, 20, 14]])"
      ]
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "source": [
    "a[1, 5] = 20\n",
    "a"
   ]
  },
  {
   "source": [
    "## Initializing Different Types of Arrays"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "metadata": {},
     "execution_count": 14
    }
   ],
   "source": [
    "# All 0s matrix\n",
    "np.zeros((2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[1, 1],\n",
       "        [1, 1]],\n",
       "\n",
       "       [[1, 1],\n",
       "        [1, 1]],\n",
       "\n",
       "       [[1, 1],\n",
       "        [1, 1]]])"
      ]
     },
     "metadata": {},
     "execution_count": 15
    }
   ],
   "source": [
    "# All 1s matrix\n",
    "np.ones((3, 2, 2), dtype='int32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[12., 12.],\n",
       "        [12., 12.]],\n",
       "\n",
       "       [[12., 12.],\n",
       "        [12., 12.]],\n",
       "\n",
       "       [[12., 12.],\n",
       "        [12., 12.]]], dtype=float32)"
      ]
     },
     "metadata": {},
     "execution_count": 16
    }
   ],
   "source": [
    "# Any other number\n",
    "np.full((3, 2, 2), 12, dtype='float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "metadata": {},
     "execution_count": 17
    }
   ],
   "source": [
    "np.eye(4, k = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "metadata": {},
     "execution_count": 18
    }
   ],
   "source": [
    "np.identity(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "<class 'list'>\n<class 'numpy.ndarray'>\n<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "print(type(a))\n",
    "a = np.asarray(a)\n",
    "print(type(a))\n",
    "a = [1, 2]\n",
    "a = np.asanyarray(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[4, 4, 4, 4, 4, 4, 4],\n",
       "       [4, 4, 4, 4, 4, 4, 4]])"
      ]
     },
     "metadata": {},
     "execution_count": 20
    }
   ],
   "source": [
    "a = np.array([[1,2,3,4,5,6,7],[8,9,10,11,12,13,14]])\n",
    "np.full_like(a, 4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[0.15950742, 0.14874082],\n",
       "       [0.86227896, 0.66489497],\n",
       "       [0.34614132, 0.12628027],\n",
       "       [0.0836899 , 0.22743309]])"
      ]
     },
     "metadata": {},
     "execution_count": 21
    }
   ],
   "source": [
    "# Random decimal numbers\n",
    "\n",
    "np.random.rand(4, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[0.60482031, 0.28191951, 0.48286495, 0.96715144, 0.63589478,\n",
       "        0.23455394, 0.68047526],\n",
       "       [0.33979163, 0.18916638, 0.10913247, 0.22838819, 0.46986637,\n",
       "        0.20791404, 0.16071461]])"
      ]
     },
     "metadata": {},
     "execution_count": 22
    }
   ],
   "source": [
    "np.random.random_sample(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[9, 4, 9],\n",
       "       [2, 0, 3],\n",
       "       [2, 2, 7],\n",
       "       [1, 6, 1]])"
      ]
     },
     "metadata": {},
     "execution_count": 23
    }
   ],
   "source": [
    "# Random integer values\n",
    "\n",
    "np.random.randint(10, size=(4, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "metadata": {},
     "execution_count": 24
    }
   ],
   "source": [
    "# The identity matrix\n",
    "np.identity(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[1 2 3]\n [1 2 3]\n [1 2 3]\n [4 5 6]\n [4 5 6]\n [4 5 6]]\n\n[[1 1 1 2 2 2 3 3 3]\n [4 4 4 5 5 5 6 6 6]]\n"
     ]
    }
   ],
   "source": [
    "# Repeat an array\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "r1 = np.repeat(arr, 3, axis=0)\n",
    "r2 = np.repeat(arr, 3, axis=1)\n",
    "print(r1, end=\"\\n\\n\")\n",
    "print(r2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 0., 9., 0., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "metadata": {},
     "execution_count": 26
    }
   ],
   "source": [
    "o = np.ones((5, 5))\n",
    "o[1:4, 1:4] = 0\n",
    "o[2, 2] = 9\n",
    "o"
   ]
  },
  {
   "source": [
    "## Math"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "metadata": {},
     "execution_count": 27
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6])"
      ]
     },
     "metadata": {},
     "execution_count": 28
    }
   ],
   "source": [
    "a + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([-1,  0,  1,  2])"
      ]
     },
     "metadata": {},
     "execution_count": 29
    }
   ],
   "source": [
    "a - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([2, 4, 6, 8])"
      ]
     },
     "metadata": {},
     "execution_count": 30
    }
   ],
   "source": [
    "a * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([0.5, 1. , 1.5, 2. ])"
      ]
     },
     "metadata": {},
     "execution_count": 31
    }
   ],
   "source": [
    "a / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([0, 1, 1, 2], dtype=int32)"
      ]
     },
     "metadata": {},
     "execution_count": 32
    }
   ],
   "source": [
    "a // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6])"
      ]
     },
     "metadata": {},
     "execution_count": 33
    }
   ],
   "source": [
    "a += 2\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([4, 4, 6, 6])"
      ]
     },
     "metadata": {},
     "execution_count": 34
    }
   ],
   "source": [
    "b = np.array([1, 0, 1, 0])\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([ 9, 16, 25, 36], dtype=int32)"
      ]
     },
     "metadata": {},
     "execution_count": 35
    }
   ],
   "source": [
    "a ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([ 0.14112001, -0.7568025 , -0.95892427, -0.2794155 ])"
      ]
     },
     "metadata": {},
     "execution_count": 36
    }
   ],
   "source": [
    "# Take the sin\n",
    "np.sin(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Linear Algebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(array([[1., 1., 1.],\n",
       "        [1., 1., 1.]]),\n",
       " array([[2, 2],\n",
       "        [2, 2],\n",
       "        [2, 2]]))"
      ]
     },
     "metadata": {},
     "execution_count": 38
    }
   ],
   "source": [
    "a = np.ones((2, 3))\n",
    "b = np.full((3, 2), 2)\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[6., 6.],\n",
       "       [6., 6.]])"
      ]
     },
     "metadata": {},
     "execution_count": 39
    }
   ],
   "source": [
    "np.matmul(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "metadata": {},
     "execution_count": 40
    }
   ],
   "source": [
    "# Find the determinant\n",
    "c = np.identity(3)\n",
    "np.linalg.det(c)"
   ]
  },
  {
   "source": [
    "## Statistics"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "metadata": {},
     "execution_count": 41
    }
   ],
   "source": [
    "stats = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "execution_count": 42
    }
   ],
   "source": [
    "np.min(stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "metadata": {},
     "execution_count": 43
    }
   ],
   "source": [
    "np.max(stats)"
   ]
  },
  {
   "source": [
    "np.min(stats, axis=1)"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": 44,
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "metadata": {},
     "execution_count": 44
    }
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "metadata": {},
     "execution_count": 45
    }
   ],
   "source": [
    "np.sum(stats)"
   ]
  },
  {
   "source": [
    "## Reorganizing Arrays"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "metadata": {},
     "execution_count": 46
    }
   ],
   "source": [
    "before = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5],\n",
       "       [6],\n",
       "       [7],\n",
       "       [8]])"
      ]
     },
     "metadata": {},
     "execution_count": 47
    }
   ],
   "source": [
    "after = before.reshape((8, 1))\n",
    "after"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[1, 2],\n",
       "        [3, 4]],\n",
       "\n",
       "       [[5, 6],\n",
       "        [7, 8]]])"
      ]
     },
     "metadata": {},
     "execution_count": 48
    }
   ],
   "source": [
    "after = before.reshape((2, 2, 2))\n",
    "after"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "metadata": {},
     "execution_count": 49
    }
   ],
   "source": [
    "v1 = np.array([1, 2, 3, 4])\n",
    "v2 = np.array([5, 6, 7, 8])\n",
    "\n",
    "np.vstack([v1, v2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 0., 0.],\n",
       "       [1., 1., 1., 1., 0., 0.]])"
      ]
     },
     "metadata": {},
     "execution_count": 50
    }
   ],
   "source": [
    "v1 = np.ones((2, 4))\n",
    "v2 = np.zeros((2, 2))\n",
    "np.hstack((v1, v2))"
   ]
  },
  {
   "source": [
    "## Miscellaneous\n",
    "\n",
    "### Load Data from file"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.genfromtxt(filename, delimiter=\"delimiter\")"
   ]
  },
  {
   "source": [
    "## Boolean Masking and Advanced Indexing"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 0  1  2  3  4  5  6  7  8  9]\n [10 11 12 13 14 15 16 17 18 19]]\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[False, False, False, False, False, False,  True,  True,  True,\n",
       "         True],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True]])"
      ]
     },
     "metadata": {},
     "execution_count": 52
    }
   ],
   "source": [
    "a = np.array([[int(i) for i in range(10)],[int(j) for j in range(10, 20)]])\n",
    "print(a)\n",
    "a > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([ 6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])"
      ]
     },
     "metadata": {},
     "execution_count": 53
    }
   ],
   "source": [
    "a[a > 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([13,  1])"
      ]
     },
     "metadata": {},
     "execution_count": 54
    }
   ],
   "source": [
    "a[[1, 0], [3, 1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([False, False,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True])"
      ]
     },
     "metadata": {},
     "execution_count": 55
    }
   ],
   "source": [
    "np.any(a > 11, axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([False,  True])"
      ]
     },
     "metadata": {},
     "execution_count": 56
    }
   ],
   "source": [
    "np.all(a > 5, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[False, False, False, False, False, False,  True,  True,  True,\n",
       "         True],\n",
       "       [ True,  True, False, False, False, False, False, False, False,\n",
       "        False]])"
      ]
     },
     "metadata": {},
     "execution_count": 57
    }
   ],
   "source": [
    "((a > 5) & (a < 12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True,  True,  True, False, False, False,\n",
       "        False],\n",
       "       [False, False,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True]])"
      ]
     },
     "metadata": {},
     "execution_count": 58
    }
   ],
   "source": [
    "(~((a > 5) & (a < 12)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 1  2  3  4  5]\n [ 6  7  8  9 10]\n [11 12 13 14 15]\n [16 17 18 19 20]\n [21 22 23 24 25]\n [26 27 28 29 30]]\n[ 2  8 14 20]\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[ 4,  5],\n",
       "       [24, 25],\n",
       "       [29, 30]])"
      ]
     },
     "metadata": {},
     "execution_count": 59
    }
   ],
   "source": [
    "b = np.array([int(i) for i in range(1, 31)])\n",
    "b = b.reshape((6, 5))\n",
    "print(b)\n",
    "print(b[[0, 1, 2, 3],[1, 2, 3,4]])\n",
    "b[[0, 4, 5], 3:]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "Python 3.8.5 32-bit",
   "display_name": "Python 3.8.5 32-bit",
   "metadata": {
    "interpreter": {
     "hash": "7b7c8faf1d9efd50dbba91a094ea215a99dec3f368cd8459cf0b9dd727c71e83"
    }
   }
  },
  "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.8.5-final"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "255.594px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}