# Indexing And Slicing A Numpy Array

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

```python
import numpy as np 
```

## 1. INDEXING IN NUMPY

We have [studied](https://tahamaddam.com/coding/python/working-with-python-list/) 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

```python
# 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

```python
# 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

```python
# 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]`

```python
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

```python
# 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]`

```python
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

```python
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]`

```python
# 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**

```python
# 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]]]
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://codingnotes.gitbook.io/coding_notes/coding/numpy/indexing-and-slicing-a-numpy-array.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.