← Back to Curriculum

Array Indexing and Slicing

📚 Lesson 3 of 15 ⏱️ 35 min

Array Indexing and Slicing

35 min

NumPy arrays support advanced indexing and slicing operations, enabling powerful data selection and manipulation. NumPy indexing is more flexible than Python lists, supporting multi-dimensional indexing, boolean indexing, and fancy indexing. Understanding indexing enables efficient data access. Indexing is fundamental to NumPy array manipulation.

Basic indexing uses integers and slices, similar to Python lists but extended to multiple dimensions. You can index with arr[i] for 1D, arr[i, j] for 2D, or arr[i, j, k] for 3D arrays. Slicing uses colon notation (arr[start:end:step]). Negative indices work from the end. Understanding basic indexing enables accessing array elements. Basic indexing is the foundation for all indexing operations.

Indexing can be done with integers, boolean arrays, and fancy indexing (integer arrays), providing different ways to select data. Boolean indexing uses boolean arrays to select elements where True. Fancy indexing uses integer arrays to select specific indices. Each indexing method serves different purposes. Understanding different indexing methods enables flexible data selection. Indexing methods are powerful tools.

Boolean indexing enables selecting elements based on conditions, creating boolean arrays with comparison operators (==, !=, <, >, <=, >=) and using them to index. Boolean indexing is intuitive and powerful for filtering data. You can combine conditions with & (and), | (or), ~ (not). Understanding boolean indexing enables conditional data selection. Boolean indexing is essential for data filtering.

Fancy indexing uses integer arrays to select specific elements, enabling non-contiguous selection and reordering. Fancy indexing creates copies, not views. You can use multiple index arrays for multi-dimensional indexing. Understanding fancy indexing enables advanced data selection. Fancy indexing is powerful but creates copies.

Best practices include understanding views vs copies (slicing creates views, fancy indexing creates copies), using boolean indexing for filtering, being careful with memory when creating copies, and understanding multi-dimensional indexing. Understanding indexing enables efficient data manipulation. Indexing is essential for NumPy array operations.

Key Concepts

  • NumPy arrays support advanced indexing and slicing operations.
  • Basic indexing uses integers and slices for element access.
  • Boolean indexing selects elements based on conditions.
  • Fancy indexing uses integer arrays to select specific elements.
  • Slicing creates views; fancy indexing creates copies.

Learning Objectives

Master

  • Using basic indexing and slicing for array access
  • Applying boolean indexing for conditional selection
  • Using fancy indexing for advanced selection
  • Understanding views vs copies in indexing

Develop

  • Understanding data selection strategies
  • Designing efficient data access patterns
  • Appreciating NumPy's indexing flexibility

Tips

  • Use boolean indexing for filtering: arr[arr > 5] selects elements > 5.
  • Remember that fancy indexing creates copies, not views.
  • Use slicing when possible—it creates views and is more efficient.
  • Combine conditions with & (and), | (or), ~ (not) for boolean indexing.

Common Pitfalls

  • Not understanding views vs copies, causing unexpected behavior.
  • Using fancy indexing when slicing would work, creating unnecessary copies.
  • Not using parentheses for boolean conditions, causing operator precedence errors.
  • Not understanding multi-dimensional indexing, causing dimension errors.

Summary

  • NumPy arrays support advanced indexing and slicing operations.
  • Boolean indexing enables conditional data selection.
  • Fancy indexing enables non-contiguous element selection.
  • Understanding indexing is crucial for data manipulation.
  • Indexing methods enable powerful data selection.

Exercise

Practice array indexing and slicing operations.

import numpy as np

# Create a sample array
arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12]])

print("Original array:")
print(arr)

# Basic indexing
print("Element at (1, 2):", arr[1, 2])

# Slicing
print("First row:", arr[0, :])
print("Second column:", arr[:, 1])
print("Subarray (rows 0-1, columns 1-3):")
print(arr[0:2, 1:3])

# Negative indexing
print("Last row:", arr[-1, :])
print("Last column:", arr[:, -1])

# Boolean indexing
mask = arr > 5
print("Elements greater than 5:")
print(arr[mask])

# Fancy indexing
indices = [0, 2]
print("Rows 0 and 2:")
print(arr[indices, :])

# Advanced slicing with step
print("Every other element in first row:", arr[0, ::2])
print("Reversed array:")
print(arr[::-1, ::-1])

Code Editor

Output