PEG Ratio: Como Usar Este Indicador de Crescimento 2026

PEG Ratio = P/L ÷ Taxa de Crescimento dos Lucros (%)

Onde:
• P/L = Preço / Lucro por Ação
• Taxa de Crescimento = Crescimento anual esperado do LPA (%)

┌─────────────────────────────────────────────────────────────┐
│                    ESCALA DO PEG                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  0.0   0.5   1.0   1.5   2.0   2.5   3.0                    │
│   │─────│─────│─────│─────│─────│─────│                     │
│   ████████████│░░░░░░░░░░░│                                 │
│   BARATO      │   JUSTO   │    CARO                         │
│               │           │                                 │
│  Oportunidade │ Avaliar   │ Evitar                          │
│  de compra    │ contexto  │                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

import requests

def calcular_peg_trailing(ticker: str, anos: int = 3) -> dict:
    """
    Calcula PEG usando crescimento histórico dos lucros
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "modules": "incomeStatementHistory",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados não encontrados"}
    
    r = data["results"][0]
    
    # Obter P/L atual
    pl = r.get("priceToEarningsTrailingTwelveMonths")
    
    if not pl or pl <= 0:
        return {"erro": "P/L não disponível ou negativo"}
    
    # Obter histórico de lucros
    statements = r.get("incomeStatementHistory", {}).get("incomeStatementHistory", [])
    
    if len(statements) < 2:
        return {"erro": "Dados históricos insuficientes"}
    
    # Calcular CAGR do lucro líquido
    lucro_recente = statements[0].get("netIncome", {}).get("raw", 0)
    lucro_antigo = statements[-1].get("netIncome", {}).get("raw", 0)
    
    if lucro_antigo <= 0 or lucro_recente <= 0:
        return {"erro": "Lucros negativos, PEG não aplicável"}
    
    periodos = len(statements) - 1
    cagr = ((lucro_recente / lucro_antigo) ** (1 / periodos) - 1) * 100
    
    # Calcular PEG
    peg = pl / cagr if cagr > 0 else float('inf')
    
    return {
        "ticker": ticker,
        "nome": r.get("longName", ""),
        "preco": r.get("regularMarketPrice", 0),
        "pl": round(pl, 2),
        "crescimento_lucro_cagr": round(cagr, 2),
        "peg_trailing": round(peg, 2),
        "interpretacao": interpretar_peg(peg)
    }

def interpretar_peg(peg: float) -> str:
    if peg < 0:
        return "Não aplicável (crescimento negativo)"
    elif peg < 0.5:
        return "Muito barato - verificar riscos"
    elif peg < 1.0:
        return "Subvalorizado - potencial oportunidade"
    elif peg < 1.5:
        return "Preço justo"
    elif peg < 2.0:
        return "Levemente caro"
    else:
        return "Sobrevalorizado"

resultado = calcular_peg_trailing("WEGE3")
print(f"\n📊 PEG RATIO: {resultado['ticker']}")
print(f"Empresa: {resultado['nome']}")
print(f"Preço: R$ {resultado['preco']:.2f}")
print(f"P/L: {resultado['pl']}x")
print(f"Crescimento (CAGR): {resultado['crescimento_lucro_cagr']}% a.a.")
print(f"PEG Ratio: {resultado['peg_trailing']}")
print(f"Interpretação: {resultado['interpretacao']}")

def calcular_peg_forward(ticker: str) -> dict:
    """
    Calcula PEG usando crescimento projetado
    Nota: brapi.dev pode não ter estimativas de analistas,
    usamos crescimento implícito como proxy
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {"fundamental": "true"}
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados não encontrados"}
    
    r = data["results"][0]
    
    # P/L atual e forward
    pl_trailing = r.get("priceToEarningsTrailingTwelveMonths")
    pl_forward = r.get("forwardPE")  # P/L projetado
    
    if not pl_trailing or not pl_forward:
        return {"erro": "Dados de P/L não disponíveis"}
    
    # Estimar crescimento implícito
    # Se P/L forward < P/L trailing, há expectativa de crescimento
    crescimento_implicito = ((pl_trailing / pl_forward) - 1) * 100 if pl_forward > 0 else 0
    
    # Usar taxa de crescimento de receita como proxy adicional
    revenue_growth = r.get("revenueGrowth", 0) * 100 if r.get("revenueGrowth") else 0
    
    # Média ponderada das estimativas
    crescimento_estimado = (crescimento_implicito * 0.6 + revenue_growth * 0.4)
    
    if crescimento_estimado <= 0:
        return {
            "ticker": ticker,
            "pl": pl_trailing,
            "crescimento": crescimento_estimado,
            "peg": None,
            "nota": "Crescimento negativo/zero, PEG não aplicável"
        }
    
    peg = pl_trailing / crescimento_estimado
    
    return {
        "ticker": ticker,
        "nome": r.get("shortName", ""),
        "pl_trailing": round(pl_trailing, 2),
        "pl_forward": round(pl_forward, 2) if pl_forward else None,
        "crescimento_estimado": round(crescimento_estimado, 2),
        "peg_forward": round(peg, 2),
        "interpretacao": interpretar_peg(peg)
    }

# Exemplo
resultado = calcular_peg_forward("TOTS3")
print(f"\n📊 PEG FORWARD: {resultado['ticker']}")
print(f"P/L Trailing: {resultado['pl_trailing']}x")
print(f"P/L Forward: {resultado['pl_forward']}x")
print(f"Crescimento Estimado: {resultado['crescimento_estimado']}%")
print(f"PEG Forward: {resultado['peg_forward']}")
print(f"Interpretação: {resultado['interpretacao']}")

def comparar_peg_setor(tickers: list, nome_setor: str) -> list:
    """
    Compara PEG de múltiplas empresas do mesmo setor
    """
    resultados = []
    
    for ticker in tickers:
        url = f"https://brapi.dev/api/quote/{ticker}"
        params = {
            "modules": "incomeStatementHistory",
            "fundamental": "true"
        }
        headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
        
        response = requests.get(url, params=params, headers=headers)
        data = response.json()
        
        if "results" not in data:
            continue
        
        r = data["results"][0]
        pl = r.get("priceToEarningsTrailingTwelveMonths")
        
        # Usar earnings growth se disponível, senão revenue growth
        earnings_growth = r.get("earningsGrowth", 0) * 100 if r.get("earningsGrowth") else None
        revenue_growth = r.get("revenueGrowth", 0) * 100 if r.get("revenueGrowth") else None
        
        crescimento = earnings_growth if earnings_growth else revenue_growth
        
        if pl and crescimento and crescimento > 0:
            peg = pl / crescimento
        else:
            peg = None
        
        resultados.append({
            "ticker": ticker,
            "nome": r.get("shortName", "")[:25],
            "pl": pl,
            "crescimento": crescimento,
            "peg": round(peg, 2) if peg else None
        })
    
    # Ordenar por PEG
    resultados.sort(key=lambda x: x['peg'] if x['peg'] else 999)
    
    return resultados

# Comparar bancos
bancos = ["ITUB4", "BBDC4", "BBAS3", "SANB11"]
resultado = comparar_peg_setor(bancos, "Bancário")

print("\n📊 COMPARATIVO PEG - SETOR BANCÁRIO\n")
print(f"{'Ticker':<10} {'Nome':<25} {'P/L':<10} {'Cresc.':<10} {'PEG':<10}")
print("-" * 65)

for r in resultado:
    pl_str = f"{r['pl']:.1f}x" if r['pl'] else "N/A"
    cresc_str = f"{r['crescimento']:.1f}%" if r['crescimento'] else "N/A"
    peg_str = f"{r['peg']:.2f}" if r['peg'] else "N/A"
    print(f"{r['ticker']:<10} {r['nome']:<25} {pl_str:<10} {cresc_str:<10} {peg_str:<10}")

┌─────────────────────────────────────────────────────────────┐
│              QUANDO USAR (OU NÃO) O PEG                     │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ✅ USE O PEG                    ❌ EVITE O PEG              │
│  ─────────────                   ──────────────             │
│  • Empresas de crescimento       • Empresas cíclicas        │
│  • Tech, varejo, saúde           • Commodities              │
│  • Lucros consistentes           • Turnarounds              │
│  • Comparação setorial           • Lucros negativos         │
│  • Mid-caps em expansão          • Utilities maduras        │
│                                                             │
│  O PEG complementa, não substitui, outras análises!        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

def analise_completa_valuation(ticker: str) -> dict:
    """
    Análise de valuation combinando múltiplos indicadores
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {"fundamental": "true"}
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados não encontrados"}
    
    r = data["results"][0]
    
    # Coletar indicadores
    pl = r.get("priceToEarningsTrailingTwelveMonths")
    pvp = r.get("priceToBook", 0)
    ev_ebitda = r.get("enterpriseValueEbitda")
    roe = r.get("returnOnEquity", 0) * 100 if r.get("returnOnEquity") else 0
    crescimento = r.get("earningsGrowth", 0) * 100 if r.get("earningsGrowth") else 0
    margem = r.get("profitMargins", 0) * 100 if r.get("profitMargins") else 0
    
    # Calcular PEG
    peg = pl / crescimento if pl and crescimento > 0 else None
    
    # Sistema de pontuação
    pontos = 0
    max_pontos = 5
    
    # Avaliar cada métrica
    if peg and peg < 1.5:
        pontos += 1
    if pvp and pvp < 3:
        pontos += 1
    if ev_ebitda and ev_ebitda < 10:
        pontos += 1
    if roe > 15:
        pontos += 1
    if margem > 10:
        pontos += 1
    
    return {
        "ticker": ticker,
        "nome": r.get("shortName", ""),
        "indicadores": {
            "P/L": pl,
            "PEG": round(peg, 2) if peg else None,
            "P/VP": round(pvp, 2),
            "EV/EBITDA": round(ev_ebitda, 2) if ev_ebitda else None,
            "ROE": round(roe, 1),
            "Margem Líquida": round(margem, 1)
        },
        "pontuacao": f"{pontos}/{max_pontos}",
        "avaliacao": "Atrativa" if pontos >= 4 else "Neutra" if pontos >= 2 else "Cara"
    }

# Exemplo
resultado = analise_completa_valuation("WEGE3")
print(f"\n📊 ANÁLISE COMPLETA: {resultado['ticker']}")
print(f"Empresa: {resultado['nome']}")
print(f"\nIndicadores:")
for ind, valor in resultado['indicadores'].items():
    valor_str = f"{valor}" if valor else "N/A"
    print(f"  {ind}: {valor_str}")
print(f"\nPontuação: {resultado['pontuacao']}")
print(f"Avaliação: {resultado['avaliacao']}")

def verificar_sustentabilidade_crescimento(ticker: str) -> dict:
    """
    Verifica se o crescimento é sustentável analisando histórico
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "modules": "incomeStatementHistory",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados não encontrados"}
    
    r = data["results"][0]
    statements = r.get("incomeStatementHistory", {}).get("incomeStatementHistory", [])
    
    if len(statements) < 3:
        return {"erro": "Histórico insuficiente"}
    
    # Calcular crescimento ano a ano
    crescimentos = []
    for i in range(len(statements) - 1):
        lucro_atual = statements[i].get("netIncome", {}).get("raw", 0)
        lucro_anterior = statements[i + 1].get("netIncome", {}).get("raw", 0)
        
        if lucro_anterior > 0:
            cresc = ((lucro_atual / lucro_anterior) - 1) * 100
            crescimentos.append(cresc)
    
    if not crescimentos:
        return {"erro": "Não foi possível calcular crescimento"}
    
    # Analisar consistência
    media = sum(crescimentos) / len(crescimentos)
    variancia = sum((x - media) ** 2 for x in crescimentos) / len(crescimentos)
    desvio = variancia ** 0.5
    
    consistencia = "Alta" if desvio < 15 else "Média" if desvio < 30 else "Baixa"
    
    return {
        "ticker": ticker,
        "crescimentos_anuais": [round(c, 1) for c in crescimentos],
        "media_crescimento": round(media, 1),
        "desvio_padrao": round(desvio, 1),
        "consistencia": consistencia,
        "alerta": desvio > 50 or any(c < -20 for c in crescimentos)
    }

# Exemplo
resultado = verificar_sustentabilidade_crescimento("TOTS3")
print(f"\n📊 SUSTENTABILIDADE DO CRESCIMENTO: {resultado['ticker']}")
print(f"Crescimentos anuais: {resultado['crescimentos_anuais']}")
print(f"Média: {resultado['media_crescimento']}%")
print(f"Consistência: {resultado['consistencia']}")
if resultado.get('alerta'):
    print("⚠️ ALERTA: Crescimento volátil - usar PEG com cautela!")

┌─────────────────────────────────────────────────────────────┐
│         ARMADILHA: CRESCIMENTO DE BASE BAIXA                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Ano 1: Lucro R$ 10 milhões                                 │
│  Ano 2: Lucro R$ 50 milhões  (+400%!)                       │
│  Ano 3: Lucro R$ 60 milhões  (+20%)                         │
│                                                             │
│  Se usar Ano 1→2: Crescimento = 400%, PEG parece ótimo      │
│  Se usar Ano 2→3: Crescimento = 20%, PEG mais realista      │
│                                                             │
│  SEMPRE use média de vários anos ou crescimento projetado   │
│  de analistas, não apenas último período                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

def screener_peg(peg_maximo: float = 1.5) -> list:
    """
    Encontra ações com PEG abaixo do limite especificado
    """
    # Lista de ações para analisar
    tickers = [
        "WEGE3", "TOTS3", "RENT3", "RADL3", "HAPV3",
        "RAIL3", "EQTL3", "PRIO3", "FLRY3", "ARZZ3"
    ]
    
    resultados = []
    
    for ticker in tickers:
        url = f"https://brapi.dev/api/quote/{ticker}"
        params = {"fundamental": "true"}
        headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
        
        response = requests.get(url, params=params, headers=headers)
        data = response.json()
        
        if "results" not in data:
            continue
        
        r = data["results"][0]
        
        pl = r.get("priceToEarningsTrailingTwelveMonths")
        crescimento = r.get("earningsGrowth", 0) * 100 if r.get("earningsGrowth") else None
        
        if not pl or not crescimento or crescimento <= 0 or pl <= 0:
            continue
        
        peg = pl / crescimento
        
        if peg <= peg_maximo:
            resultados.append({
                "ticker": ticker,
                "nome": r.get("shortName", ""),
                "preco": r.get("regularMarketPrice", 0),
                "pl": round(pl, 1),
                "crescimento": round(crescimento, 1),
                "peg": round(peg, 2),
                "roe": round(r.get("returnOnEquity", 0) * 100, 1) if r.get("returnOnEquity") else 0
            })
    
    # Ordenar por PEG
    resultados.sort(key=lambda x: x['peg'])
    
    return resultados

# Executar screener
resultados = screener_peg(peg_maximo=1.5)

print("\n" + "=" * 80)
print("📊 SCREENER: AÇÕES COM PEG ATRATIVO (< 1.5)")
print("=" * 80)
print(f"\n{'Ticker':<10} {'Preço':<12} {'P/L':<10} {'Cresc.':<12} {'PEG':<10} {'ROE':<10}")
print("-" * 80)

for r in resultados:
    print(f"{r['ticker']:<10} R$ {r['preco']:<8.2f} {r['pl']:<10.1f}x {r['crescimento']:<10.1f}% {r['peg']:<10.2f} {r['roe']:<10.1f}%")

if not resultados:
    print("Nenhuma ação encontrada com PEG abaixo do limite.")

def case_study_peg():
    """
    Comparação detalhada de PEG entre WEG e TOTVS
    """
    empresas = ["WEGE3", "TOTS3"]
    analises = []
    
    for ticker in empresas:
        url = f"https://brapi.dev/api/quote/{ticker}"
        params = {
            "modules": "incomeStatementHistory",
            "fundamental": "true"
        }
        headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
        
        response = requests.get(url, params=params, headers=headers)
        data = response.json()
        
        if "results" not in data:
            continue
        
        r = data["results"][0]
        
        pl = r.get("priceToEarningsTrailingTwelveMonths")
        crescimento = r.get("earningsGrowth", 0) * 100 if r.get("earningsGrowth") else 0
        
        peg = pl / crescimento if crescimento > 0 else None
        
        analises.append({
            "ticker": ticker,
            "nome": r.get("longName", ""),
            "setor": "Bens de Capital" if ticker == "WEGE3" else "Tecnologia",
            "preco": r.get("regularMarketPrice", 0),
            "market_cap": r.get("marketCap", 0) / 1_000_000_000,
            "pl": pl,
            "crescimento": crescimento,
            "peg": peg,
            "roe": r.get("returnOnEquity", 0) * 100 if r.get("returnOnEquity") else 0,
            "margem": r.get("profitMargins", 0) * 100 if r.get("profitMargins") else 0
        })
    
    # Comparar
    print("\n" + "=" * 70)
    print("CASE STUDY: WEG vs TOTVS - ANÁLISE PEG")
    print("=" * 70)
    
    for a in analises:
        print(f"\n{'─' * 35}")
        print(f"{a['ticker']} - {a['nome'][:30]}")
        print(f"{'─' * 35}")
        print(f"Setor: {a['setor']}")
        print(f"Preço: R$ {a['preco']:.2f}")
        print(f"Market Cap: R$ {a['market_cap']:.1f} bi")
        print(f"\nValuation:")
        print(f"  P/L: {a['pl']:.1f}x")
        print(f"  Crescimento: {a['crescimento']:.1f}%")
        print(f"  PEG: {a['peg']:.2f}" if a['peg'] else "  PEG: N/A")
        print(f"\nQualidade:")
        print(f"  ROE: {a['roe']:.1f}%")
        print(f"  Margem Líquida: {a['margem']:.1f}%")
    
    # Conclusão
    print(f"\n{'=' * 70}")
    print("CONCLUSÃO:")
    print("=" * 70)
    
    if len(analises) == 2 and analises[0]['peg'] and analises[1]['peg']:
        mais_barata = analises[0] if analises[0]['peg'] < analises[1]['peg'] else analises[1]
        print(f"\nPelo PEG, {mais_barata['ticker']} está mais atrativa (PEG {mais_barata['peg']:.2f})")
        print("\nMas lembre-se de considerar:")
        print("• Qualidade do crescimento")
        print("• Consistência histórica")
        print("• Riscos específicos de cada empresa")
        print("• Seu horizonte de investimento")

case_study_peg()