Four fields
explain everything.

The four fields

Reading element a[i, j] is then a single formula, with no searching and no per-element metadata:

address = data + i*strides[0] + j*strides[1]

The shape does not have to match how the bytes are laid out, and the strides do not have to be positive or in descending order. That freedom is the entire trick. A great many operations are just a new shape and strides tuple pointing at the same bytes, which means they cost nothing and copy nothing.

a = np.arange(12).reshape(3, 4)
a.strides        # (32, 8)
a.T.strides      # (8, 32)   transpose just swaps them. no data moved.
a[::2].strides   # (64, 8)   every other row: double the row stride.
a[::-1].strides  # (-32, 8)  reversed: walk backwards. still no copy.

Apply it to each case:

Strides explorer

One flat 24-byte buffer holding six int32 values laid out as a 3 by 2 array. Pick an operation and watch which bytes the result actually touches, what its shape and strides become, and whether NumPy could express it as a view or had to gather into new memory.

The procedure

1. Right-align the shapes, padding the shorter one with 1s on the left.
2. For each dimension, they must match or one must be 1. A 1 stretches to the other size. Anything else is an error.

  (3, 4)      (256, 256, 3)      (3, 1)       (3, 4)
  (   4)      (          3)      (   4)       (2, 4)
  -------      ---------------      -------      -------
  (3, 4)      (256, 256, 3)      (3, 4)       error: 3 vs 2

The third example is the one worth studying, because both operands stretch. Shape (3,1) against (4,) right-aligns to (3,1) and (1,4), the first stretches along the column axis, the second along the row axis, and the result is the full (3,4) outer combination. That is how you build a distance matrix or a pairwise difference in one line:

diffs = prices[:, None] - prices[None, :]   # (n, n) all pairwise differences

None in an index inserts a length-1 axis, which is the standard way to control which way a vector stretches. It is the same thing as np.newaxis and as reshape(-1, 1).

Broadcasting shape calculator

Type two shapes as comma-separated numbers. The alignment is shown dimension by dimension, marking each as matched, stretched, or the one that failed.

a = np.array([[1, 2, 3],
              [4, 5, 6]])       # shape (2, 3)

a.sum(axis=0)   # [5, 7, 9]      shape (3,)  the 2 is gone: down the columns
a.sum(axis=1)   # [6, 15]        shape (2,)  the 3 is gone: across the rows
a.sum()         # 21             shape ()    everything is gone

Do not think "axis 0 is rows so it sums the rows". Think about the shape: (2, 3) with axis 0 removed is (3,), and the only way to get three numbers out of this array is one per column. The shape tells you the answer before you reason about it, every time, in any number of dimensions.

For a 3-D array of shape (days, symbols, features), arr.sum(axis=0) gives (symbols, features), one total per symbol and feature across all days. You did not need to picture the cube.

keepdims, and why it exists

a.sum(axis=1)                 # shape (2,)
a.sum(axis=1, keepdims=True)  # shape (2, 1)

a / a.sum(axis=1, keepdims=True)   # row-normalise: (2,3) against (2,1), broadcasts
a / a.sum(axis=1)                   # (2,3) against (2,) -> error, 3 vs 2

keepdims leaves the collapsed axis in place with size 1, which is exactly the shape broadcasting needs to stretch it back. Any time you reduce and then combine with the original, you want it.

What a Python loop does per element

out = []
for x in data:
    out.append(x * 2 + 1)

For every single element, the interpreter must:

1. Fetch and decode several bytecode instructions.
2. Follow a pointer to a heap-allocated int or float object, most likely a cache miss.
3. Dispatch through the type's multiplication slot, since the types are only known at runtime.
4. Allocate a brand new object for the intermediate, and another for the result.
5. Adjust several reference counts.
6. Grow the output list, occasionally reallocating and copying it.

The actual multiply is one CPU instruction out of perhaps a hundred. Everything else is the interpreter finding out what to do and managing objects.

What data * 2 + 1 does

1. One dispatch, at the whole-array level, resolved once.
2. Allocate one output buffer of the right size, once.
3. Run a compiled C loop over contiguous memory. The dtype is known, so the operation is a fixed machine instruction with no dispatch. Sequential access lets the hardware prefetcher stay ahead. The compiler can use SIMD instructions to do four or eight elements at once.
4. No per-element objects and no refcounting at all.

Shape and selection

a.reshape(3, 4)        # -1 for one axis means "infer it": reshape(-1, 4)
a.ravel()               # flatten, a view when it can be
a.flatten()             # flatten, always a copy
a[:, None]              # add a length-1 axis, to control broadcasting
np.concatenate([a, b], axis=0)
np.stack([a, b])        # adds a new axis; vstack/hstack are the 2-D conveniences

Selection and conditionals

a[a > 0]                     # boolean mask, returns a compacted copy
np.where(a > 0, a, 0)          # elementwise if/else, same shape out
np.where(a > 0)                # one argument: returns the indices instead
np.clip(a, lo, hi)             # winsorise, exactly what you want for outliers
np.select([c1, c2], [v1, v2], default=0)   # multi-branch where

mask = (a > 0) & (b < 5)         # & | ~, and the parentheses are mandatory

The parentheses are not style. & binds tighter than > in Python, so a > 0 & b < 5 parses as a > (0 & b) < 5 and does something else entirely. And and or or on arrays raises, because Python asks for a single truth value and an array cannot supply one.

Ordering and searching

np.argsort(a)              # the indices that would sort a; the workhorse for ranking
a[np.argsort(a)]           # same as np.sort(a)
np.argsort(scores)[::-1][:10]   # top 10 by score
np.argpartition(a, -10)[-10:]  # same top 10, O(n) instead of O(n log n), unordered
np.argmax(a), np.argmin(a)

np.searchsorted(sorted_arr, values)   # binary search: where would these insert?

searchsorted is the one worth internalising for this desk. It is the vectorised binary search, so it bins values into ranges, aligns one timestamp series to another, and underpins as-of joins. Millions of lookups against a sorted array in one call, in O(log n) each. Use side='right' to control which way ties fall.

Sequential structure

np.diff(a)                 # successive differences; output is one shorter
np.cumsum(a)               # running total; cumprod, cummax likewise
np.diff(a) / a[:-1]        # simple returns from a price series
np.cumsum(returns)         # cumulative log returns

Watch the length. diff returns n−1 elements, so pairing it back against the original needs an explicit slice or a prepended value. This off-by-one is the single most common source of a one-bar misalignment, which on the pandas page becomes the lookahead bias trap.

dtype choice

np.arange(10).dtype            # int64 on most platforms
np.array([1, 2], dtype=np.float32)  # half the memory, about 7 significant digits

np.array([200], dtype=np.int8) + np.array([100], dtype=np.int8)
# overflow. NumPy uses fixed-width machine integers, so it wraps.
# Python ints are arbitrary precision; NumPy ints are not.

This is a real difference in kind from pure Python, not a detail. Python integers grow without bound. NumPy integers are machine words that wrap silently on overflow. Note that NumPy 2.0 changed the promotion rules so that a Python scalar no longer upcasts the array's dtype, which makes overflow more likely to be visible in code written against NumPy 1.x expectations.

Choosing float32 over float64 halves memory and roughly doubles how much fits in cache, which often matters more than the arithmetic. The cost is about 7 decimal digits of precision instead of about 16. For prices and for accumulating sums over millions of rows, keep float64. For features fed into a model, float32 is usually fine and considerably faster.