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.
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?
- Identificar Valor Real: Distinguir preço de valor
- Comparar Empresas: Análise objetiva entre concorrentes
- Reduzir Riscos: Evitar empresas com fundamentos fracos
- 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:
- Combine Indicadores: Nunca analise um único indicador isoladamente
- Compare com Pares: Use benchmarks setoriais adequados
- Considere Tendências: Analise evolução temporal, não apenas snapshot
- Contextualize: Considere ciclo econômico e perspectivas futuras
- Diversifique: Não concentre apenas em empresas "baratas"
Próximos Passos:
- Implemente screening personalizado com seus critérios
- Combine com análise técnica para timing de entrada
- Use nossa API para automatizar análises
- Construa sua carteira baseada em fundamentos
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!