Python for Quant Work

Vectorise everything that touches a payoff

A loop over simulation paths is the single most common thing that makes a Monte Carlo answer too slow and harder to read. Generate all your shocks at once and let NumPy broadcast. The terminal price of a geometric Brownian motion is a one-liner.

import numpy as np

z = rng.standard_normal(n)
ST = S * np.exp((r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * z)
payoff = np.exp(-r * T) * np.maximum(ST - K, 0.0)
price, se = payoff.mean(), payoff.std(ddof=1) / np.sqrt(n)

Always report a standard error

A Monte Carlo price without an error bar can't be judged — the interviewer can't tell whether a 0.3% gap to the closed form is noise or a bug. Report mean ± std/√n. The error shrinks like 1/√n, so to halve it you need 4× the paths; that fact alone is worth saying out loud.

• ▸Use ddof=1 for the sample standard deviation.
• ▸For antithetic variates, average each z/−z pair first, then take the SE over the n/2 pair-means — not naively over all n payoffs.
• ▸Seed your generator (np.random.default_rng(seed)) so results are reproducible.

Reach for SciPy for distributions and root-finding

Don't hand-roll a normal CDF or a solver. scipy.stats.norm gives you cdf/pdf/ppf; scipy.optimize.brentq gives you a bracketed root-finder that won't diverge — exactly what you want when inverting Black-Scholes for an implied vol.

from scipy.stats import norm
from scipy.optimize import brentq

def implied_vol(price, S, K, r, T):
    f = lambda s: bs_call(S, K, r, s, T) - price
    return brentq(f, 1e-4, 5.0)   # bracketed: robust, no divergence

Make it checkable

The fastest way to build trust in a numerical answer is to show it agreeing with something you already know. Benchmark Monte Carlo against the closed form. Assert put-call parity. Print a limiting case. A submission that checks itself reads as senior.

• ▸Benchmark MC against Black-Scholes on a vanilla before trusting it on an exotic.
• ▸Assert identities (put-call parity) rather than eyeballing numbers.
• ▸Keep functions pure and small so each can be tested in isolation.

Structure a pricer so every piece is testable

Have one source of truth for d1 and d2 and build price, Greeks and implied vol on top of it. Keep each function pure — parameters in, a number out, no globals or hidden state — so you can test it in isolation and an interviewer can read it top to bottom. The layout that reads as senior: small closed-form functions, a separate Greeks block, then a few asserts at the bottom that the file checks on itself.

def d1(S,K,r,sig,T): ...        # one definition, reused everywhere
def call(S,K,r,sig,T): ...      # built from N(d1), N(d2)
def greeks(S,K,r,sig,T): ...    # delta/gamma/vega/theta in one dict

if __name__ == '__main__':
    c = call(100,100,.02,.2,1); p = put(100,100,.02,.2,1)
    assert abs((c - p) - (100 - 100*exp(-.02))) < 1e-8   # put-call parity

Variance reduction that pays for itself

Brute-force Monte Carlo is fine, but two cheap tricks cut the error for free and signal that you've done this before. Antithetic variates pair each draw z with −z, halving variance for payoffs that are monotone in z. A control variate subtracts something you can price exactly (the underlying, or a vanilla) and adds back its known mean — powerful when the control is highly correlated with the payoff.

• ▸Antithetic: average the z and −z payoffs into pair-means, then take the SE over the n/2 pairs — not over all n.
• ▸Control variate: price = mean(payoff − beta·(control − E[control])); beta≈1 when the control tracks the payoff.
• ▸Report the SE before and after — showing the error shrank is more convincing than claiming it did.

Diagnose convergence, don't assert it

A number on its own proves nothing. Plot the running estimate against the number of paths with a ±2·SE band and show it settling onto the closed form. A histogram of discounted payoffs explains the variance — heavily skewed payoffs need more paths. These plots are quick and they are exactly what a Monte Carlo discussion is fishing for.

import matplotlib.pyplot as plt, numpy as np
run = np.cumsum(payoff) / np.arange(1, n+1)
se  = payoff.std(ddof=1) / np.sqrt(np.arange(1, n+1))
plt.plot(run); plt.fill_between(range(n), run-2*se, run+2*se, alpha=.2)
plt.axhline(bs_closed_form, ls='--')   # should sit inside the band

How to approach a pricing take-home

• ▸Read the spec and write the closed form first — it's your benchmark for everything else.
• ▸Then simulate, and validate the simulation against the closed form before trusting it on anything exotic.
• ▸Always report a standard error; quote put-call parity and a limiting case (vol→0 → intrinsic) as checks.
• ▸Comment on how the Greeks behave (delta→1 deep ITM, gamma peaks ATM) — interviewers want the intuition, not just the numbers.
• ▸Keep it runnable end to end with a fixed seed; a submission that reproduces is worth more than a faster one that doesn't.