Indexing And Slicing A Numpy Array

As a first step, import numpy library into the program:

import numpy as np 

1. INDEXING IN NUMPY

We have studied indexing techniques in Python list, a similar approach is taken for indexing Numpy array.

Indexing means to access the single element in the array, at a given position,

• For 1D array, it is similar to indexing Python’s list

• For nD array, it is similar to indexing Python’s lists of lists

1.1. On 1D array

# creating an array
arr1d = np.arange(1,11)
print(f"This is the array: {arr1d}")

# fetching first item in array
print(f"\nFirst Item in the array: {arr1d[0]}")
# fetching last item in array
print(f"\nLast Item in the array: {arr1d[-1]}")
# fetching middle item in array
print(f"\nMiddle Item in the array: {arr1d[int((arr1d.size/2)-1)]}") 

This is the array: [ 1  2  3  4  5  6  7  8  9 10]

First Item in the array: 1

Last Item in the array: 10

Middle Item in the array: 5

1.2. On nD array

a. 2D array

For 2D array, we need to provide the position in (x,y) scheme, where x is the x-axis position, and y is the position on y-axis

# 2d array
arr2d = np.arange(10).reshape(2,5)

print("We will perform indexing on this 2D array:")
print(arr2d)

#fetching first item in second row
print(f"\nFirst item in second row: {arr2d[1,0]}")
#fetching last item in first row
print(f"\nLast item in first row: {arr2d[0,-1]}")

We will perform indexing on this 2D array:
[[0 1 2 3 4]
 [5 6 7 8 9]]

First item in second row: 5

Last item in first row: 4

b. 3D array

For 3D array, we need to provide the position in (a,x,y) scheme, where a is position of matrix, x is the x-axis position, and y is the position on y-axis

# 3d array
arr3d = np.arange(24).reshape(2,3,4)

print("We will perform indexing on this array:")
print(arr3d)

# from first matrix, fetching first item in second row
print(f"\nFrom first matrix, first item in second row: {arr3d[0,1,0]}") 
# from second matrix, fetching last item in last row
print(f"\nFrom second matrix,last item in last row: {arr3d[-1,-1,-1]}") 

We will perform indexing on this array:
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

From first matrix, first item in second row: 4

From second matrix,last item in last row: 23

2. SLICING IN NUMPY

Slicing means to access subarray from the main array. We use [:] slice notion to perform slicing. Remember that slicing return views rather than copies of the array data. The standard format for slicing is:

1darray[start:stop:step]

The default value for start=0, step=1 and stop=index position before to stop

2.1. On 1D array

We will use the following syntax: 1darray[start:stop:step]

print(f"This is the array: {arr1d}")

# fetching first 3 elements
print(f"\nFirst three elements: {arr1d[:3]}")
# fetching last 3 elements, using negative index
print(f"Last three elements: {arr1d[-3:]}")
# fetching every other elements
print(f"Every other element: {arr1d[::2]}")
# fetching every other elements, starting from '2', with index '1'
print(f"Every other element, starting from 2: {arr1d[1::2]}")

This is the array: [ 1  2  3  4  5  6  7  8  9 10]

First three elements: [1 2 3]
Last three elements: [ 8  9 10]
Every other element: [1 3 5 7 9]
Every other element, starting from 2: [ 2  4  6  8 10]

Reversing the order: By providing step=-1, we reverse the order of elements in the array

# reversing the array
print(f"Reversing the array: {arr1d[::-1]}")
# reversing the array, every other item
print(f"Reversing the array, every other item: {arr1d[::-2]}")

Reversing the array: [10  9  8  7  6  5  4  3  2  1]
Reversing the array, every other item: [10  8  6  4  2]

2.2. On nD array

In this section, we move from 1D arrays to arrays with more than 1 dimension.

a. 2D array

For 2D array, we will use the same syntax for slicing, but each axis slicing point is separated by comma

2darray[start:stop:step, start:stop:step]

arr2d2d = np.arange(25).reshape(5,5)
print("We will perform slicing on this 2D array:")
print(arr2d2d)

# entire first row
print(f"\nFetching first row: {arr2d2d[0,:]}")
# entire first column
print(f"\nFetching first column: {arr2d2d[:,0]}")
# 2 rows, three columns
print(f"\nFetching 2 rows, 3 column: \n{arr2d2d[0:2,0:3]}")
# all rows, every other column
print(f"\nFetching all rows, every other column: \n{arr2d2d[:,::2]}") 

We will perform slicing on this 2D array:
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]

Fetching first row: [0 1 2 3 4]

Fetching first column: [ 0  5 10 15 20]

Fetching 2 rows, 3 column: 
[[0 1 2]
 [5 6 7]]

Fetching all rows, every other column: 
[[ 0  2  4]
 [ 5  7  9]
 [10 12 14]
 [15 17 19]
 [20 22 24]]

Reversing in 2D array We will reverse:

• both rows and columns values,

• only rows,

• only column

print("We will perform slicing on this 2D array:")
print(arr2d2d)

# reversing the order of elements in 2d array, at both axis
print(f"\nReversing the entire content,rows and columns, of 2D array: \n{arr2d2d[::-1,::-1]}") 
# reversing the order of rows only, first becomes last and so-on 
print(f"Reversing the order of rows only: \n{arr2d2d[::-1,:]}") 
# reversing the order of columns only, first becomes last and so-on 
print(f"Reversing the order of columns only: \n{arr2d2d[:,::-1]}") 

We will perform slicing on this 2D array:
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]

Reversing the entire content,rows and columns, of 2D array: 
[[24 23 22 21 20]
 [19 18 17 16 15]
 [14 13 12 11 10]
 [ 9  8  7  6  5]
 [ 4  3  2  1  0]]
Reversing the order of rows only: 
[[20 21 22 23 24]
 [15 16 17 18 19]
 [10 11 12 13 14]
 [ 5  6  7  8  9]
 [ 0  1  2  3  4]]
Reversing the order of columns only: 
[[ 4  3  2  1  0]
 [ 9  8  7  6  5]
 [14 13 12 11 10]
 [19 18 17 16 15]
 [24 23 22 21 20]]

b. 3D array

For 3D array, we will use the same syntax for slicing, but each axis slicing point is separated by comma

3darray[start:stop:step, start:stop:step, start:stop:slice]

# creating 3D array
arr3d3d = np.arange(36).reshape(3,3,4)

print("We will perform slicing on this array:")
print(arr3d3d)

# first row, of every dimension
print(f"\nFirst row of every dimension: \n{arr3d3d[:,:1,:]}")
# first column, of every dimension
print(f"\nFirst column of every dimension: \n{arr3d3d[:,:,:1]}")
# every other row and column, in every other dimension
print(f"\nEvery other row and column, in every other dimension: \n{arr3d3d[::2,::2,::2]}")

We will perform slicing on this array:
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]

 [[24 25 26 27]
  [28 29 30 31]
  [32 33 34 35]]]

First row of every dimension: 
[[[ 0  1  2  3]]

 [[12 13 14 15]]

 [[24 25 26 27]]]

First column of every dimension: 
[[[ 0]
  [ 4]
  [ 8]]

 [[12]
  [16]
  [20]]

 [[24]
  [28]
  [32]]]

Every other row and column, in every other dimension: 
[[[ 0  2]
  [ 8 10]]

 [[24 26]
  [32 34]]]

Reversing the 3D array

# all rows, columns and dimensions
print(f"Reversing the entire 3D array: \n{arr3d3d[::-1,::-1,::-1]}")
# Reversing rows only
print(f"\nReversing only rows in 3D array: \n{arr3d3d[:,::-1,:]}")

Reversing the entire 3D array: 
[[[35 34 33 32]
  [31 30 29 28]
  [27 26 25 24]]

 [[23 22 21 20]
  [19 18 17 16]
  [15 14 13 12]]

 [[11 10  9  8]
  [ 7  6  5  4]
  [ 3  2  1  0]]]

Reversing only rows in 3D array: 
[[[ 8  9 10 11]
  [ 4  5  6  7]
  [ 0  1  2  3]]

 [[20 21 22 23]
  [16 17 18 19]
  [12 13 14 15]]

 [[32 33 34 35]
  [28 29 30 31]
  [24 25 26 27]]]