Indicador Preço/Lucro (P/L) 2026: Guia Completo para Análise de Ações

P/L = Preço da Ação / Lucro por Ação (LPA)

Ou, de forma equivalente:

P/L = Valor de Mercado / Lucro Líquido

Empresa XYZ:
- Preço da ação: R$ 40,00
- Lucro por ação (LPA): R$ 4,00

P/L = 40 / 4 = 10

Interpretação: O investidor está pagando 10 vezes o lucro anual da empresa.
Ou seja, seriam necessários 10 anos de lucro para "pagar" o investimento.

┌─────────────────────────────────────────────────────────────┐
│              ⚠️ P/L BAIXO NÃO É SEMPRE BOM                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  P/L baixo pode significar:                                  │
│  ✅ Empresa subvalorizada (oportunidade)                     │
│  ❌ Lucros insustentáveis (vai cair)                         │
│  ❌ Empresa em declínio (mercado sabe algo)                  │
│  ❌ Setor em crise                                           │
│  ❌ Problemas de governança                                  │
│                                                              │
├─────────────────────────────────────────────────────────────┤
│              ⚠️ P/L ALTO NÃO É SEMPRE RUIM                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  P/L alto pode significar:                                   │
│  ✅ Empresa com alto crescimento justificado                 │
│  ✅ Líder de mercado com vantagens competitivas              │
│  ❌ Especulação e euforia do mercado                         │
│  ❌ Lucros temporariamente baixos                            │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def calculate_trailing_pl(preco: float, lucros_trimestrais: list) -> float:
    """
    Calcula P/L trailing (últimos 12 meses)
    """
    lpa_12m = sum(lucros_trimestrais[-4:])  # Últimos 4 trimestres
    
    if lpa_12m <= 0:
        return float('inf')  # Indica prejuízo
    
    return preco / lpa_12m

# Exemplo
lucros = [0.80, 0.95, 1.10, 1.15]  # LPA por trimestre
preco = 40.00

pl_trailing = calculate_trailing_pl(preco, lucros)
print(f"P/L Trailing: {pl_trailing:.2f}")

def calculate_forward_pl(preco: float, lpa_estimado: float) -> float:
    """
    Calcula P/L forward (projetado)
    """
    if lpa_estimado <= 0:
        return float('inf')
    
    return preco / lpa_estimado

# Exemplo
preco = 40.00
lpa_estimado = 4.80  # Expectativa de analistas

pl_forward = calculate_forward_pl(preco, lpa_estimado)
print(f"P/L Forward: {pl_forward:.2f}")

def calculate_normalized_pl(preco: float, lucros_5_anos: list) -> float:
    """
    Calcula P/L normalizado (média de 5 anos)
    Também conhecido como P/L Shiller ou CAPE
    """
    lpa_medio = sum(lucros_5_anos) / len(lucros_5_anos)
    
    if lpa_medio <= 0:
        return float('inf')
    
    return preco / lpa_medio

# Exemplo
lucros_5_anos = [3.20, 3.50, 4.00, 3.80, 4.50]  # LPA anual
preco = 40.00

pl_normalizado = calculate_normalized_pl(preco, lucros_5_anos)
print(f"P/L Normalizado: {pl_normalizado:.2f}")

import requests
import pandas as pd
from typing import List, Dict

# Configuração
API_TOKEN = "seu_token_aqui"
BASE_URL = "https://brapi.dev/api"

def get_stock_data(ticker: str) -> dict:
    """
    Busca dados completos de uma ação na brapi.dev
    """
    url = f"{BASE_URL}/quote/{ticker}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    response.raise_for_status()
    
    return response.json()["results"][0]

def analyze_pl(ticker: str) -> dict:
    """
    Analisa o P/L de uma ação
    """
    data = get_stock_data(ticker)
    
    preco = data.get("regularMarketPrice", 0)
    pl = data.get("priceToEarnings", 0)
    lpa = data.get("earningsPerShare", 0)
    
    # Classifica o P/L
    if pl <= 0:
        classificacao = "Prejuízo"
        status = "❌"
    elif pl < 8:
        classificacao = "Muito Baixo"
        status = "🔍 Investigar"
    elif pl < 12:
        classificacao = "Atrativo"
        status = "✅"
    elif pl < 18:
        classificacao = "Moderado"
        status = "✓"
    elif pl < 25:
        classificacao = "Alto"
        status = "⚠️"
    else:
        classificacao = "Muito Alto"
        status = "❌"
    
    return {
        "ticker": ticker,
        "preco": preco,
        "lpa": lpa,
        "pl": pl,
        "classificacao": classificacao,
        "status": status,
        "anos_payback": pl if pl > 0 else None
    }

# Exemplo de uso
tickers = ["PETR4", "VALE3", "ITUB4", "WEGE3", "MGLU3"]

print("ANÁLISE DE P/L - AÇÕES BRASILEIRAS")
print("=" * 60)

for ticker in tickers:
    try:
        analysis = analyze_pl(ticker)
        print(f"\n{analysis['ticker']}")
        print(f"  Preço: R$ {analysis['preco']:.2f}")
        print(f"  LPA: R$ {analysis['lpa']:.2f}")
        print(f"  P/L: {analysis['pl']:.1f} ({analysis['classificacao']})")
        print(f"  Status: {analysis['status']}")
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

def compare_pl_same_sector(tickers: List[str]) -> pd.DataFrame:
    """
    Compara P/L de empresas do mesmo setor
    """
    results = []
    
    for ticker in tickers:
        try:
            data = get_stock_data(ticker)
            
            results.append({
                "ticker": ticker,
                "nome": data.get("shortName", "N/A"),
                "preco": data.get("regularMarketPrice", 0),
                "pl": data.get("priceToEarnings", 0),
                "dividend_yield": data.get("dividendYield", 0),
                "roe": data.get("returnOnEquity", 0) * 100 if data.get("returnOnEquity") else 0
            })
        except Exception as e:
            continue
    
    df = pd.DataFrame(results)
    
    if not df.empty:
        # Calcula média do setor
        pl_medio = df[df["pl"] > 0]["pl"].mean()
        df["vs_media"] = df.apply(
            lambda row: f"{((row['pl'] / pl_medio - 1) * 100):+.1f}%" if row['pl'] > 0 else "N/A", 
            axis=1
        )
    
    return df

# Compara bancos
print("\nCOMPARATIVO DE P/L - SETOR BANCÁRIO")
print("=" * 60)

bancos = ["ITUB4", "BBDC4", "SANB11", "BBAS3", "BPAC11"]
df_bancos = compare_pl_same_sector(bancos)

if not df_bancos.empty:
    print(df_bancos[["ticker", "preco", "pl", "dividend_yield", "vs_media"]].to_string(index=False))

# Compara varejo
print("\n\nCOMPARATIVO DE P/L - SETOR VAREJO")
print("=" * 60)

varejo = ["MGLU3", "AMER3", "VIIA3", "LREN3", "PETZ3"]
df_varejo = compare_pl_same_sector(varejo)

if not df_varejo.empty:
    print(df_varejo[["ticker", "preco", "pl", "roe", "vs_media"]].to_string(index=False))

def pl_screener(min_pl: float = 5, max_pl: float = 15, min_roe: float = 10) -> pd.DataFrame:
    """
    Screener de ações por P/L
    """
    # Lista de ações para analisar
    tickers = [
        "PETR4", "VALE3", "ITUB4", "BBDC4", "WEGE3",
        "RENT3", "RADL3", "EQTL3", "SUZB3", "JBSS3",
        "PRIO3", "CSAN3", "VIVT3", "CMIG4", "TAEE11",
        "TRPL4", "ENBR3", "BEEF3", "MRFG3", "BRFS3"
    ]
    
    qualified = []
    
    for ticker in tickers:
        try:
            data = get_stock_data(ticker)
            
            pl = data.get("priceToEarnings", 0)
            roe = data.get("returnOnEquity", 0) * 100 if data.get("returnOnEquity") else 0
            
            # Filtros
            if pl < min_pl or pl > max_pl:
                continue
            
            if roe < min_roe:
                continue
            
            qualified.append({
                "ticker": ticker,
                "setor": data.get("sector", "N/A"),
                "preco": data.get("regularMarketPrice", 0),
                "pl": pl,
                "roe": roe,
                "dy": data.get("dividendYield", 0)
            })
            
        except:
            continue
    
    df = pd.DataFrame(qualified)
    
    if not df.empty:
        df = df.sort_values("pl")
    
    return df

print("\nSCREENER DE P/L (5-15) + ROE > 10%")
print("=" * 60)

df_screened = pl_screener(min_pl=5, max_pl=15, min_roe=10)
if not df_screened.empty:
    print(df_screened.to_string(index=False))

PEG = P/L / Taxa de Crescimento Anual (%)

Exemplo:
- P/L = 20
- Crescimento esperado = 25% ao ano
- PEG = 20 / 25 = 0.8

def calculate_peg(ticker: str, growth_rate: float) -> dict:
    """
    Calcula PEG Ratio
    growth_rate: taxa de crescimento anual esperada (em %)
    """
    data = get_stock_data(ticker)
    
    pl = data.get("priceToEarnings", 0)
    
    if pl <= 0 or growth_rate <= 0:
        peg = float('inf')
    else:
        peg = pl / growth_rate
    
    if peg < 1:
        avaliacao = "Subvalorizada"
        status = "✅"
    elif peg <= 1.5:
        avaliacao = "Preço Justo"
        status = "✓"
    elif peg <= 2:
        avaliacao = "Cara"
        status = "⚠️"
    else:
        avaliacao = "Muito Cara"
        status = "❌"
    
    return {
        "ticker": ticker,
        "pl": pl,
        "crescimento": growth_rate,
        "peg": peg,
        "avaliacao": avaliacao,
        "status": status
    }

# Exemplo: WEG com crescimento de 20% ao ano
resultado = calculate_peg("WEGE3", 20)
print(f"\nAnálise PEG - {resultado['ticker']}")
print(f"  P/L: {resultado['pl']:.1f}")
print(f"  Crescimento: {resultado['crescimento']}%")
print(f"  PEG: {resultado['peg']:.2f}")
print(f"  Avaliação: {resultado['status']} {resultado['avaliacao']}")

def analyze_historical_pl(ticker: str) -> dict:
    """
    Compara P/L atual com histórico
    """
    data = get_stock_data(ticker)
    
    pl_atual = data.get("priceToEarnings", 0)
    
    # P/L histórico (médias do mercado brasileiro)
    # Em produção, use dados reais de cada empresa
    historico = {
        "media_5_anos": 12.5,
        "minimo_5_anos": 6.2,
        "maximo_5_anos": 22.8
    }
    
    # Posição no range histórico
    range_total = historico["maximo_5_anos"] - historico["minimo_5_anos"]
    posicao = (pl_atual - historico["minimo_5_anos"]) / range_total * 100
    
    if posicao < 25:
        oportunidade = "🔥 P/L em zona de compra histórica"
    elif posicao < 50:
        oportunidade = "✅ P/L abaixo da média histórica"
    elif posicao < 75:
        oportunidade = "⚠️ P/L acima da média histórica"
    else:
        oportunidade = "❌ P/L em zona de topo histórica"
    
    return {
        "ticker": ticker,
        "pl_atual": pl_atual,
        "pl_medio_5y": historico["media_5_anos"],
        "pl_min_5y": historico["minimo_5_anos"],
        "pl_max_5y": historico["maximo_5_anos"],
        "posicao_historica": posicao,
        "oportunidade": oportunidade
    }

# Exemplo
resultado = analyze_historical_pl("PETR4")
print(f"\nANÁLISE HISTÓRICA DE P/L - {resultado['ticker']}")
print(f"  P/L Atual: {resultado['pl_atual']:.1f}")
print(f"  P/L Médio (5 anos): {resultado['pl_medio_5y']:.1f}")
print(f"  Range: {resultado['pl_min_5y']:.1f} - {resultado['pl_max_5y']:.1f}")
print(f"  Posição no range: {resultado['posicao_historica']:.1f}%")
print(f"  {resultado['oportunidade']}")

┌─────────────────────────────────────────────────────────────┐
│                   VALUE TRAPS COMUNS                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  🪤 SINAIS DE ALERTA:                                        │
│                                                              │
│  1. P/L baixo + Receita caindo                               │
│     → Lucros podem cair também                               │
│                                                              │
│  2. P/L baixo + Alta alavancagem                             │
│     → Risco de insolvência                                   │
│                                                              │
│  3. P/L baixo + Margens em queda                             │
│     → Perda de competitividade                               │
│                                                              │
│  4. P/L baixo + Setor em disrupção                           │
│     → Modelo de negócio obsoleto                             │
│                                                              │
│  5. P/L baixo + Governança ruim                              │
│     → Riscos ocultos                                         │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def detect_value_trap(ticker: str) -> dict:
    """
    Identifica sinais de Value Trap
    """
    data = get_stock_data(ticker)
    
    warnings = []
    score = 0
    
    pl = data.get("priceToEarnings", 0)
    
    # Só faz sentido analisar se P/L for baixo
    if pl <= 0 or pl > 10:
        return {"ticker": ticker, "is_low_pl": False, "warnings": []}
    
    # 1. Verifica crescimento de receita
    revenue_growth = data.get("revenueGrowth", 0)
    if revenue_growth and revenue_growth < 0:
        warnings.append("⚠️ Receita em queda")
        score += 25
    
    # 2. Verifica endividamento
    debt_equity = data.get("debtToEquity", 0)
    if debt_equity and debt_equity > 2:
        warnings.append("⚠️ Alta alavancagem")
        score += 25
    
    # 3. Verifica margens
    profit_margin = data.get("profitMargin", 0)
    if profit_margin and profit_margin < 0.05:
        warnings.append("⚠️ Margens muito baixas")
        score += 20
    
    # 4. Verifica ROE
    roe = data.get("returnOnEquity", 0)
    if roe and roe < 0.08:
        warnings.append("⚠️ ROE baixo")
        score += 15
    
    # 5. Verifica variação de 52 semanas
    year_change = data.get("fiftyTwoWeekLowChangePercent", 0)
    if year_change and year_change < 0.1:
        warnings.append("⚠️ Perto da mínima de 52 semanas")
        score += 15
    
    is_trap = score >= 50
    
    return {
        "ticker": ticker,
        "pl": pl,
        "is_low_pl": True,
        "warnings": warnings,
        "trap_score": score,
        "is_potential_trap": is_trap,
        "conclusion": "❌ Provável Value Trap" if is_trap else "✅ Parece genuinamente barato"
    }

# Analisa empresas com P/L baixo
for ticker in ["OIBR3", "COGN3", "IRBR3", "MRFG3", "BEEF3"]:
    try:
        result = detect_value_trap(ticker)
        if result["is_low_pl"]:
            print(f"\n{ticker} - P/L: {result['pl']:.1f}")
            print(f"  Trap Score: {result['trap_score']}/100")
            for warning in result["warnings"]:
                print(f"  {warning}")
            print(f"  {result['conclusion']}")
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

def compare_pl_with_sector(ticker: str) -> dict:
    """
    Compara P/L da empresa com a média do setor
    """
    # Médias de P/L por setor (Brasil)
    sector_pl = {
        "Financial Services": 8,
        "Utilities": 10,
        "Basic Materials": 8,
        "Consumer Cyclical": 18,
        "Technology": 25,
        "Healthcare": 20,
        "Consumer Defensive": 15,
        "Energy": 7,
        "Industrials": 12,
        "Real Estate": 12,
        "Communication Services": 15
    }
    
    data = get_stock_data(ticker)
    
    pl_empresa = data.get("priceToEarnings", 0)
    setor = data.get("sector", "Unknown")
    pl_setor = sector_pl.get(setor, 12)
    
    if pl_empresa > 0:
        diferenca = ((pl_empresa / pl_setor) - 1) * 100
    else:
        diferenca = None
    
    if diferenca is None:
        avaliacao = "Prejuízo"
    elif diferenca < -20:
        avaliacao = "Muito abaixo do setor"
    elif diferenca < -10:
        avaliacao = "Abaixo do setor"
    elif diferenca < 10:
        avaliacao = "Alinhado com o setor"
    elif diferenca < 20:
        avaliacao = "Acima do setor"
    else:
        avaliacao = "Muito acima do setor"
    
    return {
        "ticker": ticker,
        "setor": setor,
        "pl_empresa": pl_empresa,
        "pl_setor_medio": pl_setor,
        "diferenca": diferenca,
        "avaliacao": avaliacao
    }

# Exemplo
for ticker in ["ITUB4", "WEGE3", "PETR4", "RADL3"]:
    resultado = compare_pl_with_sector(ticker)
    print(f"\n{resultado['ticker']} ({resultado['setor']})")
    print(f"  P/L Empresa: {resultado['pl_empresa']:.1f}")
    print(f"  P/L Setor: {resultado['pl_setor_medio']:.1f}")
    if resultado['diferenca']:
        print(f"  Diferença: {resultado['diferenca']:+.1f}%")
    print(f"  Avaliação: {resultado['avaliacao']}")

def complete_valuation_analysis(ticker: str) -> dict:
    """
    Análise completa de valuation combinando múltiplos indicadores
    """
    data = get_stock_data(ticker)
    
    analysis = {
        "ticker": ticker,
        "nome": data.get("longName", "N/A"),
        
        # Valuation
        "pl": data.get("priceToEarnings", 0),
        "pvp": data.get("priceToBook", 0),
        "ev_ebitda": data.get("enterpriseToEbitda", 0),
        "psr": data.get("priceToSales", 0),
        
        # Rentabilidade
        "roe": (data.get("returnOnEquity", 0) or 0) * 100,
        "roa": (data.get("returnOnAssets", 0) or 0) * 100,
        "margem_liquida": (data.get("profitMargin", 0) or 0) * 100,
        
        # Dividendos
        "dividend_yield": data.get("dividendYield", 0),
        
        # Crescimento
        "revenue_growth": (data.get("revenueGrowth", 0) or 0) * 100,
        "earnings_growth": (data.get("earningsGrowth", 0) or 0) * 100,
    }
    
    # Pontuação composta
    score = 0
    
    # P/L
    if 5 < analysis["pl"] < 15:
        score += 20
    elif 0 < analysis["pl"] < 20:
        score += 10
    
    # P/VP
    if 0 < analysis["pvp"] < 1.5:
        score += 20
    elif 0 < analysis["pvp"] < 3:
        score += 10
    
    # ROE
    if analysis["roe"] > 20:
        score += 20
    elif analysis["roe"] > 15:
        score += 15
    elif analysis["roe"] > 10:
        score += 10
    
    # Dividend Yield
    if analysis["dividend_yield"] > 5:
        score += 15
    elif analysis["dividend_yield"] > 3:
        score += 10
    
    # Crescimento
    if analysis["earnings_growth"] > 15:
        score += 15
    elif analysis["earnings_growth"] > 10:
        score += 10
    
    # Margem
    if analysis["margem_liquida"] > 15:
        score += 10
    elif analysis["margem_liquida"] > 10:
        score += 5
    
    analysis["score"] = score
    analysis["rating"] = (
        "⭐⭐⭐⭐⭐" if score >= 80 else
        "⭐⭐⭐⭐" if score >= 60 else
        "⭐⭐⭐" if score >= 40 else
        "⭐⭐" if score >= 20 else
        "⭐"
    )
    
    return analysis

# Análise completa
print("\nANÁLISE COMPLETA DE VALUATION")
print("=" * 60)

for ticker in ["WEGE3", "ITUB4", "PETR4", "VALE3", "RENT3"]:
    try:
        analysis = complete_valuation_analysis(ticker)
        
        print(f"\n{analysis['ticker']} - {analysis['nome']}")
        print(f"  Rating: {analysis['rating']} ({analysis['score']}/100)")
        print(f"  P/L: {analysis['pl']:.1f} | P/VP: {analysis['pvp']:.2f}")
        print(f"  EV/EBITDA: {analysis['ev_ebitda']:.1f} | P/Receita: {analysis['psr']:.2f}")
        print(f"  ROE: {analysis['roe']:.1f}% | Margem: {analysis['margem_liquida']:.1f}%")
        print(f"  DY: {analysis['dividend_yield']:.2f}%")
        
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

def calculate_earnings_yield(ticker: str) -> dict:
    """
    Calcula Earnings Yield (inverso do P/L)
    """
    data = get_stock_data(ticker)
    
    pl = data.get("priceToEarnings", 0)
    
    if pl > 0:
        earnings_yield = (1 / pl) * 100
    else:
        earnings_yield = 0
    
    # Compara com Selic
    selic = 13.25  # Taxa Selic atual (atualizar conforme necessário)
    
    premio_sobre_selic = earnings_yield - selic
    
    if premio_sobre_selic > 5:
        avaliacao = "Muito atrativo vs renda fixa"
    elif premio_sobre_selic > 2:
        avaliacao = "Atrativo vs renda fixa"
    elif premio_sobre_selic > 0:
        avaliacao = "Levemente atrativo vs renda fixa"
    else:
        avaliacao = "Renda fixa pode ser melhor"
    
    return {
        "ticker": ticker,
        "pl": pl,
        "earnings_yield": earnings_yield,
        "selic": selic,
        "premio": premio_sobre_selic,
        "avaliacao": avaliacao
    }

# Exemplo
print("\nEARNINGS YIELD vs SELIC")
print("=" * 50)

for ticker in ["PETR4", "VALE3", "ITUB4", "BBAS3", "TAEE11"]:
    resultado = calculate_earnings_yield(ticker)
    print(f"\n{resultado['ticker']}")
    print(f"  P/L: {resultado['pl']:.1f}")
    print(f"  Earnings Yield: {resultado['earnings_yield']:.2f}%")
    print(f"  Selic: {resultado['selic']:.2f}%")
    print(f"  Prêmio sobre Selic: {resultado['premio']:+.2f}%")
    print(f"  {resultado['avaliacao']}")