Performance & Vectorization vs Loops

Vectorization is the practice of expressing a computation as operations on whole arrays instead of element-by-element Python loops — letting NumPy run the work as a single compiled C loop over contiguous memory rather than slow, interpreted Python. In this lesson you'll see why Python loops are slow, rewrite a loop as a one-line vectorized expression, preallocate instead of appending, lean on built-in aggregations, and understand why np.vectorize is convenience rather than speed.

Learn Performance & Vectorization vs Loops in our free NumPy course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a…

Part of the free Numpy course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

A Python for loop over numbers pays a tax on every iteration: it interprets bytecode and treats each number as a full Python object that must be unboxed, operated on, and reboxed. A NumPy array keeps raw numbers in contiguous memory and runs the whole operation as one compiled C loop , skipping all that overhead.

Expected output: both produce 1, 4, 9, 16, 25 — identical results, but the vectorized version is far faster on big data.

Most element-wise loops collapse into a single expression. Whenever you see a loop that does the same arithmetic to each element, look for the array version: a + b , a * 2 , or a combined formula applied to whole arrays at once.

Expected output: both give roughly [22, 22, 99] , and np.allclose confirms they match with True .

Calling np.append inside a loop is a trap: each call builds a brand-new array and copies everything, which is quadratic and painfully slow. If you truly need a loop, preallocate with np.zeros(n) once and fill slots by index. Better still, vectorize and skip the loop.

Expected output: both print [ 0 1 4 9 16] — same result, but the preallocated version avoids the costly per-step copies that np.append makes.

Don't hand-roll a running total or maximum in Python. NumPy's built-in aggregations — .sum() , .mean() , .max() , .min() — run in C and are both shorter and dramatically faster than a manual loop.

Expected output: 5050 from both the loop and .sum() , then mean 50.5 .

Beware of np.vectorize : it wraps a scalar function so it accepts arrays — handy for readability. But it still loops in Python internally, so it is not a performance tool. For real speed, express the logic with true NumPy operations (arithmetic, np.where , masks).

Expected output: both print [0 0 0 1 2] , but np.where runs in C while np.vectorize only looks fast.

Replace each ___ so the slow loop becomes a fast, vectorized one-liner that doubles every value and sums the result.

Expected output: [2 4 6 8] then 20 . (Answers: 2 , sum .)

❌ Looping over a huge array element by element

A Python for loop over millions of elements can be 50-100x slower than the array version.

✅ Fix: replace the loop with a single vectorized expression or a built-in aggregation.

It only changes how the function is called; the work still happens in a Python-level loop.

✅ Fix: rewrite the logic with real NumPy ops like np.where , masks, or arithmetic.

Compute the Euclidean distance of each point from the origin, first with a loop, then with one vectorized expression, and confirm they match.

Lesson 21 complete — you write fast NumPy now!

You know why Python loops are slow, how to rewrite them as vectorized expressions, when to preallocate, how to reach for built-in aggregations, and why np.vectorize is convenience rather than speed.

🚀 Up next: the Capstone — put it all together by treating an image as a NumPy array.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary