NumPy

NumPy eliminates the loop entirely. Operations like * 2 apply to all elements at once, and methods like .sum() replace Python's built-in functions.

Creating arrays from lists: Pass any Python list to np.array() to convert it into a NumPy array. For 1D arrays, use a simple flat list like [1, 2, 3]. For 2D arrays (matrices), use nested lists where each inner list becomes a row. The nesting level determines dimensions: one bracket = 1D, two brackets = 2D, three brackets = 3D, and so on.

Pro tip: NumPy creates a copy of your list data, so modifying the original list won't affect the array. All elements are converted to a common data type (usually int64 or float64) for efficient computation. If you mix integers and floats, all values become floats.

np.zeros(shape) creates an array filled with zeros - perfect for initializing arrays before filling them with computed values. np.ones(shape) does the same but with ones, useful for masks or starting values in algorithms.

np.arange(start, stop, step) works like Python's range() but returns a NumPy array instead of a range object. It's ideal when you need evenly spaced integers or floats with a specific step size.

np.linspace(start, stop, num) creates exactly num evenly spaced values between start and stop (both included). Unlike arange(), you specify how many values you want, not the step size - great for plotting smooth curves.

np.eye(n) creates an identity matrix (1s on diagonal, 0s elsewhere). Identity matrices are fundamental in linear algebra - multiplying any matrix by the identity returns the original matrix.

np.random.rand(d0, d1, ...) generates random floats uniformly distributed between 0 and 1. Pass dimensions directly as arguments (not as a tuple). This is commonly used for initializing neural network weights or creating test data.

np.random.randint(low, high, size) generates random integers from low (inclusive) to high (exclusive). The size parameter accepts a tuple for multi-dimensional arrays. Perfect for simulations, sampling, or generating test indices.

np.random.randn(d0, d1, ...) generates samples from the standard normal distribution (mean=0, std=1). The 'n' stands for 'normal'. This is essential for statistical simulations and machine learning initialization.

np.random.seed(n) sets the random number generator's starting point. Using the same seed always produces the same sequence of random numbers - crucial for reproducible experiments, debugging, and sharing code that others can verify.

np.full(shape, value) creates an array of any shape filled entirely with a specific value. Unlike zeros() or ones(), you choose the fill value - useful for initializing arrays with default values like -1 for "not found" or infinity for minimum-finding algorithms.

np.empty(shape) allocates memory without initializing values - it's the fastest way to create an array, but the values are garbage (whatever was in memory). Only use when you'll immediately overwrite all values.

np.zeros_like(arr) and np.ones_like(arr) create new arrays with the same shape and dtype as an existing array. This ensures compatibility when you need a result array matching your input array's structure.

np.diag() is a dual-purpose function: pass a 1D array to create a diagonal matrix with those values on the diagonal; pass a 2D matrix to extract its diagonal elements as a 1D array. Essential for linear algebra operations.

np.fromfunction(func, shape) creates an array by calling your function with the indices as arguments. The function receives the row index as the first argument and column index as the second. This is powerful for creating arrays where each element depends on its position.

np.meshgrid(x, y) takes two 1D arrays and creates two 2D arrays representing all combinations of x and y coordinates. Think of it as creating a grid where xx has x-values repeated down rows, and yy has y-values repeated across columns.

Why meshgrid? It's essential for 3D surface plots and contour plots. Instead of writing nested loops to evaluate a function at every (x, y) point, you simply write z = f(xx, yy) and NumPy computes all values at once using vectorization.

Common use case: Creating heatmaps, plotting mathematical surfaces like z = x² + y², or generating coordinate grids for image processing and computer graphics applications.

Shape returns a tuple of dimensions. For a 2D array, it's (rows, columns).

Use astype() to convert between types. Be careful converting floats to ints as decimals are truncated.

Indexing works like Python lists. Negative indices count from the end. Slicing uses [start:stop:step].

Single element access: Use arr[row, col] to get one element. Unlike nested Python lists where you'd write list[row][col], NumPy uses a single bracket with comma-separated indices - it's faster and cleaner.

Row access: arr[0] returns the entire first row as a 1D array. This is shorthand for arr[0, :] where the colon means "all columns".

Column access: arr[:, 1] returns the entire second column. The colon before the comma means "all rows", and 1 specifies the column index. This returns a 1D array, not a column vector.

Subarray slicing: arr[0:2, 1:3] extracts a rectangular region - rows 0 to 1 (not including 2) and columns 1 to 2 (not including 3). This is called "slicing" and creates a view of the original data, not a copy.

Boolean masks: When you write arr > 5, NumPy compares each element to 5 and returns an array of True/False values (called a "mask"). This mask has the exact same shape as your original array.

Applying the mask: When you use a boolean array as an index like arr[mask], NumPy returns only the elements where the mask is True. The result is always a 1D array containing the matching elements.

One-liner filtering: You can combine both steps: arr[arr > 5] creates the mask and applies it immediately. This is the most common pattern for filtering data - concise and readable.

Multiple conditions: Combine conditions using & (and), | (or), and ~ (not). Important: use parentheses around each condition, e.g., arr[(arr > 2) & (arr < 8)]. Python's and/or keywords don't work with arrays!

Basic fancy indexing: Instead of using a single index or slice, you can pass a list of specific indices to select multiple elements at once. Here [0, 2, 4] picks the 1st, 3rd, and 5th elements. The result is a new array containing just those values in the order you specified.

Key difference from slicing: Slices like arr[0:5:2] can only select evenly-spaced elements. Fancy indexing lets you pick any arbitrary positions - even repeating indices like arr[[0, 0, 2]] to duplicate elements!

2D fancy indexing: For 2D arrays, provide two lists - one for row indices and one for column indices. NumPy pairs them up: rows[0] with cols[0], rows[1] with cols[1], etc. So matrix[[0,1,2], [1,2,3]] selects elements at positions (0,1), (1,2), and (2,3).

Result shape: The output is a 1D array with the same length as your index lists. This is different from slicing which preserves the 2D structure. Think of it as "cherry-picking" specific cells from your matrix.

Selecting whole rows: When you provide only row indices like matrix[[0, 2]], NumPy returns those complete rows as a 2D array. This is equivalent to matrix[[0, 2], :]. It's perfect for extracting a subset of rows in any order.

Copy vs View: Unlike slicing which creates a "view" (reference to original data), fancy indexing always creates a copy. Modifying the result won't affect the original array. This is important for memory management and avoiding unintended side effects.

Slice assignment: You can assign a single value to a slice, and NumPy will broadcast that value to all positions in the slice. Here arr[2:5] = 99 sets elements at indices 2, 3, and 4 to 99. This is called "broadcasting" a scalar to multiple elements.

Array assignment: You can also assign an array of the same size: arr[2:5] = [10, 20, 30] would set index 2 to 10, index 3 to 20, and index 4 to 30. The shapes must match or be broadcastable!

Boolean mask assignment: Combine filtering and modification in one step! arr[arr > 5] = -1 finds all elements greater than 5 and replaces them with -1. The original array is modified in-place - no new array is created.

Common use cases: Clamping values (arr[arr > 100] = 100), replacing invalid data (arr[arr < 0] = 0), or cleaning outliers. This pattern is incredibly powerful for data preprocessing and much faster than Python loops.

Fancy index assignment: Use a list of indices to modify specific non-contiguous positions. arr[[1, 3, 5, 7]] = 100 sets elements at those exact indices to 100. You can assign a single value (broadcast) or a matching-length array.

Multiple different values: To assign different values to each position, use arr[[1, 3, 5, 7]] = [10, 30, 50, 70]. The index list and value array must have the same length. This is perfect for updating specific known positions in your data.

Arithmetic operators: When you use +, -, *, /, ** between two arrays, NumPy applies the operation to each corresponding pair of elements. a + b adds a[0]+b[0], a[1]+b[1], etc. This is called "vectorized" operation - no loops needed!

Same-shape requirement: Both arrays must have the same shape, or one must be broadcastable to the other. If shapes don't match, NumPy raises a ValueError. Always check shapes with .shape before operations.

Universal functions (ufuncs): Functions like np.sqrt(), np.sin(), np.exp() are "universal functions" that apply to every element automatically. They're optimized in C and much faster than Python's math module with loops.

In-place operations: Use +=, *=, etc. to modify arrays without creating copies: a += 1 adds 1 to every element of a directly, saving memory for large arrays.

Global aggregation: Without the axis parameter, functions like sum(), mean(), min(), max() operate on ALL elements regardless of shape. The result is a single scalar value.

axis=0 (columns): Setting axis=0 collapses rows, computing one result per column. Think of it as "working down" the array vertically. For a 2D array with shape (3, 4), sum(axis=0) returns shape (4,).

axis=1 (rows): Setting axis=1 collapses columns, computing one result per row. Think of it as "working across" horizontally. For shape (3, 4), sum(axis=1) returns shape (3,).

Other useful aggregations: std() for standard deviation, var() for variance, prod() for product, argmin()/argmax() for indices of min/max values. These all accept the axis parameter.

Scalar broadcasting: When you operate on an array with a single number (scalar), NumPy "broadcasts" that number to match the array's shape. arr + 10 adds 10 to every element - it's like the scalar expands to fill the entire array shape.

1D to 2D broadcasting: A 1D array can broadcast across a 2D array if their trailing dimensions match. Here, row has shape (3,) and arr has shape (2, 3). NumPy stretches row vertically to shape (2, 3) by repeating it for each row.

Why broadcasting matters: It lets you write concise code without explicit loops or creating large temporary arrays. arr * row multiplies each row by the same values without actually copying row in memory.

Broadcasting rules: Dimensions are compared right-to-left. Each dimension must either be equal, or one of them must be 1 (or missing). See the Broadcasting Deep Dive section for complete rules and visualizations.

reshape(new_shape): Changes the array's dimensions without modifying the underlying data. A 12-element 1D array can become 3×4, 4×3, 2×6, or even 2×2×3. The key rule: the product of all dimensions must equal the total number of elements.

Row-major order: NumPy fills the new shape row by row (C-style). Elements 0-3 become row 0, elements 4-7 become row 1, etc. This is called "row-major" order and is important when reshaping data that has a specific structure.

The -1 shortcut: Use -1 for exactly one dimension and NumPy calculates it automatically. reshape(3, -1) on 12 elements gives (3, 4) because 12÷3=4. This is incredibly useful when processing batches of data where one dimension varies.

Common patterns: reshape(-1) flattens to 1D. reshape(-1, 1) creates a column vector. reshape(1, -1) creates a row vector. These are essential for preparing data for machine learning models.

flatten(): Always creates a new copy of the data as a 1D array. Safe to modify without affecting the original array. Use when you need an independent flattened copy.

ravel(): Returns a flattened view when possible (more memory efficient). If the original array is contiguous in memory, changes to the raveled array WILL affect the original! Use when you only need to read the data or when memory is tight.

Transpose (.T): Swaps rows and columns - a (3, 4) array becomes (4, 3). Element at [i, j] moves to [j, i]. The first row [0,1,2,3] becomes the first column. Essential for matrix multiplication where dimensions must align.

Transpose is a view: .T doesn't copy data; it just changes how NumPy interprets the indices. This makes it very fast, but modifying the transposed array also modifies the original. For higher dimensions, use np.transpose(arr, axes) to specify axis order.

Scalar broadcasting: When you multiply an array by a single number (scalar), NumPy automatically "broadcasts" that number to every position in the array. It's as if the scalar 10 becomes [10, 10, 10, 10, 10] to match the array shape, then element-wise multiplication happens.

No memory overhead: NumPy doesn't actually create a full array of 10s in memory - it's smart enough to apply the operation efficiently. This makes scalar operations both fast and memory-efficient.

Row vector broadcasting: The 1D array row has shape (3,) which aligns with the matrix's columns (3 columns). NumPy stretches the row vertically, repeating it for each row of the matrix. Row 0 gets [10, 20, 30] added, row 1 gets the same, and so on.

Alignment from right: NumPy aligns shapes from the rightmost dimension. Matrix shape (3, 3) and row shape (3,) - the trailing 3s match, so broadcasting works. If row had shape (2,), you'd get an error because 2 ≠ 3.

Column vector broadcasting: The array col has shape (3, 1) - 3 rows, 1 column. NumPy stretches it horizontally, repeating the single column across all columns of the matrix. Row 0 gets 100 added to all its elements, row 1 gets 200 added, etc.

Creating column vectors: Note the double brackets [[100], [200], [300]] which creates a 2D array with shape (3, 1). Alternatively, use np.array([100, 200, 300]).reshape(-1, 1) or arr[:, np.newaxis] to convert a 1D array to a column vector.

What is an outer product? The outer product of two vectors creates a matrix where each element [i, j] is the product of a[i] and b[j]. For vectors of length 4 and 3, you get a 4×3 matrix containing all possible pairwise products.

Broadcasting trick: a.reshape(-1, 1) converts the 1D array a with shape (4,) into a column vector with shape (4, 1). When multiplied by b with shape (3,), broadcasting creates a (4, 3) result - exactly the outer product!

Why -1 in reshape? The -1 tells NumPy to automatically calculate that dimension. reshape(-1, 1) means "make it a column vector with as many rows as needed". It's shorthand that works regardless of the original array length.

Alternative: np.outer(): NumPy provides np.outer(a, b) which does exactly this operation. The broadcasting method is useful to understand because the same pattern applies to many other computations like distance matrices and correlation tables.

What is centering? Centering data means shifting each feature (column) so its mean becomes zero. This is a critical preprocessing step in machine learning - many algorithms like PCA, SVM, and neural networks work better with centered data.

Step 1 - Calculate column means: data.mean(axis=0) computes the mean of each column separately, returning a 1D array with shape (3,) - one mean per feature. The axis=0 collapses rows to get column-wise statistics.

Step 2 - Broadcast subtraction: data - column_means subtracts the means from each row. The (5, 3) matrix minus (3,) vector broadcasts the means across all 5 rows automatically. Each column gets its own mean subtracted from every element in that column.

Without broadcasting: You'd need a loop like for i in range(data.shape[0]): data[i] -= column_means. Broadcasting replaces this with a single, readable line that's also 10-100x faster for large datasets.

Verification: After centering, centered.mean(axis=0) should return zeros (or very small numbers due to floating-point precision). This confirms each column now has mean zero.

Radians, not degrees: NumPy's trig functions expect angles in radians. np.pi represents π (≈3.14159). Common angles: π/6 = 30°, π/4 = 45°, π/3 = 60°, π/2 = 90°. If you have degrees, convert with np.deg2rad(degrees).

Standard trig functions: np.sin(), np.cos(), np.tan() work element-wise on arrays. Pass an array of angles, get an array of results. The .round(3) just limits decimal places for display.

Inverse functions: np.arcsin(), np.arccos(), np.arctan() return angles (in radians) given a ratio. arcsin(0.5) returns π/6 because sin(π/6) = 0.5.

Also available: Hyperbolic functions (sinh, cosh, tanh) and their inverses (arcsinh, etc.) for advanced math applications.

Exponential (np.exp): Calculates e^x for each element, where e ≈ 2.71828. This is fundamental in statistics (normal distribution), finance (compound interest), and machine learning (softmax, sigmoid functions).

Natural logarithm (np.log): The inverse of exp(). np.log(x) returns the power you'd raise e to get x. So np.log(np.e) = 1. Warning: log of zero or negative numbers returns -inf or nan!

Other logarithm bases: np.log10() is base-10 (common in decibels, pH). np.log2() is base-2 (common in computer science, information theory). For arbitrary base b: use np.log(x) / np.log(b).

Power functions: np.power(base, exp) computes base^exp element-wise. np.sqrt() is shorthand for power of 0.5. For cube roots, use np.cbrt() or np.power(x, 1/3).

np.round(arr, decimals): Rounds to the specified number of decimal places. np.round(3.567, 1) gives 3.6. Note: Python's "banker's rounding" rounds 0.5 to the nearest even number, so 2.5 rounds to 2, not 3.

np.floor(): Always rounds DOWN toward negative infinity. floor(2.9) = 2, but floor(-2.1) = -3 (not -2!). Think of it as "the largest integer less than or equal to x".

np.ceil(): Always rounds UP toward positive infinity. ceil(2.1) = 3, and ceil(-2.9) = -2. Think of it as "the smallest integer greater than or equal to x".

np.trunc(): Removes the decimal part, rounding toward zero. trunc(2.9) = 2 and trunc(-2.9) = -2. Unlike floor, negative numbers round up (toward zero). np.abs() returns absolute values.

Central tendency: np.mean() calculates the arithmetic average. np.median() finds the middle value when sorted - more robust to outliers than mean. For weighted averages, use np.average(data, weights=w).

Spread measures: np.std() calculates standard deviation (average distance from mean). np.var() is variance (std squared). By default, these use N in the denominator; for sample statistics, use ddof=1.

Percentiles: np.percentile(data, 25) finds the value below which 25% of data falls. Median is the 50th percentile. The interquartile range (IQR) is percentile(data, 75) - percentile(data, 25).

Cumulative operations: np.cumsum() returns running totals - each element is the sum of all previous elements plus itself. np.cumprod() does the same for products. Great for calculating cumulative distributions or running balances.

Element-wise comparison: Operators like >, <, ==, != compare arrays element-by-element, returning a boolean array. This is the foundation for boolean indexing and filtering.

Aggregated checks: np.all(condition) returns True only if ALL elements satisfy the condition. np.any(condition) returns True if ANY element satisfies it. Useful for validation: np.all(arr > 0) checks if all values are positive.

np.where(): A powerful conditional selector. np.where(condition, x, y) returns x where condition is True, y where False. If x and y are arrays, it picks element-by-element. With just condition, it returns indices where True.

np.clip(): Restricts values to a range. np.clip(arr, min, max) replaces values below min with min, above max with max. Perfect for bounding data or preventing overflow in calculations.

np.union1d(a, b): Returns all unique elements that appear in either array a OR array b (or both). Like the mathematical set union (A ∪ B). The result is always sorted and contains no duplicates.

The "1d" suffix: All set operations have "1d" in their name because they work on 1D arrays. If you pass a 2D array, it gets flattened first. This is different from most NumPy functions that preserve dimensions.

np.intersect1d(a, b): Returns elements that appear in BOTH arrays (A ∩ B). Here, 3, 4, and 5 are in both a and b. The result is sorted and unique.

Real-world use: Finding common customers between two stores, overlapping skills between job candidates, or shared features between datasets. Intersection helps identify what two groups have in common.

np.setdiff1d(a, b): Returns elements in a that are NOT in b (A - B). Order matters! setdiff1d(a, b) gives [1, 2] but setdiff1d(b, a) would give [6, 7]. Think of it as "what's exclusive to the first array?"

np.setxor1d(a, b): Symmetric difference - elements in either array but NOT in both (A △ B). It's like union minus intersection. Here we get [1, 2] from a-only and [6, 7] from b-only, but not 3, 4, 5 which appear in both.

np.isin(elements, test_array): Checks each element of the first argument against the second array. Returns a boolean array of the same shape as the first argument. Here, 1 is in a (True), 2 is in a (True), 6 is not in a (False).

Filtering use case: Combine with boolean indexing: data[np.isin(data['category'], allowed_categories)] keeps only rows with valid categories. Much faster than Python loops for large datasets.

np.inf (Infinity): Represents positive infinity - a value larger than any finite number. np.inf > 1e308 is True because infinity beats even the largest float. -np.inf is negative infinity (smaller than any finite number).

When infinity appears: Division by zero with floats gives infinity (1.0 / 0.0 = inf). Overflow in calculations can produce infinity. It's also useful as an initial value: min_val = np.inf ensures any real number will be smaller.

np.nan (Not a Number): Represents missing, undefined, or invalid values. Common sources: 0/0, inf - inf, or reading missing data from files. NaN is a float value, so integer arrays can't contain NaN (use masked arrays instead).

The NaN trap: np.nan == np.nan is FALSE by IEEE standard! This catches many beginners. Never use == np.nan to check for NaN. Always use np.isnan(value) which correctly identifies NaN values.

NaN propagation: Regular NumPy functions "propagate" NaN - if any element is NaN, the result is NaN. np.mean([1, nan, 3]) returns nan, not 2. This can silently corrupt your calculations!

NaN-safe functions: Functions prefixed with "nan" ignore NaN values: nanmean, nansum, nanstd, nanvar, nanmin, nanmax, nanargmin, nanargmax. They compute statistics using only the valid (non-NaN) values.

Replacing NaN: Use boolean indexing with np.isnan() to find and replace NaN values. arr[np.isnan(arr)] = 0 replaces all NaN with 0. Choose a replacement that makes sense for your data (0, mean, median, etc.).

np.nan_to_num(): A convenient function that replaces NaN and infinity in one call. You can specify custom replacement values for nan, positive infinity (posinf), and negative infinity (neginf). Great for cleaning data before further processing.

Validation functions: np.isfinite() returns True only for "normal" numbers - not NaN and not infinity. np.isinf() detects both positive and negative infinity. np.isnan() detects NaN values.

Data cleaning pattern: Before calculations, validate your data: if not np.all(np.isfinite(data)): handle_bad_data(). This catches NaN and infinity early, preventing mysterious bugs in downstream calculations.

The reshape method transforms a 1D array into any compatible multi-dimensional shape. When you call reshape(3, 4), you're asking NumPy to arrange 12 elements into 3 rows and 4 columns. The total number of elements must remain the same—12 elements can become 3×4, 4×3, 2×6, 6×2, or any other combination that multiplies to 12.

Reshaping creates a "view" of the original data when possible, meaning both arrays share the same memory. This is extremely efficient because no data is copied. However, it also means changes to one array may affect the other. Understanding this behavior is crucial when working with large datasets where memory efficiency matters.

The -1 placeholder is a powerful shortcut that tells NumPy to automatically calculate the missing dimension based on the array's total size. When you specify reshape(2, -1) for a 12-element array, NumPy figures out that -1 must be 6 (since 2 × 6 = 12). This is especially useful when processing batches of data where one dimension might vary.

You can only use one -1 in a reshape call—NumPy can solve for one unknown dimension, but not multiple. This feature is commonly used in machine learning pipelines where you might know you want a certain batch size but want the other dimensions calculated automatically based on the input data shape.

When you need to convert a multi-dimensional array back to 1D, NumPy offers two methods with different behaviors. flatten() always creates a completely new copy of the data, guaranteeing independence from the original array. This is safer when you need to modify the flattened array without affecting the original.

ravel() is more memory-efficient because it returns a view when the array's memory layout allows it. A view shares memory with the original, so changes propagate between them. Use ravel() for read-only operations or when memory is constrained, and flatten() when you need guaranteed independence between the arrays.

np.newaxis is a special index that inserts a new dimension of size 1 at the specified position. When you write arr[np.newaxis, :], you're adding a dimension at the front, converting a 1D array of shape (3,) into a 2D row vector of shape (1, 3). Conversely, arr[:, np.newaxis] adds a dimension at the end, creating a column vector of shape (3, 1).

This technique is essential for broadcasting operations. When you need to perform calculations between arrays of different dimensions, adding dimensions with newaxis allows NumPy to properly align and broadcast the arrays. It's commonly used when you need to treat a 1D array as either a row or column vector for matrix operations.

Transposing is a fundamental operation that swaps the rows and columns of a matrix. Our original array has 2 rows and 3 columns, giving it shape (2, 3). This is a common arrangement for data where each row might represent a sample and each column represents a feature. Understanding shape is crucial before transposing.

In NumPy, shape is always represented as a tuple showing the size of each dimension. For 2D arrays, the first number is rows and the second is columns. When working with higher-dimensional arrays (3D, 4D, etc.), each position in the shape tuple represents the size along that axis.

The .T attribute is the simplest way to transpose a 2D array. What was previously at position [i, j] is now at position [j, i]. Our 2×3 matrix becomes a 3×2 matrix—the first row [1, 2, 3] becomes the first column [1, 4], and similarly for other elements. This operation is essential for matrix multiplication and many machine learning algorithms.

Like reshape, transpose returns a view of the original data, not a copy. This means it's very fast and memory-efficient, but modifications to the transposed array will affect the original. Transpose is commonly used when you need to switch between row-major and column-major data formats or when preparing data for specific mathematical operations.

For arrays with more than 2 dimensions, .T simply reverses all axes, which isn't always what you want. The transpose() method allows you to specify exactly how axes should be reordered. The argument (1, 0, 2) means: put axis 1 first, axis 0 second, and axis 2 last. This transforms shape (2, 3, 4) into (3, 2, 4).

This precise control is essential in deep learning when working with batches of images or sequences. Different frameworks expect different axis orderings—some want (batch, channels, height, width) while others want (batch, height, width, channels). The transpose method lets you convert between these formats efficiently without copying data.

Combining arrays is a common operation when you need to merge data from different sources or build larger datasets from smaller pieces. Here we create two 2×2 matrices that we'll combine in different ways. Array 'a' contains values 1-4 and array 'b' contains values 5-8.

Before combining arrays, they must have compatible shapes along the non-joining axes. For vertical stacking, columns must match; for horizontal stacking, rows must match. Understanding these requirements prevents common errors when working with real-world data of varying shapes.

vstack (vertical stack) combines arrays by placing them on top of each other, essentially adding more rows. Our two 2×2 arrays become one 4×2 array. Think of it like stacking papers on a desk—each array becomes a new section of rows in the combined result.

This operation is equivalent to concatenating along axis 0 (the row axis). It's commonly used when you have data in separate batches and need to combine them into a single dataset, such as when loading training data from multiple files or accumulating results from iterative processing.

hstack (horizontal stack) combines arrays by placing them side by side, adding more columns. Our two 2×2 arrays become one 2×4 array. The first row of the result contains the first rows of both input arrays joined together, and similarly for subsequent rows.

This operation is equivalent to concatenating along axis 1 (the column axis). It's useful when you have different features stored in separate arrays and need to combine them into a single feature matrix, such as when merging datasets that share the same samples but have different measurements.

np.concatenate is the general-purpose function that works along any axis you specify. With axis=0, it behaves like vstack; with axis=1, like hstack. This explicit control is clearer when working with higher-dimensional arrays where "vertical" and "horizontal" become ambiguous.

dstack (depth stack) adds a third dimension, stacking arrays "behind" each other. Two 2×2 arrays become a 2×2×2 3D array. This is useful in image processing where you might stack color channels, or in time series analysis where you stack multiple timesteps together.

Splitting is the inverse of stacking—it divides one array into multiple smaller arrays. Here we create a 4×4 array containing values 0 through 15, which gives us a nice symmetric shape that can be split evenly in multiple ways.

Splitting is commonly used when you need to divide data into training and testing sets, process large arrays in chunks that fit in memory, or extract specific portions of a dataset for separate analysis. NumPy provides several splitting functions optimized for different use cases.

vsplit (vertical split) divides an array into multiple sub-arrays along the row axis. When you pass the number 2, it splits into 2 equal parts—the top half and bottom half. The 4-row array becomes two 2-row arrays. The number of rows must be evenly divisible by the split count.

This function returns a list of arrays that you can unpack directly into variables. It's useful for separating header rows from data rows, dividing images into top and bottom sections, or creating train/test splits where you want an exact split ratio.

hsplit (horizontal split) divides an array along the column axis. Splitting our 4×4 array into 2 parts gives us two 4×2 arrays—the left columns and the right columns. Each row is effectively cut in half, with the first two columns going to 'left' and the last two to 'right'.

This is useful when different columns represent different types of data that need separate processing. For example, you might split a matrix to separate features from labels, or divide a wide dataset into chunks for parallel processing.

The general split() function allows you to specify exactly where to cut the array using index positions. The indices [1, 3] create cuts before row 1 and before row 3, resulting in three pieces: rows 0 (before index 1), rows 1-2 (between indices 1 and 3), and row 3 (from index 3 to the end).

This flexibility is essential when you need unequal splits. Unlike vsplit and hsplit which require equal divisions, split() lets you extract specific portions of your data. The axis parameter controls whether you're splitting rows (axis=0) or columns (axis=1), making it versatile for any splitting scenario.

np.repeat() duplicates each individual element a specified number of times. When you repeat [1, 2, 3] by 3, each element appears three times consecutively: 1 appears three times, then 2 appears three times, then 3 appears three times. The result is a longer array where elements are grouped together.

This is useful for creating expanded datasets, upsampling data, or preparing arrays for broadcasting operations. For example, if you have category labels and need to duplicate them to match the length of a detailed dataset, repeat() handles this efficiently.

np.tile() duplicates the entire array as a unit, like laying floor tiles. When you tile [1, 2, 3] by 3, the complete array is repeated three times in sequence: [1, 2, 3] then [1, 2, 3] then [1, 2, 3]. The pattern of the original array is preserved and repeated.

The key difference from repeat is what gets duplicated: repeat duplicates individual elements, while tile duplicates the whole array structure. Tile is commonly used to create periodic patterns, replicate templates across larger spaces, or build matrices with repeating block structures.

For multi-dimensional arrays, tile() accepts a tuple specifying how many times to repeat along each axis. The tuple (2, 3) means: repeat 2 times vertically (along rows) and 3 times horizontally (along columns). A 2×2 array tiled (2, 3) becomes a 4×6 array—2×2 = 4 rows, 2×3 = 6 columns.

This 2D tiling creates a checkerboard-like pattern where your original array appears 6 times (2 rows × 3 columns of tiles). It's extremely useful in image processing for creating texture patterns, in numerical simulations for building periodic boundary conditions, or in any application requiring regular repeating structures.

np.insert() adds new values at a specified position in the array. The three arguments are: the original array, the index position where insertion starts, and the values to insert. When you insert [10, 11] at index 2, the existing elements from index 2 onward shift to the right to make room.

Importantly, insert() returns a new array—it doesn't modify the original. This is because NumPy arrays have fixed sizes after creation. Creating a new array ensures you always know exactly what you're working with, avoiding unexpected mutations that could cause bugs in complex code.

np.delete() removes elements at specified indices. You can pass a single index or a list of indices to remove multiple elements at once. Deleting indices 1 and 3 from [1, 2, 3, 4, 5] removes the second element (2) and fourth element (4), leaving [1, 3, 5].

Like insert, delete returns a new array rather than modifying in place. This is by design—NumPy's contiguous memory layout means you can't simply remove elements without reallocating the entire array. When deleting many elements, it's more efficient to use boolean masking, which we covered in the indexing section.

np.append() adds values to the end of an array, similar to Python list's append but with different behavior. It concatenates the new values to the original array and returns a completely new array. The original remains unchanged, and the result contains all original elements followed by the appended values.

A critical performance note: repeatedly appending to arrays in a loop is very slow because each append creates a new array. If you need to build an array incrementally, use a Python list for accumulation, then convert to NumPy once at the end. Or better, preallocate the full array if you know the final size.

For 2D arrays, adding rows or columns is typically done with stacking functions rather than insert. Here we add a new row to a matrix using vstack. The new_row is shaped as (1, 3)—a 2D array with one row—to match the structure of the original matrix. This ensures proper alignment when stacking.

The general principle for array modification is: use insert/delete for 1D arrays when you need precise index control, and use stacking functions (vstack, hstack, concatenate) for 2D and higher arrays. These functions are more intuitive for multi-dimensional data and clearly express your intent to add rows or columns.

When you use the * operator between two NumPy arrays, you get element-wise multiplication—each element at position [i, j] in the first array is multiplied by the element at the same position in the second array. So A[0,0] × B[0,0] = 1 × 5 = 5, A[0,1] × B[0,1] = 2 × 6 = 12, and so on.

This is fundamentally different from mathematical matrix multiplication. Element-wise multiplication requires arrays of the same shape (or broadcastable shapes), while matrix multiplication follows different rules. Many beginners confuse these operations, so always be explicit about which one you need.

True matrix multiplication follows linear algebra rules: each element in the result is the dot product of a row from the first matrix with a column from the second. For result[0,0] = 19, we compute 1×5 + 2×7 = 5 + 14 = 19. The inner dimensions must match: an (m×n) matrix times an (n×p) matrix produces an (m×p) result.

NumPy provides three ways to perform matrix multiplication: the @ operator (most readable and recommended since Python 3.5), np.matmul() function, and np.dot(). For 2D arrays, they're equivalent. The @ operator is preferred because it clearly communicates intent and matches mathematical notation.

For 1D arrays (vectors), np.dot() computes the dot product—the sum of element-wise products. It multiplies corresponding elements and adds them together: 1×4 + 2×5 + 3×6 = 4 + 10 + 18 = 32. The result is a single scalar value, not an array.

The dot product measures how similar two vectors are in direction and magnitude. It's fundamental in machine learning: computing similarities, projections, and is the core operation inside neural networks. A dot product of zero means the vectors are perpendicular (orthogonal).

The determinant is a single number that captures important properties of a square matrix. It tells you whether the matrix is invertible (determinant ≠ 0), how the matrix scales area/volume (|det| is the scaling factor), and whether it flips orientation (negative det means reflection).

For a 2×2 matrix [[a,b],[c,d]], the determinant is ad - bc. For larger matrices, the calculation is more complex but np.linalg.det() handles it efficiently. In machine learning, determinants appear in multivariate Gaussian distributions and regularization techniques.

The trace is simply the sum of diagonal elements (1 + 5 + 10 = 16). Despite its simplicity, trace has useful properties: it equals the sum of eigenvalues and is invariant under cyclic permutations of matrix products. It appears in regularization and optimization algorithms.

Matrix rank tells you the number of linearly independent rows (or columns). A 3×3 matrix with rank 3 has "full rank"—all rows/columns are independent. If rank is less than matrix dimensions, some rows/columns are linear combinations of others, which affects whether systems of equations have unique solutions.

The matrix inverse A⁻¹ is the matrix that, when multiplied by A, produces the identity matrix (1s on diagonal, 0s elsewhere). Only square matrices with non-zero determinant have inverses. Computing A @ A_inv should give the identity matrix, verifying the inverse is correct.

While you can solve Ax = b using x = A⁻¹ @ b, this is generally not recommended. Computing the inverse is expensive and can introduce numerical errors. For solving equations, use np.linalg.solve() instead—it's faster and more numerically stable.

Systems of linear equations appear everywhere in science and engineering. Here we have two equations with two unknowns (x and y). In matrix form, this becomes Ax = b, where A contains the coefficients, x is the vector of unknowns, and b contains the constants on the right side.

Setting up the problem correctly is crucial: each row of matrix A corresponds to one equation's coefficients, and the corresponding element in b is that equation's constant. The order of variables must be consistent across all equations.

np.linalg.solve() finds the values of unknowns that satisfy all equations simultaneously. The function uses efficient algorithms (LU decomposition internally) that are both faster and more numerically stable than computing A⁻¹ and multiplying by b.

The solution tells us x=1 and y=2 satisfy both equations. You could verify by hand: 2(1) + 3(2) = 8 ✓ and 4(1) + 5(2) = 14 ✓. This technique scales to systems with hundreds or thousands of equations—problems that would be impossible to solve by hand.

Always verify your solution by computing A @ x and checking it equals b. Due to floating-point arithmetic, you might get values like [7.9999999, 14.0000001] instead of exact integers—this is normal and acceptable for numerical computing.

If np.linalg.solve() raises a "Singular matrix" error, it means the system has no unique solution—either no solution exists (inconsistent equations) or infinitely many solutions exist (dependent equations). Check your matrix rank or use least-squares methods for such cases.

Eigenvalues and eigenvectors reveal the fundamental behavior of a matrix transformation. When a matrix multiplies an eigenvector, the result is simply the eigenvector scaled by the eigenvalue—the direction doesn't change, only the magnitude. This special property makes eigenvectors the "natural axes" of the transformation.

Understanding this concept is essential for Principal Component Analysis (PCA), Google's PageRank algorithm, quantum mechanics, and many machine learning techniques. The eigenvectors point in directions of maximum variance or importance in your data.

np.linalg.eig() returns two arrays: eigenvalues (a 1D array of scalars) and eigenvectors (a 2D array where each COLUMN is an eigenvector). This column-based format is important—eigenvectors[:, 0] gives the first eigenvector corresponding to eigenvalues[0].

The eigenvalues [5, 2] tell us the matrix stretches by a factor of 5 along one eigenvector direction and by a factor of 2 along the other. In PCA, you'd typically sort eigenvalues in descending order and use the eigenvectors corresponding to the largest eigenvalues as your principal components.

The defining equation for eigenvectors is Av = λv, where A is the matrix, v is an eigenvector, and λ (lambda) is the corresponding eigenvalue. This verification loop confirms that multiplying the matrix by each eigenvector produces the same result as scaling the eigenvector by its eigenvalue.

When both expressions produce identical results (within floating-point precision), you've confirmed the eigenvector relationship. This property is what makes eigenvectors so useful—complex matrix operations reduce to simple scalar multiplication along these special directions.

The L2 norm (also called Euclidean norm) measures the straight-line length of a vector. For a 2D vector [3, 4], it's √(3² + 4²) = √(9 + 16) = √25 = 5. This is the classic distance formula you learned in geometry—the hypotenuse of a right triangle.

By default, np.linalg.norm() computes the L2 norm because it's the most commonly used. It measures the "magnitude" of a vector and is fundamental to normalizing vectors (making them unit length), computing distances, and many machine learning loss functions.

The L1 norm (Manhattan distance) sums absolute values: |3| + |4| = 7. It's called Manhattan distance because it measures distance as if walking on a grid of city blocks—you can only move horizontally or vertically, not diagonally. L1 regularization in ML (Lasso) promotes sparsity by driving some weights to exactly zero.

The L∞ norm (infinity norm or max norm) returns the largest absolute value: max(|3|, |4|) = 4. It measures the largest component of the vector. In ML, L∞ bounds ensure no single weight grows too large, providing different regularization properties than L1 or L2.

To find the distance between two points, compute the vector from one to the other (p2 - p1), then take its norm. Here, p2 - p1 = [4-1, 6-2] = [3, 4], and we already know the norm of [3, 4] is 5. This is the standard Euclidean distance formula: √((x₂-x₁)² + (y₂-y₁)²).

This pattern extends to any number of dimensions. In machine learning, you'll compute distances between feature vectors to find nearest neighbors, measure clustering quality, or compute similarity scores. The same formula works for 2D, 3D, or 1000-dimensional spaces.