Array Indexing

By the end of this lesson, you will be able to select specific elements from Python lists and NumPy arrays using integer indexing, slicing, and advanced multi-dimensional techniques.

What it is

Array indexing is the process of accessing individual elements or subsets of data within an ordered collection. In Python, standard list objects use zero-based indexing, meaning the first element is at index 0. When working with numerical data using the numpy library, indexing becomes more powerful, supporting multi-dimensional selection (e.g., rows and columns) and boolean masks.

Mental Model: Think of a list as a row of mailboxes numbered starting from 0. To get the letter in the third mailbox, you ask for index 2. For a 2D array (like a spreadsheet), think of coordinates: [row, column].

Related terms: Slicing, Boolean Indexing, Fancy Indexing, Zero-based vs One-based.

Why it matters

• Data Extraction: Allows you to retrieve specific values needed for calculations or display without copying entire datasets.
• Efficiency: Direct indexing is faster than looping through an entire array to find a value.
• Matrix Operations: Essential for linear algebra tasks where you need to access specific rows, columns, or diagonal elements.
• Filtering: Enables conditional selection of data points that meet specific criteria.

Syntax or steps

The basic syntax for accessing an element is array[index]. For multi-dimensional arrays, indices are separated by commas inside the brackets: array[row_index, col_index].

1. Identify the dimensionality of your array (1D list vs 2D matrix).
2. Determine the position of the target element(s). Remember: counting starts at 0.
3. Use square brackets [] to wrap the index or slice notation.
4. For ranges, use the colon operator : (e.g., a[1:4] gets items at indices 1, 2, and 3).

Example

import numpy as np

# Create a 2D array (matrix)
data = np.array([
    [10, 20, 30],
    [40, 50, 60],
    [70, 80, 90]
])

# 1. Basic Integer Indexing
print("First element:", data[0, 0])      # Output: 10
print("Row 1, Col 2:", data[1, 2])       # Output: 60

# 2. Slicing (Subsets)
print("Second row:", data[1, :])         # Output: [40 50 60]
print("First column:", data[:, 0])       # Output: [10 40 70]

# 3. Advanced/Fancy Indexing
indices = [0, 2]
print("Rows 0 and 2:", data[indices, :]) # Output: [[10 20 30] [70 80 90]]

Explanation:
data[0, 0] accesses the element at the first row and first column.
data[1, 2] accesses the element at the second row (index 1) and third column (index 2).
data[1, :] uses : to mean "all columns" for row index 1.
data[:, 0] means "all rows" for column index 0.
Fancy indexing passes a list of indices [0, 2] to grab non-contiguous rows.

Common mistakes

• Off-by-one errors: Trying to access a[3] in a list of length 3 causes an IndexError because valid indices are 0, 1, and 2.
• Confusing List vs NumPy syntax: Standard Python lists do not support list[1, 2]. You must loop or use nested indexing like list[1][2] if it's a list of lists. NumPy requires comma-separated indices.
• Modifying slices unexpectedly: In NumPy, modifying a slice often modifies the original array (view), whereas in some other contexts, it might create a copy. Always check if you need a deep copy using .copy().
• Ignoring negative indices: While -1 refers to the last element, mixing positive and negative indices incorrectly can lead to selecting unintended data.

When to use it

Practice

Guided Exercise: Given the array arr = np.arange(10), write code to print every second element starting from index 1.

Hint: Use slicing with a step: arr[start:stop:step].

Challenge: Create a 3x3 identity matrix using np.eye(3). Extract the diagonal elements into a new 1D array.

Solution Hint: Use np.diag(matrix) or fancy indexing matrix[[0,1,2], [0,1,2]].

Quick check

Question: What does data[1:3] return if data is a 1D NumPy array?

Answer: It returns a view containing elements at indices 1 and 2. The stop index (3) is exclusive.

Summary

Array indexing is fundamental for precise data manipulation in Python. Mastering the distinction between simple integer access, contiguous slicing, and advanced fancy indexing allows you to handle both simple lists and complex multidimensional matrices efficiently.