NumPy cheatsheet

NumPy is the fundamental package for scientific computing with Python. This cheat sheet provides a production-grade reference for NumPy ≥2.0 with emphasis on performance, memory efficiency, and advanced array operations.

#Getting Started

#Import Convention

import numpy as np

# For performance-critical code
np.set_printoptions(precision=4, suppress=True, linewidth=120)

# Enable error handling for floating point
np.seterr(divide='raise', over='raise', under='ignore', invalid='raise')

#Array Creation

Description	Code
From Python list	`np.array([1, 2, 3])`
From Python list of lists	`np.array([(1, 2, 3), (4, 5, 6)])`
Zeros array	`np.zeros((3, 4), dtype=np.float64)`
Ones array	`np.ones((2, 3), dtype=np.int64)`
Identity matrix	`np.eye(5, dtype=np.float32)`
Diagonal array	`np.diag([1, 2, 3])`
Full array	`np.full((2, 3), 8, dtype=np.float64)`
Empty (uninitialized)	`np.empty((3, 3), dtype=np.float64)`
Evenly spaced range	`np.linspace(0, 100, 6, dtype=np.float64)`
Arithmetic range	`np.arange(0, 10, 3)`
Log-spaced	`np.logspace(0, 3, 4, base=10)`
From function	`np.fromfunction(lambda i, j: i + j, (3, 3))`
From string	`np.fromstring('1 2 3', dtype=int, sep=' ')`

#Random Arrays

Description	Code
Uniform [0,1)	`np.random.rand(4, 5)`
Uniform [low, high)	`np.random.uniform(0, 100, (4, 5))`
Standard normal	`np.random.randn(4, 5)`
Normal (mean, std)	`np.random.normal(0, 1, (4, 5))`
Integers [low, high)	`np.random.randint(0, 10, (2, 3))`
Random choice	`np.random.choice([1, 2, 3, 4, 5], size=3, replace=False)`
Shuffle in-place	`np.random.shuffle(arr)`
Permutation	`np.random.permutation(10)`
Random seed	`np.random.seed(42)`
Generator (new API)	`rng = np.random.default_rng(seed=42); rng.random((3, 3))`

#Array Properties

#Attributes

Description	Code
Shape (dimensions)	`arr.shape`
Number of elements	`arr.size`
Number of dimensions	`arr.ndim`
Data type	`arr.dtype`
Item size (bytes)	`arr.itemsize`
Total memory (bytes)	`arr.nbytes`
Strides (memory layout)	`arr.strides`
Base (view check)	`arr.base` is not None
C-contiguous	`arr.flags['C_CONTIGUOUS']`
F-contiguous	`arr.flags['F_CONTIGUOUS']`

#Type Conversion

Description	Code
Convert dtype	`arr.astype(np.float32)`
To Python list	`arr.tolist()`
To bytes	`arr.tobytes()`
To file	`arr.tofile('data.bin')`
To string	`np.array2string(arr, precision=2)`
View as different dtype	`arr.view(np.int32)`

#Indexing & Slicing

#Basic Indexing

Description	Code
Single element	`arr[5]`
2D element	`arr[2, 5]`
Single assignment	`arr[1] = 4`
2D assignment	`arr[1, 3] = 10`
Slice (rows 0,1,2)	`arr[0:3]`
Slice (rows 0,1,2, col 4)	`arr[0:3, 4]`
First two rows	`arr[:2]`
All rows, column 1	`arr[:, 1]`
Row 0, all columns	`arr[0, :]`
Step slice	`arr[0:10:2]`
Negative indexing	`arr[-1]`, `arr[-3:]`
Ellipsis (multiple dims)	`arr[..., 1]`

#Boolean Indexing

Description	Code
Boolean mask	`arr < 5`
Multiple conditions	`(arr1 < 3) & (arr2 > 5)`
OR condition	`(arr1 < 3) \\| (arr2 > 5)`
Invert	`~arr`
Filter with condition	`arr[arr < 5]`
Where (select)	`np.where(arr < 5, arr, 0)`
Where (indices)	`np.where(arr < 5)`
Extract	`np.extract(arr < 5, arr)`

#Fancy Indexing

Description	Code
Integer list	`arr[[1, 3, 5]]`
2D integer list	`arr[[0, 1], [0, 1]]`
Using np.ix_	`arr[np.ix_([0, 2], [0, 2])]`
Select with conditions	`arr[np.where(arr > 0)]`
Clip values	`np.clip(arr, 0, 1)`
Put values	`np.put(arr, [0, 2], [10, 20])`
Take values	`np.take(arr, [0, 2])`

#Advanced Indexing

Description	Code
Index as array	`arr[[0, 1, 2], [0, 1, 0]]`
Index with masks	`arr[arr > 0.5] = 1`
Complex condition	`arr[(arr > 0.2) & (arr < 0.8)]`
Choose from arrays	`np.choose(selector, [arr1, arr2])`
Diagonal selection	`np.diagonal(arr, offset=0)`
Trace	`np.trace(arr)`

#Shape Operations

#Reshaping

Description	Code
Reshape (new view if possible)	`arr.reshape(3, 4)`
Resize (in-place, may fill)	`arr.resize((5, 6))`
Flatten (C-order)	`arr.flatten()`
Flatten (F-order)	`arr.flatten('F')`
Ravel (view when possible)	`arr.ravel()`
Transpose	`arr.T`
Transpose with axes	`arr.transpose(1, 0, 2)`
Swap axes	`arr.swapaxes(0, 1)`
Move axis	`np.moveaxis(arr, 0, -1)`
Expand dims	`np.expand_dims(arr, axis=0)`
Squeeze (remove size 1 dims)	`np.squeeze(arr)`
Broadcast to shape	`np.broadcast_to(arr, (3, 5, 5))`

#Adding/Removing Dimensions

Description	Code
New axis (view)	`arr[np.newaxis, :]`
New axis (at end)	`arr[:, np.newaxis]`
Expand dims	`np.expand_dims(arr, 1)`
Remove singleton dims	`arr.squeeze(axis=0)`
Concatenate	`np.concatenate([arr1, arr2], axis=0)`
Stack (new axis)	`np.stack([arr1, arr2], axis=0)`
Vertical stack	`np.vstack([arr1, arr2])`
Horizontal stack	`np.hstack([arr1, arr2])`
Column stack	`np.column_stack([arr1, arr2])`
Tile (repeat)	`np.tile(arr, (2, 3))`
Repeat each element	`np.repeat(arr, 3, axis=0)`

#Splitting

Description	Code
Split into N equal parts	`np.split(arr, 3)`
Split by indices	`np.split(arr, [2, 5])`
Horizontal split	`np.hsplit(arr, 5)`
Vertical split	`np.vsplit(arr, 3)`
Depth split (3D)	`np.dsplit(arr, 3)`
Array split (unequal)	`np.array_split(arr, 3)`

#Element-wise Operations

#Arithmetic

Description	Code
Addition	`np.add(arr1, arr2)` or `arr1 + arr2`
Subtraction	`np.subtract(arr1, arr2)` or `arr1 - arr2`
Multiplication	`np.multiply(arr1, arr2)` or `arr1 * arr2`
Division	`np.divide(arr1, arr2)` or `arr1 / arr2`
Floor division	`np.floor_divide(arr1, arr2)` or `arr1 // arr2`
Power	`np.power(arr1, arr2)` or `arr1 ** arr2`
Modulo	`np.mod(arr1, arr2)` or `arr1 % arr2`
Negative	`np.negative(arr)` or `-arr`
Absolute	`np.abs(arr)`
Sign	`np.sign(arr)`

#Mathematical Functions

Description	Code
Square root	`np.sqrt(arr)`
Exponential	`np.exp(arr)`
Natural log	`np.log(arr)`
Log base 10	`np.log10(arr)`
Log base 2	`np.log2(arr)`
Sin/Cos/Tan	`np.sin(arr)`, `np.cos(arr)`, `np.tan(arr)`
Arcsin/Arccos/Arctan	`np.arcsin(arr)`, `np.arccos(arr)`, `np.arctan(arr)`
Hyperbolic	`np.sinh(arr)`, `np.cosh(arr)`, `np.tanh(arr)`
Rounding	`np.round(arr, decimals=2)`
Ceiling	`np.ceil(arr)`
Floor	`np.floor(arr)`
Truncate	`np.trunc(arr)`
Degrees to radians	`np.radians(arr)`
Radians to degrees	`np.degrees(arr)`

#Comparison & Logic

Description	Code
Equal	`np.equal(arr1, arr2)` or `arr1 == arr2`
Not equal	`np.not_equal(arr1, arr2)` or `arr1 != arr2`
Less than	`np.less(arr1, arr2)` or `arr1 < arr2`
Greater than	`np.greater(arr1, arr2)` or `arr1 > arr2`
Less/equal	`np.less_equal(arr1, arr2)` or `arr1 <= arr2`
Greater/equal	`np.greater_equal(arr1, arr2)` or `arr1 >= arr2`
Logical AND	`np.logical_and(arr1, arr2)`
Logical OR	`np.logical_or(arr1, arr2)`
Logical NOT	`np.logical_not(arr)`
Logical XOR	`np.logical_xor(arr1, arr2)`
Is finite	`np.isfinite(arr)`
Is nan	`np.isnan(arr)`
Is inf	`np.isinf(arr)`

#Aggregation & Statistics

#Reductions

Description	Code
Sum (all)	`np.sum(arr)`
Sum (axis)	`np.sum(arr, axis=0)`
Mean	`np.mean(arr)`
Mean (axis)	`np.mean(arr, axis=1)`
Median	`np.median(arr)`
Min/Max	`np.min(arr)`, `np.max(arr)`
Min/Max (axis)	`np.min(arr, axis=0)`, `np.max(arr, axis=1)`
Standard deviation	`np.std(arr)`
Variance	`np.var(arr)`
Percentile	`np.percentile(arr, 75)`
Quantile	`np.quantile(arr, 0.75)`
Cumulative sum	`np.cumsum(arr)`
Cumulative product	`np.cumprod(arr)`
Dot product	`np.dot(arr1, arr2)`
Inner product	`np.inner(arr1, arr2)`
Outer product	`np.outer(arr1, arr2)`

#Statistical Functions

Description	Code
Correlation coefficient	`np.corrcoef(arr1, arr2)`
Covariance	`np.cov(arr1, arr2)`
Cross-correlation	`np.correlate(arr1, arr2, mode='full')`
Convolution	`np.convolve(arr1, arr2, mode='full')`
Histogram	`np.histogram(arr, bins=10)`
Bincount	`np.bincount(arr.astype(int))`
Unique values	`np.unique(arr)`
Unique with counts	`np.unique(arr, return_counts=True)`
Count non-zero	`np.count_nonzero(arr)`
Any/All	`np.any(arr > 0)`, `np.all(arr > 0)`

#Linear Algebra

#Matrix Operations

Description	Code
Matrix multiplication	`np.matmul(A, B)` or `A @ B`
Dot product	`np.dot(A, B)`
Inner product	`np.inner(A, B)`
Outer product	`np.outer(A, B)`
Trace	`np.trace(A)`
Determinant	`np.linalg.det(A)`
Rank	`np.linalg.matrix_rank(A)`
Condition number	`np.linalg.cond(A)`

#Matrix Decompositions

Description	Code
Inverse	`np.linalg.inv(A)`
Pseudo-inverse	`np.linalg.pinv(A)`
Eigenvalues/vectors	`np.linalg.eig(A)`
Eigenvalues (only)	`np.linalg.eigvals(A)`
SVD	`np.linalg.svd(A)`
QR decomposition	`np.linalg.qr(A)`
LU decomposition	`np.linalg.lu(A)`
Cholesky decomposition	`np.linalg.cholesky(A)`

#Solving Systems

Description	Code
Solve linear system	`np.linalg.solve(A, b)`
Least squares	`np.linalg.lstsq(A, b)`
Norm (Euclidean)	`np.linalg.norm(A)`
Norm (specific order)	`np.linalg.norm(A, ord=1)`
Singular values	`np.linalg.svdvals(A)`

#Broadcasting & Vectorization

#Broadcasting Rules

Description	Code
Scalar + array	`arr + 1`
1D + 2D	`arr2d + arr1d`
Matching trailing dims	`arr2d + arr1d.reshape(-1, 1)`
Check broadcast	`np.broadcast_shapes((2,3), (3,))`
Explicit broadcast	`np.broadcast_to(arr1d, (3, 4))`
Broadcasting in ufunc	`np.add(arr2d, arr1d)`

#Vectorization Patterns

Description	Code
Vectorized addition	`arr1 + arr2` (instead of loop)
Vectorized condition	`np.where(cond, arr1, arr2)`
Vectorized selection	`arr[mask]`
Vectorized accumulation	`np.cumsum(arr)`
Element-wise operations	`np.sqrt(arr)`
Reduce operations	`np.sum(arr)`
Universal functions	`np.exp(arr)`, `np.log(arr)`

#Memory & Performance

#Memory Management

Description	Code
View vs copy	`arr_view = arr[:]` (view); `arr_copy = arr.copy()` (copy)
Check ownership	`arr.base is None` (own memory)
Share memory check	`np.shares_memory(arr1, arr2)`
Memory alignment	`np.array(arr, copy=False, order='C')`
Memory layout	`np.ascontiguousarray(arr)`
Fortran order	`np.asfortranarray(arr)`
Byteswap	`arr.byteswap(inplace=True)`

#Performance Optimization

Description	Code
Preallocate	`np.empty((N,))`
Use local variables	`np_add = np.add`
Avoid Python loops	Use NumPy vectorized operations
Out-of-place operations	`np.add(arr1, arr2, out=result)`
Use in-place	`arr += 1` (less memory)
Reduce allocations	Reuse arrays with `out=` parameter
Use float32 if possible	`np.float32` instead of `np.float64`
Use memory-mapped files	`np.memmap('data.dat', dtype='float32', mode='r', shape=(1000, 1000))`

#Input/Output

#Text Files

Description	Code
Load text	`np.loadtxt('file.txt', delimiter=' ')`
Load CSV	`np.genfromtxt('file.csv', delimiter=',', skip_header=1)`
Load with missing values	`np.genfromtxt('file.csv', delimiter=',', filling_values=0)`
Save text	`np.savetxt('file.txt', arr, delimiter=' ', fmt='%.4f')`
Save CSV	`np.savetxt('file.csv', arr, delimiter=',', fmt='%.4f')`

#Binary Files

Description	Code
Load .npy	`np.load('file.npy')`
Save .npy	`np.save('file.npy', arr)`
Load .npz (multiple arrays)	`data = np.load('file.npz'); data['arr1']`
Save .npz	`np.savez('file.npz', arr1=arr1, arr2=arr2)`
Save compressed .npz	`np.savez_compressed('file.npz', arr1=arr1, arr2=arr2)`
Binary to file	`arr.tofile('data.bin')`
Read from file	`np.fromfile('data.bin', dtype=np.float32)`
Memory-mapped	`arr = np.memmap('data.dat', dtype='float32', mode='r', shape=(100, 100))`

#Data Types

Description	Code
Integer types	`np.int8`, `np.int16`, `np.int32`, `np.int64`
Unsigned ints	`np.uint8`, `np.uint16`, `np.uint32`, `np.uint64`
Floating types	`np.float16`, `np.float32`, `np.float64`, `np.float128`
Complex types	`np.complex64`, `np.complex128`
Boolean	`np.bool_`
Object	`np.object_`
String	`np.string_`, `np.unicode_`
Datetime	`np.datetime64`, `np.timedelta64`
Structured dtypes	`np.dtype([('name', 'U10'), ('age', 'i4')])`

#Structured Arrays

Description	Code
Create structured	`np.array([(1, 'Alice'), (2, 'Bob')], dtype=[('id','i4'), ('name','U10')])`
Access by field	`arr['name']`
Access by position	`arr[0]`
Multiple fields	`arr[['id', 'name']]`
Complex dtype	`np.dtype({'names': ['id','name'], 'formats': ['i4','U10']})`
Recarray (by attribute)	`arr = np.rec.array([(1,'Alice'),(2,'Bob')], dtype=[('id','i4'), ('name','U10')]); arr.name`

#Datetime & Timedelta

Description	Code
Create datetime	`np.datetime64('2026-07-01')`
Array of datetimes	`np.arange('2026-01', '2026-07', dtype='datetime64[M]')`
Timedelta	`np.timedelta64(1, 'D')`
Arithmetic	`np.datetime64('2026-07-01') - np.datetime64('2026-06-01')`
Extract components	`dt.astype('datetime64[Y]')` (year)
Day of week	`(dt.astype('datetime64[D]') - np.datetime64('1970-01-01')).astype('int64') % 7`

#Common Pitfalls & Best Practices

Pitfall	Solution
Copy vs view confusion	Use `arr.copy()` explicitly for independent copy
Mutation of views	Check with `arr.base is not None`
Python loops over arrays	Use vectorized operations instead of loops
Using int64 unnecessarily	Use `np.float32` or `np.int32` for memory efficiency
Mutable default arguments	Avoid `arr=[]` in functions; use `None`
Not specifying dtype	Specify `dtype` for precision control
Using `np.append` in loops	Preallocate array for better performance
Shape mismatch in broadcasting	Check shapes with `arr.shape`
Floating point comparison	Use `np.isclose()` for comparison of floats
Memory leak in large arrays	Use `del arr` or `arr = None` after use
Inconsistent random seeding	Use `np.random.seed(42)` for reproducibility
Using old random API	Use new `np.random.default_rng()` API