Value Investing 2026: Como Encontrar Ações Baratas e Subvalorizadas

def calcular_margem_seguranca(preco_atual: float, valor_intrinseco: float) -> float:
    """
    Calcula a margem de segurança de uma ação
    """
    margem = ((valor_intrinseco - preco_atual) / valor_intrinseco) * 100
    
    print(f"Preço atual: R$ {preco_atual:.2f}")
    print(f"Valor intrínseco estimado: R$ {valor_intrinseco:.2f}")
    print(f"Margem de segurança: {margem:.1f}%")
    
    if margem >= 30:
        print("✅ Excelente margem de segurança")
    elif margem >= 15:
        print("⚠️ Margem aceitável")
    else:
        print("❌ Margem insuficiente - esperar queda")
    
    return margem

calcular_margem_seguranca(35, 50)

circulo_competencia = {
    "Dentro do círculo": [
        "Negócio que você entende",
        "Setor que você conhece",
        "Produto que você usa",
        "Vantagem competitiva clara"
    ],
    "Fora do círculo": [
        "Biotecnologia complexa",
        "Empresas em países desconhecidos",
        "Setores muito técnicos",
        "Modelos de negócio confusos"
    ]
}

print("Invista dentro do seu círculo de competência:")
for item in circulo_competencia["Dentro do círculo"]:
    print(f"  ✅ {item}")

import requests

def analisar_valuation(symbol: str, token: str):
    """
    Analisa indicadores de valuation de uma ação
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    acao = data["results"][0]
    
    print(f"=== VALUATION: {symbol} ===")
    print(f"Empresa: {acao.get('longName', acao['shortName'])}")
    print(f"Preço: R$ {acao['regularMarketPrice']:.2f}")
    print()
    
    # Indicadores de valuation
    indicadores = {
        "P/L (Preço/Lucro)": acao.get("priceEarnings"),
        "P/VP (Preço/Valor Patrimonial)": acao.get("priceToBook"),
        "EV/EBITDA": acao.get("evToEbitda"),
        "P/Receita": acao.get("priceToSales"),
        "Dividend Yield": acao.get("dividendYield")
    }
    
    print("--- Indicadores de Valuation ---")
    for nome, valor in indicadores.items():
        if valor is not None:
            if nome == "Dividend Yield":
                print(f"{nome}: {valor*100:.2f}%")
            else:
                print(f"{nome}: {valor:.2f}")
        else:
            print(f"{nome}: N/A")
    
    return indicadores

# Analisar valuation
analisar_valuation("ITUB4", "SEU_TOKEN")

def analisar_qualidade(symbol: str, token: str):
    """
    Analisa indicadores de qualidade da empresa
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    acao = data["results"][0]
    
    print(f"=== QUALIDADE: {symbol} ===")
    
    indicadores = {
        "ROE (Retorno sobre PL)": acao.get("returnOnEquity"),
        "ROA (Retorno sobre Ativos)": acao.get("returnOnAssets"),
        "Margem Líquida": acao.get("profitMargins"),
        "Margem EBITDA": acao.get("ebitdaMargins"),
        "Dívida/PL": acao.get("debtToEquity")
    }
    
    print("--- Indicadores de Qualidade ---")
    for nome, valor in indicadores.items():
        if valor is not None:
            if nome == "Dívida/PL":
                print(f"{nome}: {valor:.2f}")
            else:
                print(f"{nome}: {valor*100:.1f}%")
    
    return indicadores

analisar_qualidade("WEGE3", "SEU_TOKEN")

import requests

def screener_graham(token: str):
    """
    Aplica critérios de Benjamin Graham para filtrar ações
    """
    criterios_graham = {
        "P/L": {"max": 15},
        "P/VP": {"max": 1.5},
        "P/L x P/VP": {"max": 22.5},  # Graham Number
        "Dividend Yield": {"min": 0.02},  # 2%
        "Dívida/PL": {"max": 1.0},
        "ROE": {"min": 0.10}  # 10%
    }
    
    # Buscar lista de ações
    url = "https://brapi.dev/api/quote/list"
    params = {"type": "stock", "limit": 100}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    lista = response.json()
    
    # Analisar cada ação
    aprovadas = []
    
    for stock in lista["stocks"][:50]:  # Primeiras 50
        symbol = stock["stock"]
        
        try:
            url = f"https://brapi.dev/api/quote/{symbol}"
            params = {"fundamental": "true"}
            response = requests.get(url, params=params, headers=headers)
            data = response.json()
            
            if not data["results"]:
                continue
            
            acao = data["results"][0]
            
            # Verificar critérios
            pl = acao.get("priceEarnings")
            pvp = acao.get("priceToBook")
            dy = acao.get("dividendYield")
            roe = acao.get("returnOnEquity")
            
            if not all([pl, pvp]):
                continue
            
            # Critérios Graham
            if pl > 0 and pl <= 15 and pvp > 0 and pvp <= 1.5:
                graham_number = pl * pvp
                if graham_number <= 22.5:
                    aprovadas.append({
                        "symbol": symbol,
                        "name": acao["shortName"],
                        "preco": acao["regularMarketPrice"],
                        "P/L": pl,
                        "P/VP": pvp,
                        "Graham": graham_number,
                        "DY": dy * 100 if dy else 0,
                        "ROE": roe * 100 if roe else 0
                    })
        except:
            continue
    
    print("=== AÇÕES QUE PASSAM NOS CRITÉRIOS DE GRAHAM ===")
    print(f"Critérios: P/L <= 15, P/VP <= 1.5, P/L x P/VP <= 22.5")
    print()
    
    if aprovadas:
        for a in sorted(aprovadas, key=lambda x: x["Graham"]):
            print(f"{a['symbol']:8} | P/L: {a['P/L']:5.1f} | P/VP: {a['P/VP']:.2f} | Graham: {a['Graham']:.1f}")
    else:
        print("Nenhuma ação passou em todos os critérios")
    
    return aprovadas

# Executar screener
aprovadas = screener_graham("SEU_TOKEN")

def magic_formula(token: str, top_n: int = 20):
    """
    Implementa a Magic Formula de Joel Greenblatt
    """
    url = "https://brapi.dev/api/quote/list"
    params = {"type": "stock", "limit": 100}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    lista = response.json()
    
    acoes_analisadas = []
    
    for stock in lista["stocks"][:80]:
        symbol = stock["stock"]
        
        try:
            url = f"https://brapi.dev/api/quote/{symbol}"
            params = {"fundamental": "true"}
            response = requests.get(url, params=params, headers=headers)
            data = response.json()
            
            if not data["results"]:
                continue
            
            acao = data["results"][0]
            
            # Earnings Yield (inverso do P/L)
            pl = acao.get("priceEarnings")
            roe = acao.get("returnOnEquity")
            roic = acao.get("returnOnCapital") or roe  # Usar ROE como proxy
            
            if pl and pl > 0 and roe and roe > 0:
                earnings_yield = (1 / pl) * 100
                
                acoes_analisadas.append({
                    "symbol": symbol,
                    "name": acao["shortName"][:25],
                    "preco": acao["regularMarketPrice"],
                    "earnings_yield": earnings_yield,
                    "roic": roe * 100  # Usando ROE como proxy
                })
        except:
            continue
    
    if not acoes_analisadas:
        print("Sem dados suficientes")
        return []
    
    # Rankear por Earnings Yield (maior = melhor)
    for i, a in enumerate(sorted(acoes_analisadas, key=lambda x: x["earnings_yield"], reverse=True)):
        a["rank_ey"] = i + 1
    
    # Rankear por ROIC (maior = melhor)
    for i, a in enumerate(sorted(acoes_analisadas, key=lambda x: x["roic"], reverse=True)):
        a["rank_roic"] = i + 1
    
    # Calcular rank combinado
    for a in acoes_analisadas:
        a["rank_total"] = a["rank_ey"] + a["rank_roic"]
    
    # Ordenar pelo rank total (menor = melhor)
    ranking_final = sorted(acoes_analisadas, key=lambda x: x["rank_total"])
    
    print("=== MAGIC FORMULA - TOP AÇÕES ===")
    print(f"{'#':>3} {'Ticker':8} {'EY%':>7} {'ROE%':>7} {'Rank':>6}")
    print("-" * 40)
    
    for i, a in enumerate(ranking_final[:top_n], 1):
        print(f"{i:3} {a['symbol']:8} {a['earnings_yield']:6.1f}% {a['roic']:6.1f}% {a['rank_total']:6}")
    
    return ranking_final[:top_n]

# Top 20 pela Magic Formula
top = magic_formula("SEU_TOKEN", 20)

def dcf_simplificado(
    lucro_atual: float,
    taxa_crescimento: float,
    anos_crescimento: int,
    taxa_desconto: float,
    crescimento_perpetuo: float,
    acoes_emitidas: float
) -> float:
    """
    Calcula valor intrínseco pelo método DCF simplificado
    """
    fluxos = []
    lucro = lucro_atual
    
    # Fase de crescimento
    for ano in range(1, anos_crescimento + 1):
        lucro = lucro * (1 + taxa_crescimento)
        fluxo_descontado = lucro / ((1 + taxa_desconto) ** ano)
        fluxos.append(fluxo_descontado)
    
    # Valor terminal (perpetuidade)
    lucro_terminal = lucro * (1 + crescimento_perpetuo)
    valor_terminal = lucro_terminal / (taxa_desconto - crescimento_perpetuo)
    valor_terminal_descontado = valor_terminal / ((1 + taxa_desconto) ** anos_crescimento)
    
    # Valor total da empresa
    valor_empresa = sum(fluxos) + valor_terminal_descontado
    
    # Valor por ação
    valor_por_acao = valor_empresa / acoes_emitidas
    
    print("=== VALUATION DCF ===")
    print(f"Lucro atual: R$ {lucro_atual:,.0f}")
    print(f"Taxa de crescimento: {taxa_crescimento*100:.0f}% a.a. por {anos_crescimento} anos")
    print(f"Taxa de desconto (WACC): {taxa_desconto*100:.0f}%")
    print(f"Crescimento perpetuidade: {crescimento_perpetuo*100:.1f}%")
    print(f"\nValor da empresa: R$ {valor_empresa:,.0f}")
    print(f"Ações emitidas: {acoes_emitidas:,.0f}")
    print(f"Valor intrínseco por ação: R$ {valor_por_acao:.2f}")
    
    return valor_por_acao

# Exemplo: Empresa com lucro de R$ 5 bilhões
valor = dcf_simplificado(
    lucro_atual=5_000_000_000,
    taxa_crescimento=0.08,      # 8% a.a.
    anos_crescimento=10,
    taxa_desconto=0.12,         # 12% WACC
    crescimento_perpetuo=0.03,  # 3% perpetuidade
    acoes_emitidas=5_000_000_000
)

print(f"\nSe ação está abaixo de R$ {valor * 0.7:.2f}, há margem de segurança de 30%")

import math

def graham_number(lpa: float, vpa: float) -> float:
    """
    Calcula o Graham Number (preço máximo a pagar)
    
    Graham Number = √(22.5 × LPA × VPA)
    
    lpa: Lucro Por Ação
    vpa: Valor Patrimonial por Ação
    """
    if lpa <= 0 or vpa <= 0:
        return 0
    
    graham = math.sqrt(22.5 * lpa * vpa)
    
    print(f"LPA (Lucro/Ação): R$ {lpa:.2f}")
    print(f"VPA (Patrimônio/Ação): R$ {vpa:.2f}")
    print(f"Graham Number: R$ {graham:.2f}")
    print(f"\nPreço máximo a pagar: R$ {graham:.2f}")
    
    return graham

# Exemplo
graham_number(lpa=5.50, vpa=28.00)

def valuation_multiplos(lpa: float, pl_justo: float, crescimento: float) -> float:
    """
    Valuation por múltiplos com ajuste de crescimento
    
    Regra de Peter Lynch: P/L justo = taxa de crescimento
    Empresa crescendo 15% a.a. → P/L justo de 15
    """
    # P/L ajustado pelo crescimento (PEG = 1)
    pl_ajustado = min(pl_justo, crescimento * 100)
    
    valor = lpa * pl_ajustado
    
    print(f"LPA: R$ {lpa:.2f}")
    print(f"Crescimento esperado: {crescimento*100:.0f}%")
    print(f"P/L justo (PEG = 1): {pl_ajustado:.0f}")
    print(f"Valor intrínseco: R$ {valor:.2f}")
    
    return valor

# Empresa com LPA de R$ 4 crescendo 12% a.a.
valuation_multiplos(lpa=4.00, pl_justo=15, crescimento=0.12)

def checklist_value_investing(symbol: str, token: str):
    """
    Checklist completo para análise value investing
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    acao = data["results"][0]
    
    print(f"=== CHECKLIST VALUE INVESTING: {symbol} ===\n")
    
    checks = []
    
    # 1. Valuation
    print("📊 VALUATION")
    pl = acao.get("priceEarnings")
    if pl:
        status = "✅" if pl < 15 else "⚠️" if pl < 20 else "❌"
        print(f"  {status} P/L: {pl:.1f} (ideal < 15)")
        checks.append(pl < 15)
    
    pvp = acao.get("priceToBook")
    if pvp:
        status = "✅" if pvp < 1.5 else "⚠️" if pvp < 2.5 else "❌"
        print(f"  {status} P/VP: {pvp:.2f} (ideal < 1.5)")
        checks.append(pvp < 1.5)
    
    # 2. Qualidade
    print("\n📈 QUALIDADE")
    roe = acao.get("returnOnEquity")
    if roe:
        status = "✅" if roe > 0.15 else "⚠️" if roe > 0.10 else "❌"
        print(f"  {status} ROE: {roe*100:.1f}% (ideal > 15%)")
        checks.append(roe > 0.15)
    
    # 3. Dividendos
    print("\n💰 DIVIDENDOS")
    dy = acao.get("dividendYield")
    if dy:
        status = "✅" if dy > 0.04 else "⚠️" if dy > 0.02 else "❌"
        print(f"  {status} Dividend Yield: {dy*100:.2f}% (ideal > 4%)")
        checks.append(dy > 0.04)
    
    # 4. Margem de segurança
    print("\n🛡️ MARGEM DE SEGURANÇA")
    if pl and pvp:
        graham = pl * pvp
        status = "✅" if graham < 22.5 else "❌"
        print(f"  {status} Graham (P/L x P/VP): {graham:.1f} (máx 22.5)")
        checks.append(graham < 22.5)
    
    # Resultado
    aprovados = sum(checks)
    total = len(checks)
    
    print(f"\n{'='*40}")
    print(f"SCORE: {aprovados}/{total} critérios atendidos")
    
    if aprovados >= total * 0.8:
        print("🟢 FORTE CANDIDATA para Value Investing")
    elif aprovados >= total * 0.6:
        print("🟡 ANÁLISE MAIS PROFUNDA necessária")
    else:
        print("🔴 NÃO ATENDE critérios de valor")
    
    return aprovados / total if total > 0 else 0

# Analisar uma ação
checklist_value_investing("BBAS3", "SEU_TOKEN")

def detectar_value_trap(symbol: str, token: str):
    """
    Verifica sinais de armadilha de valor
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"fundamental": "true", "range": "5y"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    acao = data["results"][0]
    
    print(f"=== DETECTOR DE VALUE TRAP: {symbol} ===\n")
    
    alertas = []
    
    # Sinais de alerta
    roe = acao.get("returnOnEquity")
    if roe and roe < 0.08:
        alertas.append(f"⚠️ ROE baixo: {roe*100:.1f}% - empresa pode estar em declínio")
    
    margem = acao.get("profitMargins")
    if margem and margem < 0.05:
        alertas.append(f"⚠️ Margem baixa: {margem*100:.1f}% - pouca rentabilidade")
    
    # Verificar tendência de preço (caiu muito = pode ser trap)
    low_52 = acao.get("fiftyTwoWeekLow")
    high_52 = acao.get("fiftyTwoWeekHigh")
    preco = acao.get("regularMarketPrice")
    
    if low_52 and high_52 and preco:
        posicao = (preco - low_52) / (high_52 - low_52)
        if posicao < 0.2:
            alertas.append(f"⚠️ Perto da mínima de 52 sem - verificar motivo da queda")
    
    # Setor em declínio
    setor = acao.get("sector")
    setores_risco = ["Varejo", "Construção", "Siderurgia"]
    if setor in setores_risco:
        alertas.append(f"⚠️ Setor {setor} enfrenta desafios estruturais")
    
    if alertas:
        print("🚨 SINAIS DE ALERTA DETECTADOS:")
        for a in alertas:
            print(f"  {a}")
    else:
        print("✅ Nenhum sinal óbvio de value trap detectado")
    
    print("\n📋 VERIFICAÇÃO MANUAL NECESSÁRIA:")
    print("  [ ] A empresa tem vantagem competitiva durável?")
    print("  [ ] Os lucros estão estáveis ou crescendo?")
    print("  [ ] A dívida está sob controle?")
    print("  [ ] O setor tem futuro promissor?")
    print("  [ ] A gestão é competente e honesta?")
    
    return len(alertas)

detectar_value_trap("MGLU3", "SEU_TOKEN")

# Carteira diversificada com critérios de valor
carteira_value = {
    # Bancos (baratos historicamente)
    "BBAS3": 0.12,   # Banco do Brasil
    "ITUB4": 0.10,   # Itaú
    
    # Utilities (previsíveis, dividendos)
    "EGIE3": 0.10,   # Engie
    "TAEE11": 0.10,  # Taesa
    "CPLE6": 0.08,   # Copel
    
    # Seguros (ROE alto, desconto)
    "BBSE3": 0.10,   # BB Seguridade
    
    # Commodities (cíclicas, comprar na baixa)
    "VALE3": 0.10,   # Vale (quando descontada)
    "GGBR4": 0.08,   # Gerdau
    
    # Consumo (marcas fortes)
    "ABEV3": 0.10,   # Ambev
    
    # Diversificado
    "WEGE3": 0.12,   # WEG (qualidade premium)
}

# Critérios para cada posição
print("Carteira Value - Critérios de Entrada:")
print("-" * 50)
for ticker, peso in carteira_value.items():
    print(f"{ticker}: {peso*100:.0f}% - Comprar quando P/L < média histórica")

def regras_compra_venda():
    """
    Regras de entrada e saída para value investing
    """
    regras = {
        "COMPRAR quando": [
            "P/L abaixo da média de 5 anos",
            "P/VP abaixo de 1.5 (ou média histórica)",
            "Dividend Yield acima da média",
            "Margem de segurança > 25%",
            "Fundamentos intactos apesar da queda",
            "Mercado em pânico (medo generalizado)"
        ],
        "VENDER quando": [
            "Tese de investimento quebrou",
            "Fundamentos deterioraram permanentemente",
            "Valuation ficou esticado (P/L > 20)",
            "Encontrou oportunidade muito melhor",
            "Posição ficou grande demais (> 15% carteira)",
            "Empresa cortou dividendos por problemas estruturais"
        ],
        "NÃO VENDER quando": [
            "Preço caiu (sem mudança de fundamentos)",
            "Mercado está em baixa",
            "Notícias ruins de curto prazo",
            "Medo ou ansiedade",
            "Lucro de curto prazo (IR reduz retorno)"
        ]
    }
    
    for categoria, items in regras.items():
        print(f"\n{categoria}:")
        for item in items:
            print(f"  • {item}")

regras_compra_venda()