NumPy: The Foundation of Numerical Computing

You have one million numbers. You want the sum of their squares.

The obvious Python code is a for-loop:

code
Copy
total = 0
for v in x:
    total += v * v

It works. It is also painfully slow.

Why slow? A plain Python list stores each number as its own separate object. So on every one of the million passes, Python stops and asks:

• "What type is this object? Let me look it up."
• "Where in memory does it live? Let me chase its pointer."
• "Which function does * mean for this pair? Let me dispatch."

One million iterations means a million rounds of bookkeeping.

So the question becomes

The answer is NumPy — and its trick starts with how it stores numbers.

At the center of NumPy is the n-dimensional array (ndarray):

Same sentence in plain words, piece by piece:

• Homogeneous — every element has the same type. All int64, or all float32. Never mixed.
• Fixed-stride — every element has the same byte size, so element number i always sits at a predictable address.
• One block — the raw values live side by side in one contiguous run of memory, not scattered inside individually boxed Python objects.

Carry this analogy through the whole topic:

• A normal Python list is a cardboard box of mixed items. Every item is wrapped and labeled on its own, so a worker — the Python interpreter — must unwrap and identify each one before using it.
• An ndarray is an egg carton: identical eggs in fixed slots. A machine arm can grab the whole carton at once.

That machine arm is optimized C / BLAS code. Because the buffer is one contiguous typed block, NumPy hands the entire array to compiled routines instead of interpreting Python bytecode per item — that is the whole secret of the speed, not magic.

An ndarray has three attributes that describe it:

• shape — a tuple of dimension sizes, e.g. (1000, 784) for 1000 images of 784 pixels each.
• dtype — the element type; picking float32 over float64 halves memory and often speeds up BLAS/GPU math.
• strides — the byte step to move one element along each axis; this is how reshapes and transposes stay views (no copy).

import numpy as np

img = np.zeros((3, 28, 28), dtype=np.float32)  # a blank "image"
print(img.shape)   # (3, 28, 28)
print(img.dtype)   # float32
print(img.nbytes)  # 9408 bytes

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.ndim, a.shape)  # 2 (2, 3)

Here is the memory layout, seen from above.

A Python list of numbers — the list holds only pointers; each value is a separate boxed object:

code
Copy
Python list           memory (scattered)
[ v0  v1  v2  v3 ] -->  [obj]    [obj]    [obj]    [obj]
                         box +    box +    box +    box +
                         label    label    label    label
                         pointers only; values scattered

An ndarray — the raw values themselves sit in one contiguous run of bytes:

code
Copy
ndarray (float64, 5 eggs)
[ 1.0 | 4.0 | 9.0 | 16.0 | 25.0 ]
   8B    8B    8B     8B      8B     <- every slot the same size

The difference in one line each:

• List → the CPU jumps between far-apart objects; each hop costs a pointer chase, a type check, and a likely cache miss.
• ndarray → the CPU sweeps straight through equal-sized values; a compiled loop flies over it.

That straight-line sweep is where the 10x–100x speedups come from.

Vectorization means

Tiny worked example. Let x = [1, 2, 3, 4] and we want the sum of squares:

• x * x → NumPy squares all four values in one compiled sweep → [1, 4, 9, 16]
• np.sum(x * x) → adds them up → 1 + 4 + 9 + 16 = 30

Two lines, zero explicit loops, and the same 30 the slow loop computed — just without paying Python bookkeeping on every item.

Functions such as np.sum, np.exp and arithmetic operators like a * 2 all run compiled loops internally. This is both faster and more readable.

A rule of thumb: if your Python code has a for-loop that only does arithmetic on array elements, there is almost always a NumPy function that does it in one line, tens or hundreds of times faster.

x = np.arange(1_000_000)

# Slow: Python-level loop
total = 0
for v in x:
    total += v * v

# Fast: vectorized (no explicit loop)
total = np.dot(x, x)          # or (x ** 2).sum()

What happens when you subtract a 2-number vector from a 3×2 table? The shapes do not match — yet NumPy "just works".

That trick is broadcasting:

The rules are mechanical. Align the shapes from the right, then compare axis by axis:

1. Two axes are compatible if they are equal.
2. They are also compatible if one of them is 1 — that size-1 axis is copied to match the other.
3. Anything else (like 3 next to 5) is an error.

Tiny worked example — center each column by subtracting its mean. Let

code
Copy
X =                          mean down each column:
3   10                        [5, 30]   shape (2,)
5   30
7   50                        stretch it down the 3 rows:
X - mean =                    -  5   30
                                  5   30
-2  -20                           5   30
 0    0
 2   20

Column 1: 3−5 = −2, 5−5 = 0, 7−5 = 2. Column 2: 10−30 = −20, 30−30 = 0, 50−30 = 20. The (2,) row of means was reused for every sample — that is the "virtual stretch".

This is why a matrix plus a row vector, or a stack of images times a scalar scale, "just work" without you writing loops over rows or channels.

X = np.random.rand(1000, 10)   # 1000 samples, 10 features
mean = X.mean(axis=0)          # shape (10,)
X_centered = X - mean          # (10,) broadcasts across (1000, 10)

One more superpower of the carton: you can look at part of it without buying a second carton.

Slicing and reshaping usually return a view that shares memory with the original, so mutating one affects the other, but with zero allocation cost. Operations like arithmetic or np.copy produce independent copies. Understanding this avoids subtle bugs and unnecessary memory use when you mutate subsets of large arrays.

Back to the analogy: a view is a window onto the same carton — turn an egg under the window and the original carton changes too. A copy is a second carton of your own.

Why AI cares:

• Every neural net in this course is arrays of weights and activations at its core.
• Training steps are written as vectorized math — dot products, elementwise multiplies, broadcasts for biases.
• Frameworks like PyTorch and TensorFlow deliberately mimic the NumPy array API, so shape, dtype, broadcasting and view habits transfer one-to-one into model code.
• Your feature matrices, image tensors and embeddings will be ndarrays long before they are GPU tensors.