Python - Array Indexing and Slicing

Array Indexing and Slicing in Python

Array indexing and slicing are fundamental operations in Python, especially when working with numerical data using libraries like NumPy. These operations allow you to retrieve, modify, or analyze subsets of array data efficiently. Mastering these techniques is critical for effective data manipulation, performance optimization, and clean code design.

This tutorial will explore the theory, syntax, and various practical use cases of array indexing and slicing in Python, focusing mainly on NumPy arrays.

1. Introduction to Array Indexing

1.1 What is Indexing?

Indexing refers to accessing individual elements of an array using their positional indices. Python uses 0-based indexing, which means the first element is at position 0.

import numpy as np

arr = np.array([10, 20, 30, 40, 50])
print(arr[0])  # 10
print(arr[4])  # 50

1.2 Negative Indexing

Python allows negative indexing to access elements from the end of an array.

print(arr[-1])  # 50
print(arr[-2])  # 40

2. One-Dimensional Array Slicing

2.1 Basic Syntax

The syntax for slicing is: array[start:stop:step]

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

print(arr[1:5])       # [1 2 3 4]
print(arr[:4])        # [0 1 2 3]
print(arr[3:])        # [3 4 5 6]
print(arr[::2])       # [0 2 4 6]
print(arr[::-1])      # [6 5 4 3 2 1 0]

2.2 Using Step Values

The third value in the slice is the step. It determines the stride between elements.

print(arr[1:6:2])  # [1 3 5]
print(arr[::3])    # [0 3 6]

3. Two-Dimensional Array Indexing

3.1 Accessing Elements

matrix = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

print(matrix[0, 0])  # 1
print(matrix[1, 2])  # 6

3.2 Using Bracket Notation

print(matrix[0][1])  # 2 (less preferred than matrix[0, 1])

3.3 Negative Indexing

print(matrix[-1, -1])  # 9

4. Two-Dimensional Array Slicing

4.1 Slicing Rows and Columns

# First two rows
print(matrix[:2, :])

# Last two columns
print(matrix[:, 1:])

# Middle element (as 2D slice)
print(matrix[1:2, 1:2])

4.2 Advanced 2D Slicing

# Even-indexed rows and columns
print(matrix[::2, ::2])

# Reverse the matrix
print(matrix[::-1, ::-1])

5. Boolean Indexing

5.1 Filtering Elements

arr = np.array([1, 2, 3, 4, 5, 6])

mask = arr > 3
print(arr[mask])  # [4 5 6]

5.2 Combining Conditions

print(arr[(arr > 2) & (arr < 5)])  # [3 4]

5.3 Modifying with Boolean Indexing

arr[arr % 2 == 0] = 0
print(arr)  # [1 0 3 0 5 0]

6. Fancy Indexing

6.1 Using Lists of Indices

arr = np.array([10, 20, 30, 40, 50])
indices = [1, 3, 4]

print(arr[indices])  # [20 40 50]

6.2 Fancy Indexing in 2D Arrays

matrix = np.array([
    [1, 2],
    [3, 4],
    [5, 6]
])

rows = [0, 2]
cols = [1, 0]

print(matrix[rows, cols])  # [2 5]

7. Slicing with Ellipsis

7.1 What is Ellipsis?

Ellipsis (...) is used to slice arrays with many dimensions more concisely.

arr = np.random.rand(3, 4, 5)

# Access entire third dimension
print(arr[..., 0].shape)  # (3, 4)

8. Modifying Arrays via Slicing

8.1 In-Place Modifications

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

8.2 Broadcasted Assignment

matrix = np.ones((3, 3))
matrix[:, 1] = [9, 8, 7]
print(matrix)

9. Copy vs View in Slicing

9.1 Views Share Memory

a = np.array([10, 20, 30])
b = a[1:3]

b[0] = 99
print(a)  # [10 99 30]

9.2 Creating Independent Copies

a = np.array([10, 20, 30])
b = a[1:3].copy()

b[0] = 99
print(a)  # [10 20 30]

10. Indexing with np.where

10.1 Extracting Matching Indices

arr = np.array([5, 10, 15, 20, 25])

indices = np.where(arr > 15)
print(indices)       # (array([3, 4]),)
print(arr[indices])  # [20 25]

10.2 Using Where to Replace Values

arr = np.array([1, 2, 3, 4, 5])
new_arr = np.where(arr % 2 == 0, 0, arr)

print(new_arr)  # [1 0 3 0 5]

11. Multi-Dimensional Indexing Summary

Quick cheatsheet:

• matrix[row, col] – Element at specific row and column
• matrix[:, col] – All rows, specific column
• matrix[row, :] – Specific row, all columns
• matrix[row1:row2, col1:col2] – Submatrix slice

12. Combining Indexing Techniques

12.1 Mixed Fancy and Boolean Indexing

matrix = np.array([
    [10, 20, 30],
    [40, 50, 60],
    [70, 80, 90]
])

rows = np.array([True, False, True])
cols = [0, 2]

print(matrix[rows][:, cols])

12.2 Conditional Assignment

arr = np.arange(10)
arr[arr % 2 == 0] = -1
print(arr)  # [-1  1 -1  3 -1  5 -1  7 -1  9]

13. Best Practices and Tips

• Use slicing instead of loops for better performance.
• Use views when memory is a concern, but be cautious of side effects.
• When modifying arrays, understand if it’s a copy or view.
• Combine Boolean indexing with slicing for expressive data operations.
• Use `np.where` for conditional logic over arrays.

Indexing and slicing are foundational tools for working with arrays in Python, especially using NumPy. They enable efficient access and manipulation of data subsets without resorting to slower and more verbose methods like loops. Whether you're filtering rows, reshaping data, or performing conditional replacements, mastering these techniques is essential for any data scientist, engineer, or analyst working with numerical data.

Advanced indexing patterns, including Boolean arrays, fancy indexing, and slicing across multiple dimensions, provide unparalleled flexibility. Understanding how views work, avoiding unintended data modification, and leveraging broadcasted assignments further enhances your ability to write clean and performant code.

With a solid grasp of indexing and slicing, you'll be better prepared to manipulate real-world data efficiently, whether for statistical analysis, machine learning, or scientific computing.