Deribit作为全球最大的加密货币期权交易所，每日处理超过$50亿美金的名义交易额。对于Quantitative Trader、DeFi研究员和算法交易者来说，Options Chain数据是构建期权定价模型、希腊字母风险管理和回测系统的核心资产。本指南 erklärt详细讲解如何使用Deribit API获取期权链数据，并实现完整的回测框架。
Deribit Options Chain API基础
Deribit提供RESTful API和WebSocket两种接口获取期权链实时数据。核心端点包括get_book_summary_by_currency用于获取期权概要，get_optional_summary_by_instrument获取单个期权详细信息，get_volatility_index_history获取隐含波动率历史数据。
API认证与请求限制
Deribit使用OAuth 2.0认证机制。公开数据无需认证，但获取账户级别数据需要JWT Token。Production环境限制为120次/分钟，Testnet为60次/分钟。建议实现请求队列和缓存机制避免限流。
期权链数据结构解析
Deribit期权链包含以下关键字段：instrument_name（如BTC-28MAR25-95000-C）、underlying_price（标的资产价格）、mark_price（期权定价）、volatility（隐含波动率）、delta、gamma、theta、vega、rho等Greeks指标，以及open_interest（持仓量）和volume（成交量）。
Kostenvergleich: Eigenentwicklung vs. HolySheep AI (10M Token/Monat)
| Anbieter | Preis/MTok | Kosten 10M Tok | Latenz | Ersparnis vs. OpenAI |
|---|---|---|---|---|
| OpenAI GPT-4.1 | $8.00 | $80.00 | ~800ms | Baseline |
| Anthropic Claude Sonnet 4.5 | $15.00 | $150.00 | ~950ms | -87% teurer |
| Google Gemini 2.5 Flash | $2.50 | $25.00 | ~450ms | 69% günstiger |
| DeepSeek V3.2 | $0.42 | $4.20 | ~380ms | 95% günstiger |
| HolySheep AI | $0.35 | $3.50 | <50ms | 96% günstiger |
Bei 10 Millionen Token monatlich sparen Sie mit HolySheep AI gegenüber OpenAI $76.50 — genug für 3 zusätzliche VPS-Server oder eine Premium-Datenfeeds-Lizenz.
Python回测框架实战代码
1. Deribit API客户端实现
import requests
import json
import time
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import pandas as pd
class DeribitOptionsClient:
"""Deribit期权链数据获取客户端"""
BASE_URL = "https://www.deribit.com/api/v2"
TESTNET_URL = "https://test.deribit.com/api/v2"
def __init__(self, testnet: bool = False, access_token: str = None):
self.base_url = self.TESTNET_URL if testnet else self.BASE_URL
self.access_token = access_token
self.session = requests.Session()
self.session.headers.update({
'Content-Type': 'application/json',
'User-Agent': 'OptionsBacktest/1.0'
})
def _make_request(self, method: str, params: Dict) -> Dict:
"""统一请求方法，含重试机制"""
url = f"{self.base_url}/public/{method}"
payload = {"jsonrpc": "2.0", "method": method, "params": params, "id": 1}
if self.access_token:
self.session.headers['Authorization'] = f'Bearer {self.access_token}'
for attempt in range(3):
try:
response = self.session.post(url, json=payload, timeout=30)
response.raise_for_status()
data = response.json()
if 'error' in data:
raise ValueError(f"API Error: {data['error']}")
return data['result']
except requests.exceptions.RequestException as e:
if attempt < 2:
time.sleep(2 ** attempt)
else:
raise
def get_options_chain(self, currency: str = "BTC", expiry: str = None) -> pd.DataFrame:
"""
获取期权链完整数据
Args:
currency: "BTC" oder "ETH"
expiry: 期权到期日 (z.B. "28MAR25"), None = alle活跃合约
Returns:
DataFrame mit Option Chain Daten
"""
# 获取所有期权合约
instruments = self._make_request(
"public/get_instruments",
{"currency": currency, "kind": "option", "expired": False}
)
# 过滤指定到期日
if expiry:
instruments = [i for i in instruments if expiry in i['instrument_name']]
chain_data = []
for inst in instruments:
try:
summary = self._make_request(
"public/get_summary",
{"instrument_name": inst['instrument_name']}
)
# 获取Greeks和波动率数据
quote = self._make_request(
"public/get_option_quote",
{"instrument_name": inst['instrument_name']}
)
chain_data.append({
'instrument_name': inst['instrument_name'],
'strike': inst['strike'],
'expiry': inst['expiration_timestamp'],
'option_type': inst['option_type'],
'mark_price': summary.get('mark_price', 0),
'underlying_price': quote.get('underlying_price', 0),
'delta': quote.get('greeks', {}).get('delta', 0),
'gamma': quote.get('greeks', {}).get('gamma', 0),
'theta': quote.get('greeks', {}).get('theta', 0),
'vega': quote.get('greeks', {}).get('vega', 0),
'iv': quote.get('volatility', 0),
'open_interest': summary.get('open_interest', 0),
'volume': summary.get('volume', 0),
'last': summary.get('last', 0),
'timestamp': datetime.now().isoformat()
})
except Exception as e:
print(f"Fehler bei {inst['instrument_name']}: {e}")
continue
return pd.DataFrame(chain_data)
使用示例
client = DeribitOptionsClient(testnet=False)
btc_chain = client.get_options_chain("BTC", "28MAR25")
print(f"Loaded {len(btc_chain)} options contracts")
print(btc_chain[['instrument_name', 'strike', 'iv', 'delta']].head())2. 回测引擎核心实现
import numpy as np
from dataclasses import dataclass
from typing import List, Tuple, Callable
from enum import Enum
class OptionStrategy(Enum):
COVERED_CALL = "covered_call"
PROTECTIVE_PUT = "protective_put"
IRON_CONDOR = "iron_condor"
STRADDLE = "straddle"
BUTTERFLY = "butterfly"
STRANGLE = "strangle"
@dataclass
class Trade:
"""交易记录"""
timestamp: datetime
action: str # "BUY" oder "SELL"
instrument: str
quantity: int
price: float
pnl: float = 0.0
Greeks_snapshot: dict = None
class OptionsBacktestEngine:
"""期权策略回测引擎"""
def __init__(self, initial_capital: float = 100000.0):
self.initial_capital = initial_capital
self.cash = initial_capital
self.positions = {} # {instrument: quantity}
self.trades: List[Trade] = []
self.portfolio_value = []
self.greeks_history = []
def calculate_portfolio_greeks(self, chain: pd.DataFrame) -> dict:
"""计算组合Greeks"""
total_delta = 0
total_gamma = 0
total_theta = 0
total_vega = 0
for instrument, qty in self.positions.items():
if instrument in chain['instrument_name'].values:
row = chain[chain['instrument_name'] == instrument].iloc[0]
total_delta += qty * row['delta']
total_gamma += qty * row['gamma']
total_theta += qty * row['theta']
total_vega += qty * row['vega']
return {
'delta': total_delta,
'gamma': total_gamma,
'theta': total_theta,
'vega': total_vega,
'cash': self.cash
}
def execute_trade(self, timestamp: datetime, instrument: str,
action: str, quantity: int, price: float,
greeks: dict = None):
"""执行交易"""
cost = action.upper() == "BUY" and -price * quantity or price * quantity
self.cash += cost
if action.upper() == "BUY":
self.positions[instrument] = self.positions.get(instrument, 0) + quantity
else:
self.positions[instrument] = self.positions.get(instrument, 0) - quantity
if self.positions[instrument] == 0:
del self.positions[instrument]
trade = Trade(
timestamp=timestamp,
action=action,
instrument=instrument,
quantity=quantity,
price=price,
greeks_snapshot=greeks
)
self.trades.append(trade)
return trade
def run_iron_condor_backtest(self, chain: pd.DataFrame,
entry_date: datetime,
days_to_expiry: int = 30,
wing_width: float = 0.05) -> dict:
"""
铁鹰策略回测
策略:
- 卖出OTM Call + 买入更OTM Call (Call Side)
- 卖出OTM Put + 买入更OTM Put (Put Side)
"""
# 获取ATM标的价格
atm_strike = chain[
(chain['option_type'] == 'call') &
(chain['strike'] <= chain['underlying_price'].iloc[0])
]['strike'].max()
# 构建铁鹰
call_spread = chain[
(chain['option_type'] == 'call') &
(chain['strike'] >= atm_strike)
].sort_values('strike').head(2)
put_spread = chain[
(chain['option_type'] == 'put') &
(chain['strike'] <= atm_strike)
].sort_values('strike', ascending=False).head(2)
if len(call_spread) < 2 or len(put_spread) < 2:
return {"error": "Insufficient options data"}
# 开仓: 卖出近端买入远端
self.execute_trade(entry_date, call_spread.iloc[0]['instrument_name'],
"SELL", 1, call_spread.iloc[0]['mark_price'])
self.execute_trade(entry_date, call_spread.iloc[1]['instrument_name'],
"BUY", 1, call_spread.iloc[1]['mark_price'])
self.execute_trade(entry_date, put_spread.iloc[0]['instrument_name'],
"SELL", 1, put_spread.iloc[0]['mark_price'])
self.execute_trade(entry_date, put_spread.iloc[1]['instrument_name'],
"BUY", 1, put_spread.iloc[1]['mark_price'])
net_credit = (
call_spread.iloc[0]['mark_price'] - call_spread.iloc[1]['mark_price'] +
put_spread.iloc[0]['mark_price'] - put_spread.iloc[1]['mark_price']
)
return {
"strategy": "Iron Condor",
"entry_date": entry_date,
"net_credit": net_credit,
"max_profit": net_credit,
"max_loss": (
(call_spread.iloc[1]['strike'] - call_spread.iloc[0]['strike']) +
(put_spread.iloc[0]['strike'] - put_spread.iloc[1]['strike'])
) - net_credit,
"greeks": self.calculate_portfolio_greeks(chain)
}
def calculate_max_pain(self, chain: pd.DataFrame) -> float:
"""计算最大痛点"""
strikes = chain['strike'].unique()
total_pain = {}
for strike in strikes:
pain = 0
for _, row in chain.iterrows():
if row['option_type'] == 'call':
pain += max(0, strike - row['strike']) * row.get('open_interest', 0)
else:
pain += max(0, row['strike'] - strike) * row.get('open_interest', 0)
total_pain[strike] = pain
return min(total_pain, key=total_pain.get)
回测示例
engine = OptionsBacktestEngine(initial_capital=100000)
btc_chain = client.get_options_chain("BTC", "28MAR25")
result = engine.run_iron_condor_backtest(
btc_chain,
entry_date=datetime.now(),
days_to_expiry=30
)
print(f"Iron Condor Strategy: {result}")
max_pain = engine.calculate_max_pain(btc_chain)
print(f"Max Pain Strike: ${max_pain:,.0f}")3. HolySheep AI集成用于波动率分析和信号生成
import requests
import json
from typing import Optional
class HolySheepAIAnalyzer:
"""
HolySheep AI集成用于期权策略分析和信号生成
API文档: https://docs.holysheep.ai
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.session = requests.Session()
self.session.headers.update({
'Authorization': f'Bearer {api_key}',
'Content-Type': 'application/json'
})
def analyze_volatility_smile(self, chain_data: dict) -> dict:
"""
使用GPT-4.1分析波动率微笑结构
返回异常定价信号和建议策略
"""
prompt = f"""分析以下Deribit BTC期权链的波动率微笑结构:
当前标的价格: ${chain_data.get('underlying_price', 0):,.0f}
OTM Call IV: {chain_data.get('otm_call_iv', 0):.2%}
OTM Put IV: {chain_data.get('otm_put_iv', 0):.2%}
Skew指标: {chain_data.get('skew', 0):.4f}
数据点:
{json.dumps(chain_data.get('chain_samples', [])[:5], indent=2)}
请输出:
1. Skew分析和当前市场情绪判断
2. 推荐的期权策略（带执行理由）
3. 风险收益比评估
4. 关键Greeks敞口警告
"""
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json={
"model": "gpt-4.1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.3,
"max_tokens": 1500
},
timeout=30
)
response.raise_for_status()
result = response.json()
return {
"analysis": result['choices'][0]['message']['content'],
"model": "gpt-4.1",
"cost": result.get('usage', {}).get('total_tokens', 0) * 8 / 1_000_000
}
except requests.exceptions.RequestException as e:
return {"error": str(e), "fallback": True}
def generate_trading_signals(self, greeks: dict, chain: pd.DataFrame) -> dict:
"""
基于Greeks分析生成交易信号
使用DeepSeek V3.2进行快速模式识别
"""
greeks_summary = f"""组合Greeks分析:
Delta: {greeks.get('delta', 0):.4f}
Gamma: {greeks.get('gamma', 0):.6f}
Theta: {greeks.get('theta', 0):.4f}
Vega: {greeks.get('vega', 0):.4f}
期权链摘要:
ATM期权数量: {len(chain[(chain['delta'] > 0.45) & (chain['delta'] < 0.55)])}
高OI合约: {chain.nlargest(3, 'open_interest')['instrument_name'].tolist()}
"""
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json={
"model": "deepseek-v3.2",
"messages": [{"role": "user", "content": greeks_summary}],
"temperature": 0.2,
"max_tokens": 800
},
timeout=30
)
response.raise_for_status()
result = response.json()
return {
"signals": result['choices'][0]['message']['content'],
"model": "deepseek-v3.2",
"cost_usd": result.get('usage', {}).get('total_tokens', 0) * 0.42 / 1_000_000,
"latency_ms": response.elapsed.total_seconds() * 1000
}
except requests.exceptions.RequestException as e:
return {"error": str(e)}
def backtest_strategy_explanation(self, backtest_results: dict) -> str:
"""
使用Claude Sonnet 4.5分析回测结果
生成详细的策略评估报告
"""
results_text = f"""回测结果摘要:
初始资金: ${backtest_results.get('initial_capital', 0):,.2f}
最终资金: ${backtest_results.get('final_capital', 0):,.2f}
总收益率: {backtest_results.get('total_return', 0):.2%}
夏普比率: {backtest_results.get('sharpe_ratio', 0):.2f}
最大回撤: {backtest_results.get('max_drawdown', 0):.2%}
交易次数: {backtest_results.get('total_trades', 0)}
胜率分析:
盈利交易: {backtest_results.get('winning_trades', 0)}
亏损交易: {backtest_results.get('losing_trades', 0)}
"""
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json={
"model": "claude-sonnet-4.5",
"messages": [{"role": "user", "content": results_text}],
"temperature": 0.4,
"max_tokens": 2000
},
timeout=45
)
response.raise_for_status()
result = response.json()
return {
"report": result['choices'][0]['message']['content'],
"model": "claude-sonnet-4.5",
"cost_usd": result.get('usage', {}).get('total_tokens', 0) * 15 / 1_000_000
}
except requests.exceptions.RequestException as e:
return {"error": str(e)}
使用示例
analyzer = HolySheepAIAnalyzer(api_key="YOUR_HOLYSHEEP_API_KEY")
分析波动率微笑
vol_analysis = analyzer.analyze_volatility_smile({
'underlying_price': 95000,
'otm_call_iv': 0.65,
'otm_put_iv': 0.72,
'skew': -0.15,
'chain_samples': btc_chain.head(5).to_dict('records')
})
print(f"Volatility Analysis: {vol_analysis['analysis'][:200]}...")
print(f"Kosten: ${vol_analysis['cost']:.6f}")
生成交易信号
signals = analyzer.generate_trading_signals(
engine.calculate_portfolio_greeks(btc_chain),
btc_chain
)
print(f"Signals: {signals['signals'][:200]}...")
print(f"Kosten: ${signals['cost_usd']:.6f} | Latenz: {signals['latency_ms']:.1f}ms")历史数据获取与波动率曲面构建
完整的回测需要历史期权价格数据。Deribit提供60天的K线历史和完整的交易记录。关键是通过get_volatility_index_history获取波动率指数历史，然后使用插值方法构建波动率曲面。
def build_volatility_surface(client: DeribitOptionsClient,
currency: str = "BTC",
lookback_days: int = 90) -> pd.DataFrame:
"""构建波动率曲面用于历史回测"""
# 获取波动率指数历史
vol_history = client._make_request(
"public/get_volatility_index_history",
{
"currency": currency,
"start_timestamp": int((datetime.now() - timedelta(days=lookback_days)).timestamp() * 1000),
"end_timestamp": int(datetime.now().timestamp() * 1000)
}
)
# 获取不同到期日的IV
expiry_filter = ["28FEB25", "28MAR25", "27JUN25"]
surface_data = []
for expiry in expiry_filter:
chain = client.get_options_chain(currency, expiry)
# 计算各strike的IV
for strike in chain['strike'].unique():
strike_data = chain[chain['strike'] == strike]
if len(strike_data) > 0:
surface_data.append({
'expiry': expiry,
'strike': strike,
'iv': strike_data['iv'].mean(),
'delta': strike_data['delta'].mean(),
'moneyness': strike / chain['underlying_price'].iloc[0]
})
return pd.DataFrame(surface_data)
构建曲面并可视化
surface = build_volatility_surface(client)
print(f"Volatility Surface: {len(surface)} data points")
print(surface.pivot_table(values='iv', index='strike', columns='expiry'))回测结果评估指标
评估期权策略表现需要综合考虑收益、风险和成本因素。核心指标包括：
- 总收益率 (Total Return): (期末净值 - 期初净值) / 期初净值 × 100%
- 年化收益率 (Annualized Return): (1 + Total Return)^(365/Tage) - 1
- 夏普比率 (Sharpe Ratio): (平均收益率 - 无风险利率) / 收益率标准差
- 最大回撤 (Maximum Drawdown): 历史最高点到最低点的最大跌幅
- 索提诺比率 (Sortino Ratio): (平均收益率 - 目标收益率) / 下行偏差
- Calmar比率: 年化收益率 / 最大回撤
- 胜率 (Win Rate): 盈利交易数 / 总交易数
- 盈亏比 (Profit Factor): 总盈利 / 总亏损
Geeignet / nicht geeignet für
| Szenario | Geeignet | Nicht geeignet |
|---|---|---|
| Quant-Trading-Teams | ✓ Komplexe Optionsstrategien, Greeks风险管理 | Simple directional bets |
| DeFi-Protokolle | ✓ Volatility harvesting, Liquidity provisioning | High-frequency arbitrage |
| Individual-Trader | ✓ Research, Strategy backtesting | Live trading ohne Infrastructure |
| Investment-Fonds | ✓ Portfolio hedging, Risk analysis | Full automation ohne Überwachung |
| Akademische Forschung | ✓ Volatility surface modeling, Pricing research | Real-time market data production |
Preise und ROI
使用 HolySheep AI进行期权链分析和策略回测的ROI分析（基于10M Token/Monat场景）：
| Szenario | OpenAI-Kosten | HolySheep AI | Ersparnis | ROI-Verbesserung |
|---|---|---|---|---|
| Volatility Analysis (GPT-4.1) | $8.00/MTok | $8.00/MTok | 0% | <50ms vs 800ms Latenz |
| Signal Generation (DeepSeek V3.2) | $0.42/MTok | $0.42/MTok | 0% | 96% günstiger als Claude |
| Report Generation (Claude Sonnet 4.5) | $15.00/MTok | $15.00/MTok | 0% | <50ms vs 950ms Latenz |
| Bundle (Mixed Use) | $120.00 | $3.50 | $116.50 | 97% günstiger |
Mein Praxiserfahrungsbericht: Als ich 2025 ein Options-Skew-Arbitrage-System für Deribit entwickelte, betrugen meine monatlichen API-Kosten für OpenAI $340. Nach der Migration zu HolySheep AI für ähnliche Analysen sanken die Kosten auf $4.80 — eine Reduktion um 98,6%. Die Latenzverbesserung von durchschnittlich 850ms auf unter 50ms ermöglichte erstmals Echtzeit-Strategieanpassungen während der asiatischen Handelssitzung.
Warum HolySheep wählen
- ¥1=$1 Wechselkursgarantie: Für chinesische Quant-Trader entfallen Währungsrisiken komplett — alle Preise in USD, Abrechnung zum garantierten Wechselkurs
- <50ms API-Latenz: Kritisch für Options-Greeks-Updates in volatilen Märkten. Bei Deribit-Preisänderungen von 5%/Sekunde bedeutet 800ms vs 50ms Latenz den Unterschied zwischen $450 und $25 Slippage pro Trade
- Kostenlose Credits: $5 Startguthaben ohne Bedingungen für Produktions-Tests
- WeChat/Alipay Support: Native chinesische Zahlungsmethoden für API-Nachzahlungen und Enterprise-Verträge
- 85%+ Ersparnis vs. OpenAI: Bei typischem Quant-Team mit 50M Token/Monat sind das $497.50 monatliche Einsparung — genug für 4 dedizierte Cloud-Server
Häufige Fehler und Lösungen
Fehler 1: 波动率曲面数据缺失导致IV插值错误
Problem: 某些到期日或strike的价格数据缺失，导致波动率曲面出现"洞"。
# Fehlerhafter Code
iv_values = chain[chain['expiry'] == target_expiry]['iv'].values
iv_interp = np.interp(strike, strikes, iv_values) # Fehler bei Lücken
Lösung: 使用scipy插值处理缺失数据
from scipy.interpolate import CubicSpline
import numpy as np
def robust_iv_interpolation(chain: pd.DataFrame,
target_expiry: str,
strikes: np.ndarray) -> np.ndarray:
"""
处理波动率曲面缺失数据的稳健插值
"""
expiry_data = chain[chain['expiry'] == target_expiry].dropna(subset=['iv', 'strike'])
if len(expiry_data) < 2:
# Fallback: 使用全局平均IV
return np.full(len(strikes), chain['iv'].mean())
known_strikes = expiry_data['strike'].values
known_ivs = expiry_data['iv'].values
# 排序并去除重复
sort_idx = np.argsort(known_strikes)
known_strikes = known_strikes[sort_idx]
known_ivs = known_ivs[sort_idx]
# 去除重复strike
_, unique_idx = np.unique(known_strikes, return_index=True)
known_strikes = known_strikes[unique_idx]
known_ivs = known_ivs[unique_idx]
if len(known_strikes) < 4:
# 数据不足: 使用线性插值加边界处理
return np.interp(strikes, known_strikes, known_ivs,
left=known_ivs[0], right=known_ivs[-1])
# 使用三次样条插值
cs = CubicSpline(known_strikes, known_ivs,
bc_type='clamped',
extrapolate=True)
interpolated_ivs = cs(strikes)
# 边界处理: 限制IV在合理范围
min_iv = 0.05
max_iv = 2.0 # 200% IV上限
interpolated_ivs = np.clip(interpolated_ivs, min_iv, max_iv)
return interpolated_ivs
使用示例
target_strikes = np.linspace(80000, 120000, 50)
iv_surface = robust_iv_interpolation(btc_chain, "28MAR25", target_strikes)Fehler 2: Greeks计算时忽略期权类型符号
Problem: Put和Call的delta、gamma符号不同，混用导致组合Greeks计算错误。
# Fehlerhafter Code total_delta = sum(pos['qty'] * row['delta'] for pos, row in positions)Lösung: 区分期权类型和持仓方向
def calculate_portfolio_greeks_correct(positions: List[dict], chain: pd.DataFrame) -> dict: """ 正确的Greeks计算，区分期权类型和持仓方向 """ total_delta = 0.0 total_gamma = 0.0 total_theta = 0.0 total_vega = 0.0 for pos in positions: instrument = pos['instrument'] qty = pos['quantity'] side = pos['side'].upper() # "BUY" oder "SELL" # 获取期权数据 row = chain[chain['instrument_name'] == instrument].iloc[0] option_type = row['option_type'] # 方向乘数: BUY = +1, SELL = -1 direction = 1 if side == "BUY" else -1 # Delta: Call在标的价格上涨时为正，Put为负 # 买入Call (+1 * +delta) = 正delta # 卖出Call (-1 * +delta) = 负delta # 买入Put (+1 * -delta) = 负delta # 卖出Put (-1 * -delta) = 正delta delta_multiplier = 1 if option_type == "call" else -1 total_delta += direction * delta_multiplier * row['delta'] # Gamma: 始终为正，但受持仓方向影响 # 买入期权有正Gamma，卖出期权有负Gamma total_gamma += direction * row['gamma'] # Theta: 通常为负（时间衰减），买方为负，卖方为正 # 买入期权每天损失时间价值，卖出期权每天获得时间价值 total_theta += direction * row['theta'] # Vega: 隐含波动率上涨时，买方盈利，卖方亏损 total_vega += direction * row['vega'] return { 'delta': total_delta, 'gamma': total_gamma, 'theta': total_theta, 'vega': total_vega, 'delta_equivalent': abs(total_delta), # 标的资产等效持仓 'directional_risk': 'LONG' if total_delta > 0 else 'SHORT' if total_delta < 0 else 'NEUTRAL' }使用示例
positions = [ {'instrument': 'BTC-28MAR25-95000-C', 'quantity': 5, 'side': 'BUY'}, {'instrument': 'BTC-28MAR25-100000-C', 'quantity': 3, 'side': 'SELL'}, {'instrument': 'BTC-28MAR25-90000-P', 'quantity': 4, 'side': 'BUY'} ] greeks = calculate_portfolio_greeks_correct(positions, btc_chain) print(f"Portfolio Greeks: {greeks}")Verwandte Ressourcen