Options Trading Strategies and their Payoff Structures
Learn about different Options Trading strategies. Python code included.
In this article you will:
Learn about different types of options trading strategies
Understand the use cases for each strategy
Plot the payoffs using Python code
Introduction
By combining simple call and put options, traders can create a vast array of options strategies, each offering a unique risk and payoff.
These strategies can be used for income generation, betting on market volatility or even reducing the cost of an option premium.
In this article, we'll discuss basic options trading strategies, exploring their potential payoffs and practical applications.
Load Imports
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as pltplt.style.use('ggplot')Black Scholes Options Pricing Code
In a prevouis article, I discussed the Black-Scholes Options Pricing Formula and provided the Python code implementation. The code will be used again in this article.
def calc_d1(s, k, t, r, sigma):
return (np.log(s / k) + (r + sigma ** 2 / 2) * t) / (sigma * np.sqrt(t))
def calc_d2(s, k, t, r, sigma):
return calc_d1(s, k, t, r, sigma) - sigma * np.sqrt(t)
def call(s, k, t, r, sigma):
d1 = calc_d1(s, k, t, r, sigma)
d2 = calc_d2(s, k, t, r, sigma)
return s * norm.cdf(d1) - k * np.exp(-r * t) * norm.cdf(d2)
def put(s, k, t, r, sigma):
d1 = calc_d1(s, k, t, r, sigma)
d2 = calc_d2(s, k, t, r, sigma)
return k * np.exp(-r * t) * norm.cdf(-d2) - s * norm.cdf(-d1)Utils
settlement_values = np.linspace(0, 200, 300)def plot_option_strategy(strategy_function, settlement_prices, kwargs):
at_expiry_kwargs = kwargs.copy()
at_expiry_kwargs['t'] = 0
del at_expiry_kwargs['s']
initial_premium = strategy_function(**kwargs)
print('Initial premium (negative means credit)', initial_premium)
option_payoffs = [strategy_function(settlement, **at_expiry_kwargs) - initial_premium for settlement in settlement_prices]
plt.figure(figsize=(10, 8))
plt.plot(settlement_prices, option_payoffs, label=strategy_function.__name__)
plt.axhline(0, color='black', linestyle='--', linewidth=0.8)
plt.xlabel('Settlement Price')
plt.ylabel('Payoff')
plt.title(strategy_function.__name__)
plt.legend()
plt.grid(True)
plt.show()Options Trading Strategies Categories
This article will cover these options strategies grouped into these categories:
Credit Spreads
Debit Spreads
Volatility
Credit Spreads
A credit spread trade is where a trader sells an option with a higher premium and buys an option with a lower premium, therefore receiving a net credit upfront.
The trader is betting on low volatility (limited underlying price movements) and benefits from the time decay of options.
Bull Put Spreads
Bull Put spread is where a trader sells a high strike put (higher premium) and buys a lower strike put (lower premium). The trader receives a premium upfront and is hoping that the underlying price stays the same or doesn’t go down.
def bull_put_spread(s, k_low, k_high, t, r, sigma):
return put(s, k_low, t, r, sigma) - put(s, k_high, t, r, sigma)bull_put_spread_args = {'s': 110,
'k_low': 80,
'k_high': 100,
't': 1,
'r': 0.05,
'sigma': 0.2}
plot_option_strategy(bull_put_spread, settlement_values, bull_put_spread_args)
Bear Call Spread
Bear Call spread is where a trader sells a low strike call (higher premium) and buys a high strike call (lower premium). The trader receives a premium upfront and hoping that the underlying price stays the same or doesn’t go up.
def bear_call_spread(s, k_low, k_high, t, r, sigma):
return call(s, k_high, t, r, sigma) - call(s, k_low, t, r, sigma)bear_call_spread_args = {'s': 70,
'k_low': 80,
'k_high': 100,
't': 1,
'r': 0.05,
'sigma': 0.2}
plot_option_strategy(bear_call_spread, settlement_values, bear_call_spread_args)
Debit Spreads Strategies
A debit spread trade is where a trader buys an option with a higher premium and sells an option with a lower premium, therefore paying net debit upfront.
A trader enters into a debit spread if they have a view on the direction of the market but does not want to pay the full premium of a normal call or put option.
Therefore, a debit spread allows the trader to enter a trade to bet on the direction of the market while paying a smaller premium.
However, unlike a normal call or put option, the potential payoff of a debit spread has a capped upside.
Bull Call Spread
Bull Call spread is where a trader buys a low strike call (higher premium) and sells a high strike call (lower premium). The trader is paying a premium upfront and is betting that the underlying price will go up. The premium is reduced compared to buying a call option but potential payoff is capped.
def bull_call_spread(s, k_low, k_high, t, r, sigma):
return call(s, k_low, t, r, sigma) - call(s, k_high, t, r, sigma)bull_call_spread_args = {'s': 90,
'k_low': 100,
'k_high': 110,
't': 1,
'r': 0.05,
'sigma': 0.2}
plot_option_strategy(bull_call_spread, settlement_values, bull_call_spread_args)
Bear Put Spread
Bear Put spread is where a trader buys a high strike put (higher premium) and sells a lower strike put (lower premium). The trader pays a premium upfront and is betting that the underlying price will go down. The premium is reduced compared to buying a put option but the potential payoff is capped.
def bear_put_spread(s, k_low, k_high, t, r, sigma):
return put(s, k_high, t, r, sigma) - put(s, k_low, t, r, sigma)bear_put_spread_args = {'s': 110,
'k_low': 90,
'k_high': 100,
't': 1,
'r': 0.05,
'sigma': 0.2}
plot_option_strategy(bear_put_spread, settlement_values, bear_put_spread_args)
Volatility Strategies
A trader can bet on an increase in volatility without having to predict which directional the price is going to move using volatility strategies.
The two main types of volatility strategies are Straddles and Strangles which benefit from extreme price moves and increases in implied volatility.
Straddle
A straddle is a long position in both an at-the-money call and at-the-money put. The trader will enter into a straddle position if they believe the price will move excessively in either direction, or that the implied volatility will increase.
However, it is important to note that the cost to enter a straddle position is expensive, as the trader needs to pay the premium for both the call and the put option.
def straddle(s, k, t, r, sigma):
return call(s, k, t, r, sigma) + put(s, k, t, r, sigma)straddle_args = {'s': 100,
'k': 100,
't': 1,
'r': 0.05,
'sigma': 0.2}
plot_option_strategy(straddle, settlement_values, straddle_args)
Strangle
A strangle is a long position in both an out-the-money call and out-the-money put. Similarly to the straddle, the trader will enter into a strangle if they believe the price will move excessively in either direction or that the implied volatility will increase.
As the trader is buying out-the-money options, the premium is cheaper compared to the straddle. However, the underlying price will need to move more excessively to become in-the-money compared to the straddle. In addition, the strangle will not benefit as much as the straddle from increases in implied volatility.
def strangle(s, k_low, k_high, t, r, sigma):
return call(s, k_low, t, r, sigma) + put(s, k_high, t, r, sigma)strangle_args = {'s': 100,
'k_low': 90,
'k_high': 110,
't': 1,
'r': 0.05,
'sigma': 0.2}
plot_option_strategy(strangle, settlement_values, strangle_args)
In this article you have:
Learnt about different types of options trading strategies
Understood the use cases for each strategy
Plotted the payoffs using Python code
That’s a wrap! If you enjoyed my content please subscribe to my newsletter and check out my Twitter account where I post daily content on Quant Finance and Python.
Other Social Media:
Twitter: @Quant_prep