Options Greeks Explained: Delta, Gamma, Theta, Vega — With Python Code

Options trading is a cornerstone of quantitative finance. Before pricing exotic derivatives or building a volatility surface, you need to master the Greeks — sensitivity measures that tell you how an option's price changes with respect to underlying parameters.

This post breaks down the four primary Greeks with intuition, formulas, and production-ready Python code.

What Are the Greeks?

The Greeks are partial derivatives of the option pricing model. They measure risk — how your P&L shifts when market conditions change.

Black-Scholes Greeks: The Formulas

For a European call option under Black-Scholes:

The Greeks are:

Where N(.) is the standard normal CDF and N'(.) is the PDF.

Python Implementation

import numpy as np

from scipy.stats import norm





def black_scholes_greeks(S, K, T, r, sigma, option_type="call"):

    """

    Calculate Black-Scholes Greeks for European options.



    Parameters:

        S: Current stock price

        K: Strike price

        T: Time to expiry (years)

        r: Risk-free rate

        sigma: Volatility

        option_type: "call" or "put"



    Returns:

        dict with delta, gamma, theta, vega

    """

    d1 = (np.log(S / K) + (r + sigma**2 / 2) * T) / (sigma * np.sqrt(T))

    d2 = d1 - sigma * np.sqrt(T)



    nd1 = norm.cdf(d1)

    npdf_d1 = norm.pdf(d1)

    nd2 = norm.cdf(d2)



    # Delta

    delta = nd1 if option_type == "call" else nd1 - 1



    # Gamma (same for calls and puts)

    gamma = npdf_d1 / (S * sigma * np.sqrt(T))



    # Theta

    if option_type == "call":

        theta = (-S * npdf_d1 * sigma / (2 * np.sqrt(T))

                 - r * K * np.exp(-r * T) * nd2)

    else:

        theta = (-S * npdf_d1 * sigma / (2 * np.sqrt(T))

                 + r * K * np.exp(-r * T) * norm.cdf(-d2))



    # Vega (same for calls and puts, per 1% vol move)

    vega = S * npdf_d1 * np.sqrt(T) / 100



    return {

        "delta": round(delta, 4),

        "gamma": round(gamma, 4),

        "theta": round(theta, 4),

        "vega": round(vega, 4)

    }





# Example: ATM call on a $100 stock

result = black_scholes_greeks(

    S=100, K=100, T=0.25, r=0.05, sigma=0.20, option_type="call"

)

print(result)

# {'delta': 0.5596, 'gamma': 0.0355, 'theta': -6.414, 'vega': 0.1782}

Practical Interpretation

Delta

• 
  ATM options: Delta ~ 0.50 (call) or -0.50 (put)


• 
  Deep ITM: Delta approaches 1.0 (call) or -1.0 (put)


• 
  Deep OTM: Delta approaches 0.0 (both)


• 
  Delta hedging: Hold -Delta shares to neutralize directional risk

Gamma

• Highest for ATM options near expiry


• Gamma risk spikes as expiry approaches


• Long options = long gamma; short options = short gamma

Theta

• Always negative for long option holders (time decay)


• Accelerates in the last 30 days before expiry


• Theta is the "cost" of holding an option position

Vega

• Highest for ATM options with long tenor


• Vega exposure = exposure to implied volatility changes


• Critical during earnings season or macro events

Greeks Sensitivity Table

# How Greeks change with moneyness

strikes = [90, 95, 100, 105, 110]

print(f"{'Strike':<8} {'Delta':<8} {'Gamma':<8} {'Theta':<8} {'Vega':<8}")

print("-" * 40)

for K in strikes:

    g = black_scholes_greeks(100, K, 0.25, 0.05, 0.20)

    print(f"{K:<8} {g['delta']:<8} {g['gamma']:<8} {g['theta']:<8} {g['vega']:<8}")

Output:

Strike   Delta    Gamma    Theta    Vega

----------------------------------------

90       0.8429   0.0096   -4.58    0.0481

95       0.7184   0.0214   -5.66    0.1069

100      0.5596   0.0355   -6.41    0.1782

105      0.3961   0.0449   -6.73    0.2243

110      0.2553   0.0443   -6.54    0.2213

Notice how Gamma peaks ATM (strike 100-105) while Delta transitions from 0 to 1.

Greeks in Portfolio Risk Management

In practice, portfolio-level Greeks aggregate across all positions:

portfolio_delta = sum(pos.quantity * pos.delta for pos in positions)

portfolio_gamma = sum(pos.quantity * pos.gamma for pos in positions)

portfolio_theta = sum(pos.quantity * pos.theta for pos in positions)

portfolio_vega = sum(pos.quantity * pos.vega for pos in positions)

A delta-neutral portfolio has portfolio_delta = 0. But with non-zero gamma, your delta changes as the market moves — this is dynamic hedging.

Common Interview Questions

1. 
   What happens to Gamma as expiry approaches for an ATM option? — Gamma increases, creating "pin risk"


2. 
   How do you delta-hedge a short call? — Buy Delta shares of the underlying


3. 
   Why is Vega important during earnings? — Implied volatility spikes before earnings and crushes after


4. 
   What's the relationship between Theta and Gamma? — For delta-hedged options, Theta decay ~ Gamma * S^2 * sigma^2 / 2 (the theta-gamma tradeoff)

Level Up Your Quant Skills

Want to go deeper into options pricing, Greeks, and quant interview prep? Check out the Desk2Quant Quant Interview Problem Book — 100+ problems with detailed solutions covering derivatives pricing, stochastic calculus, and probability.

Published by Desk2Quant — helping you break into quantitative finance.