NumPy — Beginner Track

A full walkthrough of installing NumPy, understanding why arrays exist, indexing/slicing, basic array math, and writing your first small analysis script.

1. What NumPy actually is

NumPy (Numerical Python) is the foundational array-computing library nearly every other Python data/science tool is built on top of — pandas, scikit-learn, TensorFlow, and PyTorch all either use NumPy arrays directly or mirror its API. Its core contribution is a single data structure, the ndarray (n-dimensional array), plus a huge set of functions that operate on it far faster than equivalent pure-Python loops. The reason it's fast: a NumPy array stores all its elements as one contiguous, fixed-type block of memory and pushes loops down into pre-compiled C code, instead of looping element-by-element in Python the way a plain list does.

The beginner track gets you from "never imported numpy" to comfortably creating arrays, indexing/slicing them, and doing basic elementwise math — the foundation everything later builds on.

2. Environment setup

1. Confirm Python is installed: run python3 --version in a terminal (3.9 or newer is fine).
2. Install NumPy: pip install numpy (use pip3 if that's how your system distinguishes Python versions).
3. Open a Python REPL or a notebook — either a plain python3 interactive shell, a Jupyter notebook (pip install notebook, then jupyter notebook), or any code editor with a Python runner works fine for this track.
4. Import NumPy using its standard alias — every example in this guide and virtually all NumPy code you'll ever read assumes this convention:

import numpy as np

3. Why arrays instead of lists

A Python list can hold mixed types and grows/shrinks freely, but that flexibility is exactly what makes it slow for numeric work — Python has to check each element's type individually. A NumPy array requires every element to be the same type and a fixed shape, which is what lets NumPy vectorize operations (apply them to the whole array at once, in compiled code) instead of looping in Python.

import numpy as np

# A Python list requires a manual loop or comprehension to do math on every element
prices = [10, 20, 30, 40]
doubled = [p * 2 for p in prices]

# A NumPy array does the same thing directly — no loop needed
prices_arr = np.array([10, 20, 30, 40])
doubled_arr = prices_arr * 2   # array([20, 40, 60, 80])

4. Creating arrays

import numpy as np

# From a Python list
a = np.array([1, 2, 3, 4, 5])

# From a nested list — becomes a 2D array (a matrix)
b = np.array([[1, 2, 3], [4, 5, 6]])

# Built-in generators — avoid typing values by hand
np.zeros(5)              # array([0., 0., 0., 0., 0.])
np.ones((2, 3))          # a 2x3 array of 1.0
np.arange(0, 10, 2)      # array([0, 2, 4, 6, 8]) — like Python's range()
np.linspace(0, 1, 5)     # 5 evenly spaced values from 0 to 1, inclusive

Inspecting an array

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

a.shape   # (2, 3) — 2 rows, 3 columns
a.ndim    # 2 — number of dimensions
a.dtype   # dtype('int64') — the single data type every element shares
a.size    # 6 — total number of elements

5. Indexing and slicing

a = np.array([10, 20, 30, 40, 50])

a[0]        # 10 — first element
a[-1]       # 50 — last element
a[1:4]      # array([20, 30, 40]) — slice, same rules as Python lists
a[:3]       # array([10, 20, 30]) — first three
a[::2]      # array([10, 30, 50]) — every other element

# 2D indexing — [row, column], not [row][column]
b = np.array([[1, 2, 3], [4, 5, 6]])
b[0, 2]     # 3 — row 0, column 2
b[1, :]     # array([4, 5, 6]) — entire second row
b[:, 0]     # array([1, 4]) — entire first column

6. Basic array math

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

a + b        # array([11, 22, 33, 44]) — elementwise addition
a * b        # array([10, 40, 90, 160]) — elementwise multiplication
a ** 2       # array([1, 4, 9, 16]) — elementwise power
b / a        # array([10., 10., 10., 10.]) — elementwise division

# Aggregate functions — reduce the whole array to one number
a.sum()      # 10
a.mean()     # 2.5
a.max()      # 4
a.min()      # 1
a.std()      # standard deviation

All of the arithmetic operators above work elementwise by default — this is different from how * behaves on two Python lists (which either errors or repeats the list, depending on the types involved). Elementwise-by-default is another core NumPy convention worth internalizing early.

7. Lab: a small analysis script

8. Pre-attempt checklist

• I can explain why NumPy arrays are faster than Python lists for numeric work
• I can create an array from a list, and with zeros/ones/arange/linspace
• I can check an array's shape, dtype, and ndim
• I can index and slice both 1D and 2D arrays using [row, column] syntax
• I can perform elementwise arithmetic and basic aggregates (sum, mean, max, min)

9. What to do after this lab

Rebuild the capstone script for the same problem using plain Python lists and a for loop instead of NumPy, and time both versions on a much larger array (say, 1,000,000 elements) using Python's built-in time module — seeing the actual speed gap firsthand is more convincing than reading about it. Once array creation, indexing, and basic math feel automatic, move to the Intermediate track, which covers broadcasting, boolean/fancy indexing, and reshaping.

← Back to all practice tools & labs

NumPy — Intermediate Track

Where simple elementwise math stops being enough. This guide covers broadcasting, boolean and fancy indexing, reshaping, axis-aware aggregation, and basic linear algebra.

1. What changes at this level

Beginner work does math between arrays of the exact same shape. Intermediate work is about NumPy's rules for combining arrays of different shapes (broadcasting), selecting elements based on a condition rather than a fixed position (boolean/fancy indexing), and reasoning about multi-dimensional arrays along a specific axis rather than just as one flat aggregate. This is also where basic linear algebra — the actual mathematical purpose NumPy was originally built for — enters the picture.

2. Broadcasting

Broadcasting is the set of rules NumPy uses to perform elementwise operations on arrays of different shapes without you having to manually resize either one. The core rule: comparing shapes from the rightmost dimension inward, two dimensions are compatible if they're equal, or if one of them is 1.

import numpy as np

# Scalar broadcast — this is broadcasting you already used in the beginner track
a = np.array([1, 2, 3])
a * 2                      # array([2, 4, 6]) — the scalar "stretches" to match

# 1D array broadcast against each row of a 2D array
grid = np.array([[1, 2, 3], [4, 5, 6]])
row = np.array([10, 20, 30])
grid + row
# array([[11, 22, 33],
#        [14, 25, 36]])   — row is applied to every row of grid

# Column vector broadcast against each column
col = np.array([[100], [200]])   # shape (2, 1)
grid + col
# array([[101, 102, 103],
#        [204, 205, 206]])

3. Boolean and fancy indexing

Beginner indexing selects elements by fixed position. Boolean indexing selects elements by condition, and fancy indexing selects them by an arbitrary list of positions — both return new arrays rather than a single value.

a = np.array([15, 22, 8, 40, 3, 27])

# Boolean indexing — the condition builds a True/False array of the same shape,
# then that mask selects only the True positions
mask = a > 20
mask          # array([False, True, False, True, False, True])
a[mask]       # array([22, 40, 27])
a[a > 20]     # same thing, written inline — the common idiom

# Modify in place using a boolean mask
a[a < 10] = 0
a             # array([15, 22, 0, 40, 0, 27])

# Fancy indexing — select by an explicit list of positions, in any order
idx = [0, 3, 5]
a[idx]        # array([15, 40, 27])

# Combine conditions with & and | (not "and"/"or" — those don't work elementwise)
a[(a > 10) & (a < 30)]

4. Reshaping arrays

a = np.arange(12)          # array([0, 1, 2, ..., 11]), shape (12,)

a.reshape(3, 4)             # 3 rows, 4 columns — total elements must match (3*4=12)
a.reshape(4, 3)              # 4 rows, 3 columns — same data, different layout
a.reshape(-1, 1)             # -1 means "figure this dimension out automatically"
                              # → turns a flat array into an explicit column vector

grid = a.reshape(3, 4)
grid.flatten()               # back to 1D, as a copy
grid.T                       # transpose — swaps rows and columns, shape becomes (4, 3)

5. Axis-aware aggregation

Aggregate functions like sum() and mean() default to collapsing the entire array to one number. On a multi-dimensional array, the axis parameter lets you collapse along just one dimension instead.

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

grid.sum()             # 21 — every element added together
grid.sum(axis=0)       # array([5, 7, 9]) — sum DOWN each column (collapses rows)
grid.sum(axis=1)       # array([6, 15])   — sum ACROSS each row (collapses columns)

grid.mean(axis=0)      # column-wise means
grid.max(axis=1)       # row-wise maximums

6. Basic linear algebra

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

a @ b                # matrix multiplication (preferred modern syntax)
np.dot(a, b)         # equivalent, older syntax
a * b                # NOT matrix multiplication — this is still elementwise!

np.linalg.inv(a)     # matrix inverse
np.linalg.det(a)     # determinant
np.linalg.eig(a)     # eigenvalues and eigenvectors, returned as a tuple

# Solving a system of linear equations Ax = b
A = np.array([[3, 1], [1, 2]])
b_vec = np.array([9, 8])
np.linalg.solve(A, b_vec)   # the x that satisfies the system

7. Lab: a small grade-book analysis

8. Pre-attempt checklist

• I can explain NumPy's broadcasting rule and predict whether two shapes are compatible
• I can build and apply a boolean mask, and combine conditions with &/|
• I can reshape an array and explain why it doesn't copy the underlying data
• I can correctly choose axis=0 vs. axis=1 for a given aggregation question
• I know the difference between * (elementwise) and @ (matrix multiplication)

← Back to all practice tools & labs

NumPy — Expert Track

Views vs. copies, memory layout and strides, real vectorization performance work, structured arrays, and interfacing with C/Cython for the cases NumPy alone can't make fast enough.

1. What changes at this level

Intermediate work treats NumPy as a black box that's simply "faster than loops." Expert work is about understanding why — how arrays are actually laid out in memory, when an operation returns a view (sharing memory with the original) versus a copy, how to profile and eliminate the last hidden Python-level loops in your code, and when NumPy itself isn't enough and you need to drop into compiled code directly. This track assumes real fluency with everything in the intermediate guide.

2. Views vs. copies

This is the single most consequential thing to understand at the expert level, because getting it wrong causes silent bugs rather than errors. Basic slicing returns a view — a new array object that shares the same underlying memory as the original. Boolean indexing, fancy indexing, and most operations that reshape or combine data return a copy.

import numpy as np

a = np.arange(10)
b = a[2:5]          # a VIEW — shares memory with a
b[0] = 999
a                    # array([0, 1, 999, 3, 4, 5, 6, 7, 8, 9]) — a changed too!

c = a[[2, 3, 4]]     # fancy indexing — a COPY
c[0] = -1
a                    # unchanged by modifying c

# Check explicitly rather than guessing
b.base is a          # True — b is a view into a
c.base is a           # False — c owns its own data

# Force a copy when you need one, regardless of the default behavior
d = a[2:5].copy()

3. Memory layout: strides and contiguity

A NumPy array's shape is really just a "view configuration" on top of a flat block of memory, and strides — the number of bytes to step in memory to move one position along each axis — are what let the same underlying data be reinterpreted as different shapes without copying.

a = np.arange(12).reshape(3, 4)
a.strides            # (32, 8) on a typical 64-bit int64 array —
                      # 32 bytes to move one row down, 8 bytes to move one column right

a.flags['C_CONTIGUOUS']   # True — stored row-major (C order), the NumPy default
a.T.flags['C_CONTIGUOUS'] # False — the transpose is a view with different strides,
                           # not physically reordered data

# Forcing a specific memory layout matters for performance-critical code,
# especially when passing arrays to C extensions or certain BLAS-backed operations
b = np.ascontiguousarray(a.T)

4. Real vectorization: eliminating hidden Python loops

The intermediate track taught you to prefer vectorized operations over explicit loops. Expert work is about finding the loops that are still hiding — often inside a seemingly-vectorized line that's secretly falling back to slow, general-purpose code.

# Slow: np.vectorize is just a thin wrapper around a Python loop —
# it exists for convenience/broadcasting semantics, NOT for speed
def my_func(x):
    return x ** 2 if x > 0 else 0
slow = np.vectorize(my_func)(a)

# Fast: express the same logic using real vectorized primitives
fast = np.where(a > 0, a ** 2, 0)

# Slow: appending to a Python list inside a loop, converting to array at the end,
# is often fine for small N but breaks down badly at scale
results = []
for row in big_array:
    results.append(row.sum())
results = np.array(results)

# Fast: axis-aware aggregation does the same thing with zero Python-level looping
results = big_array.sum(axis=1)

Profiling before optimizing

# %timeit inside IPython/Jupyter — the standard first step
%timeit my_slow_function(data)

# From a plain script, use the timeit module directly
import timeit
timeit.timeit(lambda: my_slow_function(data), number=100)

5. Structured arrays

A structured array lets a single NumPy array hold named fields of different types per "row," similar in spirit to a lightweight, fixed-schema table — useful when you want array-level performance without pulling in a full library like pandas.

dt = np.dtype([('name', 'U10'), ('age', 'i4'), ('score', 'f8')])
people = np.array([('Ada', 32, 91.5), ('Grace', 45, 88.2)], dtype=dt)

people['name']         # array(['Ada', 'Grace'], dtype=' 90]   # rows matching a condition, same boolean-mask idiom as before

6. Interfacing with C and Cython

For the small fraction of cases where even well-vectorized NumPy code isn't fast enough (typically tight numerical loops with data-dependent branching that can't be expressed as array operations at all), the standard escape hatches are:

• Cython — write Python-like code with optional static type declarations, compiled to C. The most common on-ramp for NumPy-heavy code because it understands NumPy arrays natively via typed memoryviews.
• Numba — a JIT compiler that speeds up plain Python/NumPy functions with a single @njit decorator, no separate compilation step required. Often the lowest-effort option to try first.
• The NumPy C API directly — writing a C extension that manipulates ndarray objects at the buffer level; the most control, and the most work, reserved for library-authoring rather than typical application code.

# Numba example — often the fastest path from "slow Python loop" to "fast compiled loop"
from numba import njit

@njit
def sum_of_squares(arr):
    total = 0.0
    for x in arr:
        total += x ** 2
    return total

7. Lab: profile, diagnose, and fix a slow pipeline

8. Pre-attempt checklist

• I can predict whether a given NumPy operation returns a view or a copy
• I can check and explain an array's strides and C-contiguity
• I can identify a hidden Python-level loop (e.g. np.vectorize) and replace it with a true vectorized equivalent
• I profile before optimizing, using %timeit or timeit, rather than guessing
• I can build a structured array and explain when it's a reasonable alternative to pandas
• I know the standard escape hatches (Numba, Cython, the C API) and when each is appropriate

← Back to all practice tools & labs