Quick Reference & Tips

import numpy as np

# From data
np.array([1, 2, 3])                    # 1D array
np.array([[1, 2], [3, 4]])             # 2D array

# Initialized arrays
np.zeros((N, D))                        # all zeros
np.ones((N, D))                         # all ones
np.full((N, D), fill_value=7)          # all sevens
np.eye(N)                               # identity matrix
np.empty((N, D))                        # uninitialized (fast)

# Sequences
np.arange(start, stop, step)            # like range()
np.linspace(start, stop, num)           # evenly spaced

# Random
rng = np.random.default_rng(42)         # modern API (preferred)
rng.standard_normal((N, D))             # standard normal
rng.uniform(low, high, (N, D))         # uniform
rng.integers(low, high, (N,))          # random integers
rng.choice(arr, size=k, replace=False) # sampling
rng.permutation(N)                      # random permutation
rng.shuffle(arr)                        # in-place shuffle

# Reshape (returns view when possible)
x.reshape(3, 4)                         # explicit shape
x.reshape(3, -1)                        # infer one dimension
x.ravel()                               # flatten to 1D (view)
x.flatten()                             # flatten to 1D (copy)

# Transpose
x.T                                     # matrix transpose
x.transpose(0, 2, 1)                   # permute axes

# Add/remove dimensions
x[None, :]                              # add axis at front: (D,) -> (1, D)
x[:, None]                              # add axis at back:  (D,) -> (D, 1)
x[np.newaxis, :]                       # same as x[None, :]
x.squeeze()                             # remove size-1 dimensions
np.expand_dims(x, axis=0)              # add axis

# Joining
np.concatenate([a, b], axis=0)         # join along existing axis
np.stack([a, b], axis=0)               # join along new axis
np.vstack([a, b])                      # vertical stack
np.hstack([a, b])                      # horizontal stack
np.column_stack([a, b])                # stack as columns

# Splitting
np.split(x, 3, axis=0)                # split into 3 equal parts
np.array_split(x, 3, axis=0)          # split (allows unequal)

# Reductions (always specify axis!)
x.sum(axis=0)                           # sum per column
x.mean(axis=1)                          # mean per row
x.std(axis=0, ddof=1)                  # sample std per column
x.min(axis=1)                           # min per row
x.max(axis=0)                           # max per column
x.argmin(axis=1)                        # index of min per row
x.argmax(axis=0)                        # index of max per column
x.cumsum(axis=0)                        # cumulative sum

# Linear algebra
a @ b                                   # matrix multiply (recommended)
np.dot(a, b)                            # dot product / matmul
np.linalg.norm(x, axis=1)              # L2 norm per row
np.linalg.inv(A)                        # matrix inverse
np.linalg.solve(A, b)                  # solve Ax = b (preferred over inv)
np.linalg.eigh(A)                      # eigenvalues (symmetric)
np.linalg.svd(A, full_matrices=False)  # SVD (compact)
np.linalg.det(A)                        # determinant

# Element-wise
np.maximum(x, 0)                        # ReLU
np.exp(x)                               # exponential
np.log(x)                               # natural log
np.clip(x, a_min, a_max)               # clamp values
np.where(cond, x, y)                    # conditional select
np.sign(x)                              # sign function

# Sorting and searching
np.sort(x, axis=1)                      # sort per row
np.argsort(x, axis=1)                  # indices that would sort
np.argpartition(x, k)                  # O(n) partial sort
np.searchsorted(sorted_arr, values)    # binary search
np.unique(x, return_counts=True)       # unique values

# BROADCASTING RULES:
# 1. Arrays are compared shape from RIGHT to LEFT
# 2. Dimensions are compatible if they are EQUAL or one is 1
# 3. Missing dimensions are treated as 1

# Examples:
# (5, 3) + (3,)    -> (5, 3) + (1, 3) -> (5, 3)   OK
# (5, 3) + (5, 1)  -> (5, 3)                        OK
# (5, 3) + (5,)    -> ERROR! 3 != 5

# Common patterns:
# (N, D) - (D,)         -> subtract per-feature value from all samples
# (N, D) - (N, 1)       -> subtract per-sample value from all features
# (N, 1) * (1, M)       -> outer product: (N, M)
# (N, 1, D) - (1, M, D) -> pairwise differences: (N, M, D)

# Fix shape mismatches:
# If you have shape (N,) and need (N, 1):
x = x[:, None]      # or x[:, np.newaxis] or x.reshape(-1, 1)

# If you have shape (D,) and need (1, D):
x = x[None, :]      # or x[np.newaxis, :] or x.reshape(1, -1)