Categories

# Part 2: INDEXING AND SLICING A NUMPY ARRAY

We will learn how to index and slice 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]]]
``````

## 1 reply on “Part 2: INDEXING AND SLICING A NUMPY ARRAY”

[…] learned in Numpy like indexing, slicing, fancy indexing, boolean masking and combination – will be applied to Pandas Series and […]