NumPy: Fast Numerical Computing with Python Arrays

# Python list — explicit loop, slow
numbers = list(range(1_000_000))
result = [x + 5 for x in numbers]  # ~100 ms

# NumPy array — vectorized, C speed
import numpy as np
numbers = np.arange(1_000_000)
result = numbers + 5                # ~1 ms

pip install numpy

import numpy as np  # np is the universal alias

# 1D array (vector)
a = np.array([10, 20, 30, 40, 50])
print(a)        # [10 20 30 40 50]
print(a.dtype)  # int64

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

np.zeros(5)          # [0. 0. 0. 0. 0.]
np.zeros((3, 4))     # 3×4 matrix of zeros
np.ones((2, 3))      # 2×3 matrix of ones
np.empty((3, 8))     # 3×8 uninitialized — fastest, for arrays you'll immediately overwrite

np.arange(6)            # [0 1 2 3 4 5]
np.arange(2, 10, 2)     # [2 4 6 8] — start, stop (exclusive), step
np.arange(2, 4, 0.5)    # [2.  2.5 3.  3.5] — float steps work

# Specify number of points instead of step size
np.linspace(0, 1, 5)   # [0.   0.25 0.5  0.75 1.  ] — 5 evenly spaced values
np.linspace(1, 10, 4, dtype=np.int64)  # [1 4 7 10]

rng = np.random.default_rng(seed=42)   # reproducible with a seed
rng.integers(0, 100, size=(3, 4))      # 3×4 matrix of random ints 0–99
rng.random((2, 3))                     # 2×3 matrix of floats in [0, 1)
rng.normal(loc=70, scale=10, size=100) # 100 values from a normal distribution

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

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

a = np.array([12, 89, 45, 67, 23])

a[0]     # 12  — first element (zero-indexed)
a[-1]    # 23  — last element
a[1:3]   # [89 45] — index 1 up to (not including) 3
a[:2]    # [12 89] — first two elements
a[3:]    # [67 23] — from index 3 to end
a[:-2]   # [12 89 45] — all except last two

m = np.array([
    [10, 11, 12, 13],
    [20, 21, 22, 23],
    [30, 31, 32, 33],
    [40, 41, 42, 43]
])

m[1, :]      # [20 21 22 23] — entire row 1
m[:, 2]      # [12 22 32 42] — entire column 2
m[1:3, 1:3]  # [[21 22], [31 32]] — 2×2 sub-grid
m[::2, ::2]  # [[10 12], [30 32]] — every other row and column

scores = np.array([55, 82, 44, 91, 67, 38, 75])

# Create a mask
passing = scores >= 60    # [False True False True True False True]

# Filter with the mask
scores[passing]           # [82 91 67 75]

# One-liner
scores[scores >= 60]      # [82 91 67 75]

# Multiple conditions — wrap each in parentheses, use & / |
scores[(scores >= 60) & (scores < 80)]  # [67 75]

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

a + b    # [11 22 33]
a - b    # [ 9 18 27]
a * b    # [10 40 90]
a / b    # [10. 10. 10.]
a ** 2   # [100 400 900]

np.sqrt(a)          # [3.16 4.47 5.48]
np.abs(np.array([-5, 3, -1]))  # [5 3 1]

matrix = np.array([[10, 20, 30],
                   [40, 50, 60]])   # shape (2, 3)

row = np.array([1, 2, 3])          # shape (3,)

matrix + row   # row broadcasts across both rows of the matrix
# [[11 22 33]
#  [41 52 63]]

column = np.array([[1], [2]])       # shape (2, 1)

matrix + column  # column broadcasts across all three columns
# [[11 21 31]
#  [42 52 62]]

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

np.sum(a)           # 45 — total of all elements
np.sum(a, axis=0)   # [12 15 18] — sum down each column
np.sum(a, axis=1)   # [6 15 24] — sum across each row

np.mean(a)          # 5.0
np.std(a)           # standard deviation of all elements
np.min(a, axis=1)   # [1 4 7] — minimum of each row
np.max(a, axis=0)   # [7 8 9] — maximum of each column
np.cumsum(a.flatten())  # [1 3 6 10 15 21 28 36 45] — running total

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

a.reshape(3, 4)          # 3×4 matrix (reads row by row)
a.reshape(4, 3)          # 4×3 matrix
a.reshape(2, 2, 3)       # 3D tensor

# Flatten back to 1D
a.reshape(3, 4).flatten()   # deep copy — modifying result does not affect original
a.reshape(3, 4).ravel()     # view — modifying result DOES affect original

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

np.sort(arr)          # [10 20 30 40 50] — returns sorted copy
np.argsort(arr)       # [1 3 0 4 2] — indices that would sort the array

# Get the top-3 values efficiently
np.partition(arr, -3)[-3:]   # three largest values (not sorted among themselves)

import numpy as np

# Raw student exam scores
scores = np.array([45, 78, 62, 91, 38, 85, 55, 70, 44, 88])

print(f"Original scores: {scores}")
print(f"Min: {scores.min()}, Max: {scores.max()}")
print(f"Mean: {scores.mean():.1f}, Std: {scores.std():.1f}")

# ── Min-Max Normalization (0 to 1) ──────────────────────────────────────────
min_val = scores.min()
max_val = scores.max()
normalized = (scores - min_val) / (max_val - min_val)
print(f"\nMin-Max normalized:\n{np.round(normalized, 2)}")

# ── Z-Score Standardization (mean=0, std=1) ─────────────────────────────────
mean = scores.mean()
std  = scores.std()
standardized = (scores - mean) / std
print(f"\nZ-score standardized:\n{np.round(standardized, 2)}")

# ── Grade classification using boolean masking ───────────────────────────────
grades = np.where(scores >= 75, "Pass",
         np.where(scores >= 60, "Merit", "Fail"))
print(f"\nGrades: {grades}")

# ── Summary statistics ───────────────────────────────────────────────────────
pass_rate = np.mean(scores >= 60) * 100
print(f"\nPass rate (≥60): {pass_rate:.0f}%")
print(f"Top scorer: {scores.max()} (index {scores.argmax()})")

Original scores: [45 78 62 91 38 85 55 70 44 88]
Min: 38, Max: 91
Mean: 65.6, Std: 18.9

Min-Max normalized:
[0.13 0.75 0.45 1.   0.   0.89 0.32 0.6  0.11 0.94]

Z-score standardized:
[-1.09  0.66 -0.19  1.35 -1.46  1.02 -0.56  0.23 -1.14  1.19]

Grades: ['Fail' 'Pass' 'Merit' 'Pass' 'Fail' 'Pass' 'Fail' 'Pass' 'Fail' 'Pass']

Pass rate (≥60): 50%
Top scorer: 91 (index 3)