One Calculation for a Whole Report

Suppose we need to compare every greenhouse reading with a target. A Python loop can visit each entry, subtract the target, and save the result. Once we understand those steps, an array expression can ask NumPy to perform that same repeated calculation.

This is vectorisation. It is useful because common numerical loops can run inside compiled library routines, but a short expression is not automatically correct or economical. We still need to understand the operations and the shapes it creates.

Try one reading above the target and another equally far below it. Botie still made two errors. Follow the deviations through squaring and averaging to see how both contribute.

14.6667

A for statement visits each value in a collection. The indented instructions run for the current value, then repeat for the next. We can append each result to an initially empty list.

An array subtraction performs the corresponding elementwise operation. Elementwise means each output is calculated from the corresponding input entry or aligned entries.

import numpy as np

readings = np.array([18,22,26])
differences = []
for reading in readings:
    differences.append(int(reading - 20))
print(differences)
print((readings - 20).tolist())

[-2, 2, 6]
[-2, 2, 6]

The size of an error and its direction answer different questions. abs discards the sign. square squares each entry. sqrt takes square roots. Reducing afterwards, with mean for example, combines the separate contributions.

Keep intermediate arrays named while learning the calculation. That makes it possible to check whether a sign was lost too soon or a reduction happened along the wrong axis.

import numpy as np

residuals = np.array([18.,22.,26.]) - 20
squared = np.square(residuals)
print(np.abs(residuals).tolist())
print(squared.tolist())
print(np.round(squared.mean(), 4))
print(np.round(np.sqrt(squared.mean()), 4))

[2.0, 2.0, 6.0]
[4.0, 4.0, 36.0]
14.6667
3.8297

A Boolean mask selects a subset and can shorten an array. where instead chooses one of two values at each position, preserving the aligned output shape. Its arguments are a condition, the value when true, and the value when false.

Use parentheses around each array comparison when combining them with & for and, | for or, and ~ for not. Python's plain and and or expect single truth decisions and are not substitutes for these elementwise operators.

import numpy as np

readings = np.array([18,22,26])
inside = (readings >= 20) & (readings <= 25)
print(inside.tolist())
print(np.where(inside, "within band", "review").tolist())
print(readings[inside].tolist())

[False, True, False]
['review', 'within band', 'review']
[22]

maximum can compare each entry with a lower bound; minimum can compare with an upper bound; clip applies both limits. These operations change values rather than filtering observations. Preserve the original if the clipped values are only intended for a display.

Other ufuncs used later include exp and log for exponential and logarithmic calculations, and sin and cos for angles in radians. Their input assumptions matter: a real logarithm needs a positive value, and a negative value has no real square root.

import numpy as np

readings = np.array([18,22,26])
display = np.clip(readings, 20, 25)
print(display.tolist())
print(readings.tolist())
ratios = np.array([1.,2.,4.])
print(np.round(np.exp(np.log(ratios)), 6).tolist())

[20, 22, 25]
[18, 22, 26]
[1.0, 2.0, 4.0]

Broadcasting can create a large output even when both inputs are modest. Comparing every observation with every reference can produce a three-dimensional intermediate: observation, reference, feature. A batch reduces how many observations we handle at once.

The nbytes attribute reports an array's numerical storage size. A copy and a view can expose equal nbytes even when the view shares storage, so it is not the total unique memory used by a whole program. Profile real workloads before making speed claims.

import numpy as np

readings = np.array([[18.,22.,26.],[19.,23.,27.]])
print(readings.nbytes)
expanded = readings[:, None, :]
print(expanded.shape)
print(np.shares_memory(readings, expanded))
print(np.square(readings).shape)

48
(2, 1, 3)
True
(2, 3)

Botie needs a ratio only where the denominator is nonzero. It is tempting to put the division inside np.where and expect the unwanted positions to be skipped. But Python evaluates that division before where chooses which results to keep. We can still get a division-by-zero warning.

Instead, put the condition on np.divide itself. It accepts a where mask and an output array. We first fill that output with our chosen missing value, then divide only at the allowed positions. The other positions keep the value we supplied.

import numpy as np
amount = np.array([6., 8., 10.])
count = np.array([2., 0., 5.])
result = np.full(amount.shape, np.nan)
np.divide(amount, count, out=result, where=count != 0)
print(result.tolist())

[3.0, nan, 2.0]

Before replacing a loop, write down what one iteration consumes and produces. Test the array expression against that loop on unequal dimensions, negative values and boundary cases. Two expressions agreeing on a square table is weak evidence when an axis could be wrong.

Vectorisation is useful when it expresses a repeated numerical operation clearly or removes Python iteration overhead. It does not require converting every control-flow decision into a large temporary array. A chunked loop around vectorised arithmetic can be both readable and economical.