Intuition The One Core IdeaBroadcasting is NumPy's way of doing math between arrays of different shapes by pretending the smaller one is copied to fit the bigger one — without ever actually copying it in memory. Everything on the parent page is just a set of rules for deciding whether that pretend-copy is allowed and what the final shape becomes .
Before you can read a single broadcasting rule, you need a vocabulary. The parent note throws around words like shape , dimension , axis , trailing , singleton , 0-D scalar , and symbols like (2, 3), [:, np.newaxis], (). This page builds every one of them from nothing, in an order where each idea rests on the one before it.
An array is a grid of numbers, all of the same type, arranged in a rectangular pattern. A single number, a row of numbers, a table of numbers, and a stack of tables are all arrays — they just differ in how many directions you can travel.
The word "array" only means "orderly arrangement". The pictures below are the whole idea.
Look at the four panels:
Panel 1 — a lone number. You cannot walk anywhere; there are zero directions to move.Panel 2 — a row. There is exactly one direction to walk: left↔right.Panel 3 — a table. There are two directions: down↔up (rows) and left↔right (columns).Panel 4 — a stack of tables. Three directions: which sheet, which row, which column.
That "number of directions you can walk" is the single most important idea on the whole page, so it gets its own name next.
Definition Axis and dimensionAn axis is one direction of travel through an array. The number of axes is called the array's rank (also loosely called its "number of dimensions"). Panel 1 has rank 0, Panel 2 has rank 1, Panel 3 has rank 2, Panel 4 has rank 3.
Intuition Why NumPy cares about axesEvery math operation between two arrays must pair up elements. To pair them, NumPy must first know along which directions the arrays extend. Counting and matching axes is literally step one of broadcasting — no axes, nothing to match.
The axes are numbered starting from the left , beginning at 0:
For a table (rank 2):
axis 0 points down the rows (the vertical direction).axis 1 points across the columns (the horizontal direction).
Common mistake axis 0 is NOT "the x-axis"In a school graph, the horizontal is the first thing you meet. In NumPy it is the opposite: axis 0 goes down , axis 1 goes across . Reason: NumPy lists the outermost grouping first (which sheet → which row → which column), and rows are the outer grouping of a table.
Now we can decode the symbol you saw everywhere on the parent page: (2, 3).
The shape of an array is a list of how many entries sit along each axis, written left-to-right as (size of axis 0, size of axis 1, ...). The round brackets with commas are a tuple , Python's word for a fixed ordered list.
Worked example Reading a shape out loud(2, 3) reads: "2 along axis 0 (2 rows), 3 along axis 1 (3 columns)" — a 2-row, 3-column table.
A = np.array([[ 1 , 2 , 3 ], [ 4 , 5 , 6 ]]) A.shape # (2, 3)
Special cases of shape, all of which appear on the parent page:
Written shape
Rank
Picture
Note
()0
one lone number
empty tuple — no axes at all
(3,)1
a row of 3
the lonely comma means "one axis"
(3, 1)2
a column of 3
3 rows, 1 column
(1, 3)2
a row of 3, but 2-D
1 row, 3 columns
(2, 3)2
a 2×3 table
(3,) versus (3, 1) versus (1, 3) — three different things!
(3,) is a flat row with one axis. (1, 3) is a table with two axes that happens to have one row. (3, 1) is a table with two axes and one column. They look similar when printed but behave very differently under broadcasting, because broadcasting counts axes.
Why the trailing comma in (3,)? Because (3) in Python is just the number 3 in brackets; the comma is what tells Python "this is a one-item tuple, i.e. a shape".
Definition Singleton dimensionA singleton is an axis whose size is exactly 1 — a direction along which the array has only one slot. (3, 1) has a singleton on axis 1; (1, 3) has a singleton on axis 0.
Intuition Why 1 is the magic numberAn axis of size 1 holds a single slice. Broadcasting is allowed to reuse that one slice as many times as needed to line up with a bigger array — like a rubber stamp pressed repeatedly. This "stretch a 1 into any size" move is Rule 2 of the parent page, and it is the heart of the whole mechanism.
The figure shows a (3, 1) column (one slice along axis 1) being virtually stretched into (3, 3). Notice the arrows: no new memory is created — the same three numbers are re-read three times. That is why broadcasting is fast and memory-light.
Definition Element-wise operationAn element-wise operation (like +, -, *, / between two arrays) pairs the element at each position of one array with the element at the same position of the other, and applies the operation slot-by-slot.
Intuition Why broadcasting exists at allElement-wise math demands both arrays have the same shape — otherwise there is no "same position" to pair. Broadcasting is the escape hatch: when shapes differ, it tries to virtually grow the smaller array (using singletons and padding) until the shapes match, then does the element-wise op. No broadcasting → you'd have to type out full-size arrays by hand.
Worked example Element-wise vs. matrix multiplynp.array([ 1 , 2 , 3 ]) * np.array([ 10 , 20 , 30 ]) # -> [10, 40, 90] element-wise! This is not the dot product. The * operator on NumPy arrays is always element-wise. This distinction matters when you reach matrix operations in neural networks .
Definition Trailing dimensionThe trailing (or rightmost) dimension is the last number in the shape tuple — the fastest-changing axis. In (2, 3) the trailing dimension is 3 (the columns).
Intuition Why broadcasting starts from the rightNumPy stores rows one after another in memory ("row-major"): as you read memory left-to-right, the rightmost index ticks fastest. Aligning shapes from the right therefore matches the natural memory order, keeping the operation cache-friendly and fast — the same reason it matters in performance optimization .
This is the mechanical step the parent page performs in every example. When two arrays have different ranks , NumPy lines their shapes up flush to the right , then fills the shorter one with 1s on the left until both have equal length.
(4,) against (3, 1)
(3, 1) <- 2 axes
(4,) <- 1 axis, flush right
Pad the shorter with 1 on the left:
(3, 1)
(1, 4) <- the invisible axis 0 becomes size 1
Now compare axis by axis from the right: 1 vs 4 → stretch; 3 vs 1 → stretch. Result (3, 4).
Common mistake Padding goes on the LEFT, never the rightA (3,) vector becomes (1, 3), never (3, 1). This is exactly why the transposed-data bug on the parent page happens: (3,) weights line up against the last axis, not the axis of size 3 you were hoping for.
np.newaxis (equal to None) is a slicing token that inserts a brand-new singleton axis at the position you place it. a[:, np.newaxis] reads: "keep every element along axis 0, then add a new axis after it."
Intuition Why you'd want to add an empty axisBecause left-padding always adds the new axis on the outside , you cannot control where NumPy puts it. np.newaxis lets you manually place a singleton so the array stretches along the axis you intend — the fix for the transposed-weights bug and the trick that builds the outer product. It relies on the slicing you learned in array indexing and slicing .
Trailing rightmost dimension
Read it top-to-bottom: you cannot understand right-alignment until you understand shape and singletons; you cannot understand np.newaxis until you understand axes; and every arrow eventually funnels into the broadcasting rules node. Broadcasting also feeds forward into practical uses like feature normalization and vectorization , and it depends on the memory-efficient patterns that make the "no-copy" trick possible.
Test yourself — cover the right side and answer before revealing.
What is the shape of a lone number (a scalar)? () — the empty tuple, rank 0, no axes at all.
How many axes does an array of shape (3, 1) have? Two axes (rank 2): 3 down axis 0, 1 across axis 1.
Which direction does axis 0 point in a 2-D table? Down the rows (vertical), not across.
What is a singleton dimension and why does it matter? An axis of size 1; it can be virtually stretched to any size (Rule 2 of broadcasting).
What is the trailing dimension of shape (2, 3, 4)? 4 — the rightmost, fastest-changing axis.
When two shapes have different ranks, where does NumPy add the padding 1s? On the LEFT (outermost side), flush-aligning the shapes to the right.
What does a[:, np.newaxis] do to a (3,) array? Turns it into shape (3, 1) by inserting a new singleton axis on the right.
Why does NumPy compare dimensions starting from the right? Because arrays are stored row-major, so the rightmost index changes fastest in memory — right-to-left matching is cache-friendly.
Is A * B between two NumPy arrays a dot product? No — it is element-wise multiplication, pairing same-position elements.
