pyhogs-code/notebooks/tutorials/Slicing_and_indexing.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:392cbbb5ef8413ff73c7b01bdbb2af6af0f35b567ffe660971189fc7ac0ff39f"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Python Array Indexing/Slicing"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Jake Steinberg (28 July 2014)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This is meant to highlight differences in indexing methods/techniques between Python and MATLAB. I came upon this problem while attempting to pull out a 2-D array from within a larger 2-D array"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To begin let's create an array for manipulation"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "A = np.random.randint(0,51, size=(5,6))\n",
      "A"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "array([[18, 41, 16, 20,  0, 40],\n",
        "       [10, 24, 38, 42, 24,  8],\n",
        "       [28,  7,  7, 18, 36,  5],\n",
        "       [36, 47, 23, 38,  0, 40],\n",
        "       [49, 18, 19, 11,  7, 36]])"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This array could represent a bathymetry file (spatially defined depth values), an image (pixel values), or any dataset. I would now like to define a new array (B) as a subset of array A. I would like to define B as rows 1:2 and columns 2:4 of array A. The following is a correct method to do so."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "B = np.copy(A[1:3,2:5])\n",
      "print B"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[38 42 24]\n",
        " [ 7 18 36]]\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Remember that the last indexed value (row or column in this case) is not included (i.e. row 3 and column 5 are not included). Here the colon implies that I want rows one through 3 (exclusive) and columns 2 through 5 (exclusive). Now if instead I were to use commas to represent the rows and columns I would like to select, a different operation would be executed."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "B1 = np.copy(A[[1,2,3],[2,3,4]])\n",
      "print B1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[38 18  0]\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here the indexes provided are treated as coordinate points and thus three values are pulled from A and defined as B1. In MATLAB, this is not the case and the values would be treated as rows and columns! Note that the coordinate points must be provided as pairs. Where B was defined I pulled a different amount of rows than columns...here if you attempted the same an error would be returned. Another acceptable form is:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "B2 = np.copy(A[1:3,[1,4]])\n",
      "print B2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[24 24]\n",
        " [ 7 36]]\n"
       ]
      }
     ],
     "prompt_number": 61
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Additional Properties"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's create a 1-D array"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.array([1,3,6,8,7,2,9,0])\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1 3 6 8 7 2 9 0]\n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = x[3:]\n",
      "b = x[0:6:2]\n",
      "c = x[-3:8]\n",
      "print a\n",
      "print b\n",
      "print c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[8 7 2 9 0]\n",
        "[1 6 7]\n",
        "[2 9 0]\n"
       ]
      }
     ],
     "prompt_number": 50
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Methods for Indexing and Slicing Arrays "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "index1,index2 = np.nonzero((A>=10) & (A<30))\n",
      "print A\n",
      "\n",
      "print index1 \n",
      "print index2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[18 41 16 20  0 40]\n",
        " [10 24 38 42 24  8]\n",
        " [28  7  7 18 36  5]\n",
        " [36 47 23 38  0 40]\n",
        " [49 18 19 11  7 36]]\n",
        "[0 0 0 1 1 1 2 2 3 4 4 4]\n",
        "[0 2 3 0 1 4 0 3 2 1 2 3]\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The output of the numpy command nonzero is a tuple of arrays providing pairs of coordinates within A where the input argument is true (i.e. position (0,0) contains a value greater than 10 and less than 30). "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "index3 = np.logical_and(A>=10,A<=30)\n",
      "print index3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[ True False  True  True False False]\n",
        " [ True  True False False  True False]\n",
        " [ True False False  True False False]\n",
        " [False False  True False False False]\n",
        " [False  True  True  True False False]]\n"
       ]
      }
     ],
     "prompt_number": 57
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This output is an array equal in size to A. It returns true/false values where the input argument is satisfied or violated."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "C1 = np.copy(A[index3])  \n",
      "print C1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[18 16 20 10 24 24 28 18 23 18 19 11]\n"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Returns an array of the desired values. But does not include their indices (as does np.nonzero)"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}