24Python

Solution of Interview question 24.1.

[1], [1, 2], [3]. The default list is created once, when def runs, and every call without the argument appends to the same list; the third call passes its own. Fix: def add_fill(fill, fills=None) and if fills is None: fills = []. A linter flags the pattern (ruff’s B006), which is how to find it without being told.

What the interviewer is looking for: evaluation time of defaults, the standard fix, and tooling that catches it.

Solution of Interview question 24.2.

[20, 20, 20] then [0, 10, 20]. The lambdas capture the variable k, not its value, and are called after the loop ends with k = 2. A default argument k=k is evaluated when each lambda is created, capturing the current value; functools.partial does the same.

What the interviewer is looking for: late binding of closures and the default-argument fix.

Solution of Interview question 24.3.

True True then True False. The language guarantees only the equalities. CPython keeps one object for each integer from $-5$ to 256, so the two 256s are the same object, while int(’1000’) creates a new object each time. Never use is to compare numbers or strings; use it for None and sentinels.

What the interviewer is looking for: equality against identity, and naming the CPython detail as a detail.

Solution of Interview question 24.4.

5 then 0: the first sum consumes the generator ($0 + 1 + 4$) and the second finds it exhausted. Use a list if the values are needed twice, or recreate the generator.

What the interviewer is looking for: single-pass iterators.

Solution of Interview question 24.5.

Deleting a key while iterating over the dictionary changes its size, and CPython raises RuntimeError: dictionary changed size during iteration at the next step. Build a new dictionary with a comprehension (the last line), or iterate over a copy of the keys (for sym in list(positions)).

What the interviewer is looking for: the mutation-during-iteration rule and two safe patterns.

Solution of Interview question 24.6.

Stream it: a generator that reads one line at a time, a generator that filters, and a dictionary accumulating notional per symbol (Listing 24.2); memory is the dictionary plus one line, whatever the file’s size. The chapter’s test runs it on 5 000 generated fills and checks it against a direct computation. For speed rather than memory, read in chunks with pandas or Polars and aggregate per chunk.

What the interviewer is looking for: constant-memory streaming with generators.

Solution of Interview question 24.7.

@contextmanager
def temporary_limit(limits, key, value):
    """Change a risk limit for a block and restore it even if the block raises."""
    old = limits[key]
    limits[key] = value
    try:
        yield limits
    finally:
        limits[key] = old

The finally runs whether the block ends normally or by an exception, and the exception still propagates. The chapter’s test checks both paths.

What the interviewer is looking for: contextlib.contextmanager with try/finally.

Solution of Interview question 24.8.

[100. 0. 102. 103.] and True False. prices[1:3] is a view, so writing to it changes prices[1]; prices[[2, 3]] is a copy, so writing to it changes nothing in prices. The function np.shares_memory confirms which is which.

What the interviewer is looking for: basic slicing gives views, fancy indexing gives copies.

Solution of Interview question 24.9.

False 0.9999999999999999 and True: 0.1 is not exactly representable in binary, and the running sum accumulates the rounding; math.fsum tracks the lost low-order bits and returns the correctly rounded sum. On a desk it matters when a position or cash balance is checked for exact zero, when many small fills are summed, and when two systems reconcile totals computed in different orders: keep money in integer units (cents, ticks) and compare floats with a tolerance.

What the interviewer is looking for: binary representation, compensated summation, and integer units for money.

Solution of Interview question 24.10.

The work is mostly waiting on sockets, so asyncio (one thread, 300 streams, cheap task switches) or a thread per group of streams both fit; threads help because they release the lock while blocked. If the per-message statistic is heavy pure Python, the lock serialises it: move it to numpy (which releases the lock), to a compiled extension, or to worker processes fed through queues. The lock does not make compound operations atomic: a shared counter or dictionary updated from several threads still needs a lock (or a queue to a single owner).

What the interviewer is looking for: matching the concurrency model to I/O-bound and CPU-bound work, and the limits of the GIL.

Solution of Interview question 24.11.

With $c$ the cumulative sum of the prices preceded by a zero, the mean of the window ending at $i$ is $(c_{i+1} - c_{i+1-k})/k$ (Listing 24.3). Check it against the obvious loop on random inputs of random lengths and windows, as the chapter’s test does for 50 seeds; for long series of large numbers, beware the cancellation in differences of large cumulative sums, and use np.convolve or pandas’ rolling for stability.

What the interviewer is looking for: the cumulative-sum trick, an oracle check, and its numerical caveat.

Solution of Interview question 24.12.

[0, 0, 0], True, [0, 1, 0]. df[df[’qty’] < 0] (a boolean mask) returns a copy, and [’flag’] = 1 assigns into that copy, which is discarded: the frame is unchanged and pandas 2.3 emits a SettingWithCopyWarning. The .loc[mask, ’flag’] = 1 form assigns in one step on the frame itself. Under copy-on-write every indexing result behaves as a copy, so chained assignment never modifies the original and pandas warns about it; .loc remains the way to write.

What the interviewer is looking for: copies from masks, one-step assignment with .loc, and awareness of copy-on-write.

Solution of Interview question 24.13.

@dataclass(frozen=True)
class OrderKey:
    """A value type usable as a dict key: equality and hash from the fields, immutable."""

    venue: str
    client_order_id: int

A mutable key changed after insertion keeps its old hash bucket, so lookups by the new value and by the old one can both fail, and the entry is lost in the dictionary. A frozen dataclass cannot be changed, and its generated __hash__ is consistent with __eq__. A plain tuple works too.

What the interviewer is looking for: hash and equality consistency, immutability, and what breaks otherwise.