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

WHAT we do: apply start=2, stop=9, step=3. Indices are $2,5,8$ (next would be $11\ge 9$, so we stop). Count from the formula: $n=\lceil \frac{9-2}{3}\rceil =\lceil \frac{7}{3}\rceil =\lceil 2.33\rceil =3$. Since a[i] == i here, the values equal the indices: $a[2:9:3]=[2,5,8],n=3.$ View or copy? A view — a slice only changes offset/strides.

a[::-1] means start=default-last, stop=default-before-first, step=-1 → the array reversed: $[9,8,7,6,5,4,3,2,1,0].$ a[8:2:-2]: start at index 8, walk down by 2, stop before index 2. Indices: $8,6,4$ (next is $2$, excluded). Values: $[8,6,4]$. Count (negative step): replace with $\lceil \frac{start-stop}{|step|}\rceil =\lceil \frac{8-2}{2}\rceil =\lceil 3\rceil =3$. ✓ Both are views.

• (a) a[1:4] — basic slice → view.
• (b) a[a > 5] — boolean mask → copy.
• (c) a[[1,1,3]] — fancy (integer-list) indexing → copy.
• (d) a[::2] — basic slice → view. Rule: Slices Stay (view); Masks & Fancy Make a copy.

(a) Compare each element to 0, elementwise: $[3>0,-1>0,4>0,-2>0,5>0,-9>0,0>0]=[T,F,T,F,T,F,F].$ (b) Keep positions where the mask is True, in order: $[3,4,5]$. (c) Count of True = 3. (Note $0>0$ is False, so zero is dropped.)

Two masks, then elementwise AND:

• x < 0 → $[F,T,F,T,F,T,F]$
• x > -5 → $[T,T,T,T,T,F,T]$ (only $-9$ fails > -5)
• & (elementwise AND) → $[F,T,F,T,F,F,F]$ Selecting True positions: values $-1$ and $-2$ → $x[(x<0)\&(x>-5)]=[-1,-2].$ Why and errors: Python's and wants a single True/False, but each side is a 7-element array; NumPy refuses to collapse it → ValueError: ambiguous truth value. Use & (elementwise) and wrap each side in parentheses because & binds tighter than <.

Fancy indexing reads positions in the order given, repeats allowed:

• position 3 → 40
• position 0 → 10
• position 0 → 10 (again!)
• position 2 → 30 $v[[3,0,0,2]]=[40,10,10,30].$ Length = 4 = length of the index array (which happens to be 4), even though it repeats element 0. The result shape follows the index array, not v.

First index 0:2 picks rows {0,1}; second index 1:3 picks cols {1,2}. The result is their rectangular intersection — the yellow block in the figure: $A[0:2,1:3]=\left[\begin{array}{cc}1& 2\\ 5& 6\end{array}\right],\text{shape }(2,2).$ Both indices are ranges → result stays 2-D.

Fancy index arrays are zipped pointwise, not crossed. Pair them up:

• element 0: row 0, col 1 → A[0,1] = 1
• element 1: row 2, col 3 → A[2,3] = 11 $A[[0,2],[1,3]]=[1,11],\text{shape }(2,).$ This is the magenta diagonal pick in the figure — a 1-D result, not the 2×2 block of rows {0,2} × cols {1,3}.

Use np.ix_ to cross the index lists (it reshapes them so they broadcast into a grid):

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

Rows {0,2} × cols {1,3} = $\left[\begin{array}{cc}A[0,1]& A[0,3]\\ A[2,1]& A[2,3]\end{array}\right]=\left[\begin{array}{cc}1& 3\\ 9& 11\end{array}\right],\text{shape }(2,2).$

A[0] is a view onto row 0 (basic indexing, shares memory). Writing b[0] = 99 writes into the same buffer, so: $A[0,0]=99.$ To edit independently: b = A[0].copy().

Boolean assignment: the mask on the left, a scalar on the right — the scalar broadcasts into every True slot:

y[y < 0] = 0

Mask y < 0 = $[F,T,F,T,F,T]$ → positions 1,3,5 become 0: $y=[5,0,8,0,0,0].$

Step 1 (WHAT): np.argsort(s) returns indices that sort ascending: s = [7,2,9,4,6] → argsort [1,3,4,0,2] (values $2,4,6,7,9$). Step 2 (WHY reverse): we want largest first, so reverse and take the first three indices: np.argsort(s)[::-1][:3] = [2,0,4]. Step 3: fancy-index with those positions:

s[np.argsort(s)[::-1][:3]]

Positions 2,0,4 → values $9,7,6$: $[9,7,6].$

Step 1 — mask (copy): pos = w[w > 0] → $[3,8,1,6]$. Step 2 — sort descending: np.sort is ascending, so reverse it: np.sort(pos)[::-1]. np.sort([3,8,1,6]) = [1,3,6,8]; reversed → $[8,6,3,1]$. $\text{result}=[8,6,3,1].$

Fancy indexing gives the result the shape of the index array, filling each slot with a[that index]: $a[idx]=\left[\begin{array}{cc}a[0]& a[1]\\ a[2]& a[3]\end{array}\right]=\left[\begin{array}{cc}10& 20\\ 30& 40\end{array}\right],\text{shape }(2,2).$ A 1-D source became a 2-D result — driven entirely by idx's shape.

The mask A % 2 == 0 marks the even cells. Even values in row-major order across $\left[\begin{array}{cccc}0& 1& 2& 3\\ 4& 5& 6& 7\\ 8& 9& 10& 11\end{array}\right]$ are $0,2,4,6,8,10$: $A[A\%2==0]=[0,2,4,6,8,10],\text{shape }(6,).$ Always 1-D: the True cells don't form a rectangle, so NumPy cannot keep 2-D structure — it gathers them into a flat copy.

Assignment walks the index/value pairs left-to-right:

• c[0] = 10
• c[1] = 20
• c[1] = 30 ← overwrites the previous 20
• c[2] = 40 $c=[10,30,40,0,0].$ Key insight: with a repeated index, the last write wins — no accumulation. (For accumulation you'd need np.add.at(c, [0,1,1,2], [10,20,30,40]), which would give c[1]=50.)

Two separate index lists zipped pointwise would give only M[0,1], M[3,4] (a 1-D diagonal). For the Cartesian block, use np.ix_:

M[np.ix_([0,3],[1,4])]

With $M[i,j]=5i+j$: $\left[\begin{array}{cc}M[0,1]& M[0,4]\\ M[3,1]& M[3,4]\end{array}\right]=\left[\begin{array}{cc}1& 4\\ 16& 19\end{array}\right],\text{shape }(2,2).$

Slice count a[2:9:3] ::: 3 elements → indices 2,5,8 a[8:2:-2] ::: [8,6,4] (stop excluded, downward) x[(x<0) & (x>-5)] for x=[3,-1,4,-2,5,-9,0] ::: [-1,-2] v[[3,0,0,2]] for v=[10,20,30,40] ::: [40,10,10,30] A[[0,2],[1,3]] ::: [1,11], shape (2,) — pointwise pairs A[np.ix_([0,2],[1,3])] ::: 1,3,[9,11]], the true block A[A%2==0] ::: [0,2,4,6,8,10], flattened to 1-D c[[0,1,1,2]] = [10,20,30,40] ::: [10,30,40,0,0] — last write wins