Boolean Masking and Fancy Indexing

You have a year of daily returns for a stock and want every day the stock moved more than 2%. The loop version, walk every element, check the condition, append to a list, works but is slow and verbose for large arrays. NumPy's boolean masking lets you write returns[returns > 0.02] and get exactly that subset back in one vectorized pass, with no explicit Python loop.

Two related tools

Boolean masking: returns > 0.02 doesn't compute a single true/false, applied to an array, comparisons broadcast elementwise, producing a same-shaped array of booleans. Indexing with that array, returns[mask], pulls out only the True positions, always as a flat 1D result regardless of the original shape.

Fancy indexing: instead of a condition, you supply an explicit list or array of positions: returns0, 5, 9 returns the 1st, 6th, and 10th elements. np.where(mask) converts a boolean mask into the integer positions where it's True, bridging the two approaches, useful when you need the locations of a condition, not just the values.

Both return copies, not views, because the selected elements generally aren't a regular stride pattern NumPy can describe as a reinterpretation of the original memory.

Worked example

returns = np.array([0.010, 0.030, -0.010, 0.040, 0.000])
mask = returns > 0.02                       # [False, True, False, True, False]
big_moves = returns[mask]                    # [0.03, 0.04]
positions = np.where(mask)[0]                # [1, 3]
returns[mask] = 0.02                         # cap: set every big move to exactly 0.02
print(returns)                               # [0.01, 0.02, -0.01, 0.02, 0.00]

The last line shows the other direction: a mask isn't just for reading, returns[mask] = 0.02 writes back to every True position at once, capping outliers in a single vectorized statement, no explicit loop over indices needed either way.

What this means in practice

Masking and fancy indexing are the standard way to filter, cap, and flag data in a quant pipeline: pulling out days a strategy triggered, capping extreme returns before computing volatility, or selecting the subset of a universe passing a liquidity filter. Combining conditions uses &, |, ~ (not Python's and/or/not, which don't broadcast) with parentheses around each condition: returns[(returns > 0.02) & (volume > 1e6)].