期权策略进阶：Delta中性与备兑开仓实战

import numpy as np
from scipy.stats import norm
from options_pricing import BlackScholes

class DeltaNeutralStrategy:
    def __init__(self, underlying, initial_price, strike, maturity, rate=0.05, vol=0.2):
        self.underlying = underlying
        self.S = initial_price
        self.K = strike
        self.T = maturity
        self.r = rate
        self.sigma = vol
        
        # 初始头寸：卖出1份看涨期权 + 买入Delta股股票
        self.option_position = -1  # 卖出
        self.stock_position = self.calculate_delta() * 100  # Delta hedging
        
    def calculate_delta(self):
        """计算看涨期权Delta"""
        d1 = (np.log(self.S / self.K) + (self.r + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
        delta = norm.cdf(d1)
        return delta
    
    def rebalance(self, new_price):
        """价格变动后，重新平衡Delta"""
        old_delta = self.calculate_delta()
        self.S = new_price
        new_delta = self.calculate_delta()
        
        # 需要调整的股票数量
        delta_change = (new_delta - old_delta) * 100 * self.option_position
        self.stock_position += delta_change
        
        # 记录交易
        return {
            'price': new_price,
            'old_delta': old_delta,
            'new_delta': new_delta,
            'shares_traded': delta_change,
            'new_stock_position': self.stock_position
        }

# 使用示例
strategy = DeltaNeutralStrategy(underlying="AAPL", initial_price=150, strike=150, maturity=30/365)
print(f"初始Delta: {strategy.calculate_delta():.4f}")
print(f"初始持股: {strategy.stock_position} 股")

# 模拟价格上涨
result = strategy.rebalance(new_price=155)
print(f"价格上涨后，需要调整持股: {result['shares_traded']:.2f} 股")

class CoveredCallStrategy:
    def __init__(self, stock_price, strike_price, premium, shares=100):
        self.S0 = stock_price  # 买入成本价
        self.K = strike_price  # 期权行权价
        self.premium = premium  # 权利金收入（每股）
        self.shares = shares
        
        # 计算关键指标
        self.max_profit = (self.K - self.S0 + self.premium) * self.shares
        self.breakeven = self.S0 - self.premium
        
    def calculate_payoff(self, stock_price_at_expiry):
        """计算到期时的收益"""
        # 股票端收益
        stock_pnl = (stock_price_at_expiry - self.S0) * self.shares
        
        # 期权端收益（卖出期权，收取权利金）
        option_pnl = self.premium * self.shares
        
        # 如果股价高于行权价，期权被行权
        if stock_price_at_expiry > self.K:
            # 必须以K价格卖出股票
            stock_pnl = (self.K - self.S0) * self.shares
        
        total_pnl = stock_pnl + option_pnl
        return total_pnl

# 使用示例
strategy = CoveredCallStrategy(stock_price=150, strike_price=155, premium=3)
print(f"最大收益: {strategy.max_profit} 元")
print(f"盈亏平衡点: {strategy.breakeven} 元")

# 模拟不同到期价的收益
for price in [145, 150, 155, 160, 165]:
    pnl = strategy.calculate_payoff(price)
    print(f"到期价 {price} 元 → 收益: {pnl} 元")