5. Slicing & Indexing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array(range(100)).reshape((10,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### select an element by row and column indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "print(arr[5][5])\n",
    "# or more concisely\n",
    "print(arr[5,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### indexing with slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14 15]\n",
      " [24 25]]\n"
     ]
    }
   ],
   "source": [
    "print(arr[1:3, 4:6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0 1]\n",
      "  [2 3]]\n",
      "\n",
      " [[4 5]\n",
      "  [6 7]]]\n"
     ]
    }
   ],
   "source": [
    "# ellipsis slicing: auto-complete the dimensions\n",
    "arr = np.array(range(16)).reshape(2,2,2,2)\n",
    "# equivalent to arr[0,:,:,:]\n",
    "print(arr[0, ...])    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### assign a scalar to a slice by broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[  0   1]\n",
      "   [  2   3]]\n",
      "\n",
      "  [[  4   5]\n",
      "   [  6   7]]]\n",
      "\n",
      "\n",
      " [[[100 100]\n",
      "   [100 100]]\n",
      "\n",
      "  [[100 100]\n",
      "   [100 100]]]]\n"
     ]
    }
   ],
   "source": [
    "arr[1:3,:] = 100    # or simply arr[1:3]\n",
    "arr[:,8:] = 100\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### boolean indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [15 16 17 18 19]]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.arange(25).reshape((5,5))\n",
    "bools = np.array([True, True, False, True, False])\n",
    "print(arr1[bools])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 11 12 13 14]\n",
      " [20 21 22 23 24]]\n"
     ]
    }
   ],
   "source": [
    "# negate the condition\n",
    "print(arr1[~bools])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [20 21 22 23 24]]\n"
     ]
    }
   ],
   "source": [
    "arr2 = np.array([1,2,3,4,5])\n",
    "# multiple conditions\n",
    "print(arr1[(arr2<2) | (arr2>4)])    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.rand(10,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.29404208 0.06137223 0.59811053]\n"
     ]
    }
   ],
   "source": [
    "# select arr[3,3], arr[1,2], arr[2,1]\n",
    "print(arr[[3,1,2], [3,2,1]])       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.09566854 0.2190723  0.6754328 ]\n",
      " [0.28997889 0.13675444 0.07718654]\n",
      " [0.15862308 0.45510309 0.94789792]]\n"
     ]
    }
   ],
   "source": [
    "# select rows 3,1,2 and columns 6,4,8 \n",
    "print(arr[[3,1,2]][:, [6,4,8]])    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dimension inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 4)\n"
     ]
    }
   ],
   "source": [
    "# dimension inference using any negative number (usually -1)\n",
    "arr = np.array(range(16)).reshape((4,-1))\n",
    "print(arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### find elements/indices by conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.arange(16).reshape(4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6  7  8  9 10 11 12 13 14 15]\n"
     ]
    }
   ],
   "source": [
    "# find the elements greater than 5 and return a flattened array\n",
    "print(arr[arr>5])    # or arr[np.where(arr>5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 10 10 10]\n",
      " [10 10 -1 -1]\n",
      " [-1 -1 -1 -1]\n",
      " [-1 -1 -1 -1]]\n"
     ]
    }
   ],
   "source": [
    "# return values based on conditions \n",
    "# np.where(condition, true_return, false_return)\n",
    "print(np.where(arr>5, -1, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [1 3]\n",
      " [2 0]\n",
      " [2 1]\n",
      " [2 2]\n",
      " [2 3]\n",
      " [3 0]\n",
      " [3 1]\n",
      " [3 2]\n",
      " [3 3]]\n"
     ]
    }
   ],
   "source": [
    "# find the indices of the elements on conditions\n",
    "print(np.argwhere(arr>5))"
   ]
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}