A deep roadmap for students and developers across core concepts, interview prep, and the NumPy reference
NumPy Learning Companion
A deep roadmap for students and developers across core concepts, interview prep, and the NumPy reference.
This guide is intentionally written in a way that works in three modes at once:
5 Levels Basics to extremely advanced, with a clear learning ladder.
28 Core Q&A Blocks Each section teaches a concept, then checks understanding.
100 Interview Bank Questions Beginner, intermediate, advanced, and expert revision questions in dropdown format.
Start with Part 1 and Part 2, then revisit Part 3 slowly. Use the dropdown questions after each topic before moving on.
Read each Q&A section in order, then use the “Interview Check” dropdowns as rapid revision prompts for self-testing.
Focus especially on dtypes, views vs copies, reusable API design, testing, interoperability, memory mapping, and numerical edge cases.
No single blog can replace the full NumPy manual, but this one is designed to cover the major user-guide and reference areas that students and practitioners actually need: array creation, indexing, dtypes, broadcasting, copies/views, strings, structured data, ufuncs, logic, sorting, sets, statistics, linear algebra, random sampling, I/O, datetime handling, masked arrays, performance, and a reference map for the rest.
This post is written so you can read it both ways.
import numpy as np
import numpy.ma as ma
import numpy.typing as npt
from tempfile import TemporaryDirectory
from time import perf_counter
rng = np.random.default_rng(42)
np.set_printoptions(suppress=True, precision=3)
print("NumPy version:", np.__version__)NumPy version: 1.24.4If NumPy is missing in your environment:
pip install numpyndarray is, how shape works, and why vectorized arithmetic feels different from Python lists.| Level | Focus | Outcome |
|---|---|---|
| Basics | ndarray basics, shapes, indexing, arithmetic |
Read and create arrays confidently |
| Core | Broadcasting, manipulation, sorting, logic, linear algebra | Solve practical array problems without loops |
| Advanced | Dtypes, views/copies, ufunc internals, strings, structured data, dates, masked arrays, random, I/O | Write cleaner, safer, more advanced NumPy code |
| Expert | API design, testing, interoperability, memory-mapped workflows, sliding windows | Build robust NumPy-heavy codebases and tools |
| Extremely Advanced | Typing, FFT, polynomials, floating-point handling, interoperability map, lower-level ecosystem topics | Navigate the wider NumPy platform with confidence |
ndarray, and why is it the center of the library?Answer: The ndarray is NumPy’s main array object. It is a multi-dimensional container of elements that are usually all the same type.
Why this matters:
python_list = [1, 2, 3, 4]
array_1d = np.array([1, 2, 3, 4], dtype=np.int32)
array_2d = np.array([[1, 2], [3, 4]], dtype=np.float64)
print("Python list type:", type(python_list))
print("NumPy 1D type:", type(array_1d))
print("NumPy 1D dtype:", array_1d.dtype)
print("NumPy 2D shape:", array_2d.shape)
print("Array arithmetic:", array_1d * 2)Python list type: <class 'list'>
NumPy 1D type: <class 'numpy.ndarray'>
NumPy 1D dtype: int32
NumPy 2D shape: (2, 2)
Array arithmetic: [2 4 6 8]The change in operator meaning is a big conceptual shift:
print("List * 2:", python_list * 2)
print("Array * 2:", array_1d * 2)List * 2: [1, 2, 3, 4, 1, 2, 3, 4]
Array * 2: [2 4 6 8]list * 2 repeats a sequence. array * 2 performs elementwise multiplication.
ndarray performance?
Answer: Array creation is broader than np.array(...). The official NumPy docs group creation into several patterns:
zeros, ones, fullarange, linspace, logspace, geomspacemeshgridfrom_list = np.array([10, 20, 30])
as_array = np.asarray((1, 2, 3, 4))
zeros = np.zeros((2, 3))
ones = np.ones((2, 2))
filled = np.full((2, 3), 7)
arange_values = np.arange(0, 10, 2)
linspace_values = np.linspace(0, 1, 5)
logspace_values = np.logspace(0, 3, 4)
identity = np.eye(3)
print("from_list:", from_list)
print("asarray:", as_array)
print("zeros:\n", zeros)
print("ones:\n", ones)
print("full:\n", filled)
print("arange:", arange_values)
print("linspace:", linspace_values)
print("logspace:", logspace_values)
print("eye:\n", identity)from_list: [10 20 30]
asarray: [1 2 3 4]
zeros:
[[0. 0. 0.]
[0. 0. 0.]]
ones:
[[1. 1.]
[1. 1.]]
full:
[[7 7 7]
[7 7 7]]
arange: [0 2 4 6 8]
linspace: [0. 0.25 0.5 0.75 1. ]
logspace: [ 1. 10. 100. 1000.]
eye:
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]Less common but very useful creation tools:
from_iter = np.fromiter((x * x for x in range(6)), dtype=np.int64)
raw_bytes = np.array([100, 200, 300, 400], dtype=np.int16).tobytes()
from_buffer = np.frombuffer(raw_bytes, dtype=np.int16)
x = np.linspace(-1, 1, 3)
y = np.linspace(0, 2, 2)
X, Y = np.meshgrid(x, y)
print("fromiter:", from_iter)
print("frombuffer:", from_buffer)
print("meshgrid X:\n", X)
print("meshgrid Y:\n", Y)fromiter: [ 0 1 4 9 16 25]
frombuffer: [100 200 300 400]
meshgrid X:
[[-1. 0. 1.]
[-1. 0. 1.]]
meshgrid Y:
[[0. 0. 0.]
[2. 2. 2.]]Important distinction:
np.arange(start, stop, step) is step-based.np.linspace(start, stop, num) is count-based.For predictable scientific sampling, linspace is usually safer.
np.linspace over np.arange?
linspace guarantees the count, while arange is step-based and can be awkward with decimal steps.
shape, ndim, size, dtype, itemsize, nbytes, and strides tell me?Answer: These attributes describe the structure of the array before you even inspect the values.
tensor = np.arange(24, dtype=np.float64).reshape(2, 3, 4)
print("tensor:\n", tensor)
print("shape:", tensor.shape)
print("ndim:", tensor.ndim)
print("size:", tensor.size)
print("dtype:", tensor.dtype)
print("itemsize:", tensor.itemsize)
print("nbytes:", tensor.nbytes)
print("strides:", tensor.strides)
print("C contiguous?:", tensor.flags.c_contiguous)
print("F contiguous?:", tensor.flags.f_contiguous)tensor:
[[[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]
[ 8. 9. 10. 11.]]
[[12. 13. 14. 15.]
[16. 17. 18. 19.]
[20. 21. 22. 23.]]]
shape: (2, 3, 4)
ndim: 3
size: 24
dtype: float64
itemsize: 8
nbytes: 192
strides: (96, 32, 8)
C contiguous?: True
F contiguous?: FalseHow to read them:
shape=(2, 3, 4) means two blocks, each with three rows and four columns.ndim=3 means three axes.size=24 means 2 * 3 * 4.itemsize=8 means each float64 uses 8 bytes.nbytes=192 means the raw data block uses 24 x 8 bytes.strides tell NumPy how many bytes to jump in memory when moving along each axis.Students usually ignore strides, but they matter for understanding views, transposes, and performance.
dtype is float64 and the array has 100 elements, how many bytes does the raw data use?
float64 uses 8 bytes per element, so the raw data uses 100 x 8 = 800 bytes.
Answer: NumPy extends Python indexing into multiple dimensions.
: to mean “take everything on this axis.”grid = np.arange(1, 13).reshape(3, 4)
print("grid:\n", grid)
print("Element at row 1, col 2:", grid[1, 2])
print("Last row:", grid[-1])
print("First two rows:\n", grid[:2, :])
print("Second column:", grid[:, 1])
print("Submatrix rows 0:2, cols 1:4:\n", grid[0:2, 1:4])grid:
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
Element at row 1, col 2: 7
Last row: [ 9 10 11 12]
First two rows:
[[1 2 3 4]
[5 6 7 8]]
Second column: [ 2 6 10]
Submatrix rows 0:2, cols 1:4:
[[2 3 4]
[6 7 8]]If you want indexed iteration:
small = grid[:2, :2]
for idx, value in np.ndenumerate(small):
print("Index:", idx, "Value:", value)Index: (0, 0) Value: 1
Index: (0, 1) Value: 2
Index: (1, 0) Value: 5
Index: (1, 1) Value: 6Simple indexing mental model:
grid[:, 1] return?
1, so it is the second column of the array.
Answer: NumPy is strongest at:
sum, mean, min, maxsqrt, exp, sintemperatures_c = np.array([
[21.5, 23.0, 19.8],
[24.1, 22.7, 20.3],
[25.5, 24.8, 21.1]
])
temperatures_f = temperatures_c * 9 / 5 + 32
print("temperatures_c:\n", temperatures_c)
print("temperatures_f:\n", temperatures_f.round(2))
print("mean by row:", temperatures_c.mean(axis=1).round(2))
print("mean by column:", temperatures_c.mean(axis=0).round(2))
print("row sums:", temperatures_c.sum(axis=1).round(2))
print("max value:", temperatures_c.max())temperatures_c:
[[21.5 23. 19.8]
[24.1 22.7 20.3]
[25.5 24.8 21.1]]
temperatures_f:
[[70.7 73.4 67.64]
[75.38 72.86 68.54]
[77.9 76.64 69.98]]
mean by row: [21.43 22.37 23.8 ]
mean by column: [23.7 23.5 20.4]
row sums: [64.3 67.1 71.4]
max value: 25.5And the same array can be pushed through many mathematical functions:
values = np.array([1, 4, 9, 16, 25], dtype=float)
print("sqrt:", np.sqrt(values))
print("log:", np.log(values).round(3))
print("sin:", np.sin(values).round(3))
print("square:", np.square(values))sqrt: [1. 2. 3. 4. 5.]
log: [0. 1.386 2.197 2.773 3.219]
sin: [ 0.841 -0.757 0.412 -0.288 -0.132]
square: [ 1. 16. 81. 256. 625.]The phrase elementwise is fundamental in NumPy. Unless you ask for matrix multiplication or a reduction, NumPy usually works element by element.
axis=0 versus axis=1 on a 2D array?
axis=0 reduces down the rows and gives one result per column. axis=1 reduces across the columns and gives one result per row.
np.array(...) and np.asarray(...)?
np.array(...) can create a new array copy by default more eagerly, while np.asarray(...) mainly converts input into an array without copying when the input is already a compatible NumPy array.
shape usually the first thing you should inspect when debugging NumPy code?
arr.shape == (4, 5), how many rows and columns does it have?
Answer: Broadcasting lets NumPy combine arrays with different shapes when those shapes are compatible.
Two dimensions are compatible if:
1NumPy compares shapes from the rightmost dimension backward.
| Left shape | Right shape | Works? | Result |
|---|---|---|---|
(3, 4) |
(4,) |
Yes | (3, 4) |
(3, 1) |
(1, 4) |
Yes | (3, 4) |
(2, 3) |
(3, 2) |
No | Error |
scores = np.array([
[78, 85, 90],
[88, 79, 92],
[95, 91, 87]
])
bonus = np.array([2, 0, 5])
print("scores:\n", scores)
print("bonus:", bonus)
print("scores + bonus:\n", scores + bonus)scores:
[[78 85 90]
[88 79 92]
[95 91 87]]
bonus: [2 0 5]
scores + bonus:
[[80 85 95]
[90 79 97]
[97 91 92]]Broadcasting with a column vector:
weights = np.array([[1.0], [0.5], [1.5]])
print("weights shape:", weights.shape)
print("scores shape:", scores.shape)
print("scores * weights:\n", scores * weights)weights shape: (3, 1)
scores shape: (3, 3)
scores * weights:
[[ 78. 85. 90. ]
[ 44. 39.5 46. ]
[142.5 136.5 130.5]]Broadcasting often removes the need for manual repetition or loops.
(3, 4) and (4,) broadcast together?
4 matches 4, so the 1D array can be applied across each row of the (3, 4) array.
Answer: The official array-manipulation routines are large, but the first group to master is:
reshapetranspose or .Travelflattensqueezeexpand_dims or np.newaxisswapaxesarr = np.arange(12)
matrix = arr.reshape(3, 4)
column = np.expand_dims(arr[:4], axis=1)
row = arr[:4][np.newaxis, :]
print("matrix:\n", matrix)
print("matrix.T:\n", matrix.T)
print("ravel:", matrix.ravel())
print("flatten:", matrix.flatten())
print("column shape:", column.shape)
print("row shape:", row.shape)matrix:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
matrix.T:
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
ravel: [ 0 1 2 3 4 5 6 7 8 9 10 11]
flatten: [ 0 1 2 3 4 5 6 7 8 9 10 11]
column shape: (4, 1)
row shape: (1, 4)Difference worth remembering:
ravel() tries to return a view when possible.flatten() always returns a copy.Squeezing size-1 axes:
three_d = np.arange(6).reshape(1, 2, 3)
print("before squeeze:", three_d.shape)
print("after squeeze:", np.squeeze(three_d).shape)
print("swapaxes shape:", np.swapaxes(np.arange(24).reshape(2, 3, 4), 0, 2).shape)before squeeze: (1, 2, 3)
after squeeze: (2, 3)
swapaxes shape: (4, 3, 2)Manipulation is mostly about axis control. If you know what each axis means, these operations become easy to reason about.
ravel() and flatten()?
ravel() usually returns a view when possible, while flatten() always returns a new copy.
Answer: Use the function that matches the kind of composition you want.
concatenate joins along an existing axisstack creates a new axissplit breaks arrays apartrepeat duplicates elementstile repeats patternsleft = np.array([[1, 2], [3, 4]])
right = np.array([[5, 6], [7, 8]])
print("concatenate axis=0:\n", np.concatenate([left, right], axis=0))
print("concatenate axis=1:\n", np.concatenate([left, right], axis=1))
print("stack axis=0:\n", np.stack([left, right], axis=0))concatenate axis=0:
[[1 2]
[3 4]
[5 6]
[7 8]]
concatenate axis=1:
[[1 2 5 6]
[3 4 7 8]]
stack axis=0:
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]Splitting:
combined = np.arange(12).reshape(3, 4)
left_half, right_half = np.hsplit(combined, 2)
top, middle, bottom = np.vsplit(combined, 3)
print("combined:\n", combined)
print("left_half:\n", left_half)
print("right_half:\n", right_half)
print("top:\n", top)
print("middle:\n", middle)
print("bottom:\n", bottom)combined:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
left_half:
[[0 1]
[4 5]
[8 9]]
right_half:
[[ 2 3]
[ 6 7]
[10 11]]
top:
[[0 1 2 3]]
middle:
[[4 5 6 7]]
bottom:
[[ 8 9 10 11]]Repeating patterns:
base = np.array([1, 2, 3])
print("repeat each element:", np.repeat(base, 2))
print("tile pattern:", np.tile(base, 3))repeat each element: [1 1 2 2 3 3]
tile pattern: [1 2 3 1 2 3 1 2 3]concatenate and stack?
concatenate joins arrays along an axis that already exists. stack creates a new axis, increasing the number of dimensions by one.
Answer: These routines are easy to ignore at first, but they are extremely practical.
scores = np.array([81, 95, 67, 88, 73, 95, 79])
print("scores:", scores)
print("sorted:", np.sort(scores))
print("argsort:", np.argsort(scores))
print("top 3 indices (unordered):", np.argpartition(scores, -3)[-3:])
print("top 3 scores:", scores[np.argpartition(scores, -3)[-3:]])scores: [81 95 67 88 73 95 79]
sorted: [67 73 79 81 88 95 95]
argsort: [2 4 6 0 3 1 5]
top 3 indices (unordered): [3 1 5]
top 3 scores: [88 95 95]ordered = np.sort(scores)
labels = np.array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3])
print("ordered:", ordered)
print("searchsorted for 80:", np.searchsorted(ordered, 80))
print("count >= 80:", np.count_nonzero(scores >= 80))
print("bincount:", np.bincount(labels))ordered: [67 73 79 81 88 95 95]
searchsorted for 80: 3
count >= 80: 4
bincount: [1 2 3 4]section_a = np.array([101, 102, 103, 104, 105])
section_b = np.array([104, 105, 106, 107])
print("unique scores:", np.unique(scores))
print("intersection:", np.intersect1d(section_a, section_b))
print("union:", np.union1d(section_a, section_b))
print("isin for [103, 106]:", np.isin([103, 106], section_a))unique scores: [67 73 79 81 88 95]
intersection: [104 105]
union: [101 102 103 104 105 106 107]
isin for [103, 106]: [ True False]These functions become especially useful for ranking students, de-duplicating values, building histograms, and aligning keys between datasets.
argsort so useful compared to sort?
sort gives sorted values. argsort gives the indices that would sort the array, which is more useful when you need to rank or reorder related arrays consistently.
Answer: They are the building blocks of masks, rules, and compact state representation.
Logic functions work with boolean conditions:
marks = np.array([55, 72, 89, 91, 64, 77])
passed = marks >= 60
distinction = marks >= 85
safe_range = np.logical_and(marks >= 60, marks <= 90)
print("passed:", passed)
print("distinction:", distinction)
print("safe_range:", safe_range)
print("any distinction?:", np.any(distinction))
print("all passed?:", np.all(passed))passed: [False True True True True True]
distinction: [False False True True False False]
safe_range: [False True True False True True]
any distinction?: True
all passed?: FalseBitwise operations matter when integer values encode flags:
permissions = np.array([0b0011, 0b0101, 0b0111], dtype=np.uint8)
read_mask = np.uint8(0b0001)
write_mask = np.uint8(0b0010)
print("permissions:", permissions)
print("has read?:", (permissions & read_mask) > 0)
print("has write?:", (permissions & write_mask) > 0)
print("toggle write bit:", permissions ^ write_mask)permissions: [3 5 7]
has read?: [ True True True]
has write?: [ True False True]
toggle write bit: [1 7 5]The key idea is that boolean logic creates masks, and masks drive filtering, replacement, and conditional computation.
& and |?
(arr > 0) & (arr < 10), to create masks over many values at once.
Answer: Even if you are not a math specialist, there are a few routines that appear everywhere:
@ or matmul for matrix multiplicationdot for dot productslinalg.solve for linear systemslinalg.det for determinantslinalg.eig or eigh for eigen problemslinalg.norm for magnitudesA = np.array([[3.0, 1.0], [1.0, 2.0]])
B = np.array([[1.0, 4.0], [2.0, 5.0]])
v = np.array([9.0, 8.0])
print("A @ B:\n", A @ B)
print("dot([1,2],[3,4]):", np.dot([1, 2], [3, 4]))
print("norm of B:", np.linalg.norm(B))A @ B:
[[ 5. 17.]
[ 5. 14.]]
dot([1,2],[3,4]): 11
norm of B: 6.782329983125268Solving Ax = b:
x = np.linalg.solve(A, v)
print("solution x:", x)
print("check A @ x:", A @ x)
print("det(A):", np.linalg.det(A))solution x: [2. 3.]
check A @ x: [9. 8.]
det(A): 5.000000000000001Eigenvalues and eigenvectors:
M = np.array([[4.0, 2.0], [2.0, 3.0]])
eigvals, eigvecs = np.linalg.eig(M)
print("eigenvalues:", eigvals.round(4))
print("eigenvectors:\n", eigvecs.round(4))eigenvalues: [5.562 1.438]
eigenvectors:
[[ 0.788 -0.615]
[ 0.615 0.788]]Practical advice: if you want to solve Ax = b, use np.linalg.solve(A, b) instead of computing inv(A) @ b.
np.linalg.solve(A, b) preferred over np.linalg.inv(A) @ b?
(2, 1) and (2, 3) broadcast in multiplication?
(2, 3) because the size-1 dimension expands across the matching larger dimension.
np.stack(...) instead of np.concatenate(...)?
np.stack(...) when you want to create a new axis. Use np.concatenate(...) when you want to join arrays along an axis that already exists.
argsort often more useful than sort in real applications?
argsort returns the indices that define the ordering, which lets you reorder related arrays or rank records consistently.
Answer: NumPy calculations are strongly influenced by data types.
The major ideas are:
astype is often necessaryints = np.array([1, 2, 3], dtype=np.int16)
floats = np.array([0.5, 1.5, 2.5], dtype=np.float32)
mixed = ints + floats
print("ints dtype:", ints.dtype)
print("floats dtype:", floats.dtype)
print("mixed result:", mixed)
print("mixed dtype:", mixed.dtype)
print("result_type:", np.result_type(ints, floats))ints dtype: int16
floats dtype: float32
mixed result: [1.5 3.5 5.5]
mixed dtype: float32
result_type: float32Overflow example:
small_uint = np.array([250, 251, 252], dtype=np.uint8)
overflowed = small_uint + np.array([10, 10, 10], dtype=np.uint8)
print("small_uint:", small_uint)
print("overflowed uint8 result:", overflowed)small_uint: [250 251 252]
overflowed uint8 result: [4 5 6]Casting explicitly:
as_float32 = mixed.astype(np.float32)
as_int64 = mixed.astype(np.int64)
print("astype float32:", as_float32, as_float32.dtype)
print("astype int64:", as_int64, as_int64.dtype)astype float32: [1.5 3.5 5.5] float32
astype int64: [1 3 5] int64This is why NumPy’s dtype system is not a minor detail. It directly affects correctness.
Answer: This topic is one of the most important for writing correct NumPy code.
Rule of thumb:
base = np.arange(12).reshape(3, 4)
slice_view = base[:, 1:3]
fancy_copy = base[:, [1, 3]]
print("base:\n", base)
print("slice_view:\n", slice_view)
print("fancy_copy:\n", fancy_copy)
print("slice shares memory:", np.shares_memory(base, slice_view))
print("fancy shares memory:", np.shares_memory(base, fancy_copy))base:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
slice_view:
[[ 1 2]
[ 5 6]
[ 9 10]]
fancy_copy:
[[ 1 3]
[ 5 7]
[ 9 11]]
slice shares memory: True
fancy shares memory: FalseMutating the view changes the original:
slice_view[0, 0] = 999
print("updated slice_view:\n", slice_view)
print("base after slice mutation:\n", base)updated slice_view:
[[999 2]
[ 5 6]
[ 9 10]]
base after slice mutation:
[[ 0 999 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]Memory layout also matters:
c_order = np.ascontiguousarray(base)
f_order = np.asfortranarray(base)
print("base strides:", base.strides)
print("c_order C contiguous?:", c_order.flags.c_contiguous)
print("f_order F contiguous?:", f_order.flags.f_contiguous)base strides: (32, 8)
c_order C contiguous?: True
f_order F contiguous?: TrueIf you need independence, call .copy() explicitly.
np.sqrt and np.sin?Answer: Universal functions, or ufuncs, are NumPy’s fast elementwise operators.
Students usually first see them as functions like:
np.sqrtnp.expnp.sinnp.addnp.multiplyBut ufuncs also support advanced patterns:
out= to write into an existing arraywhere= to compute only where a mask is truereduce() to collapse an arrayaccumulate() to build running resultsouter() to compute pairwise combinationsx = np.arange(1, 6, dtype=float)
out = np.empty_like(x)
np.sqrt(x, out=out)
print("sqrt with out:", out)sqrt with out: [1. 1.414 1.732 2. 2.236]Conditional application with where=:
result = np.full_like(x, -1.0)
mask = x % 2 == 0
np.sqrt(x, out=result, where=mask)
print("mask:", mask)
print("sqrt only on even entries:", result)mask: [False True False True False]
sqrt only on even entries: [-1. 1.414 -1. 2. -1. ]Reduction and accumulation:
print("np.add.reduce(x):", np.add.reduce(x))
print("np.add.accumulate(x):", np.add.accumulate(x))
print("np.multiply.outer([1,2,3],[10,20]):\n", np.multiply.outer([1, 2, 3], [10, 20]))np.add.reduce(x): 15.0
np.add.accumulate(x): [ 1. 3. 6. 10. 15.]
np.multiply.outer([1,2,3],[10,20]):
[[10 20]
[20 40]
[30 60]]When you understand ufuncs, you start seeing NumPy as a system of composable array primitives rather than a bag of isolated functions.
out= argument useful in ufuncs?
Answer: NumPy can store fixed-width text and byte strings, but you should understand the limitations.
dtype='U...'dtype='S...'words = np.array(["numpy", "python", "vector"], dtype="U10")
short_words = np.array(["broadcasting"], dtype="U5")
byte_codes = np.array([b"AA", b"BB", b"CC"], dtype="S2")
print("words:", words)
print("short_words (truncated):", short_words)
print("byte_codes:", byte_codes)
print("decoded byte_codes:", byte_codes.astype("U"))words: ['numpy' 'python' 'vector']
short_words (truncated): ['broad']
byte_codes: [b'AA' b'BB' b'CC']
decoded byte_codes: ['AA' 'BB' 'CC']Vectorized string operations exist too:
print("upper:", np.char.upper(words))
print("lengths:", np.char.str_len(words))
print("endswith 'y':", np.char.endswith(words, "y"))upper: ['NUMPY' 'PYTHON' 'VECTOR']
lengths: [5 6 6]
endswith 'y': [ True False False]NumPy string arrays are useful, but for very heavy text processing, pandas or plain Python string workflows are often more natural.
U5?
Answer: Structured arrays allow one array to hold records with named fields, similar to rows in a tiny in-memory table.
They are useful when:
student_dtype = np.dtype([
("name", "U20"),
("age", "i4"),
("scores", "f4", (3,)),
("passed", "?")
])
students = np.array([
("Asha", 20, [88.0, 92.0, 85.0], True),
("Rahul", 21, [75.0, 81.0, 79.0], True),
("Meera", 19, [91.0, 95.0, 93.0], True)
], dtype=student_dtype)
print("students:\n", students)
print("names:", students["name"])
print("ages:", students["age"])
print("scores:\n", students["scores"])
print("mean score per student:", students["scores"].mean(axis=1))students:
[('Asha', 20, [88., 92., 85.], True)
('Rahul', 21, [75., 81., 79.], True)
('Meera', 19, [91., 95., 93.], True)]
names: ['Asha' 'Rahul' 'Meera']
ages: [20 21 19]
scores:
[[88. 92. 85.]
[75. 81. 79.]
[91. 95. 93.]]
mean score per student: [88.333 78.333 93. ]Field access feels natural:
top_students = students[students["scores"].mean(axis=1) > 90]
print("top_students:\n", top_students)top_students:
[('Meera', 19, [91., 95., 93.], True)]Structured arrays are powerful, but if you need rich column operations or mixed missing data handling, pandas may be more convenient.
datetime64 and timedelta64 bring dates into NumPy?Answer: NumPy has dedicated date and duration types.
datetime64 stores dates or timestampstimedelta64 stores durationsdays = np.arange(np.datetime64("2026-03-01"), np.datetime64("2026-03-06"))
print("days:", days)
print("dtype:", days.dtype)days: ['2026-03-01' '2026-03-02' '2026-03-03' '2026-03-04' '2026-03-05']
dtype: datetime64[D]Differences produce timedeltas:
start = np.datetime64("2026-03-10")
end = np.datetime64("2026-03-15")
gap = end - start
print("start:", start)
print("end:", end)
print("gap:", gap)
print("gap in days:", gap / np.timedelta64(1, "D"))start: 2026-03-10
end: 2026-03-15
gap: 5 days
gap in days: 5.0You can do vectorized date arithmetic:
deadlines = days + np.timedelta64(7, "D")
print("deadlines one week later:", deadlines)deadlines one week later: ['2026-03-08' '2026-03-09' '2026-03-10' '2026-03-11' '2026-03-12']Dates become especially useful for time-indexed simulations, business calendars, and temporal feature engineering.
datetime64 value from another?
timedelta64, which represents a duration rather than an absolute date.
NaN and masked arrays?Answer: NumPy supports two major approaches:
np.nan inside floating-point arraysnumpy.ma masked arrays when invalid entries need an explicit maskNaNmeasurements = np.array([18.2, 19.1, np.nan, 20.4, 18.9, np.nan, 21.0])
print("measurements:", measurements)
print("mean:", np.mean(measurements))
print("nanmean:", np.nanmean(measurements))
print("nanmedian:", np.nanmedian(measurements))
print("missing mask:", np.isnan(measurements))measurements: [18.2 19.1 nan 20.4 18.9 nan 21. ]
mean: nan
nanmean: 19.52
nanmedian: 19.1
missing mask: [False False True False False True False]sensor = np.array([1.2, -99.0, 1.5, -99.0, 1.7])
masked_sensor = ma.masked_equal(sensor, -99.0)
print("masked_sensor:", masked_sensor)
print("mask:", masked_sensor.mask)
print("masked mean:", masked_sensor.mean())masked_sensor: [1.2 -- 1.5 -- 1.7]
mask: [False True False True False]
masked mean: 1.4666666666666668When to choose which:
NaN is simple and common for floating-point data.np.nanmean exist when np.mean already exists?
np.mean does not ignore NaN values, while np.nanmean is designed to skip missing numeric entries and still compute a useful average.
Generator important?Answer: NumPy’s modern random workflow uses np.random.default_rng() to create a Generator.
This is preferred because it is:
generator = np.random.default_rng(123)
print("integers:", generator.integers(1, 10, size=5))
print("normal samples:", generator.normal(loc=0, scale=1, size=5).round(3))
print("choice without replacement:", generator.choice(np.arange(10), size=4, replace=False))
print("permutation:", generator.permutation(np.arange(6)))integers: [1 7 6 1 9]
normal samples: [ 0.194 0.92 0.577 -0.636 0.542]
choice without replacement: [7 6 1 8]
permutation: [2 4 5 1 3 0]You can also generate matrices for simulations:
weights = generator.normal(0, 0.1, size=(3, 4))
print("random weight matrix:\n", weights.round(3))random weight matrix:
[[ 0.014 0.153 -0.066 -0.031]
[ 0.034 -0.221 0.083 0.154]
[ 0.113 0.075 -0.015 0.128]]The random module is huge, but the core habit is simple: create a generator and keep using it.
np.random.default_rng() better than scattering global random calls everywhere?
Answer: NumPy has both binary and text-based I/O tools.
Common choices:
np.save and np.load for .npynp.savez for multiple arraysnp.savetxt and np.loadtxt for text fileswith TemporaryDirectory() as tmp:
arr = np.arange(12).reshape(3, 4)
npy_path = f"{tmp}/demo.npy"
txt_path = f"{tmp}/demo.csv"
npz_path = f"{tmp}/bundle.npz"
np.save(npy_path, arr)
loaded_npy = np.load(npy_path)
np.savetxt(txt_path, arr, fmt="%d", delimiter=",")
loaded_txt = np.loadtxt(txt_path, delimiter=",", dtype=int)
np.savez(npz_path, first=arr, second=arr * 10)
bundle = np.load(npz_path)
print("loaded_npy:\n", loaded_npy)
print("loaded_txt:\n", loaded_txt)
print("npz keys:", bundle.files)
print("bundle['second']:\n", bundle["second"])loaded_npy:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
loaded_txt:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
npz keys: ['first', 'second']
bundle['second']:
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]General rule:
.npy or .npz when you care about exact dtype and shape preservation.npy usually safer than plain text for NumPy arrays?
.npy preserves shape and dtype exactly, while text formats can lose type precision, require parsing, and are generally less efficient.
Answer: Vectorization means expressing computation in whole-array operations instead of Python loops.
Example task:
data = rng.normal(size=100_000)
data_list = data.tolist()
def python_clip_square(values):
out = []
for x in values:
clipped = x if x > 0 else 0.0
out.append(clipped ** 2)
return out
def numpy_clip_square(values):
return np.square(np.clip(values, 0, None))
start = perf_counter()
python_result = python_clip_square(data_list)
python_time = perf_counter() - start
start = perf_counter()
numpy_result = numpy_clip_square(data)
numpy_time = perf_counter() - start
print(f"python loop time: {python_time:.6f} seconds")
print(f"numpy vectorized time: {numpy_time:.6f} seconds")
print("first 5 python values:", np.array(python_result[:5]).round(4))
print("first 5 numpy values:", numpy_result[:5].round(4))python loop time: 0.013484 seconds
numpy vectorized time: 0.000428 seconds
first 5 python values: [0.093 0. 0.563 0.885 0. ]
first 5 numpy values: [0.093 0. 0.563 0.885 0. ]Vectorization is often better because:
np.square(np.clip(arr, 0, None))
uint8 arithmetic produce surprising answers like wraparound values?
uint8 can only represent integers from 0 to 255. Values outside that range overflow and wrap according to the dtype’s storage rules.
U5?
Answer: A good NumPy function is not only mathematically correct. It also has clear expectations about:
The biggest shift from student code to developer code is moving from “this works on my example” to “this behaves predictably for valid inputs and fails clearly for invalid ones.”
def zscore_columns(x, dtype=np.float64):
arr = np.asarray(x, dtype=dtype)
if arr.ndim != 2:
raise ValueError("Expected a 2D array of shape (n_samples, n_features)")
mean = arr.mean(axis=0, keepdims=True)
std = arr.std(axis=0, keepdims=True)
if np.any(std == 0):
raise ValueError("At least one column has zero standard deviation")
return (arr - mean) / std
features = np.array([
[10, 100],
[12, 120],
[14, 140],
[16, 160]
], dtype=np.int32)
normalized = zscore_columns(features)
print("normalized:\n", normalized.round(3))
print("column means:", normalized.mean(axis=0).round(6))
print("column std:", normalized.std(axis=0).round(6))normalized:
[[-1.342 -1.342]
[-0.447 -0.447]
[ 0.447 0.447]
[ 1.342 1.342]]
column means: [0. 0.]
column std: [1. 1.]Developer habits worth adopting:
np.asarray(...)ndim, shape, and edge cases earlykeepdims=True when shape stability matterskeepdims=True often useful in reusable NumPy functions?
Answer: Numerical code often contains floating-point rounding, so exact equality is usually the wrong assertion.
Use:
np.allclose(...) for boolean checksnp.testing.assert_allclose(...) for proper testsassert_array_equal(...) only when exact equality is truly expecteddef standardize_rows(x):
arr = np.asarray(x, dtype=np.float64)
mean = arr.mean(axis=1, keepdims=True)
std = arr.std(axis=1, keepdims=True)
return (arr - mean) / std
sample = np.array([
[1.0, 2.0, 3.0],
[2.0, 4.0, 6.0]
])
zs = standardize_rows(sample)
np.testing.assert_allclose(zs.mean(axis=1), np.zeros(2), atol=1e-12)
np.testing.assert_allclose(zs.std(axis=1), np.ones(2), atol=1e-12)
print("standardized rows:\n", zs.round(6))
print("row means:", zs.mean(axis=1))
print("row std:", zs.std(axis=1))standardized rows:
[[-1.225 0. 1.225]
[-1.225 0. 1.225]]
row means: [0. 0.]
row std: [1. 1.]What developers should check in array code:
NaN, or zero varianceTesting habits are part of NumPy literacy because numerical bugs are often subtle, not obvious.
assert_allclose usually better than exact equality for floating-point results?
assert_allclose lets you verify that results are numerically close enough instead of bit-for-bit identical.
Answer: NumPy is not isolated. Many libraries cooperate with it through protocols and shared conventions.
Important ideas from the interoperability docs:
np.asarray(...) converts array-like objects into NumPy arrays__array__ lets custom objects define how they become arrays__array_ufunc__ and __array_function__ let array-like types control NumPy operationsHere is a minimal object that participates through __array__:
class ArrayWrapper:
def __init__(self, data):
self.data = np.asarray(data)
def __array__(self, dtype=None, copy=None):
arr = self.data
if dtype is not None:
arr = arr.astype(dtype, copy=False)
if copy:
arr = arr.copy()
return arr
wrapped = ArrayWrapper([1, 2, 3, 4])
arr = np.asarray(wrapped, dtype=np.float64)
print("converted array:", arr)
print("dtype:", arr.dtype)
print("arr + 10:", arr + 10)converted array: [1. 2. 3. 4.]
dtype: float64
arr + 10: [11. 12. 13. 14.]Why developers care:
If your function should accept “anything array-like,” np.asarray(...) is the normal entry point.
np.asarray(x)?
Answer: These tools matter when normal in-memory arrays are not enough or when you want sophisticated views without copying data.
Memory mapping lets you treat data on disk like an array, which is useful for large datasets.
with TemporaryDirectory() as tmp:
mmap_path = f"{tmp}/big.npy"
mapped = np.lib.format.open_memmap(
mmap_path, mode="w+", dtype=np.float32, shape=(5, 4)
)
mapped[:] = np.arange(20, dtype=np.float32).reshape(5, 4)
mapped.flush()
reopened = np.load(mmap_path, mmap_mode="r")
print("memory-mapped shape:", reopened.shape)
print("row means:", reopened.mean(axis=1))memory-mapped shape: (5, 4)
row means: [ 1.5 5.5 9.5 13.5 17.5]series = np.arange(8)
windows = np.lib.stride_tricks.sliding_window_view(series, window_shape=3)
print("series:", series)
print("sliding windows:\n", windows)series: [0 1 2 3 4 5 6 7]
sliding windows:
[[0 1 2]
[1 2 3]
[2 3 4]
[3 4 5]
[4 5 6]
[5 6 7]]Why this is powerful:
Important caution:
sliding_window_view creates overlapping views into the same memoryas_strided is even lower-level and should be used only when you understand the risk of invalid memory interpretationnp.asarray(x)?
assert_allclose are usually more appropriate.
Answer: NumPy has dedicated floating-point error handling tools for situations like divide-by-zero, overflow, underflow, or invalid operations.
values = np.array([1.0, 0.0, -1.0])
with np.errstate(divide="ignore", invalid="ignore"):
logged = np.log(values)
ratio = 1.0 / values
print("values:", values)
print("log(values):", logged)
print("1 / values:", ratio)
print("finite mask for ratio:", np.isfinite(ratio))values: [ 1. 0. -1.]
log(values): [ 0. -inf nan]
1 / values: [ 1. inf -1.]
finite mask for ratio: [ True False True]This matters in scientific code because numerical failures are not always syntax errors. Sometimes the code runs but produces inf or nan, and you need to detect that explicitly.
np.errstate(...)?
Answer: The NumPy reference is much broader than arrays plus arithmetic. Here are several advanced areas that students should at least know by name.
signal = np.sin(2 * np.pi * np.arange(8) / 8)
spectrum = np.fft.rfft(signal)
print("signal:", signal.round(3))
print("rfft spectrum:", spectrum.round(3))signal: [ 0. 0.707 1. 0.707 0. -0.707 -1. -0.707]
rfft spectrum: [ 0.+0.j -0.-4.j 0.-0.j 0.+0.j 0.+0.j]poly = np.polynomial.Polynomial([1.0, -3.0, 2.0]) # 1 - 3x + 2x^2
print("poly(0):", poly(0))
print("poly(2):", poly(2))poly(0): 1.0
poly(2): 3.0numpy.typingFloatVector = npt.NDArray[np.float64]
def center(x: FloatVector) -> FloatVector:
return x - x.mean()
sample = np.array([1.0, 2.0, 3.0], dtype=np.float64)
print("center(sample):", center(sample))center(sample): [-1. 0. 1.]Other important reference areas that are worth knowing about:
You do not need all of these on day one, but knowing they exist helps you scale from student projects to serious technical work.
np.errstate(...) in production numerical code?
numpy.typing useful in larger codebases even though NumPy itself is dynamic?
This is a 100-question revision bank designed for real interview preparation. The split is:
Try answering each question first, then open the dropdown and compare your explanation with the answer.
ndarray in NumPy?
shape tell you about an array?
ndim tell you?
size mean in NumPy?
dtype and why does it matter?
dtype is the data type of the array elements. It matters because it affects memory usage, precision, overflow behavior, and performance.
np.array(...) and np.asarray(...)?
np.array(...) may create a new array more eagerly, while np.asarray(...) mainly converts input to an array without copying when the input is already compatible.
np.linspace(...) over np.arange(...)?
linspace when you care about the exact number of points, especially for floating-point ranges.
np.zeros((2, 3)) create?
np.ones((2, 2)) create?
np.full(...)?
np.eye(3) return?
arr[0] mean for a 1D array?
arr[-1] mean?
arr[1:4] return?
arr[0, :] return?
arr[:, 1] return?
* 2?
axis=0 usually mean for a 2D array?
axis=1 usually mean for a 2D array?
arr.sum() do?
arr.mean() do?
arr > 5, then use arr[arr > 5].
np.where(condition, x, y) do?
x where the condition is true and from y where it is false.
reshape(...) do?
.T do on a 2D array?
np.newaxis useful?
np.max(arr) and np.argmax(arr)?
np.max(arr) returns the maximum value, while np.argmax(arr) returns the index of the maximum value.
np.random.default_rng() preferred over older global random calls?
astype(...) do?
(3, 1) and (3, 4) broadcast-compatible?
(3, 4).
np.concatenate(...) and np.stack(...)?
concatenate joins arrays along an existing axis. stack creates a new axis.
np.hstack(...) and np.vstack(...)?
np.split(...) do?
np.squeeze(...) do?
np.expand_dims(...) do?
flatten() and ravel()?
flatten() always returns a copy. ravel() tries to return a view when possible.
np.sort(...) return?
np.argsort(...) return?
argsort useful in ranking problems?
np.unique(...) do?
np.bincount(...) do?
np.searchsorted(...) do?
np.any(...) check?
np.all(...) check?
(arr > 0) & (arr < 10) instead of using and?
& performs elementwise logical combination on arrays, while Python’s and does not work correctly for array-wise comparisons.
keepdims=True change in a reduction?
reshape(...) fail even if the syntax looks correct?
np.clip(...) do?
* operator.
@ operator performs matrix multiplication.
np.linalg.solve(A, b) usually preferred over np.linalg.inv(A) @ b?
np.linalg.norm(...) compute?
U5?
datetime64 used for?
datetime64 from another?
timedelta64, which represents a duration.
uint8 arithmetic produce surprising wraparound results?
uint8 only stores values from 0 to 255, so results outside that range overflow according to the dtype rules.
NaN not be stored directly inside a normal integer array?
NaN is a floating-point concept and integer dtypes do not provide a representation for it.
np.shares_memory(a, b) help you check?
float32 be attractive for large workloads?
float64, which can reduce memory pressure and sometimes improve throughput.
float64 to float32?
out= argument useful in ufuncs?
where= do in many ufuncs?
np.add.reduce(...) do conceptually?
np.add.accumulate(...) do?
np.multiply.outer(a, b) produce?
a and elements of b.
np.nanmean(...) do differently from np.mean(...)?
NaN values when computing the mean.
NaN handling?
.npy usually safer than plain text for saving NumPy arrays?
.npy preserves exact dtype and shape information and avoids text parsing issues.
np.asarray(x)?
keepdims=True often useful in reusable APIs?
np.testing.assert_allclose(...)?
np.errstate(...)?
np.load(..., mmap_mode=\"r\")?
sliding_window_view(...) be more memory efficient than manually building windows in Python?
as_strided(...) be used with extreme caution?
np.ascontiguousarray(...) be useful?
strides represent?
__array__ protocol help with?
__array_ufunc__ and __array_function__?
numpy.typing useful in larger projects?
* with matrix multiplication @.axis=0 and axis=1 mean different aggregation directions.NaN were always enough.NumPy becomes much easier when you stop seeing it as a list of functions and start seeing it as a system built around:
ndarrayIf you master those ideas, the rest of the library becomes much more navigable.
This blog intentionally moved from:
That progression works for both audiences:
If you keep those two tracks together, NumPy becomes both easier to learn and more useful in real software.
ndarray)numpy.typing)errstate)memmap)