Broadcasting NumPy arrays

Broadcasting is the mechanism that lets NumPy perform element-wise operations on arrays of different shapes without copying data.

NumPy automatically "stretches" smaller arrays so they behave as if they had the same shape as the larger one.

Scalar broadcasting is the simplest case:

import numpy as np

arr = np.array([1, 2, 3, 4])
print(arr + 10)  # [11 12 13 14]

Here, NumPy conceptually treated 10 as if it had been repeated four times - but behind the scenes, it never created [10, 10, 10, 10].

Array broadcasting works the same way. NumPy virtually lines up the shapes and stretches the smaller array as needed:

mat = np.array([[1, 2, 3],
                [4, 5, 6]])

vec = np.array([10, 20, 30])
print(mat + vec)

[[11 22 33]
 [14 25 36]]

The 1D array vec was stretched across each row of mat - no copying of data, no for loops.

To understand what broadcasting can and cannot do, we need the rules.

NumPy compares array shapes dimension by dimension, starting from the last axis (rightmost).

If the shapes have different lengths, we conceptually pad the shorter shape with 1s on the left so the dimensions line up for comparison. (NumPy does not actually reshape the array - this is just how we reason about alignment.)

The resulting shape is the maximum size along each axis.

Let us now check broadcasting compatibility for a few array shape combinations.

Example 1: Array A has shape (5, 3) and array B has shape (3,)

A and B can be broadcast. Operations like A + B and A * B behave as if B were repeated across each of A's rows.

Example 2: Array C has shape (4, 1, 6) and array D has shape (3, 6)

C and D can be broadcast. This effectively repeats D across the first axis of C.

Example 3: Array E has shape (7, 5) and array F has shape (7, 4)

E and F cannot be broadcast. Any operation like E + F will raise a ValueError.

Let us now look at broadcasting in action with concrete arrays.

Example 1: 1D added to 2D

a = np.ones((2, 3))
b = np.array([10, 20, 30])

print(a + b)

[[11. 21. 31.]
 [11. 21. 31.]]

Here b has shape (3,), which is padded to (1, 3) and stretched across both rows of a. The result has shape (2, 3).

Example 2: Outer sum (column + row)

c = np.array([[1],
              [2],
              [3]])   # shape (3, 1)

d = np.array([10, 20, 30])   # shape (3,)

print(c + d)

[[11 21 31]
 [12 22 32]
 [13 23 33]]

d of shape (3,) is padded to (1, 3). Comparing (3, 1) and (1, 3) - both axes have one side equal to 1, so broadcasting produces an outer sum with shape (3, 3).

Example 3: Incompatible case

e = np.ones((3, 2))   # shape (3, 2)
f = np.ones((4,))     # shape (4,)

print(e + f)   # ValueError!

Why does this fail?

• We pad (4,) to (1, 4).
• Shape comparison: (3, 2) vs (1, 4).
• The last axis gives (2 vs 4) - incompatible, because neither equals the other and neither is 1.

Broadcasting fails and NumPy raises an error.

When we reduce an array with operations like sum, mean, or max, NumPy removes the reduced axis. This often produces a result with fewer dimensions - for example, reducing a 2D array along rows gives a 1D vector.

In many workflows we need the reduced result to retain its shape context so it can broadcast back against the original array. This is where keepdims=True comes in - it tells NumPy to keep the reduced axes as size-1 dimensions, so the result stays broadcast-compatible.

Suppose we have a 2D array and want to divide each entry in a row by the sum of that row - a common step in data normalisation.

import numpy as np

array = np.array([[2, 2, 4],
                  [1, 5, 4]])

# Reduce along rows (axis=1), but keep dimensions
row_sums = np.sum(array, axis=1, keepdims=True)
print(row_sums.shape)  # (2, 1)
print(row_sums)
# [[ 8]
#  [10]]

# Broadcasts cleanly across rows
print(array / row_sums)
# [[0.25 0.25 0.5 ]
#  [0.1  0.5  0.4 ]]

Here, row_sums has shape (2, 1). This pairs perfectly with the (2, 3) shape of array, so broadcasting divides each row by its own sum without any reshaping.

row_sums = np.sum(array, axis=1)
print(row_sums.shape)  # (2,)

print(array / row_sums)  # ValueError

row_sums = np.sum(array, axis=1).reshape(-1, 1)  # (2, 1)

Row vs. column aggregations for 2D arrays

For a 2D array with shape (n, m), row sums without keepdims produce shape (n,), which pads to (1, n) and fails to align with (n, m). With keepdims=True we get (n, 1), which broadcasts cleanly.

Column sums do not have this problem - the result has shape (m,), which pads to (1, m) and is directly compatible with (n, m).