Análise de Performance de Portfólio com Python: Medindo o Alpha e o Sucesso Real da sua Carteira

Nos nossos encontros anteriores, construímos um arsenal poderoso para a gestão de portfólios, desde a otimização de Markowitz até a quantificação de risco com VaR e CVaR. Agora, vamos ao teste definitivo: a análise de performance de portfólio. Não basta ter retorno positivo; um verdadeiro especialista precisa responder com precisão: a sua estratégia está, de fato, gerando valor acima do mercado?

Neste artigo técnico, vamos aprofundar nossa análise para medir o sucesso real de uma carteira. Iremos além das métricas básicas e implementaremos um framework completo em Python para calcular o Alpha e o Beta, os dois indicadores mais críticos para avaliar a performance ajustada ao risco. Ao final, você terá um painel de controle que não apenas mostra se você ganhou dinheiro, mas quantifica como e com que eficiência você o fez em relação ao benchmark.

Vamos estruturar e executar um backtest de performance completo, passo a passo.

O Código Completo: Um Framework de Análise de Performance

A seguir, apresento o script completo que servirá como nossa ferramenta de análise. Ele é composto por 12 partes, desde a importação das bibliotecas até a execução final, e foi projetado para ser modular e de fácil compreensão. Copie e cole este código em seu ambiente de desenvolvimento (como Jupyter ou Google Colab) para acompanhar a análise.

# ==============================================================================
# 1. IMPORTAÇÃO DE BIBLIOTECAS E CONFIGURAÇÕES INICIAIS
# ==============================================================================
import pandas as pd
import numpy as np
import yfinance as yf
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from scipy.stats import linregress # Essencial para o cálculo de Alpha e Beta

# --- Parâmetros da Análise ---
ATIVOS = ['WEGE3.SA', 'PETR4.SA', 'VALE3.SA', 'BBDC4.SA']
PESOS_PORTFOLIO = np.array([0.25, 0.25, 0.25, 0.25])
BENCHMARK = '^BVSP'
DATA_INICIO = '2023-01-01'
DATA_FIM = '2025-01-01'

# --- Constantes Financeiras ---
DIAS_UTEIS_ANO = 252
NIVEL_CONFIANCA_VaR = 0.95

# ==============================================================================
# 2. FUNÇÃO: DOWNLOAD DE DADOS DO YFINANCE
# ==============================================================================
def baixar_dados_completos(ativos, benchmark, data_inicio, data_fim):
    """Baixa dados históricos de preços de fechamento ajustados."""
    todos_ativos = ativos + [benchmark]
    print("📥 Baixando dados do Yahoo Finance...")
    dados_multi = yf.download(todos_ativos, start=data_inicio, end=data_fim, progress=False)
    try:
        precos = dados_multi['Adj Close']
    except KeyError:
        precos = dados_multi['Close']
    print(f"✅ Dados baixados: {len(precos)} períodos")
    return precos

# ==============================================================================
# 3. FUNÇÃO: CÁLCULO DE RETORNOS DIÁRIOS
# ==============================================================================
def calcular_retornos_diarios(precos):
    """Calcula retornos diários a partir dos preços."""
    retornos = precos.pct_change().dropna()
    print("📊 Retornos diários calculados")
    return retornos

# ==============================================================================
# 4. FUNÇÃO: CÁLCULO DAS MÉTRICAS DE DESEMPENHO
# ==============================================================================
def calcular_metricas_desempenho(retornos_portfolio):
    """Calcula métricas de desempenho do portfólio."""
    retorno_anualizado = retornos_portfolio.mean() * DIAS_UTEIS_ANO
    volatilidade_anualizada = retornos_portfolio.std() * np.sqrt(DIAS_UTEIS_ANO)
    sharpe_ratio = retorno_anualizado / volatilidade_anualizada
    return retorno_anualizado, volatilidade_anualizada, sharpe_ratio

# ==============================================================================
# 5. FUNÇÃO: CÁLCULO DAS MÉTRICAS DE RISCO (VaR e CVaR)
# ==============================================================================
def calcular_metricas_risco(retornos_portfolio, confianca=0.95):
    """Calcula Value at Risk (VaR) e Conditional VaR (CVaR) históricos."""
    var_hist = retornos_portfolio.quantile(1 - confianca)
    var_hist_perda = -var_hist
    cvar_hist = -retornos_portfolio[retornos_portfolio < var_hist].mean()
    print("✅ Métricas de risco calculadas")
    return var_hist_perda, cvar_hist

# ==============================================================================
# 6. FUNÇÃO: CÁLCULO DE MÉTRICAS COMPARATIVAS (ALPHA E BETA)
# ==============================================================================
def calcular_metricas_comparativas(retornos_portfolio, retornos_benchmark):
    """Calcula Alpha, Beta e outras métricas comparativas."""
    slope, intercept, r_value, p_value, std_err = linregress(retornos_benchmark, retornos_portfolio)
    beta = slope
    alpha = intercept * DIAS_UTEIS_ANO

    retorno_anual_port, vol_anual_port, sharpe_port = calcular_metricas_desempenho(retornos_portfolio)
    retorno_anual_bench, vol_anual_bench, sharpe_bench = calcular_metricas_desempenho(retornos_benchmark)

    metricas = {
        'portfolio': {'retorno_anual': retorno_anual_port, 'volatilidade': vol_anual_port, 'sharpe': sharpe_port},
        'benchmark': {'retorno_anual': retorno_anual_bench, 'volatilidade': vol_anual_bench, 'sharpe': sharpe_bench},
        'alpha': alpha,
        'beta': beta
    }
    print("✅ Métricas comparativas (Alpha e Beta) calculadas")
    return metricas

# ==============================================================================
# 7. FUNÇÃO: CRIAÇÃO DE GRÁFICO COMPARATIVO
# ==============================================================================
def criar_grafico_comparativo(retornos_acum_port, retornos_acum_bench):
    """Cria gráfico comparativo entre portfólio e benchmark."""
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=retornos_acum_port.index, y=retornos_acum_port.values, mode='lines', name='Portfólio', line=dict(color='#2E86AB', width=3)))
    fig.add_trace(go.Scatter(x=retornos_acum_bench.index, y=retornos_acum_bench.values, mode='lines', name='IBOVESPA', line=dict(color='#A23B72', width=3, dash='dash')))
    fig.update_layout(title='📊 COMPARAÇÃO: PORTFÓLIO vs IBOVESPA (Retorno Acumulado)', xaxis_title='Data', yaxis_title='Retorno Acumulado (Base 1)', template='plotly_white', height=500, legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01))
    return fig

# ==============================================================================
# 8. FUNÇÃO: CRIAÇÃO DE GRÁFICO DE ATIVOS INDIVIDUAIS
# ==============================================================================
def criar_grafico_ativos_individual(retornos, retornos_acum_bench, ativos):
    """Cria gráfico com evolução individual de cada ativo."""
    fig = make_subplots(rows=2, cols=2, subplot_titles=[f'📈 {ativo}' for ativo in ativos], vertical_spacing=0.1, horizontal_spacing=0.1)
    cores = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
    for i, ativo in enumerate(ativos):
        row, col = (i // 2) + 1, (i % 2) + 1
        retorno_acum_ativo = (1 + retornos[ativo]).cumprod()
        fig.add_trace(go.Scatter(x=retorno_acum_ativo.index, y=retorno_acum_ativo.values, mode='lines', name=ativo, line=dict(color=cores[i], width=2)), row=row, col=col)
        fig.add_trace(go.Scatter(x=retornos_acum_bench.index, y=retornos_acum_bench.values, mode='lines', name='IBOVESPA', line=dict(color='black', width=1, dash='dot'), showlegend=(i==0)), row=row, col=col)
    fig.update_layout(title='📈 EVOLUÇÃO INDIVIDUAL DOS ATIVOS vs IBOVESPA', template='plotly_white', height=600, showlegend=True)
    fig.update_yaxes(title_text="Retorno Acumulado", row=1, col=1)
    fig.update_yaxes(title_text="Retorno Acumulado", row=2, col=1)
    return fig

# ==============================================================================
# 9. FUNÇÃO: CRIAÇÃO DE GRÁFICO DE PERFORMANCE RELATIVA
# ==============================================================================
def criar_grafico_performance_relativa(retornos_acum_port, retornos_acum_bench):
    """Cria gráfico de performance relativa entre portfólio e benchmark."""
    performance_relativa = retornos_acum_port / retornos_acum_bench
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=performance_relativa.index, y=performance_relativa.values, mode='lines', name='Performance Relativa', line=dict(color='#FF6B6B', width=3), fill='tozeroy', fillcolor='rgba(255, 107, 107, 0.2)'))
    fig.add_hline(y=1, line_dash="dash", line_color="gray", annotation_text="Linha de Referência")
    fig.update_layout(title='📈 PERFORMANCE RELATIVA (Portfólio / IBOVESPA)', xaxis_title='Data', yaxis_title='Razão de Performance', template='plotly_white', height=400)
    return fig

# ==============================================================================
# 10. FUNÇÃO: EXIBIÇÃO DE RESULTADOS NO CONSOLE
# ==============================================================================
def exibir_resultados_console(metricas, var_perda, cvar_perda, ativos, pesos):
    """Exibe resultados detalhados no console."""
    print("\n" + "="*80); print("📈 ANÁLISE COMPLETA DO PORTFÓLIO"); print("="*80)
    print(f"\n🎯 COMPOSIÇÃO DO PORTFÓLIO:")
    for i, ativo in enumerate(ativos): print(f"  {ativo}: {pesos[i]*100:.1f}%")
    print(f"\n🏆 DESEMPENHO ANUALIZADO:")
    print(f"Portfólio: {metricas['portfolio']['retorno_anual']*100:7.2f}%"); print(f"IBOVESPA:  {metricas['benchmark']['retorno_anual']*100:7.2f}%")
    print(f"Diferença: {(metricas['portfolio']['retorno_anual'] - metricas['benchmark']['retorno_anual'])*100:+.2f}%")
    print(f"\n📊 VOLATILIDADE:"); print(f"Portfólio: {metricas['portfolio']['volatilidade']*100:7.2f}%"); print(f"IBOVESPA:  {metricas['benchmark']['volatilidade']*100:7.2f}%")
    print(f"\n⭐ SHARPE RATIO:"); print(f"Portfólio: {metricas['portfolio']['sharpe']:7.2f}"); print(f"IBOVESPA:  {metricas['benchmark']['sharpe']:7.2f}")
    print(f"\n🔗 RISCO SISTEMÁTICO:"); print(f"Beta: {metricas['beta']:.2f}"); print(f"Alpha: {metricas['alpha']*100:.2f}%")
    print(f"\n📉 MÉTRICAS DE RISCO (Diário, {NIVEL_CONFIANCA_VaR*100}% Confiança):"); print(f"VaR:  {var_perda*100:.2f}%"); print(f"CVaR: {cvar_perda*100:.2f}%")

# ==============================================================================
# 11. FUNÇÃO PRINCIPAL (main)
# ==============================================================================
def main():
    """Função principal que executa toda a análise do portfólio."""
    print("🚀 INICIANDO ANÁLISE DE PORTFÓLIO"); print("="*50)
    precos = baixar_dados_completos(ATIVOS, BENCHMARK, DATA_INICIO, DATA_FIM)
    retornos = calcular_retornos_diarios(precos)
    retornos_portfolio = retornos[ATIVOS].dot(PESOS_PORTFOLIO)
    retornos_benchmark = retornos[BENCHMARK]
    var_perda, cvar_perda = calcular_metricas_risco(retornos_portfolio, NIVEL_CONFIANCA_VaR)
    metricas = calcular_metricas_comparativas(retornos_portfolio, retornos_benchmark)
    retornos_acum_port = (1 + retornos_portfolio).cumprod()
    retornos_acum_bench = (1 + retornos_benchmark).cumprod()
    exibir_resultados_console(metricas, var_perda, cvar_perda, ATIVOS, PESOS_PORTFOLIO)
    fig_comparacao = criar_grafico_comparativo(retornos_acum_port, retornos_acum_bench)
    fig_ativos = criar_grafico_ativos_individual(retornos, retornos_acum_bench, ATIVOS)
    fig_relativa = criar_grafico_performance_relativa(retornos_acum_port, retornos_acum_bench)
    print("\n🎯 RESULTADO FINAL:")
    if metricas['portfolio']['retorno_anual'] > metricas['benchmark']['retorno_anual']: print("✅ PORTFÓLIO SUPEROU O IBOVESPA!")
    else: print("❌ PORTFÓLIO INFERIOR AO IBOVESPA")
    print(f"\n📅 Período de Análise: {DATA_INICIO} até {DATA_FIM}")
    fig_comparacao.show(); fig_ativos.show(); fig_relativa.show()

# ==============================================================================
# 12. EXECUÇÃO DO PROGRAMA
# ==============================================================================
if __name__ == "__main__":
    main()

Resultados e Diagnóstico do Portfólio

Ao executar o script, ele produzirá um conjunto de visualizações e um relatório detalhado no console. Vamos interpretar esses resultados como um especialista faria, conectando cada imagem a uma análise específica.

Se você é um iniciante leia sobre o assunto – Análise Quantitativa para Iniciantes em Python

Visão Geral: Portfólio vs. Ibovespa

O primeiro passo de qualquer análise de performance é a comparação direta. O gráfico abaixo, gerado pela função criar_grafico_comparativo, plota a curva de retorno acumulado da nossa carteira (azul) contra a do benchmark (tracejado).

A imagem é clara: o portfólio não apenas acompanhou, mas estabeleceu uma trajetória de descolamento positivo do Ibovespa, especialmente a partir do segundo semestre de 2024. Este é o primeiro sinal de uma performance superior e o que nos motiva a investigar mais a fundo.

Análise de Componentes: Performance Individual dos Ativos

Um portfólio é a soma de suas partes. Para entender os drivers de retorno, a função criar_grafico_ativos_individual dissecou o desempenho de cada componente.

Esta visão granular é crucial. Identificamos que WEGE3.SA foi um forte contribuinte para o alfa, superando consistentemente o benchmark. Em contrapartida, VALE3.SA atuou como um detrator de performance no período. Essa análise é fundamental para futuras decisões de rebalanceamento e para entender quais teses de investimento se provaram corretas.

O Teste Decisivo: Performance Relativa

Este gráfico, produto da função criar_grafico_performance_relativa, é talvez o mais importante. Ele normaliza o retorno do portfólio pelo retorno do benchmark, nos dando uma visão clara da performance relativa.

A interpretação é inequívoca:

• Acima da linha de 1: Nosso portfólio está superando o Ibovespa.
• Abaixo da linha de 1: Desempenho inferior. A tendência ascendente da curva a partir de 2024 demonstra que nossa capacidade de gerar alfa foi crescente ao longo do tempo, um sinal de robustez da estratégia.

O Relatório Final: Métricas Consolidadas

Finalmente, a função exibir_resultados_console nos entrega o resumo quantitativo, que é a base para o nosso diagnóstico final.

Diagnóstico de Especialista com base nos dados:

1. Desempenho Anualizado: O portfólio entregou 14.76% ao ano, mais que o dobro dos 7.35% do Ibovespa. Uma performance absoluta impressionante.
2. Eficiência (Sharpe Ratio): Com um Sharpe de 0.92 contra 0.49 do benchmark, o portfólio gerou quase o dobro de retorno por unidade de risco. Uma eficiência notável.
3. Alpha e Beta (O Veredito): Aqui reside a confirmação do nosso sucesso. Um Beta de 0.87 revela que a carteira foi defensiva, ou seja, 13% menos volátil que o mercado. O Alpha de 8.34% é a prova quantitativa de que a estratégia gerou um retorno excedente significativo, mesmo após o ajuste pelo seu baixo risco de mercado.

Conclusão: Da Análise à Decisão

Realizar uma análise de performance de portfólio vai muito além de observar o retorno final. Exige uma dissecação metódica do risco, da eficiência e, crucialmente, da geração de valor real (Alpha) em relação a um benchmark justo. O processo de testar uma estratégia com dados históricos é conhecido como backtesting, uma prática essencial para qualquer investidor quantitativo.

Com o framework em Python que desenvolvemos e a análise visual que realizamos, você está equipado não apenas para executar um backtest, mas para diagnosticar com precisão a saúde e a eficácia de qualquer estratégia de investimento. Você pode agora responder, com dados e confiança, à pergunta mais importante de todas: sua estratégia é vencedora?

Use este código como ponto de partida para testar suas próprias carteiras, ajustar os parâmetros e refinar suas estratégias de investimento.

About the Author

Diego V. Righetti

Administrator

Investidor autônomo especializado em dados, quants e análise de ações.

Visit Website View All Posts