从零实现 Black-Scholes 期权定价：Python 完整代码 + Greeks 深度解析 2026

1import numpy as np
2from scipy.stats import norm
3import matplotlib.pyplot as plt
4from dataclasses import dataclass
5from typing import Literal
6
7@dataclass
8class BSMOption:
9    """Black-Scholes-Merton 期权定价模型
10    
11    参数:
12        S: 标的资产当前价格
13        K: 行权价
14        T: 到期时间（年）
15        r: 无风险利率（年化）
16        sigma: 波动率（年化）
17        option_type: 'call' 或 'put'
18    """
19    S: float
20    K: float
21    T: float
22    r: float
23    sigma: float
24    option_type: Literal['call', 'put'] = 'call'
25    
26    def _d1_d2(self):
27        """计算 d1 和 d2"""
28        d1 = (np.log(self.S / self.K) + 
29              (self.r + 0.5 * self.sigma**2) * self.T) / \
30             (self.sigma * np.sqrt(self.T))
31        d2 = d1 - self.sigma * np.sqrt(self.T)
32        return d1, d2
33    
34    def price(self) -> float:
35        """计算期权理论价格"""
36        d1, d2 = self._d1_d2()
37        if self.option_type == 'call':
38            return (self.S * norm.cdf(d1) - 
39                    self.K * np.exp(-self.r * self.T) * norm.cdf(d2))
40        else:  # put
41            return (self.K * np.exp(-self.r * self.T) * norm.cdf(-d2) - 
42                    self.S * norm.cdf(-d1))
43    
44    def delta(self) -> float:
45        """Delta: 期权价格对标的资产价格的一阶导数"""
46        d1, _ = self._d1_d2()
47        if self.option_type == 'call':
48            return norm.cdf(d1)
49        else:
50            return norm.cdf(d1) - 1
51    
52    def gamma(self) -> float:
53        """Gamma: Delta 对标的资产价格的导数（二阶导数）"""
54        d1, _ = self._d1_d2()
55        return norm.pdf(d1) / (self.S * self.sigma * np.sqrt(self.T))
56    
57    def theta(self) -> float:
58        """Theta: 期权价格对时间的导数（每日时间价值损耗）"""
59        d1, d2 = self._d1_d2()
60        term1 = -(self.S * norm.pdf(d1) * self.sigma) / (2 * np.sqrt(self.T))
61        if self.option_type == 'call':
62            term2 = -self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(d2)
63        else:
64            term2 = self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(-d2)
65        return (term1 + term2) / 365  # 转换为每日
66    
67    def vega(self) -> float:
68        """Vega: 期权价格对波动率的导数（每 1% 波动率变化）"""
69        d1, _ = self._d1_d2()
70        return self.S * norm.pdf(d1) * np.sqrt(self.T) / 100
71    
72    def rho(self) -> float:
73        """Rho: 期权价格对无风险利率的导数（每 1% 利率变化）"""
74        _, d2 = self._d1_d2()
75        if self.option_type == 'call':
76            return self.K * self.T * np.exp(-self.r * self.T) * norm.cdf(d2) / 100
77        else:
78            return -self.K * self.T * np.exp(-self.r * self.T) * norm.cdf(-d2) / 100
79    
80    def greeks_summary(self) -> dict:
81        """返回所有 Greeks 的汇总"""
82        return {
83            'Price': self.price(),
84            'Delta': self.delta(),
85            'Gamma': self.gamma(),
86            'Theta (daily)': self.theta(),
87            'Vega (per 1%)': self.vega(),
88            'Rho (per 1%)': self.rho(),
89        }
90
91
92# 示例：Apple 看涨期权
93option = BSMOption(
94    S=185.0,    # 当前股价
95    K=190.0,    # 行权价
96    T=30/365,   # 30 天到期
97    r=0.05,     # 5% 无风险利率
98    sigma=0.25, # 25% 年化波动率
99    option_type='call'
100)
101
102print("=== Black-Scholes 期权定价结果 ===")
103for key, value in option.greeks_summary().items():
104    print(f"{key:20s}: {value:.6f}")

1import numpy as np
2
3def monte_carlo_option_price(
4    S: float, K: float, T: float, r: float, sigma: float,
5    option_type: str = 'call', n_simulations: int = 100_000
6) -> tuple[float, float]:
7    """
8    Monte Carlo 期权定价
9    返回: (价格估计, 标准误差)
10    """
11    # 生成标的资产到期价格
12    Z = np.random.standard_normal(n_simulations)
13    S_T = S * np.exp((r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * Z)
14    
15    # 计算到期收益
16    if option_type == 'call':
17        payoffs = np.maximum(S_T - K, 0)
18    else:
19        payoffs = np.maximum(K - S_T, 0)
20    
21    # 折现到当前时刻
22    discounted_payoffs = np.exp(-r * T) * payoffs
23    
24    price = np.mean(discounted_payoffs)
25    std_error = np.std(discounted_payoffs) / np.sqrt(n_simulations)
26    
27    return price, std_error
28
29
30# 对比 Black-Scholes 解析解和 Monte Carlo 结果
31np.random.seed(42)
32mc_price, mc_se = monte_carlo_option_price(
33    S=185.0, K=190.0, T=30/365, r=0.05, sigma=0.25
34)
35bs_price = BSMOption(185.0, 190.0, 30/365, 0.05, 0.25).price()
36
37print(f"Black-Scholes 解析解: {bs_price:.4f}")
38print(f"Monte Carlo 估计:    {mc_price:.4f} ± {mc_se:.4f}")
39print(f"相对误差:            {abs(mc_price - bs_price) / bs_price * 100:.2f}%")