Python Finance: Calculating In-the-Money Probability for Options

Ever Wondered How Likely Your Option Will Finish in the Money?

Options trading can be exhilarating, but it also comes with its fair share of complexities. One of the most important metrics to understand is the probability that your option will finish in the money (ITM). This single calculation can influence your trading strategy, risk management, and overall portfolio performance.

As someone who has spent years exploring financial modeling, I know firsthand how daunting these calculations can appear. Fortunately, Python provides an elegant way to compute ITM probabilities using well-established models like Black-Scholes and the Binomial Tree. In this guide, we’ll dive deep into both methods, share real working code, troubleshoot common pitfalls, and wrap it all up with actionable insights.

Understanding ITM Probability

Before jumping into the models, it’s essential to understand what “in the money” means. For a call option, it’s ITM when the underlying asset price is above the strike price. For a put option, it’s ITM when the underlying asset price is below the strike price. The ITM probability is essentially the likelihood that this condition will be true at expiration.

Traders use ITM probability to answer critical questions like:

• Risk Assessment: How likely is it that my option will expire worthless?
• Profit Potential: What are the chances of my option being profitable at expiration?
• Portfolio Hedging: Should I buy or sell options to hedge against potential market movements?

With these questions in mind, let’s explore two popular methods to calculate ITM probability: Black-Scholes and the Binomial Tree model.

Using the Black-Scholes Formula

The Black-Scholes model is a cornerstone of modern finance. It assumes that the underlying asset price follows a log-normal distribution and calculates option prices using several key inputs, including volatility and time to expiration. While primarily used for pricing, it can also estimate ITM probability.

Here’s how you can implement it in Python:

from math import log, sqrt, exp
from scipy.stats import norm

def black_scholes_itm_probability(option_type, strike_price, underlying_price, volatility, time_to_expiration):
    # Calculate d1 and d2
    d1 = (log(underlying_price / strike_price) + (volatility ** 2 / 2) * time_to_expiration) / (volatility * sqrt(time_to_expiration))
    d2 = d1 - volatility * sqrt(time_to_expiration)

    # Determine in-the-money probability based on option type
    if option_type.lower() == "call":
        return norm.cdf(d1)
    elif option_type.lower() == "put":
        return norm.cdf(-d2)
    else:
        raise ValueError("Invalid option type. Use 'call' or 'put'.")

Let’s break this down:

• d1 and d2 are intermediate variables derived from the Black-Scholes formula.
• The norm.cdf function calculates the cumulative distribution function (CDF) of the standard normal distribution, which gives us the ITM probability.
• This function works for European options (exercisable only at expiration).

For example:

# Inputs
option_type = "call"
strike_price = 100
underlying_price = 120
volatility = 0.2  # 20%
time_to_expiration = 0.5  # 6 months

# Calculate ITM probability
probability = black_scholes_itm_probability(option_type, strike_price, underlying_price, volatility, time_to_expiration)
print(f"In-the-money probability: {probability:.2f}")

In this example, the call option has a roughly 70% chance of finishing in the money.