numpy/indexing_slicing.ipynb

{
 "metadata": {
  "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.7.7-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.7.7 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "1005f71a2f2c9f7da6acb75e9bc0247674183f6cab85bd2a339bd069fc0cd207"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Indexing, Slicing"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "metadata": {},
     "execution_count": 16
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.arange(10).reshape(2, 5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "execution_count": 17
    }
   ],
   "source": [
    "x[1, 3] == x[1][3]  # both are 8"
   ]
  },
  {
   "source": [
    "Note that `x[1,3]` equals to `x[1][3]` though the second case is **more inefficient** as a new temporary array is created after the first index that is subsequently indexed by 3."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6],\n",
       "       [ 7,  8,  9, 10, 11, 12, 13],\n",
       "       [14, 15, 16, 17, 18, 19, 20],\n",
       "       [21, 22, 23, 24, 25, 26, 27],\n",
       "       [28, 29, 30, 31, 32, 33, 34]])"
      ]
     },
     "metadata": {},
     "execution_count": 18
    }
   ],
   "source": [
    "y = np.arange(35).reshape(5,7)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[ 7, 10, 13],\n",
       "       [21, 24, 27]])"
      ]
     },
     "metadata": {},
     "execution_count": 19
    }
   ],
   "source": [
    "y[1:5:2, ::3]"
   ]
  },
  {
   "source": [
    "Above, we use `1:5:2` to control the indexing of the first dimension, we select from row **1** to **5** $[1, 5)$ with step **2**, which are rows 1 and 3.\n",
    "\n",
    "On rows 1 and 3, we use `::3` to select from **first element to last element** with step **3**, which are the elements with `0, 3, 6` indexes.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Indexing Arrays or Multidimensional Arrays"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[10  9  8  7  6  5  4  3]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10, 2, -1)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[10  9  8  3  4]\n[[10 10]\n [ 3  4]]\n"
     ]
    }
   ],
   "source": [
    "print(  x[np.array([0, 1, 2, -1, -2])]   )\n",
    "print(  x[np.array([[0, 0], [-1, -2]])]  )"
   ]
  },
  {
   "source": [
    "We can extract the numpy array from an index array, and we can even specify the shape of the result array."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 0  1  2  3]\n [ 4  5  6  7]\n [ 8  9 10 11]\n [12 13 14 15]]\n"
     ]
    }
   ],
   "source": [
    "y = np.arange(16).reshape(4, 4)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 4  5  6  7]\n [ 8  9 10 11]\n [12 13 14 15]]\n[[ 5  7]\n [ 9 11]\n [13 15]]\n[ 7 11]\n[ 7 11]\n"
     ]
    }
   ],
   "source": [
    "# select multiple rows by indexing\n",
    "print(  y[np.array([1, 2, 3])]                   )\n",
    "print(  y[np.array([1, 2, 3]), 1:4:2]            )\n",
    "\n",
    "# select specific elements by indexing\n",
    "print(  y[np.array([1, 2]), np.array([-1, -1])]  ) # same \n",
    "print(  y[np.array([1, 2]), -1]                  ) # same"
   ]
  },
  {
   "source": [
    "## Masking Arrays or Multidimensional Arrays"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n[6 7 8 9]\n[6 7]\n[0 2 4 6 8 9]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "print(  x                    )\n",
    "print(  x[x>5]               )\n",
    "print(  x[(x>5) & (x<8)]     )\n",
    "print(  x[(x%2==0) | (x>7)]  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 0  1  2  3  4]\n [ 5  6  7  8  9]\n [10 11 12 13 14]\n [15 16 17 18 19]\n [20 21 22 23 24]\n [25 26 27 28 29]]\n[ 6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]\n(24,)\n"
     ]
    }
   ],
   "source": [
    "y = np.arange(30).reshape(6, 5)\n",
    "print(  y             )\n",
    "print(  y[y>5]        )\n",
    "print(  y[y>5].shape  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 0  1  2  3  4]\n [ 5  6  7  8  9]\n [10 11 12 13 14]\n [20 21 22 23 24]]\n[[ 2  4]\n [ 7  9]\n [12 14]\n [22 24]]\n"
     ]
    }
   ],
   "source": [
    "print(  y[[True]*3 + [False] + [True] + [False]]        )  # row 0, 1, 2, 4\n",
    "print(  y[[True]*3 + [False] + [True] + [False], 2::2]  )  # row 0, 1, 2, 4, select 2:end and step=2 each row"
   ]
  },
  {
   "source": [
    "## Ellipsis syntax (...)\n",
    "\n",
    "The dots (...) represent as many colons as needed to produce a complete indexing tuple. For example, if x is an array with 5 axes, then \n",
    "\n",
    "- `x[1,2,...]` is equivalent to `x[1,2,:,:,:]`\n",
    "- `x[...,3]` to `x[:,:,:,:,3]`\n",
    "- `x[4,...,5,:]` to `x[4,:,:,5,:]`"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3,  4],\n",
       "        [ 5,  6,  7,  8,  9]],\n",
       "\n",
       "       [[10, 11, 12, 13, 14],\n",
       "        [15, 16, 17, 18, 19]],\n",
       "\n",
       "       [[20, 21, 22, 23, 24],\n",
       "        [25, 26, 27, 28, 29]],\n",
       "\n",
       "       [[30, 31, 32, 33, 34],\n",
       "        [35, 36, 37, 38, 39]],\n",
       "\n",
       "       [[40, 41, 42, 43, 44],\n",
       "        [45, 46, 47, 48, 49]]])"
      ]
     },
     "metadata": {},
     "execution_count": 27
    }
   ],
   "source": [
    "x = np.arange(50).reshape(5, 2, 5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([43, 48])"
      ]
     },
     "metadata": {},
     "execution_count": 28
    }
   ],
   "source": [
    "x[-1, ..., 3]  # same as x[-1, :, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3,  4],\n",
       "        [ 5,  6,  7,  8,  9]],\n",
       "\n",
       "       [[10, 11, 12, 13, 14],\n",
       "        [15, 16, 17, 18, 19]],\n",
       "\n",
       "       [[20, 21, 22, 23, 24],\n",
       "        [25, 26, 27, 28, 29]]])"
      ]
     },
     "metadata": {},
     "execution_count": 29
    }
   ],
   "source": [
    "x[:3, ...]  # same as x[0:3, :, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[ 0,  2],\n",
       "        [ 5,  7]],\n",
       "\n",
       "       [[20, 22],\n",
       "        [25, 27]],\n",
       "\n",
       "       [[40, 42],\n",
       "        [45, 47]]])"
      ]
     },
     "metadata": {},
     "execution_count": 30
    }
   ],
   "source": [
    "x[::2, ..., np.array([0, 2])]  # same as x[0:5:2, :, np.array([0, 2])]"
   ]
  },
  {
   "source": [
    "# Reference\n",
    "\n",
    "- https://numpy.org/doc/stable/user/basics.indexing.html\n",
    "- https://numpy.org/doc/stable/user/absolute_beginners.html#indexing-and-slicing\n",
    "- https://numpy.org/doc/stable/user/quickstart.html#indexing-slicing-and-iterating\n",
    "- https://numpy.org/doc/stable/user/quickstart.html#advanced-indexing-and-index-tricks"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}