Aggregation and the axis argument

cups.sum() with no arguments adds up everything and gives you one number. The interesting question is what happens when you only want to collapse part of the array — and that's what axis= is for.

Nearly everyone learns axis=0 as "rows" and axis=1 as "columns", gets it backwards half the time, and never quite trusts it. The reliable reading is different:

The axis you name is the axis that disappears.

cups is (4, 3) — four days by three stalls. cups.sum(axis=0) removes axis 0, so the days are gone and you're left with (3,): one total per stall. cups.sum(axis=1) removes axis 1, so the stalls are gone and you get (4,): one total per day.

Check it against the shape every time and you'll never guess again.

keepdims

Sometimes you want the axis collapsed but not removed — usually so the result still broadcasts against the original:

cups.sum(axis=1)                  # (4,)   — flat
cups.sum(axis=1, keepdims=True)   # (4, 1) — still 2-D
cups / cups.sum(axis=1, keepdims=True)   # each row as fractions

Without keepdims that last line fails: a (4,) lines up against the last axis of (4, 3), which is 3, and 4 ≠ 3. With it, you get (4, 1), which stretches perfectly. This is where lesson 5 starts paying rent.

The rest of the family

They all take axis and behave the same way: mean, min, max, std, var, prod, any, all.

argmax and argmin are worth knowing separately — they return the position of the largest value rather than the value:

cups.max(axis=0)      # the biggest number per stall
cups.argmax(axis=0)   # which day it happened on

And cumsum is the odd one out: it accumulates rather than collapsing, so the shape stays the same. Handy for running totals.

One practical note — if your data has NaN, ordinary sum and mean return NaN. The nan-prefixed versions (np.nansum, np.nanmean) skip them instead.