Python, Pandas and NumPy quiz

Question 1

In Pandas, what is the key difference in memory and copy semantics between `df.loc[]`-based assignment and chained indexing like `df[df.a > 0]['b'] = 1`?

Accepted Answer

Chained indexing may write to a temporary copy and fail silently, while .loc writes atomically to the original

Answer

They are fully equivalent in all cases

Answer

Only chained indexing avoids copies

Answer

`.loc` always returns a copy, chained indexing always a view

Question 2

What does NumPy broadcasting do when adding an array of shape (3,1) to one of shape (1,4)?

Accepted Answer

Produces shape (3,4)

Answer

Raises a shape mismatch error

Answer

Produces shape (1,1)

Answer

Produces shape (4,3)

Question 3

Why can `df.apply(func, axis=1)` be dramatically slower than a vectorized alternative, and what is the typical fix?

Accepted Answer

Because it runs a Python callable per row instead of a C-level vectorized loop

Answer

Because apply releases the GIL inefficiently

Answer

Because axis=1 copies the entire DataFrame each call

Answer

Because apply always converts to object dtype

Question 4

What is the difference between `np.array([1,2,3], dtype=np.float32)` arithmetic and `float64` regarding precision and performance?

Accepted Answer

float32 halves memory with lower precision; float64 is higher precision and the default

Answer

float32 is more precise but slower

Answer

They have identical precision

Answer

float64 uses 4 bytes

Question 5

In Pandas, how does `merge(how='left')` differ from `join()` by default, and what governs the join keys?

Accepted Answer

merge defaults to column keys/inner; join defaults to index/left

Answer

merge joins on index, join on columns

Answer

They are identical

Answer

join only supports inner joins

Question 6

What does `df.groupby('k', observed=True)` change when grouping by a Categorical column?

Accepted Answer

It restricts groups to categories that actually appear in the data

Answer

It sorts the groups alphabetically

Answer

It forces float output

Answer

It disables aggregation

Question 7

Why is `np.dot(A, B)` preferred over a Python nested loop for matrix multiplication beyond just convenience?

Accepted Answer

It calls optimized multithreaded BLAS kernels

Answer

It uses less code only

Answer

It is identical in speed but cleaner

Answer

It avoids floating point entirely

Question 8

What is the effect of `pd.options.mode.copy_on_write = True` (default in Pandas 3.0)?

Accepted Answer

It defers copies until a mutation, giving consistent copy semantics

Answer

It forces eager deep copies everywhere

Answer

It disables all copying

Answer

It only affects merge operations

Question 9

How does `np.where(cond, a, b)` differ from boolean masking `arr[cond] = x`?

Accepted Answer

np.where returns a new array with if/else selection; masking assigns in place only where True

Answer

They are identical

Answer

np.where mutates in place

Answer

Masking always returns a new array

Question 10

What does `df.memory_usage(deep=True)` reveal that the shallow version does not?

Accepted Answer

It includes the real memory of object/string contents, not just pointers

Answer

Nothing, it is just slower

Answer

It only measures the index

Answer

It compresses the data

Question 11

Why does `0.1 + 0.2 == 0.3` evaluate to False in Python/NumPy, and how should equality be tested?

Accepted Answer

Binary floating-point rounding; use np.isclose/math.isclose

Answer

A Python bug

Answer

Because integers overflow

Answer

Because == is not defined for floats

Question 12

What does the `@` operator do for NumPy arrays, and how does it treat 1-D operands?

Accepted Answer

Matrix multiplication; inner product for 1-D operands

Answer

Elementwise multiplication

Answer

Outer product always

Answer

Concatenation

Question 13

When reading a large CSV with `pd.read_csv`, what does specifying `dtype` and `usecols` upfront accomplish?

Accepted Answer

They reduce memory/parse time by skipping columns and type inference

Answer

They only affect output formatting

Answer

They are deprecated

Answer

They force everything to strings

Question 14

What is the difference between `Series.map`, `Series.apply`, and `DataFrame.applymap`/`DataFrame.map`?

Accepted Answer

map/apply work elementwise on a Series; DataFrame.map works on every cell, DataFrame.apply on rows/columns

Answer

All three are identical

Answer

apply only works on DataFrames

Answer

map cannot take a dict

Question 15

How does `np.nan` behave in comparisons and aggregations, and how does `np.nanmean` differ from `np.mean`?

Accepted Answer

np.mean returns NaN if any element is NaN; np.nanmean skips NaNs

Answer

np.mean ignores NaN automatically

Answer

They are identical

Answer

nanmean raises on NaN

Question 16

Why might `df.iterrows()` corrupt dtypes, and what should you use instead for performance-sensitive row iteration?

Accepted Answer

iterrows coerces mixed dtypes via Series and is slow; use itertuples or vectorize

Answer

iterrows is the fastest option

Answer

itertuples is slower than iterrows

Answer

iterrows preserves all dtypes

Question 17

What does `np.reshape(arr, (-1, 3))` mean, and when does it return a view vs a copy?

Accepted Answer

-1 infers that dimension; reshape returns a view when memory layout permits, else a copy

Answer

-1 means reverse the array

Answer

reshape always copies

Answer

-1 means zero rows

Question 18

What is the semantic difference between `df.dropna(how='any')` and `how='all'`?

Accepted Answer

any drops rows with at least one NaN; all drops only fully-NaN rows

Answer

any drops only all-NaN rows

Answer

They are identical

Answer

all drops rows with any NaN

Question 19

How does `pd.merge(..., validate='one_to_many')` help catch data bugs?

Accepted Answer

It asserts the key cardinality and raises if duplicates violate the expected relationship

Answer

It sorts the result

Answer

It removes duplicates automatically

Answer

It only affects performance

Question 20

What does `arr.flags['C_CONTIGUOUS']` tell you, and why does contiguity matter?

Accepted Answer

Whether memory is row-major contiguous, affecting copy-free ops and performance

Answer

Whether the array is sorted

Answer

Whether it is read-only

Answer

Whether it contains NaNs

Question 21

In a `groupby`, what is the difference between `agg`, `transform`, and `filter`?

Accepted Answer

agg reduces per group; transform returns original-shaped aligned output; filter keeps/drops whole groups

Answer

They all reduce to one row per group

Answer

transform reduces, agg broadcasts

Answer

filter aggregates to scalars

Question 22

Why can chaining `astype('category')` on high-cardinality string columns hurt rather than help?

Accepted Answer

Category helps only for low cardinality; high cardinality adds overhead with little reuse

Answer

Category always saves memory

Answer

Category never affects memory

Answer

Category is faster only for unique values

Question 23

What does `np.einsum('ij,jk->ik', A, B)` compute, and what is its advantage?

Accepted Answer

Matrix multiplication A@B via index contraction over j

Answer

Elementwise product

Answer

Transpose of A

Answer

Outer product

Question 24

What problem does `pd.to_datetime(s, format='%Y-%m-%d')` with an explicit format solve over inference?

Accepted Answer

It speeds parsing and avoids ambiguous/inconsistent date interpretation

Answer

It only changes the timezone

Answer

It converts to Unix integers

Answer

It has no effect

Question 25

How do NumPy's `view` and `copy` differ when you slice `b = a[2:5]` and then modify `b`?

Accepted Answer

Basic slicing returns a view sharing memory; modifying it affects the original

Answer

Slicing always copies

Answer

Slicing returns a deep copy

Answer

b and a are always independent

Question 26

What is the purpose of `df.set_index(...).sort_index()` before doing many `.loc` lookups?

Accepted Answer

A sorted index enables fast binary-search lookups and range slicing

Answer

It only changes display order

Answer

It deduplicates rows

Answer

It is required for all .loc calls

Question 27

Why does `np.random.seed()` (legacy) differ from the modern `np.random.default_rng()` Generator API?

Accepted Answer

Generator API gives isolated, better-quality, explicitly-seeded streams vs the global legacy state

Answer

They are identical

Answer

Legacy is preferred in 2026

Answer

default_rng is not seedable

Question 28

What does `df.pivot_table(values='v', index='a', columns='b', aggfunc='mean')` do that `df.pivot` cannot?

Accepted Answer

pivot_table aggregates duplicates via aggfunc; pivot needs unique pairs

Answer

pivot aggregates, pivot_table does not

Answer

They are identical

Answer

pivot supports margins

Question 29

What is the difference between `pd.concat([df1, df2], axis=0)` and `axis=1`, and what governs alignment?

Accepted Answer

axis=0 stacks rows aligning on columns; axis=1 stacks columns aligning on index

Answer

axis=0 stacks columns

Answer

They are identical

Answer

axis=1 ignores the index

Question 30

How does NumPy's integer dtype overflow behave, e.g., `np.array([255], dtype=np.uint8) + 1`?

Accepted Answer

It wraps around modulo the dtype range (255+1 -> 0)

Answer

It raises an OverflowError

Answer

It promotes to int64 automatically

Answer

It returns NaN

Test yourself