NumPy: Fast Arrays

Almost everything in data science — pandas, scikit-learn, even deep learning frameworks — is built on top of NumPy and its core data structure, the ndarray. In this lesson you'll see why arrays crush plain Python lists for numerical work, and learn the handful of operations you'll use every single day.

Why not just use lists?

Python lists are flexible, but that flexibility has a price. Watch what happens when you try to do math with them:

Python — runs in your browser

Run

nums = [1, 2, 3] # Multiplying a list REPEATS it — it doesn't multiply the numbers! print(nums * 3) # And adding two lists concatenates them: print([1, 2, 3] + [4, 5, 6])

To actually multiply every element you'd need a loop or a list comprehension. NumPy arrays behave the way a mathematician expects — operations apply elementwise:

Python — runs in your browser

Run

import numpy as np a = np.array([1, 2, 3]) print(a * 3) # [3 6 9] print(a + np.array([4, 5, 6])) # [5 7 9]

This style — operating on whole arrays at once instead of looping — is called vectorization, and it isn't just prettier, it's dramatically faster because the loop happens in optimized C code instead of Python. Let's measure it:

Python — runs in your browser

Run

import numpy as np import time n = 1_000_000 py_list = list(range(n)) np_array = np.arange(n) t0 = time.perf_counter() squared_list = [x ** 2 for x in py_list] t_list = time.perf_counter() - t0 t0 = time.perf_counter() squared_array = np_array ** 2 t_array = time.perf_counter() - t0 print(f"list comprehension : {t_list*1000:7.1f} ms") print(f"numpy vectorized : {t_array*1000:7.1f} ms") print(f"speedup : {t_list/t_array:.0f}x")

A 10–100x speedup is typical. On millions of rows, that's the difference between "instant" and "coffee break".

Creating arrays

You'll create arrays in a few standard ways — from lists, from constructors, or as evenly spaced sequences:

Python — runs in your browser

Run

import numpy as np print(np.array([1, 2, 3])) # from a list print(np.zeros(4)) # [0. 0. 0. 0.] print(np.ones((2, 3))) # 2x3 matrix of ones print(np.arange(0, 10, 2)) # like range(): start, stop, step print(np.linspace(0, 10, 5)) # 5 evenly spaced values from 0 to 10

Note the difference between the last two: arange takes a step size (and excludes the stop), while linspace takes a count of points (and includes both endpoints). linspace is the go-to for plotting smooth curves.

Every array carries metadata describing itself:

Python — runs in your browser

Run

import numpy as np m = np.array([[1, 2, 3], [4, 5, 6]]) print(m.shape) # (2, 3) -> 2 rows, 3 columns print(m.ndim) # 2 dimensions print(m.dtype) # int64 (or int32 on some platforms) print(m.size) # 6 elements total # dtype matters: mixing in a float upgrades everything print(np.array([1, 2, 3.5]).dtype) # float64

Unlike lists, an array holds values of one dtype — that uniformity is exactly what makes it fast.

Indexing, slicing, and boolean masks

One-dimensional indexing works like lists, but 2-D arrays take a comma-separated [row, column] pair:

Python — runs in your browser

Run

import numpy as np a = np.arange(10, 20) print(a[0], a[-1]) # first and last print(a[2:5]) # slice: [12 13 14] m = np.arange(1, 13).reshape(3, 4) print(m) print(m[1, 2]) # row 1, column 2 -> 7 print(m[0]) # entire first row print(m[:, 1]) # entire second column print(m[0:2, 1:3]) # top-middle 2x2 block

The real superpower is boolean masking — filtering with a condition instead of a loop:

Python — runs in your browser

Run

import numpy as np scores = np.array([72, 95, 48, 88, 61, 99, 55]) mask = scores >= 70 print(mask) # array of True/False print(scores[mask]) # only the passing scores print(scores[scores < 60]) # usually written in one line # masks also let you modify in place: scores[scores < 60] = 60 print(scores)

Keep this pattern in mind — pandas filtering in the next lessons works exactly the same way.

Elementwise math and broadcasting

All the usual math works elementwise, and NumPy ships fast versions of common functions (np.sin, np.exp, np.sqrt, …):

Python — runs in your browser

Run

import numpy as np a = np.array([1.0, 4.0, 9.0]) b = np.array([10.0, 20.0, 30.0]) print(a + b, a * b, sep="\n") print(np.sqrt(a)) # Broadcasting: a scalar "stretches" to match the array... print(a * 100) # ...and a 1-D row stretches down a 2-D matrix: m = np.zeros((3, 3)) row = np.array([1, 2, 3]) print(m + row)

Broadcasting is NumPy quietly repeating the smaller operand so shapes line up. It saves you from writing loops to, say, subtract a column mean from every row — a trick you'll use constantly when scaling features for machine learning.

Aggregations and the axis argument

Reducing an array to summary numbers is a one-liner:

Python — runs in your browser

Run

import numpy as np sales = np.array([ [120, 135, 150], # store A: Jan, Feb, Mar [ 80, 95, 110], # store B ]) print(sales.sum()) # grand total print(sales.mean()) # overall average print(sales.std()) # spread # axis=0 collapses ROWS (result: one value per column/month) print(sales.sum(axis=0)) # monthly totals across stores # axis=1 collapses COLUMNS (result: one value per row/store) print(sales.sum(axis=1)) # total per store

Random numbers, the modern way

Simulations, synthetic datasets, and train/test splits all need randomness. The modern API is np.random.default_rng, which gives you a generator object — pass a seed to make results reproducible:

Python — runs in your browser

Run

import numpy as np rng = np.random.default_rng(42) print(rng.random(3)) # uniform floats in [0, 1) print(rng.integers(1, 7, size=5)) # dice rolls (1-6) print(rng.normal(loc=170, scale=8, size=4).round(1)) # ~heights in cm # Same seed -> same "random" numbers, every time: rng2 = np.random.default_rng(42) print(rng2.random(3))

Seeding matters more than it looks: it makes your experiments reproducible, so a colleague (or future you) can rerun your notebook and get identical results.

Check your understanding

5 questions · free

1. Q1.What does [1, 2, 3] * 2 return in plain Python?

   A[2, 4, 6]B[1, 2, 3, 1, 2, 3]CAn errorD[[1, 2, 3], [1, 2, 3]]

2. Q2.Why is a vectorized NumPy operation so much faster than a Python loop?

   ANumPy skips half the elementsBThe loop runs in optimized C code on a single, uniform block of memoryCNumPy caches the answer from previous runsDIt runs on the GPU by default

3. Q3.np.linspace(0, 10, 5) returns…

   A[0, 5, 10]B[0, 2, 4, 6, 8]C[0, 2.5, 5, 7.5, 10]D[0, 1, 2, 3, 4]

4. Q4.For a 2-D array m of monthly sales with shape (n_stores, n_months), how do you get the total per store?

   Am.sum()Bm.sum(axis=0)Cm.sum(axis=1)Dm.total(rows=True)

5. Q5.What is the purpose of the seed in np.random.default_rng(42)?

   AIt makes the numbers more randomBIt sets the size of the output arraysCIt makes the random sequence reproducible across runsDIt limits values to a maximum of 42

Exercise: Analyze a week of temperatures

Simulate one week (7 days) of daily temperatures for two cities as a (2, 7) array using np.random.default_rng — give Jakarta a mean around 31 °C and Bandung around 24 °C. Then compute: (1) each city's average temperature, (2) each city's hottest day, (3) how many days each city was above 30 °C, and (4) all readings above the overall average, using a boolean mask.

Next up: pandas — where NumPy arrays get labels, column names, and a whole toolkit for real-world tabular data.