Indexing and slicing — basic, boolean masking, fancy indexing

1. Basic slicing — `start:stop:step`

WHAT it returns: a view — a new array object that shares the same data buffer. Mutating the slice mutates the original.

WHY a view (HOW it works): A slice just changes the offset and strides of the recipe; no data is copied. That's why it's instant even for huge arrays.

Worked example 2-D slicing

A = np.arange(12).reshape(3, 4)   # rows 0..2, cols 0..3
A[1, 2]      # -> 6     (row 1, col 2; comma separates dims)
A[0:2, 1:3]  # -> [[1,2],[5,6]]   (rows 0-1, cols 1-2)
A[:, -1]     # -> [3,7,11]  last column of every row
A[::2, ::2]  # -> [[0,2],[8,10]] every other row & col

Why A[0:2,1:3]? First index picks rows {0,1}, second picks cols {1,2}; the intersection is a 2×2 block. Both indices are ranges, so result is 2-D.

2. Boolean masking — select by a condition

WHY a copy: the selected elements are scattered irregularly in memory; you can't describe them with a single stride, so NumPy must gather them into fresh contiguous memory.

Worked example Filtering

a = np.array([3, -1, 4, -2, 5])
mask = a > 0          # array([ True, False,  True, False,  True])
a[mask]               # -> array([3, 4, 5])
a[a > 0] = 0          # ASSIGN into mask: a -> [0,-1,0,-2,0]
a[(a < 0) & (a > -2)] # combine with & | ~  (NOT and/or!)

Why & not and? Python's and works on single booleans; here we need elementwise AND over the whole array, which is &. Wrap each condition in parentheses because & binds tighter than <.

3. Fancy (integer-array) indexing — select by position list

Worked example Reorder & repeat

a = np.array([10, 20, 30, 40])
a[[3, 0, 0, 2]]        # -> array([40, 10, 10, 30])  (order + repeats!)
idx = np.array([[0,1],[2,3]])
a[idx]                 # -> [[10,20],[30,40]]  shape follows idx

2-D fancy: A[[0,2],[1,3]] pairs them up → returns A[0,1], A[2,3] (a diagonal-style pick), not a 2×2 block. To get the block use np.ix_ or slicing.

Figure — Indexing and slicing — basic, boolean masking, fancy indexing

Common mistake Steel-manning the classic traps

Trap 1 — "A slice is a fresh copy, so editing it is safe." Why it feels right: in pure-Python lists, lst[1:3] is a copy. Fix: NumPy slices are views; b = A[0]; b[0]=99 also changes A. Use A[0].copy() if you need independence.

Trap 2 — "A[[0,2],[1,3]] gives the 2×2 block of rows {0,2} × cols {1,3}." Why it feels right: basic slicing A[0:2,1:3] does give a block, so we generalize. Fix: fancy index arrays are zipped pointwise: index 0 → (0,1), index 1 → (2,3). For a true block, use A[np.ix_([0,2],[1,3])].

Trap 3 — using and/or in a mask. Why it feels right: reads like English. Fix: those raise "ambiguous truth value"; use &, |, ~ with parentheses.

Trap 4 — "Boolean mask keeps the original 2-D shape." Fix: it always flattens to 1-D, because selected cells aren't a rectangle.

Recall Feynman: explain to a 12-year-old

Imagine a long row of numbered lockers full of toys.

Slicing = "open lockers 2 through 8, skipping every other one." Fast, and you're looking at the real lockers — move a toy and it's really moved.
Boolean masking = you have a checklist: tick the lockers that hold a red toy, then copy just those toys into a basket.
Fancy indexing = you hand a list "lockers 5, 1, 1, 3 please" and get those toys in that order, even repeats. Masking and the list make a basket (copy); the range just peeks at the real lockers (view).

Flashcards

What three ways can you index a NumPy array?

Basic slicing (start:stop:step), boolean masking, fancy (integer-array) indexing.

Does basic slicing return a view or a copy?

A view — it shares the original data buffer (only offset/strides change).

Do boolean masking and fancy indexing return a view or a copy?

A copy (gathered into fresh memory).

Why must you use &, |, ~ instead of and, or, not in a mask?

They operate elementwise over the array; and/or need a single boolean and raise an ambiguity error.

Formula for the length of a[start:stop:step] (step>0)?

\lceil (stop-start)/step \rceil

, clamped to ≥0.

What does A[[0,2],[1,3]] return for a 2-D A?

The pointwise pairs A[0,1] and A[2,3] — NOT a 2×2 block.

How do you select the actual block of rows {0,2} × cols {1,3}?

A[np.ix_([0,2],[1,3])].

What shape does a[idx] have when idx is a 2×2 integer array?

Same shape as idx (2×2); fancy indexing follows the index array's shape.

What does a boolean mask do to the dimensionality of a 2-D array?

Flattens the selection to 1-D.

How to safely edit the first row of A without changing A?

b = A[0].copy().

Connections

NumPy arrays — shape, strides, dtype (why views are cheap)
Broadcasting (masks/index arrays broadcast to array shape)
Views vs Copies — memory model
np.where and conditional selection
Vectorization — replacing Python loops
Pandas .loc / .iloc indexing (same ideas at DataFrame level)

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, NumPy array bas memory me numbers ki ek line hai, aur ek "recipe" (shape + strides) jo batati hai kaunsa element kahan rakha hai. Element(s) maangne ke teen tareeke hain. Pehla basic slicing — a[start:stop:step], yaani ek range. Ye view deta hai, matlab original memory hi share karta hai — agar slice me kuch change karoge to original array bhi badal jayega. Isliye fast hai, copy nahi banati.

Doosra boolean masking — ek True/False array banao (jaise a > 0), aur a[mask] sirf wahi elements deta hai jahan True hai. Ye ek copy hai aur hamesha 1-D ho jaata hai. Yaad rakho conditions jodne ke liye &, |, ~ use karo, and/or nahi — kyunki yahan har element pe alag-alag operation chahiye, aur har condition ko bracket me daalna padta hai.

Teesra fancy indexing — seedha positions ki list do, a[[3,0,0,2]] — jo order maango wahi milega, repeat bhi chalega. Ye bhi copy hai aur result ka shape index array ke shape jaisa banta hai. Bada trap: A[[0,2],[1,3]] 2×2 block nahi deta — wo (0,1) aur (2,3) ko pair karke deta hai. Block chahiye to np.ix_ use karo.

Kyun important hai? Kyunki ye sab vectorized hai — Python ka slow for loop hatao, ek line me lakhon elements filter/reorder karo. 80/20 funda: bas "view vs copy" aur "fancy index pointwise zip hota hai" ye do cheezein pakad lo, baaki sab samajh aa jayega.

Indexing and slicing — basic, boolean masking, fancy indexing

1. Basic slicing — `start:stop:step`

2. Boolean masking — select by a condition

3. Fancy (integer-array) indexing — select by position list

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Scientific Computing (Python)

Connections

1. Basic slicing — start:stop:step

2. Boolean masking — select by a condition

3. Fancy (integer-array) indexing — select by position list

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Scientific Computing (Python)

Connections

1. Basic slicing — `start:stop:step`