Academy — Sanjib Sikder

Why NumPy Exists

Python lists are flexible — they can hold any mix of types, grow dynamically, and handle arbitrary data. That flexibility has a cost: every operation on a list is slow compared to what a computer can do natively with numbers.

Scientific computing requires speed. Working with a million measurements, a matrix of pixel values, or the weights of a neural network — Python lists are orders of magnitude too slow.

NumPy solves this with the ndarray — an N-dimensional array of a single fixed type, stored in a contiguous block of memory. Operations on NumPy arrays are executed in compiled C code, not interpreted Python. The difference in speed is typically 100x or more.

NumPy is the foundation of the entire scientific Python ecosystem — SciPy, Pandas, Matplotlib, scikit-learn, and PyTorch all build on it.

Creating Arrays

Python

Ctrl+Enter to run

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(a)
print(type(a))
print(a.dtype)
print(a.shape)

np.array() creates an array from a Python list. dtype is the data type of the elements — int64 here. shape is a tuple describing the dimensions — (5,) means one dimension with 5 elements.

Built-in constructors

Python

Ctrl+Enter to run

import numpy as np

print(np.zeros(5))
print(np.ones((2, 3)))
print(np.arange(0, 10, 2))
print(np.linspace(0, 1, 5))

zeros / ones — arrays of zeros or ones, given a shape
arange(start, stop, step) — like Python's range, but returns an array
linspace(start, stop, n) — n evenly spaced values between start and stop (inclusive)

linspace is particularly useful in scientific work — generating the x-axis for a plot, sampling a function at regular intervals, and so on.

The Critical Difference: Vectorised Operations

With Python lists, to add 10 to every element you write a loop or comprehension. With NumPy, you operate on the whole array at once:

Python

Ctrl+Enter to run

import numpy as np

scores = np.array([45, 88, 72, 61, 93, 38, 55])

print(scores + 10) # Add 10 to every element
print(scores * 2) # Multiply every element by 2
print(scores ** 2) # Square every element
print(scores > 60) # Compare every element — returns boolean array

Every operation applies to the entire array simultaneously. No loops. No comprehensions. The computation runs in compiled code. For large arrays, this is not a stylistic preference — it's a practical necessity.

2D Arrays — Matrices

NumPy arrays can have any number of dimensions. A 2D array is a matrix:

Python

Ctrl+Enter to run

import numpy as np

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

print(matrix)
print(#22c55e">"Shape:", matrix.shape)
print(#22c55e">"Dimensions:", matrix.ndim)
print(#22c55e">"Total elements:", matrix.size)

shape is (3, 3) — 3 rows, 3 columns. ndim is 2. Rows come first, columns second — consistent with mathematical convention.

Indexing and Slicing

1D indexing works exactly like lists:

Python

Ctrl+Enter to run

import numpy as np

a = np.array([10, 20, 30, 40, 50])
print(a[0])
print(a[-1])
print(a[1:4])

2D indexing uses a comma: array[row, col]

Python

Ctrl+Enter to run

import numpy as np

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

print(m[0, 0]) # First row, first column
print(m[1, 2]) # Second row, third column
print(m[0]) # Entire first row
print(m[:, 1]) # Entire second column
print(m[0:2, 1:3]) # Submatrix

m[:, 1] — all rows, column 1. The : means "all of this dimension". This notation is compact and expressive once you're used to it.

Boolean Indexing — Filtering by Condition

Python

Ctrl+Enter to run

import numpy as np

scores = np.array([45, 88, 72, 61, 93, 38, 55])

mask = scores >= 60
print(mask)

passing = scores[mask]
print(passing)

# In one step:

print(scores[scores >= 60])

A comparison produces a boolean array — True where the condition holds, False elsewhere. Using that array as an index selects only the elements where it's True. This is the NumPy equivalent of a filter — no loops, no comprehensions.

Aggregate Functions

Python

Ctrl+Enter to run

import numpy as np

data = np.array([4.5, 7.2, 3.1, 8.8, 5.6, 2.9, 9.1])

print(#22c55e">"Sum:", np.sum(data))
print(#22c55e">"Mean:", np.mean(data))
print(#22c55e">"Std:", np.std(data))
print(#22c55e">"Min:", np.min(data))
print(#22c55e">"Max:", np.max(data))
print(#22c55e">"Argmax:", np.argmax(data)) # Index of the maximum value

argmax and argmin return the position of the extreme value — useful when you need to know which element, not just what the value is.

For 2D arrays, most aggregate functions accept an axis argument:

Python

Ctrl+Enter to run

import numpy as np

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

print(#22c55e">"Sum of each column:", np.sum(m, axis=0))
print(#22c55e">"Sum of each row:", np.sum(m, axis=1))
print(#22c55e">"Total sum:", np.sum(m))

axis=0 operates along rows (down the columns). axis=1 operates along columns (across the rows). Visualise folding the array along that axis.

Broadcasting

Broadcasting is NumPy's rule for operating on arrays of different shapes. When shapes are compatible, NumPy stretches the smaller array to match the larger one — without copying data.

Python

Ctrl+Enter to run

import numpy as np

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
row = np.array([10, 20, 30])

print(matrix + row)

row has shape (3,). matrix has shape (3, 3). NumPy broadcasts row across all three rows of matrix — adding [10, 20, 30] to each row.

Python

Ctrl+Enter to run

import numpy as np

col = np.array([[10], [20], [30]]) # Shape (3, 1)
row = np.array([1, 2, 3]) # Shape (3,) → treated as (1, 3)

print(col + row) # Outer addition — produces a 3×3 matrix

Every combination of col and row values is computed — a full outer addition. Broadcasting eliminates a large category of explicit loops in numerical code.

A Practical Example: Normalising Data

Python

Ctrl+Enter to run

import numpy as np

measurements = np.array([23.5, 18.2, 31.7, 25.1, 19.8, 28.4, 22.6])

mean = np.mean(measurements)
std = np.std(measurements)

normalised = (measurements - mean) / std

print(#22c55e">"Original: ", measurements)
print(#22c55e">"Normalised:", np.round(normalised, 3))
print(#22c55e">"Mean of normalised:", np.round(np.mean(normalised), 10))
print(#22c55e">"Std of normalised: ", np.round(np.std(normalised), 10))

Normalising data to zero mean and unit standard deviation — one of the most common preprocessing steps in data science and machine learning — expressed as two arithmetic lines. No loops. No intermediate lists. The entire array is transformed in place by broadcasting.

What You Have Learned

NumPy is the engine behind scientific Python — its array model and vectorised operations are the foundation everything else builds on.

The key ideas:

np.array() creates an ndarray — fast, fixed-type, stored in contiguous memory
Vectorised operations apply to entire arrays simultaneously — no loops needed
shape, dtype, ndim, size describe an array's structure
arange and linspace generate numeric sequences
2D indexing: a[row, col], a[:, col], a[row, :]
Boolean indexing: a[a > threshold] selects elements by condition
Aggregate functions: sum, mean, std, min, max, argmax — with optional axis
Broadcasting: NumPy stretches smaller arrays to match larger ones for element-wise operations

In the next lesson, you'll learn Pandas — the library that brings NumPy's power to labelled, structured data, making data analysis natural and expressive.

NumPy Basics

Why NumPy Exists

Creating Arrays

Built-in constructors

The Critical Difference: Vectorised Operations

2D Arrays — Matrices

Indexing and Slicing

Boolean Indexing — Filtering by Condition

Aggregate Functions

Broadcasting

A Practical Example: Normalising Data

What You Have Learned