Slicing Multi-Dimensional Arrays in Python

Introduction

Slicing is a fundamental concept in Python that allows you to extract specific portions of an array. When working with multi-dimensional arrays, slicing becomes even more powerful, enabling efficient data manipulation without modifying the original array.

In this blog, we’ll explore how to slice multi-dimensional NumPy arrays, understand its syntax, and look at practical examples.

What is Slicing?

Slicing is the process of extracting a portion of an array using indexing and step values. The syntax for slicing is:

array[start:stop:step]

Where:

• start – The index where slicing begins (default is 0).
• stop – The index where slicing ends (exclusive).
• step – The interval between indices (default is 1).

For multi-dimensional arrays, slicing is done along different axes.

Creating a Multi-Dimensional NumPy Array

Before diving into slicing, let’s create a 2D NumPy array:

import numpy as np

arr = np.array([[10, 20, 30, 40],
[50, 60, 70, 80],
[90, 100, 110, 120]])

print(arr)

Output:

[[ 10 20 30 40]
[ 50 60 70 80]
[ 90 100 110 120]]

Basic Slicing in Multi-Dimensional Arrays

1. Extracting a Specific Row

To extract a row, specify its index:

row = arr[1, :]
print(row)

Output:

[50 60 70 80]

Here, arr[1, :] means:

• 1 → Selects the second row (indexing starts from 0).
• : → Selects all columns.

2. Extracting a Specific Column

To extract a column, use : for rows and specify the column index:

column = arr[:, 2]
print(column)

Output:

[30 70 110]

Here, arr[:, 2] means:

• : → Selects all rows.
• 2 → Selects the third column.

3. Extracting a Subarray

To extract a smaller portion of the array:

subarray = arr[0:2, 1:3]
print(subarray)

Output:

[[20 30]
[60 70]]

Here, arr[0:2, 1:3] means:

• 0:2 → Select rows from index 0 to 1 (excluding 2).
• 1:3 → Select columns from index 1 to 2 (excluding 3).

Advanced Slicing Techniques

4. Using Step in Slicing

To extract elements with a step, use the third parameter in slicing:

step_slicing = arr[:, ::2]
print(step_slicing)

Output:

[[ 10 30]
[ 50 70]
[ 90 110]]

Here, ::2 means select every second column.

neg_slicing = arr[-2:, -2:]
print(neg_slicing)

Output:

[[ 70 80]
[110 120]]

Here, -2: selects the last two rows, and -2: selects the last two columns.

6. Reversing an Array Using Slicing

reversed_rows = arr[::-1, :]
print(reversed_rows)

Output:

[[ 90 100 110 120]
[ 50 60 70 80]
[ 10 20 30 40]]

Similarly, you can reverse columns:

reversed_cols = arr[:, ::-1]
print(reversed_cols)

Output:

[[ 40 30 20 10]
[ 80 70 60 50]
[120 110 100 90]]

Slicing in 3D Arrays

For a 3D array, slicing works similarly but includes an additional dimension.

# Creating a 3D array (2 blocks, 3 rows, 4 columns)
arr3d = np.array([[[1, 2, 3, 4],  
                   [5, 6, 7, 8],  
                   [9, 10, 11, 12]],  
                  
                  [[13, 14, 15, 16],  
                   [17, 18, 19, 20],  
                   [21, 22, 23, 24]]])  

print(arr3d)

To extract a specific block (first dimension):

block = arr3d[0, :, :]
print(block)

Output:

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

To extract a specific row from all blocks:

row_blocks = arr3d[:, 1, :]
print(row_blocks)

Output:

[[ 5 6 7 8]
[17 18 19 20]]

Here, : selects all blocks, 1 selects the second row, and : selects all columns.

Performance Considerations

Slicing in NumPy is highly efficient because it does not create a new copy of the data—it provides a view of the original array.

However, if you need to create a separate copy, use .copy():

copy_array = arr[1:, :].copy()

This ensures modifications to copy_array don’t affect arr.

Key Takeaways:

✔ Use : to select entire rows or columns.
✔ Use [start:stop:step] to extract specific portions of an array.
✔ Use negative indices to slice from the end.
✔ Step values allow skipping elements.
✔ Slicing does not create a new copy unless .copy() is used.

By mastering slicing, you can work with large datasets efficiently and extract meaningful insights from them. 🚀