The first habit to unlearn from Java: don't write the loop. NumPy applies a function to a whole array at once with a universal function (ufunc) that runs in compiled C — element by element, but with no Python loop in sight. It's both shorter to read and often 10–100× faster, which is why every ML library is built on it.
A ufunc like np.sqrt, np.exp, or even plain arr * 2 takes an array
and returns a new array of the same shape, having applied the operation to each element independently.
Conceptually it's "map this function over the array," but the looping happens down in C, not in your Python
code. Pick an operation and watch it sweep across the array:
You could get the same answer with a Python loop or comprehension. It works, but every iteration pays Python's per-element overhead (type checks, object boxing). The vectorized call hands the whole array to optimised C that processes it in a tight loop — frequently with CPU SIMD instructions doing several elements at once:
slow — Python loops over each element:
fast — one vectorized call:
Drag the array size and compare rough run-times (vectorized stays flat-fast as the array grows):
Every model you'll train multiplies, exponentiates, and sums over millions of numbers. Done with Python loops it would be unusably slow; done with vectorized ufuncs it's fast and the code reads like the math. When you combine ufuncs with broadcasting (operate across mismatched shapes) and axis aggregations (sum/mean along a dimension), you can express an entire forward pass of a neural net in a handful of loop-free lines. That trio — vectorize, broadcast, aggregate — is the core NumPy skill.
arr ** 2 / np.exp(arr), never a Python for over the elements. Pair
with broadcasting and axis reductions to write whole ML computations loop-free.A great visual companion: Jay Alammar — A Visual Intro to NumPy.