Indicadores Fundamentalistas 2025: Guia Definitivo para B3

Domine TODOS os indicadores fundamentalistas! P/L, ROE, ROIC, EBITDA, margens e múltiplos. Framework completo para análise e investimento na B3 ✓

Categoria:Análise Fundamentalista • Framework Completo
28 min
Atualizado em:
Expertise: Framework completo de análise fundamentalista com 8+ anos de experiência
Tags:
Indicadores FundamentalistasAnálise FundamentalistaB3ValuationInvestimentosMúltiplosFramework

Neste artigo

Guia Completo dos Indicadores Fundamentalistas para Investir na Bovespa (B3)

Este é o guia definitivo dos indicadores fundamentalistas para análise de ações brasileiras. Aprenda a interpretar e usar P/L, ROE, ROIC, margens, múltiplos e indicadores de endividamento para construir uma estratégia sólida de investimentos na B3.

Publicado em 29 de janeiro, 2024

Introdução aos Indicadores Fundamentalistas

Os indicadores fundamentalistas são métricas que permitem avaliar a saúde financeira, rentabilidade, eficiência e valor de uma empresa. Eles são essenciais para tomar decisões de investimento baseadas em dados concretos, não em especulação.

Por que Usar Indicadores Fundamentalistas?

  1. Identificar Valor Real: Distinguir preço de valor
  2. Comparar Empresas: Análise objetiva entre concorrentes
  3. Reduzir Riscos: Evitar empresas com fundamentos fracos
  4. Construir Estratégia: Base para decisões de longo prazo

Framework Completo de Análise

Categorias de Indicadores

import requests
import json
from datetime import datetime, timedelta

class AnalisadorFundamentalista:
    def __init__(self, token=''):
        self.token = token
        self.base_url = "https://brapi.dev/api"
    
    def buscar_dados_completos(self, ticker):
        """Busca todos os dados necessários para análise fundamentalista"""
        
        modules = [
            'defaultKeyStatistics',
            'financialData', 
            'summaryDetail',
            'balanceSheetHistory',
            'incomeStatementHistory',
            'cashflowStatementHistory'
        ]
        
        url = f"{self.base_url}/quote/{ticker}?modules={','.join(modules)}&token={self.token}"
        
        try:
            response = requests.get(url)
            return response.json()['results'][0]
        except Exception as e:
            print(f"Erro ao buscar dados de {ticker}: {e}")
            return None
    
    def calcular_todos_indicadores(self, ticker):
        """Calcula todos os indicadores fundamentalistas"""
        
        dados = self.buscar_dados_completos(ticker)
        if not dados:
            return None
        
        indicadores = {
            'ticker': ticker,
            'nome': dados.get('longName', ''),
            'setor': dados.get('sector', ''),
            'subsector': dados.get('industry', ''),
            
            # 1. MÚLTIPLOS DE AVALIAÇÃO
            'multiplos': self.calcular_multiplos_avaliacao(dados),
            
            # 2. INDICADORES DE RENTABILIDADE  
            'rentabilidade': self.calcular_rentabilidade(dados),
            
            # 3. INDICADORES DE EFICIÊNCIA
            'eficiencia': self.calcular_eficiencia(dados),
            
            # 4. INDICADORES DE LIQUIDEZ
            'liquidez': self.calcular_liquidez(dados),
            
            # 5. INDICADORES DE ENDIVIDAMENTO
            'endividamento': self.calcular_endividamento(dados),
            
            # 6. INDICADORES DE CRESCIMENTO
            'crescimento': self.calcular_crescimento(dados),
            
            # 7. INDICADORES DE DIVIDEND YIELD
            'dividendos': self.calcular_indicadores_dividendos(dados),
            
            # 8. SCORE GERAL
            'score_geral': 0
        }
        
        # Calcular score geral
        indicadores['score_geral'] = self.calcular_score_geral(indicadores)
        
        return indicadores

    def calcular_multiplos_avaliacao(self, dados):
        """Múltiplos de avaliação (P/L, P/VP, PSR, EV/EBITDA)"""
        
        return {
            # Preço/Lucro
            'pl': dados.get('trailingPE', 0),
            'pl_forward': dados.get('forwardPE', 0),
            
            # Preço/Valor Patrimonial
            'pvp': dados.get('priceToBook', 0),
            
            # Preço/Vendas
            'psr': dados.get('priceToSalesTrailing12Months', 0),
            
            # Enterprise Value/EBITDA
            'ev_ebitda': dados.get('enterpriseToEbitda', 0),
            
            # Enterprise Value/Revenue
            'ev_revenue': dados.get('enterpriseToRevenue', 0),
            
            # PEG Ratio
            'peg': dados.get('pegRatio', 0)
        }
    
    def calcular_rentabilidade(self, dados):
        """Indicadores de rentabilidade"""
        
        return {
            # Return on Equity
            'roe': dados.get('returnOnEquity', 0),
            
            # Return on Assets  
            'roa': dados.get('returnOnAssets', 0),
            
            # Return on Investment Capital
            'roic': self.calcular_roic(dados),
            
            # Margens
            'margem_bruta': dados.get('grossMargins', 0) * 100,
            'margem_operacional': dados.get('operatingMargins', 0) * 100,
            'margem_liquida': dados.get('profitMargins', 0) * 100,
            
            # EBITDA Margin
            'margem_ebitda': dados.get('ebitdaMargins', 0) * 100
        }
    
    def calcular_eficiencia(self, dados):
        """Indicadores de eficiência operacional"""
        
        # Buscar dados do balanço e DRE
        balanco = dados.get('balanceSheetHistory', {}).get('balanceSheetHistory', [])
        dre = dados.get('incomeStatementHistory', {}).get('incomeStatementHistory', [])
        
        if not balanco or not dre:
            return {}
        
        balanco_atual = balanco[0]
        dre_atual = dre[0]
        
        # Receita e ativos
        receita = dre_atual.get('totalRevenue', 0)
        total_assets = balanco_atual.get('totalAssets', 0)
        inventory = balanco_atual.get('inventory', 0)
        accounts_receivable = balanco_atual.get('netReceivables', 0)
        
        return {
            # Giro do Ativo
            'giro_ativo': (receita / total_assets) if total_assets > 0 else 0,
            
            # Giro do Estoque (dias)
            'giro_estoque_dias': (inventory * 365 / receita) if receita > 0 and inventory > 0 else 0,
            
            # Prazo Médio de Recebimento (dias)
            'pmr_dias': (accounts_receivable * 365 / receita) if receita > 0 and accounts_receivable > 0 else 0,
            
            # Asset Turnover
            'asset_turnover': (receita / total_assets) if total_assets > 0 else 0
        }
    
    def calcular_liquidez(self, dados):
        """Indicadores de liquidez"""
        
        return {
            # Liquidez Corrente
            'liquidez_corrente': dados.get('currentRatio', 0),
            
            # Liquidez Seca
            'liquidez_seca': dados.get('quickRatio', 0),
            
            # Liquidez Imediata  
            'liquidez_imediata': self.calcular_liquidez_imediata(dados)
        }
    
    def calcular_endividamento(self, dados):
        """Indicadores de endividamento"""
        
        return {
            # Debt to Equity
            'debt_to_equity': dados.get('debtToEquity', 0),
            
            # Debt to Assets
            'debt_to_assets': self.calcular_debt_to_assets(dados),
            
            # Interest Coverage
            'interest_coverage': dados.get('interestCoverage', 0),
            
            # Cobertura de Juros por EBITDA
            'ebitda_interest_coverage': self.calcular_ebitda_interest_coverage(dados)
        }
    
    def calcular_crescimento(self, dados):
        """Indicadores de crescimento"""
        
        # Buscar histórico para calcular crescimento
        dre_historico = dados.get('incomeStatementHistory', {}).get('incomeStatementHistory', [])
        
        if len(dre_historico) < 2:
            return {}
        
        dre_atual = dre_historico[0]
        dre_anterior = dre_historico[1]
        
        receita_atual = dre_atual.get('totalRevenue', 0)
        receita_anterior = dre_anterior.get('totalRevenue', 0)
        
        lucro_atual = dre_atual.get('netIncome', 0)
        lucro_anterior = dre_anterior.get('netIncome', 0)
        
        return {
            # Crescimento de Receita
            'crescimento_receita': self.calcular_taxa_crescimento(receita_anterior, receita_atual),
            
            # Crescimento de Lucro
            'crescimento_lucro': self.calcular_taxa_crescimento(lucro_anterior, lucro_atual),
            
            # Earnings Growth Rate
            'earnings_growth': dados.get('earningsGrowth', 0),
            
            # Revenue Growth Rate
            'revenue_growth': dados.get('revenueGrowth', 0)
        }
    
    def calcular_indicadores_dividendos(self, dados):
        """Indicadores relacionados a dividendos"""
        
        return {
            # Dividend Yield
            'dividend_yield': dados.get('dividendYield', 0) * 100,
            
            # Payout Ratio
            'payout_ratio': dados.get('payoutRatio', 0) * 100,
            
            # Dividendos por Ação
            'dividends_per_share': dados.get('dividendsPerShare', 0),
            
            # Taxa de Crescimento de Dividendos
            'dividend_growth': self.calcular_crescimento_dividendos(dados)
        }

# Métodos auxiliares
    def calcular_roic(self, dados):
        """Calcula Return on Invested Capital"""
        try:
            dre = dados.get('incomeStatementHistory', {}).get('incomeStatementHistory', [])
            balanco = dados.get('balanceSheetHistory', {}).get('balanceSheetHistory', [])
            
            if not dre or not balanco:
                return 0
            
            # NOPAT (Net Operating Profit After Tax)
            ebit = dre[0].get('operatingIncome', 0)
            tax_rate = 0.25  # Taxa aproximada de IR no Brasil
            nopat = ebit * (1 - tax_rate)
            
            # Invested Capital
            total_equity = balanco[0].get('totalStockholdersEquity', 0)
            total_debt = balanco[0].get('totalDebt', 0)
            invested_capital = total_equity + total_debt
            
            return (nopat / invested_capital * 100) if invested_capital > 0 else 0
            
        except:
            return 0
    
    def calcular_taxa_crescimento(self, valor_anterior, valor_atual):
        """Calcula taxa de crescimento entre dois períodos"""
        if valor_anterior <= 0:
            return 0
        return ((valor_atual - valor_anterior) / valor_anterior) * 100
    
    def calcular_score_geral(self, indicadores):
        """Calcula score geral da empresa (0-100)"""
        score = 0
        
        # Score múltiplos (peso 25%)
        multiplos = indicadores['multiplos']
        if 8 <= multiplos.get('pl', 0) <= 15:
            score += 10
        elif multiplos.get('pl', 0) < 8:
            score += 15
        
        if multiplos.get('pvp', 0) < 1.5:
            score += 10
        
        # Score rentabilidade (peso 30%)
        rentabilidade = indicadores['rentabilidade']
        if rentabilidade.get('roe', 0) >= 15:
            score += 15
        elif rentabilidade.get('roe', 0) >= 10:
            score += 10
        
        if rentabilidade.get('margem_liquida', 0) >= 10:
            score += 15
        elif rentabilidade.get('margem_liquida', 0) >= 5:
            score += 10
        
        # Score liquidez (peso 15%)  
        liquidez = indicadores['liquidez']
        if liquidez.get('liquidez_corrente', 0) >= 1.5:
            score += 15
        elif liquidez.get('liquidez_corrente', 0) >= 1.0:
            score += 10
        
        # Score endividamento (peso 15%)
        endiv = indicadores['endividamento']
        if endiv.get('debt_to_equity', 0) < 0.5:
            score += 15
        elif endiv.get('debt_to_equity', 0) < 1.0:
            score += 10
        
        # Score crescimento (peso 15%)
        crescimento = indicadores['crescimento']
        if crescimento.get('crescimento_receita', 0) >= 10:
            score += 15
        elif crescimento.get('crescimento_receita', 0) >= 5:
            score += 10
        elif crescimento.get('crescimento_receita', 0) >= 0:
            score += 5
        
        return min(score, 100)

# Exemplo de uso
analisador = AnalisadorFundamentalista('SEU_TOKEN')
analise_completa = analisador.calcular_todos_indicadores('ITUB4')

if analise_completa:
    print("📊 ANÁLISE FUNDAMENTALISTA COMPLETA - ITUB4")
    print("=" * 70)
    print(f"Empresa: {analise_completa['nome']}")
    print(f"Setor: {analise_completa['setor']}")
    print(f"Score Geral: {analise_completa['score_geral']:.0f}/100")
    
    print(f"\n📈 MÚLTIPLOS DE AVALIAÇÃO:")
    multiplos = analise_completa['multiplos']
    print(f"P/L: {multiplos['pl']:.1f}")
    print(f"P/VP: {multiplos['pvp']:.2f}")
    print(f"PSR: {multiplos['psr']:.2f}")
    print(f"EV/EBITDA: {multiplos['ev_ebitda']:.1f}")
    
    print(f"\n💰 RENTABILIDADE:")
    rent = analise_completa['rentabilidade']
    print(f"ROE: {rent['roe']:.1f}%")
    print(f"ROA: {rent['roa']:.1f}%")
    print(f"ROIC: {rent['roic']:.1f}%")
    print(f"Margem Líquida: {rent['margem_liquida']:.1f}%")
    
    print(f"\n💧 LIQUIDEZ:")
    liq = analise_completa['liquidez']
    print(f"Liquidez Corrente: {liq['liquidez_corrente']:.2f}")
    print(f"Liquidez Seca: {liq['liquidez_seca']:.2f}")
    
    print(f"\n💳 ENDIVIDAMENTO:")
    end = analise_completa['endividamento']
    print(f"Debt/Equity: {end['debt_to_equity']:.2f}")
    
    print(f"\n📈 CRESCIMENTO:")
    cresc = analise_completa['crescimento']
    print(f"Crescimento Receita: {cresc.get('crescimento_receita', 0):+.1f}%")
    print(f"Crescimento Lucro: {cresc.get('crescimento_lucro', 0):+.1f}%")

1. Múltiplos de Avaliação

P/L (Preço sobre Lucro)

Definição: Relaciona o preço da ação com o lucro por ação Fórmula: P/L = Preço da Ação ÷ Lucro por Ação

Interpretação:

  • P/L < 10: Possivelmente subvalorizada
  • 10 < P/L < 20: Faixa considerada normal
  • P/L > 20: Pode estar cara ou com grande potencial

P/VP (Preço sobre Valor Patrimonial)

Definição: Compara valor de mercado com patrimônio líquido Fórmula: P/VP = Preço da Ação ÷ Valor Patrimonial por Ação

Interpretação:

  • P/VP < 1: Negociada abaixo do valor contábil
  • P/VP = 1: Preço igual ao valor patrimonial
  • P/VP > 1: Prêmio sobre valor contábil

EV/EBITDA (Enterprise Value sobre EBITDA)

Definição: Valor da empresa sobre lucro operacional Fórmula: EV/EBITDA = (Market Cap + Dívida Líquida) ÷ EBITDA

Interpretação:

  • EV/EBITDA < 8: Potencialmente barata
  • 8 < EV/EBITDA < 15: Faixa normal
  • EV/EBITDA > 15: Possivelmente cara

2. Indicadores de Rentabilidade

ROE (Return on Equity)

Definição: Retorno sobre patrimônio líquido Fórmula: ROE = Lucro Líquido ÷ Patrimônio Líquido

Interpretação:

  • ROE > 15%: Excelente
  • 10% < ROE < 15%: Boa
  • ROE < 10%: Abaixo da média

ROIC (Return on Invested Capital)

Definição: Retorno sobre capital investido Fórmula: ROIC = NOPAT ÷ Capital Investido

Interpretação:

  • ROIC > 12%: Empresa cria valor
  • ROIC = Custo do Capital: Neutra
  • ROIC < Custo do Capital: Destrói valor

Margens de Lucro

def analisar_margens_empresa(ticker, token=''):
    """Análise detalhada das margens de lucro"""
    
    url = f"https://brapi.dev/api/quote/{ticker}?modules=incomeStatementHistory&token={token}"
    response = requests.get(url)
    data = response.json()
    
    dre_list = data['results'][0]['incomeStatementHistory']['incomeStatementHistory']
    
    analise_margens = []
    
    for dre in dre_list[:3]:  # Últimos 3 anos
        receita = dre.get('totalRevenue', 0)
        lucro_bruto = dre.get('grossProfit', 0)
        lucro_operacional = dre.get('operatingIncome', 0)
        lucro_liquido = dre.get('netIncome', 0)
        ebitda = dre.get('ebitda', 0)
        
        if receita > 0:
            margens = {
                'ano': datetime.fromtimestamp(dre['endDate']).year,
                'margem_bruta': (lucro_bruto / receita) * 100,
                'margem_operacional': (lucro_operacional / receita) * 100,
                'margem_liquida': (lucro_liquido / receita) * 100,
                'margem_ebitda': (ebitda / receita) * 100 if ebitda > 0 else 0
            }
            analise_margens.append(margens)
    
    return analise_margens

# Análise de margens
margens_itub4 = analisar_margens_empresa('ITUB4')

print("📊 ANÁLISE DE MARGENS - ITUB4")
print("=" * 50)
for margem in margens_itub4:
    print(f"\n📅 {margem['ano']}:")
    print(f"  Margem Bruta: {margem['margem_bruta']:.1f}%")
    print(f"  Margem Operacional: {margem['margem_operacional']:.1f}%")
    print(f"  Margem Líquida: {margem['margem_liquida']:.1f}%")
    print(f"  Margem EBITDA: {margem['margem_ebitda']:.1f}%")

3. Indicadores de Eficiência

Giro dos Ativos

Definição: Eficiência no uso dos ativos para gerar receita Fórmula: Giro = Receita Líquida ÷ Ativo Total

ROA (Return on Assets)

Definição: Retorno sobre ativos totais Fórmula: ROA = Lucro Líquido ÷ Ativo Total

4. Indicadores de Liquidez

Liquidez Corrente

Definição: Capacidade de pagamento no curto prazo Fórmula: LC = Ativo Circulante ÷ Passivo Circulante

Interpretação:

  • LC > 2: Excelente liquidez
  • 1,5 < LC < 2: Boa liquidez
  • LC < 1: Problemas de liquidez

Liquidez Seca

Definição: Liquidez excluindo estoques Fórmula: LS = (Ativo Circulante - Estoques) ÷ Passivo Circulante

5. Indicadores de Endividamento

Debt-to-Equity

Definição: Proporção entre dívida e patrimônio Fórmula: D/E = Dívida Total ÷ Patrimônio Líquido

Interpretação:

  • D/E < 0,5: Baixo endividamento
  • 0,5 < D/E < 1,0: Endividamento moderado
  • D/E > 1,0: Alto endividamento

Screening Fundamentalista Avançado

Sistema de Filtros Múltiplos

def screening_fundamentalista_completo(universo_acoes, criterios, token=''):
    """Sistema completo de screening fundamentalista"""
    
    analisador = AnalisadorFundamentalista(token)
    resultados = []
    
    print(f"🔍 Iniciando screening de {len(universo_acoes)} ações...")
    print("=" * 60)
    
    for i, ticker in enumerate(universo_acoes, 1):
        print(f"[{i:2d}/{len(universo_acoes)}] Analisando {ticker}...", end=' ')
        
        try:
            analise = analisador.calcular_todos_indicadores(ticker)
            
            if not analise:
                print("❌ Dados insuficientes")
                continue
            
            # Aplicar todos os filtros
            if filtrar_por_criterios(analise, criterios):
                resultados.append(analise)
                print("✅ Aprovada")
            else:
                print("❌ Rejeitada")
                
        except Exception as e:
            print(f"❌ Erro: {e}")
            continue
    
    # Ordenar por score geral
    resultados_ordenados = sorted(resultados, key=lambda x: x['score_geral'], reverse=True)
    
    return resultados_ordenados

def filtrar_por_criterios(analise, criterios):
    """Aplica filtros de screening"""
    
    multiplos = analise['multiplos']
    rentabilidade = analise['rentabilidade']
    liquidez = analise['liquidez']
    endividamento = analise['endividamento']
    crescimento = analise['crescimento']
    
    # Filtros de múltiplos
    if (multiplos.get('pl', 999) > criterios['pl_max'] or
        multiplos.get('pvp', 999) > criterios['pvp_max'] or
        multiplos.get('ev_ebitda', 999) > criterios['ev_ebitda_max']):
        return False
    
    # Filtros de rentabilidade
    if (rentabilidade.get('roe', 0) < criterios['roe_min'] or
        rentabilidade.get('margem_liquida', 0) < criterios['margem_min']):
        return False
    
    # Filtros de liquidez
    if liquidez.get('liquidez_corrente', 0) < criterios['liquidez_min']:
        return False
    
    # Filtros de endividamento
    if endividamento.get('debt_to_equity', 999) > criterios['debt_equity_max']:
        return False
    
    # Filtros de crescimento
    if crescimento.get('crescimento_receita', -999) < criterios['crescimento_min']:
        return False
    
    return True

# Critérios de screening conservador
criterios_conservador = {
    # Múltiplos
    'pl_max': 15,
    'pvp_max': 2.0,
    'ev_ebitda_max': 12,
    
    # Rentabilidade  
    'roe_min': 12,
    'margem_min': 8,
    
    # Liquidez
    'liquidez_min': 1.2,
    
    # Endividamento
    'debt_equity_max': 0.8,
    
    # Crescimento
    'crescimento_min': 0  # Pelo menos estável
}

# Universo para screening
universo_blue_chips = [
    'ITUB4', 'BBDC4', 'PETR4', 'VALE3', 'ABEV3', 'BBAS3', 'WEGE3', 'RENT3',
    'MGLU3', 'LREN3', 'RAIL3', 'VIVT3', 'KLBN11', 'SBSP3', 'SUZB3', 'CCRO3',
    'EGIE3', 'TAEE11', 'CMIG4', 'ENBR3', 'EQTL3', 'CSAN3', 'USIM5', 'GOAU4'
]

# Executar screening
empresas_aprovadas = screening_fundamentalista_completo(universo_blue_chips, criterios_conservador)

print(f"\n🎯 RESULTADO DO SCREENING")
print("=" * 60)
print(f"Empresas analisadas: {len(universo_blue_chips)}")
print(f"Empresas aprovadas: {len(empresas_aprovadas)}")
print(f"Taxa de aprovação: {len(empresas_aprovadas)/len(universo_blue_chips)*100:.1f}%")

print(f"\n🏆 TOP 10 EMPRESAS APROVADAS:")
print("-" * 60)

for i, empresa in enumerate(empresas_aprovadas[:10], 1):
    print(f"{i:2d}. {empresa['ticker']} - Score: {empresa['score_geral']:.0f}/100")
    
    mult = empresa['multiplos']
    rent = empresa['rentabilidade'] 
    
    print(f"    P/L: {mult['pl']:.1f} | P/VP: {mult['pvp']:.2f} | ROE: {rent['roe']:.1f}%")
    print(f"    Margem Líquida: {rent['margem_liquida']:.1f}% | Setor: {empresa['setor']}")
    print()

Análise Setorial Comparativa

Benchmarking por Setor

def analise_setorial_detalhada(setor_empresas, nome_setor, token=''):
    """Análise fundamentalista por setor"""
    
    analisador = AnalisadorFundamentalista(token)
    empresas_setor = []
    
    print(f"📊 ANÁLISE SETORIAL - {nome_setor.upper()}")
    print("=" * 60)
    
    for ticker in setor_empresas:
        analise = analisador.calcular_todos_indicadores(ticker)
        if analise:
            empresas_setor.append(analise)
    
    if not empresas_setor:
        return None
    
    # Calcular estatísticas do setor
    estatisticas = calcular_estatisticas_setor(empresas_setor)
    
    # Ranking por score
    ranking = sorted(empresas_setor, key=lambda x: x['score_geral'], reverse=True)
    
    # Exibir resultados
    print(f"\n📈 ESTATÍSTICAS DO SETOR ({len(empresas_setor)} empresas):")
    print("-" * 40)
    print(f"P/L Médio: {estatisticas['pl_medio']:.1f}")
    print(f"P/VP Médio: {estatisticas['pvp_medio']:.2f}")
    print(f"ROE Médio: {estatisticas['roe_medio']:.1f}%")
    print(f"Margem Líquida Média: {estatisticas['margem_media']:.1f}%")
    print(f"Debt/Equity Médio: {estatisticas['debt_equity_medio']:.2f}")
    
    print(f"\n🏆 RANKING DO SETOR:")
    print("-" * 40)
    
    for i, empresa in enumerate(ranking, 1):
        score = empresa['score_geral']
        mult = empresa['multiplos']
        rent = empresa['rentabilidade']
        
        print(f"{i:2d}. {empresa['ticker']} - Score: {score:.0f}/100")
        print(f"    P/L: {mult['pl']:.1f} | ROE: {rent['roe']:.1f}% | ML: {rent['margem_liquida']:.1f}%")
    
    return {
        'estatisticas': estatisticas,
        'ranking': ranking,
        'lider_setor': ranking[0] if ranking else None
    }

def calcular_estatisticas_setor(empresas):
    """Calcula estatísticas agregadas do setor"""
    
    pls = [e['multiplos']['pl'] for e in empresas if e['multiplos']['pl'] > 0]
    pvps = [e['multiplos']['pvp'] for e in empresas if e['multiplos']['pvp'] > 0]
    roes = [e['rentabilidade']['roe'] for e in empresas if e['rentabilidade']['roe'] > 0]
    margens = [e['rentabilidade']['margem_liquida'] for e in empresas if e['rentabilidade']['margem_liquida'] > 0]
    debt_equity = [e['endividamento']['debt_to_equity'] for e in empresas if e['endividamento']['debt_to_equity'] > 0]
    
    return {
        'pl_medio': sum(pls) / len(pls) if pls else 0,
        'pvp_medio': sum(pvps) / len(pvps) if pvps else 0,
        'roe_medio': sum(roes) / len(roes) if roes else 0,
        'margem_media': sum(margens) / len(margens) if margens else 0,
        'debt_equity_medio': sum(debt_equity) / len(debt_equity) if debt_equity else 0
    }

# Análise por setores
setores = {
    'Bancos': ['ITUB4', 'BBDC4', 'BBAS3', 'SANB11', 'BPAC11'],
    'Mineração': ['VALE3', 'CSNA3', 'USIM5', 'GOAU4'],
    'Energia Elétrica': ['EGIE3', 'CMIG4', 'ENBR3', 'TAEE11', 'SBSP3'],
    'Petróleo': ['PETR4', 'PRIO3'],
    'Varejo': ['MGLU3', 'LREN3', 'AMER3', 'PCAR3']
}

# Executar análise para cada setor
resultados_setoriais = {}

for nome_setor, empresas in setores.items():
    resultado = analise_setorial_detalhada(empresas, nome_setor)
    if resultado:
        resultados_setoriais[nome_setor] = resultado

# Comparação entre setores
print(f"\n🔍 COMPARAÇÃO ENTRE SETORES")
print("=" * 60)

for setor, dados in resultados_setoriais.items():
    stats = dados['estatisticas']
    lider = dados['lider_setor']
    
    print(f"\n📊 {setor}:")
    print(f"  ROE Médio: {stats['roe_medio']:.1f}% | Líder: {lider['ticker']}")
    print(f"  P/L Médio: {stats['pl_medio']:.1f} | Margem Média: {stats['margem_media']:.1f}%")

Dashboard de Monitoramento

Sistema de Alertas

def sistema_alertas_fundamentalista(watchlist, parametros_alerta, token=''):
    """Sistema de alertas baseado em indicadores fundamentalistas"""
    
    analisador = AnalisadorFundamentalista(token)
    alertas = {
        'oportunidades': [],
        'deterioracao': [],
        'riscos': []
    }
    
    for ticker in watchlist:
        analise = analisador.calcular_todos_indicadores(ticker)
        
        if not analise:
            continue
        
        # Verificar oportunidades
        if (analise['multiplos']['pl'] < parametros_alerta['pl_oportunidade'] and
            analise['rentabilidade']['roe'] > parametros_alerta['roe_min_oportunidade']):
            alertas['oportunidades'].append({
                'ticker': ticker,
                'motivo': 'P/L baixo com ROE alto',
                'pl': analise['multiplos']['pl'],
                'roe': analise['rentabilidade']['roe']
            })
        
        # Verificar deterioração
        if analise['score_geral'] < parametros_alerta['score_min_qualidade']:
            alertas['deterioracao'].append({
                'ticker': ticker,
                'motivo': 'Score fundamentalista baixo',
                'score': analise['score_geral']
            })
        
        # Verificar riscos
        if (analise['endividamento']['debt_to_equity'] > parametros_alerta['debt_equity_max'] or
            analise['liquidez']['liquidez_corrente'] < parametros_alerta['liquidez_min']):
            alertas['riscos'].append({
                'ticker': ticker,
                'motivo': 'Alto endividamento ou baixa liquidez',
                'debt_equity': analise['endividamento']['debt_to_equity'],
                'liquidez': analise['liquidez']['liquidez_corrente']
            })
    
    return alertas

# Configurar alertas
watchlist_pessoal = ['ITUB4', 'PETR4', 'VALE3', 'WEGE3', 'MGLU3']

parametros = {
    'pl_oportunidade': 12,
    'roe_min_oportunidade': 15,
    'score_min_qualidade': 60,
    'debt_equity_max': 1.0,
    'liquidez_min': 1.2
}

alertas = sistema_alertas_fundamentalista(watchlist_pessoal, parametros)

# Exibir alertas
print("🚨 SISTEMA DE ALERTAS FUNDAMENTALISTA")
print("=" * 50)

if alertas['oportunidades']:
    print("\n💎 OPORTUNIDADES DETECTADAS:")
    for opp in alertas['oportunidades']:
        print(f"• {opp['ticker']}: {opp['motivo']}")
        print(f"  P/L: {opp['pl']:.1f} | ROE: {opp['roe']:.1f}%")

if alertas['deterioracao']:
    print("\n⚠️ DETERIORAÇÃO DE QUALIDADE:")
    for det in alertas['deterioracao']:
        print(f"• {det['ticker']}: {det['motivo']}")
        print(f"  Score: {det['score']:.0f}/100")

if alertas['riscos']:
    print("\n🔴 RISCOS IDENTIFICADOS:")
    for risco in alertas['riscos']:
        print(f"• {risco['ticker']}: {risco['motivo']}")
        print(f"  D/E: {risco['debt_equity']:.2f} | LC: {risco['liquidez']:.2f}")

if not any(alertas.values()):
    print("\n✅ Nenhum alerta ativo. Carteira dentro dos parâmetros.")

Casos Práticos de Análise

Exemplo 1: Análise Bancária (ITUB4)

Indicadores-Chave para Bancos:

  • ROE > 15%
  • P/VP próximo a 1,0-1,5
  • Eficiência (relação custo/receita)
  • Qualidade da carteira de crédito

Exemplo 2: Análise Industrial (WEGE3)

Indicadores-Chave para Indústria:

  • ROIC > 12%
  • Margem EBITDA > 15%
  • Giro dos ativos
  • Crescimento sustentável

Exemplo 3: Análise Utilities (EGIE3)

Indicadores-Chave para Utilities:

  • Dividend Yield > 5%
  • Debt/Equity controlado
  • ROE estável
  • Crescimento de dividendos

Estratégias de Investimento

1. Growth Investing

  • Foco: Crescimento de receita e lucro
  • Indicadores: ROE, crescimento, ROIC
  • Aceita múltiplos mais altos

2. Value Investing

  • Foco: Múltiplos baixos
  • Indicadores: P/L, P/VP, EV/EBITDA
  • Empresas temporariamente desvalorizadas

3. Quality Investing

  • Foco: Empresas de alta qualidade
  • Indicadores: ROE consistente, baixo endividamento
  • Múltiplos justos por qualidade superior

4. Dividend Investing

  • Foco: Renda passiva
  • Indicadores: DY, payout ratio, histórico
  • Empresas maduras e estáveis

Conclusão

Os indicadores fundamentalistas são ferramentas essenciais para análise de investimentos. Use este guia como referência, mas lembre-se de sempre considerar o contexto setorial, macroeconômico e qualitativo.

Pontos-Chave para Sucesso:

  1. Combine Indicadores: Nunca analise um único indicador isoladamente
  2. Compare com Pares: Use benchmarks setoriais adequados
  3. Considere Tendências: Analise evolução temporal, não apenas snapshot
  4. Contextualize: Considere ciclo econômico e perspectivas futuras
  5. Diversifique: Não concentre apenas em empresas "baratas"

Próximos Passos:

Recursos Complementares:

Lembre-se: A análise fundamentalista é uma ferramenta poderosa, mas deve ser usada junto com gestão de risco e diversificação adequada!

Artigos Relacionados