Análise de Derivativos e Opções com Python: Precificação, Risco e Estratégias Quantitativas
Eles são amplamente utilizados por investidores, traders e instituições financeiras para proteção contra riscos (hedge), especulação e alavancagem de posições.
Neste artigo, exploraremos como usar Python para analisar, simular e precificar derivativos e opções financeiras, aplicando conceitos clássicos como o modelo de Black-Scholes, gregas, Monte Carlo e estratégias com opções.
1. O que são Derivativos e Opções?
Derivativos:
Instrumentos cujo valor depende do comportamento de outro ativo, como:
Futuros (contratos de compra/venda futura);
Swaps (troca de fluxos financeiros);
Opções (direito de comprar ou vender algo no futuro).
Opções:
São contratos que dão o direito, mas não a obrigação, de comprar ou vender um ativo a um preço pré-definido (strike) até uma data de vencimento.
Tipos principais:
Call → Direito de comprar o ativo.
Put → Direito de vender o ativo.
📈 O comprador paga um prêmio pela opção.
Se o mercado se mover a seu favor, ele exerce; se não, perde apenas o prêmio.
2. Importando Bibliotecas e Preparando o Ambiente
Vamos começar configurando as principais bibliotecas em Python:
pip install numpy pandas matplotlib scipy yfinance seaborn
E depois importar:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import norm
import yfinance as yf
3. Coletando Dados de Ações com yfinance
Para ilustrar, usaremos os dados da PETR4.SA (Petrobras) como ativo subjacente:
dados = yf.download("PETR4.SA", start="2023-01-01", end="2025-01-01")
dados["Close"].plot(figsize=(12,5), title="Preço PETR4.SA", color="blue")
plt.ylabel("Preço (R$)")
plt.show()
4. Implementando o Modelo de Black-Scholes
O modelo Black-Scholes-Merton é o padrão clássico para precificar opções europeias (exercidas apenas no vencimento).
Fórmulas principais:
[
d_1 = \frac{\ln(\frac{S}{K}) + (r + \frac{\sigma^2}{2})T}{\sigma\sqrt{T}}
]
[
d_2 = d_1 - \sigma\sqrt{T}
]
[
C = S \cdot N(d_1) - K \cdot e^{-rT} \cdot N(d_2)
]
[
P = K \cdot e^{-rT} \cdot N(-d_2) - S \cdot N(-d_1)
]
Onde:
( S ) = preço atual do ativo
( K ) = preço de exercício (strike)
( r ) = taxa de juros anual
( \sigma ) = volatilidade anual
( T ) = tempo até o vencimento (em anos)
( N() ) = função de distribuição normal cumulativa
Código em Python:
def black_scholes(S, K, T, r, sigma, tipo="call"):
d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if tipo == "call":
preco = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
else:
preco = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
return preco
Exemplo de uso:
S = 40 # Preço atual da ação
K = 42 # Strike
T = 0.5 # Tempo até vencimento (6 meses)
r = 0.10 # Taxa livre de risco (10% a.a.)
sigma = 0.25 # Volatilidade anual
call = black_scholes(S, K, T, r, sigma, "call")
put = black_scholes(S, K, T, r, sigma, "put")
print(f"Preço Call: R$ {call:.2f}")
print(f"Preço Put: R$ {put:.2f}")
5. Visualizando o Comportamento da Opção
Podemos observar como o valor da opção Call muda conforme o preço do ativo:
precos = np.linspace(30, 55, 50)
valores_call = [black_scholes(s, K, T, r, sigma, "call") for s in precos]
plt.figure(figsize=(10,5))
plt.plot(precos, valores_call, color="green")
plt.title("Preço da Opção Call vs Preço da Ação")
plt.xlabel("Preço da Ação (S)")
plt.ylabel("Preço da Opção (Call)")
plt.grid(True)
plt.show()
📈 Quanto maior o preço da ação em relação ao strike, mais valiosa a opção call se torna.
6. Cálculo das "Gregas"
As gregas medem a sensibilidade do preço da opção em relação a diversas variáveis:
| Grega | Significado | Mede |
|---|---|---|
| Delta | Sensibilidade ao preço do ativo | Variação da opção para 1 unidade no ativo |
| Gamma | Sensibilidade da Delta | Curvatura do preço da opção |
| Vega | Sensibilidade à volatilidade | Variação por 1% na volatilidade |
| Theta | Sensibilidade ao tempo | Decaimento temporal da opção |
| Rho | Sensibilidade à taxa de juros | Impacto de 1% em r |
Código para cálculo:
def greeks(S, K, T, r, sigma):
d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
d2 = d1 - sigma*np.sqrt(T)
delta = norm.cdf(d1)
gamma = norm.pdf(d1)/(S*sigma*np.sqrt(T))
vega = S*norm.pdf(d1)*np.sqrt(T)/100
theta = -(S*norm.pdf(d1)*sigma)/(2*np.sqrt(T)) - r*K*np.exp(-r*T)*norm.cdf(d2)
rho = K*T*np.exp(-r*T)*norm.cdf(d2)/100
return delta, gamma, vega, theta, rho
7. Simulação de Monte Carlo para Opções
Podemos estimar o preço de uma opção por simulação estocástica dos preços futuros do ativo.
Código:
def monte_carlo_call(S, K, T, r, sigma, n_sim=100000):
np.random.seed(42)
Z = np.random.standard_normal(n_sim)
ST = S * np.exp((r - 0.5*sigma**2)*T + sigma*np.sqrt(T)*Z)
payoff = np.maximum(ST - K, 0)
preco = np.exp(-r*T)*np.mean(payoff)
return preco
mc_preco = monte_carlo_call(S, K, T, r, sigma)
print(f"Preço estimado via Monte Carlo: R$ {mc_preco:.2f}")
8. Estratégias com Opções (Python)
Exemplo: Bull Spread (Estratégia Otimista)
Compra uma Call com strike baixo e vende uma Call com strike alto.
K1, K2 = 40, 45
call_bought = [black_scholes(s, K1, T, r, sigma, "call") for s in precos]
call_sold = [black_scholes(s, K2, T, r, sigma, "call") for s in precos]
spread = np.array(call_bought) - np.array(call_sold)
plt.figure(figsize=(10,5))
plt.plot(precos, spread, label="Bull Spread", color="orange")
plt.xlabel("Preço da Ação (S)")
plt.ylabel("Lucro / Prejuízo")
plt.title("Estratégia Bull Spread com Opções Call")
plt.axhline(0, color="black", linestyle="--")
plt.legend()
plt.grid(True)
plt.show()
📈 Essa estratégia limita o lucro e reduz o risco, ideal para investidores moderadamente otimistas.
9. Avaliando Volatilidade Histórica e Implícita
A volatilidade é o coração da precificação de opções. Podemos calcular a volatilidade histórica de um ativo com:
dados["Retornos"] = np.log(dados["Close"] / dados["Close"].shift(1))
vol_hist = dados["Retornos"].std() * np.sqrt(252)
print(f"Volatilidade Histórica: {vol_hist:.2%}")
📊 Para a volatilidade implícita, utiliza-se o valor de mercado da opção e resolve-se inversamente o modelo Black-Scholes (via métodos numéricos).
10. Aplicações Reais
✅ Gestão de Risco: Hedge cambial e proteção de portfólios.
✅ Trading Quantitativo: Identificação de opções sub ou sobrevalorizadas.
✅ Avaliação de volatilidade: Modelagem de incertezas do mercado.
✅ Precificação de derivativos exóticos: Opções asiáticas, barrier options etc.
11. Conclusão
Os derivativos e opções são ferramentas essenciais no mercado financeiro moderno.
Com Python, é possível desenvolver análises avançadas, precificar contratos, medir riscos e testar estratégias complexas com alta precisão.
A combinação de modelos teóricos (como Black-Scholes) e simulações computacionais (como Monte Carlo) oferece uma base sólida para quem deseja trabalhar com finanças quantitativas, gestão de risco ou trading algorítmico.
Comentários
Postar um comentário