To implement the Black-Scholes model using Python and visualize the option pricing for stocks like Apple, Microsoft, and Tesla, we'll proceed step by step. Below is a Python implementation that uses historical stock data to calculate option prices using the Black-Scholes formula, and then plots the results.
### Step 1: Import Necessary Libraries
We'll need several libraries, including `numpy` for numerical operations, `scipy` for cumulative distribution functions, and `matplotlib` for plotting.
```python
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
import pandas as pd
import yfinance as yf
```
### Step 2: Define the Black-Scholes Formula
We'll define a function `black_scholes` that calculates the price of a European call option.
```python
def black_scholes(S, K, T, r, sigma, option_type="call"):
"""
S: Current stock price
K: Option strike price
T: Time to expiration (in years)
r: Risk-free interest rate (annualized)
sigma: Volatility of the stock (annualized)
option_type: "call" or "put"
"""
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type == "call":
price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
elif option_type == "put":
price = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
else:
raise ValueError("Invalid option type. Use 'call' or 'put'.")
return price
```
### Step 3: Get Stock Data
We'll use the `yfinance` library to download the historical stock prices for Apple, Microsoft, and Tesla.
```python
# Define the stocks and the time period
stocks = ["AAPL", "MSFT", "TSLA"]
start_date = "2023-01-01"
end_date = "2024-01-01"
# Download the data
data = yf.download(stocks, start=start_date, end=end_date)['Adj Close']
# Calculate the annualized volatility
volatility = data.pct_change().std() * np.sqrt(252) # 252 trading days in a year
print(volatility)
```
### Step 4: Calculate Option Prices
Now, we’ll calculate the option prices for each stock using the Black-Scholes formula. We'll assume some values for the strike price, time to maturity, and risk-free rate.
```python
# Parameters for the Black-Scholes model
K = 1.05 * data.iloc[-1] # Assume strike price is 5% higher than the last price
T = 1 # 1 year to maturity
r = 0.05 # 5% risk-free rate
# Calculate option prices
option_prices = {}
for stock in stocks:
S = data[stock].iloc[-1] # Last available price
sigma = volatility[stock]
call_price = black_scholes(S, K[stock], T, r, sigma, option_type="call")
put_price = black_scholes(S, K[stock], T, r, sigma, option_type="put")
option_prices[stock] = {"call": call_price, "put": put_price}
# Display the option prices
option_prices
```
### Step 5: Plot the Results
Finally, let's plot the option prices against different stock prices to visualize how they change.
```python
# Stock price range for plotting
S_range = np.linspace(0.8 * data.iloc[-1].min(), 1.2 * data.iloc[-1].max(), 100)
# Plotting
plt.figure(figsize=(14, 8))
for stock in stocks:
S = S_range
sigma = volatility[stock]
call_prices = black_scholes(S, K[stock], T, r, sigma, option_type="call")
put_prices = black_scholes(S, K[stock], T, r, sigma, option_type="put")
plt.plot(S, call_prices, label=f"{stock} Call Option")
plt.plot(S, put_prices, label=f"{stock} Put Option", linestyle='--')
plt.title('Black-Scholes Option Prices')
plt.xlabel('Stock Price')
plt.ylabel('Option Price')
plt.legend()
plt.grid(True)
plt.show()
```
### Explanation of the Code:
1. Black-Scholes Formula (`black_scholes`):
- Inputs: Current stock price \( S \), strike price \( K \), time to expiration \( T \), risk-free rate \( r \), volatility \( \sigma \), and option type (call or put).
- Outputs: Price of the European call or put option.
2. Stock Data:
- We use the `yfinance` library to fetch historical adjusted closing prices for Apple, Microsoft, and Tesla.
- Annualized volatility is calculated based on daily returns.
3. Option Pricing:
- The option prices are computed using the last stock prices and the corresponding volatilities.
- We assume a strike price 5% higher than the last stock price and a time to expiration of one year.
4. Plotting:
- We plot the option prices (both call and put) as a function of different stock prices within a specified range.
### Step 6: Execute the Code
You can execute this code in a Python environment (like Jupyter Notebook) to visualize how the option prices for Apple, Microsoft, and Tesla behave under the Black-Scholes model.
No comments:
Post a Comment