When working with large datasets and numerical computations in Python, NumPy is the go-to library. One of its powerful features is the ability to extract portions of data using slicing.

In this article, you’ll learn everything you need to know about array slicing in NumPy, how it differs from standard Python lists, and how to use slicing for both 1D and multi-dimensional arrays.

What is Slicing?

Slicing is a technique used to extract a portion (or slice) of an array using a start:stop:step syntax.

In NumPy, slicing returns views of the original array, not copies, meaning changes to the slice may affect the original array (unless explicitly copied).

NumPy Slicing Syntax

array[start:stop:step]

• start – index of where to begin the slice (inclusive)

• stop – index of where to end the slice (exclusive)

• step – interval between elements (default is 1)

1D Array Slicing

Let’s start with a simple example:

import numpy as np

arr = np.array([10, 20, 30, 40, 50, 60])

✅ Basic Slicing

print(arr[1:4])   # Output: [20 30 40]

✅ Omitting Indices

print(arr[:3])    # Output: [10 20 30]
print(arr[3:])    # Output: [40 50 60]

✅ Using Step

print(arr[::2])   # Output: [10 30 50]
print(arr[1:5:2]) # Output: [20 40]

✅ Negative Indexing

print(arr[-3:])   # Output: [40 50 60]
print(arr[::-1])  # Output: [60 50 40 30 20 10] (reversed)

2D Array Slicing

With multi-dimensional arrays, you use a comma to separate dimensions.

arr2d = np.array([
    [11, 12, 13],
    [21, 22, 23],
    [31, 32, 33],
    [41, 42, 43]
])

✅ Slice Rows and Columns

# Slice first two rows
print(arr2d[:2])

Output:

[[11 12 13]
 [21 22 23]]

# Slice specific rows and columns
print(arr2d[1:3, 0:2])

Output:

[[21 22]
 [31 32]]

✅ Slice a Single Row or Column

# Row 2
print(arr2d[2, :])  # [31 32 33]

# Column 1
print(arr2d[:, 1])  # [12 22 32 42]

✅ Step Slicing in 2D

# Every other row
print(arr2d[::2, :])

Output:

[[11 12 13]
 [31 32 33]]

3D Array Slicing

3D arrays follow the same logic, just with one more dimension.

arr3d = np.array([
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]],
    [[9, 10], [11, 12]]
])

# Slice first two 2D arrays
print(arr3d[:2])

Slicing Returns a View, Not a Copy

When you slice a NumPy array, it returns a view, not a new array.

arr = np.array([1, 2, 3, 4, 5])
slice_arr = arr[1:4]
slice_arr[0] = 99

print(arr)  # Output: [1 99 3 4 5]

To prevent this, use .copy():

safe_copy = arr[1:4].copy()

Tips and Best Practices

⚠️ Common Pitfalls

Full Example

import numpy as np

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

# Slice: rows 1 to 3, columns 0 and 1
sub = arr[1:4, 0:2]
print("Sliced subarray:\n", sub)

# Reverse all rows
reversed_rows = arr[::-1]
print("Reversed rows:\n", reversed_rows)

# Every other column
every_other_col = arr[:, ::2]
print("Every other column:\n", every_other_col)

Conclusion

Slicing in NumPy is a fast and flexible way to work with subsets of data. Whether you're analyzing large matrices or manipulating data in bulk, slicing lets you extract, modify, and work with data in an efficient manner.

You now know:

• How to slice 1D, 2D, and 3D arrays

• Use of step and negative indices

• Difference between views and copies

• Best practices to avoid common mistakes

Next Steps

Now that you're comfortable with slicing, explore:

• Boolean indexing

• Fancy indexing

• Broadcasting

• Advanced slicing with np.where()