Does indexing an array return a copy or the original data?

A single-element lookup like `arr[0]` returns a scalar value (a copy). But indexing a range, e.g. `arr[1:3]`, returns a 'view' into the original array — modifying it modifies the source array too.

Can I use negative indices with multi-dimensional arrays?

Yes — negative indexing works per-dimension. `mat[-1, -1]` returns the last element of the last row, exactly as you'd expect.

What's the biggest mistake beginners make with NumPy indexing?

Chaining brackets like `matrix[0][1]` out of habit from nested Python lists, instead of the faster, idiomatic `matrix[0, 1]` comma syntax.

HTML MASTER CLASS /// LEARN TAGS /// BUILD STRUCTURE /// SEMANTIC WEB /// HTML MASTER CLASS /// LEARN TAGS ///

NumPy Array Indexing in Python

Learn about NumPy Array Indexing in this comprehensive Python tutorial. Learn how to access array elements using 1-D, 2-D, and 3-D indices, and discover the power of negative indexing.

⚡ Total XP: 0|💻 numpy XP: 0

Skill Matrix

UNLOCK NODES BY LEARNING NEW TAGS.

System Hub

Core logic.

Quick Quiz //

In matrix[0, 1] for a 2D array, what do the two numbers represent?

🚀 LEVEL UP TO SENIOR:Unlock 500+ Advanced Practical Challenges & Exercises.

🎓 COURSERA PARTNER:Earn professional Google, Meta, and IBM certificates to supercharge your resume.

Listen up. If you're doing numerical computing in Python, you need to understand NumPy Array Indexing in Python. NumPy is the backbone of the entire scientific Python ecosystem, and using it correctly is the difference between a script that takes seconds versus hours.

1Coordinates, Not Just Positions

Indexing a 1-D NumPy array works exactly like a Python list: arr[0] for the first element, arr[-1] for the last. The difference shows up once you move to 2-D and higher: instead of chaining brackets like matrix[0][1], NumPy lets you pass a single comma-separated tuple, matrix[0, 1].

That's not just a stylistic shortcut. matrix[0][1] first builds an intermediate 1-D array for row 0, then indexes into it — two separate operations. matrix[0, 1] resolves directly to one element in the underlying buffer in a single step, which is why NumPy's own documentation and every performance guide recommend the comma form.

The same pattern extends indefinitely: a 3-D tensor is indexed as tensor[a, b, c], where each position walks one dimension deeper — matrix index, then row, then column — always outermost to innermost.

—

# Example
import numpy as np
print("Running NumPy...")

localhost:3000

Jupyter Notebook / Console Output

Code Executed Successfully
Matrix operations completed.

2Step-by-Step Breakdown

Data is useless if you cannot access it. Indexing in NumPy allows you to precisely target any element inside an n-dimensional array.

For 1-D arrays, it works EXACTLY like standard Python lists. The index starts at 0. You use square brackets to fetch the value.

What will arr[1] output if arr = np.array([5, 10, 15, 20])?

→5
→10
→15

You can also use negative indexing to access elements from the end of the array. -1 is the last element, -2 is the second to last.

When moving to 2-D arrays (matrices), things change. You use a comma-separated tuple [row, column] to access elements. Row first, then column.

How would you access the value 40 in the matrix np.array([[10, 20], [30, 40]])?

→matrix[2, 2]
→matrix[1, 1]
→matrix[0, 1]

Technically, you can use standard Python chained indexing like matrix[0][1], but NumPy's matrix[0, 1] is computationally faster and universally preferred.

For 3-D arrays, you just keep adding commas: [matrix_index, row, column]. The order always follows the dimensions from outermost to innermost.

In the syntax tensor[a, b, c], what does a typically represent in a 3-D array context?

→The specific column
→The specific row
→The index of the 2D matrix within the 3D tensor

You can also mutate (change) elements by assigning new values via their indices. Remember, arrays are homogenous, so it will cast types if necessary.

Now, prepare yourself. We are about to enter the ADA Defense Protocol. Ensure you understand negative and multi-dimensional indexing.

ADA DEFENSE: If mat = np.array([[10, 20, 30], [40, 50, 60]]), what will mat[-1, -1] return?

→30
→40
→60

Threat neutralized. You can now pinpoint any coordinate within the multi-dimensional structure.

Index a Real 2D Matrix. Finish get_value(): fetch matrix[row, col] using NumPy's comma-separated index syntax.

Level Up 🚀

Advanced cheat sheets, SEO tricks, and interview prep for this topic.

Browser Support

ChromeSupported

Fully supported.

FirefoxSupported

Fully supported.

SafariSupported

Fully supported.

EdgeSupported

Fully supported.

Accessibility (A11y)

1Prefer the Comma Form for Clarity

`matrix[row, col]` reads as one coordinate lookup, which is easier for a code reviewer (or anyone using a screen reader to step through code) to parse than a chain of separate bracket lookups.

# Prefer:
matrix[0, 1]
# Over:
matrix[0][1]

SEO Implications

1
High-Intent Reference Content
'NumPy array indexing' and 'numpy negative index' are common, high-volume search queries for people learning array-based data manipulation, making precise coverage valuable for organic search.

Best Practices

Use the Comma Syntax for Multi-Dimensional Arrays

`arr[i, j]` resolves in a single step and is the idiomatic, faster way to index 2-D+ arrays, versus chained `arr[i][j]` which builds an intermediate array first.

Reach for Negative Indices Instead of arr[len(arr)-1]

`arr[-1]` is clearer and less error-prone than manually computing the last valid index from the array's length.

Frequent Bugs

THE BUG

An IndexError when accessing an index that's out of bounds for one of the array's dimensions.

THE FIX

Check `arr.shape` before indexing into unfamiliar data, and remember each dimension has its own valid index range.

Real-World Examples

Extracting a Single Pixel Channel

An image loaded as a 3-D array (height, width, color channels) needs the red channel value of one specific pixel.

image = np.array(...)  # shape: (height, width, 3)
red_value = image[10, 20, 0]  # row 10, col 20, channel 0 (red)

Interview Prep

?Frequently Asked Questions

Pascual Vila

Frontend Instructor // Code Syllabus

Common Pitfalls & Errors

The Error //

Chaining brackets instead of using comma indexing

# Slower, non-idiomatic
val = matrix[0][1]

# Correct: single-step lookup
val = matrix[0, 1]

The Solution //

`matrix[0][1]` works, but it builds a full intermediate 1-D array for row 0 before indexing into it. `matrix[0, 1]` resolves in a single step and is the idiomatic NumPy way.

The Error //

Forgetting that slices return views, not copies

arr = np.array([1, 2, 3, 4])
slice_ = arr[1:3]
slice_[0] = 99
print(arr)  # [1, 99, 3, 4] -- the original changed!

# To avoid this:
slice_ = arr[1:3].copy()

The Solution //

Unlike single-element indexing, slicing a NumPy array returns a view of the original data. Mutating the slice mutates the source array too, unless you explicitly call .copy().