Como Analisar Ações em 2026: Guia Completo para Iniciantes

def tipos_de_analise():
    """
    Comparação entre os dois principais métodos de análise
    """
    analises = {
        'fundamentalista': {
            'foco': 'Valor intrínseco da empresa',
            'pergunta': 'Essa empresa vale quanto?',
            'horizonte': 'Médio a longo prazo',
            'dados': ['Balanço', 'DRE', 'Indicadores', 'Setor'],
            'objetivo': 'Comprar boas empresas com desconto',
            'praticantes': 'Warren Buffett, Luiz Barsi'
        },
        'tecnica': {
            'foco': 'Padrões de preço e volume',
            'pergunta': 'Para onde o preço vai?',
            'horizonte': 'Curto a médio prazo',
            'dados': ['Gráficos', 'Indicadores técnicos', 'Volume'],
            'objetivo': 'Identificar momentos de entrada e saída',
            'praticantes': 'Traders profissionais'
        }
    }
    
    return analises

analises = tipos_de_analise()
for tipo, info in analises.items():
    print(f"\n=== ANÁLISE {tipo.upper()} ===")
    for k, v in info.items():
        if isinstance(v, list):
            print(f"{k}: {', '.join(v)}")
        else:
            print(f"{k}: {v}")

import requests

def calcular_pl(preco, lpa):
    """
    Calcula o índice Preço/Lucro
    
    Args:
        preco: Preço atual da ação
        lpa: Lucro Por Ação (últimos 12 meses)
    
    Returns:
        P/L e interpretação
    """
    if lpa <= 0:
        return {'pl': None, 'interpretacao': 'Empresa com prejuízo'}
    
    pl = preco / lpa
    
    if pl < 5:
        interpretacao = 'Muito barato (ou armadilha)'
    elif pl < 10:
        interpretacao = 'Barato'
    elif pl < 15:
        interpretacao = 'Preço justo'
    elif pl < 25:
        interpretacao = 'Caro'
    else:
        interpretacao = 'Muito caro (ou alto crescimento)'
    
    return {
        'preco': preco,
        'lpa': lpa,
        'pl': round(pl, 2),
        'interpretacao': interpretacao,
        'anos_payback': round(pl, 1)
    }

# Exemplo
resultado = calcular_pl(preco=35.50, lpa=4.20)
print(f"P/L: {resultado['pl']}")
print(f"Interpretação: {resultado['interpretacao']}")
print(f"'Payback' em lucros: {resultado['anos_payback']} anos")

def calcular_pvp(preco, vpa):
    """
    Calcula o índice Preço/Valor Patrimonial
    
    Args:
        preco: Preço atual da ação
        vpa: Valor Patrimonial por Ação
    
    Returns:
        P/VP e interpretação
    """
    if vpa <= 0:
        return {'pvp': None, 'interpretacao': 'Patrimônio líquido negativo'}
    
    pvp = preco / vpa
    
    if pvp < 0.8:
        interpretacao = 'Abaixo do patrimônio (pode ser oportunidade)'
    elif pvp < 1.0:
        interpretacao = 'Próximo do patrimônio'
    elif pvp < 1.5:
        interpretacao = 'Prêmio pequeno sobre patrimônio'
    elif pvp < 3.0:
        interpretacao = 'Prêmio médio (empresa de qualidade)'
    else:
        interpretacao = 'Prêmio alto (marca forte ou alto crescimento)'
    
    return {
        'preco': preco,
        'vpa': vpa,
        'pvp': round(pvp, 2),
        'interpretacao': interpretacao
    }

# Exemplo
resultado = calcular_pvp(preco=35.50, vpa=28.00)
print(f"P/VP: {resultado['pvp']}")
print(f"Interpretação: {resultado['interpretacao']}")

def calcular_roe(lucro_liquido, patrimonio_liquido):
    """
    Calcula o Return on Equity (ROE)
    
    Args:
        lucro_liquido: Lucro líquido anual
        patrimonio_liquido: Patrimônio líquido
    
    Returns:
        ROE e interpretação
    """
    if patrimonio_liquido <= 0:
        return {'roe': None, 'interpretacao': 'PL negativo'}
    
    roe = (lucro_liquido / patrimonio_liquido) * 100
    
    if roe < 5:
        interpretacao = 'Baixo - empresa pouco eficiente'
    elif roe < 10:
        interpretacao = 'Moderado - abaixo da média'
    elif roe < 15:
        interpretacao = 'Bom - acima da média'
    elif roe < 25:
        interpretacao = 'Muito bom - empresa eficiente'
    else:
        interpretacao = 'Excelente (verificar se é sustentável)'
    
    return {
        'lucro_liquido': lucro_liquido,
        'patrimonio_liquido': patrimonio_liquido,
        'roe': round(roe, 2),
        'interpretacao': interpretacao
    }

# Exemplo
resultado = calcular_roe(lucro_liquido=5_000_000_000, patrimonio_liquido=25_000_000_000)
print(f"ROE: {resultado['roe']}%")
print(f"Interpretação: {resultado['interpretacao']}")

def calcular_dividend_yield(dividendos_12m, preco):
    """
    Calcula o Dividend Yield
    
    Args:
        dividendos_12m: Dividendos pagos nos últimos 12 meses
        preco: Preço atual da ação
    """
    dy = (dividendos_12m / preco) * 100
    
    if dy < 2:
        interpretacao = 'Baixo - foco em crescimento'
    elif dy < 4:
        interpretacao = 'Moderado'
    elif dy < 6:
        interpretacao = 'Bom para renda passiva'
    elif dy < 10:
        interpretacao = 'Alto (verificar sustentabilidade)'
    else:
        interpretacao = 'Muito alto (pode ser insustentável)'
    
    return {
        'dividendos_12m': dividendos_12m,
        'preco': preco,
        'dy': round(dy, 2),
        'interpretacao': interpretacao
    }

# Exemplo
resultado = calcular_dividend_yield(dividendos_12m=3.50, preco=35.50)
print(f"Dividend Yield: {resultado['dy']}%")
print(f"Interpretação: {resultado['interpretacao']}")

def calcular_divida_ebitda(divida_liquida, ebitda):
    """
    Calcula a relação Dívida Líquida/EBITDA
    
    Args:
        divida_liquida: Dívida bruta - Caixa
        ebitda: EBITDA dos últimos 12 meses
    """
    if ebitda <= 0:
        return {'ratio': None, 'interpretacao': 'EBITDA negativo'}
    
    ratio = divida_liquida / ebitda
    
    if ratio < 0:
        interpretacao = 'Caixa líquido (mais caixa que dívida)'
    elif ratio < 1:
        interpretacao = 'Endividamento baixo'
    elif ratio < 2:
        interpretacao = 'Endividamento moderado'
    elif ratio < 3:
        interpretacao = 'Endividamento alto'
    else:
        interpretacao = 'Endividamento perigoso'
    
    return {
        'divida_liquida': divida_liquida,
        'ebitda': ebitda,
        'ratio': round(ratio, 2),
        'interpretacao': interpretacao,
        'anos_para_pagar': round(ratio, 1) if ratio > 0 else 0
    }

# Exemplo
resultado = calcular_divida_ebitda(divida_liquida=10_000_000_000, ebitda=8_000_000_000)
print(f"Dívida/EBITDA: {resultado['ratio']}x")
print(f"Interpretação: {resultado['interpretacao']}")

import requests

def analisar_acao_completa(ticker, token):
    """
    Análise fundamentalista completa usando brapi.dev
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        'token': token,
        'modules': 'defaultKeyStatistics,financialData,summaryDetail'
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    if 'results' not in data or len(data['results']) == 0:
        return None
    
    ativo = data['results'][0]
    
    # Extrair indicadores
    analise = {
        'ticker': ticker,
        'nome': ativo.get('shortName', ''),
        'preco': ativo.get('regularMarketPrice', 0),
        'variacao_dia': ativo.get('regularMarketChangePercent', 0),
        
        # Indicadores de valuation
        'indicadores': {
            'P/L': ativo.get('priceToEarnings', 'N/A'),
            'P/VP': ativo.get('priceToBook', 'N/A'),
            'EV/EBITDA': ativo.get('enterpriseToEbitda', 'N/A'),
            'Dividend Yield': f"{ativo.get('dividendYield', 0):.2f}%",
        },
        
        # Métricas de rentabilidade
        'rentabilidade': {
            'ROE': ativo.get('returnOnEquity', 'N/A'),
            'ROA': ativo.get('returnOnAssets', 'N/A'),
            'Margem Líquida': ativo.get('profitMargin', 'N/A'),
        },
        
        # Métricas de crescimento
        'crescimento': {
            'Crescimento Receita': ativo.get('revenueGrowth', 'N/A'),
            'Crescimento Lucro': ativo.get('earningsGrowth', 'N/A'),
        }
    }
    
    return analise

# Exemplo de uso
# resultado = analisar_acao_completa('PETR4', 'SEU_TOKEN')
# print(f"Análise de {resultado['ticker']}:")
# for categoria, metricas in resultado.items():
#     if isinstance(metricas, dict):
#         print(f"\n{categoria.upper()}:")
#         for k, v in metricas.items():
#             print(f"  {k}: {v}")

def comparar_acoes(tickers, token):
    """
    Compara indicadores de múltiplas ações
    """
    tickers_str = ','.join(tickers)
    
    url = f"https://brapi.dev/api/quote/{tickers_str}"
    params = {
        'token': token,
        'modules': 'defaultKeyStatistics'
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    comparativo = []
    
    for ativo in data.get('results', []):
        comparativo.append({
            'Ticker': ativo.get('symbol'),
            'Preço': ativo.get('regularMarketPrice'),
            'P/L': ativo.get('priceToEarnings'),
            'P/VP': ativo.get('priceToBook'),
            'DY': f"{ativo.get('dividendYield', 0):.2f}%",
            'ROE': ativo.get('returnOnEquity')
        })
    
    return comparativo

# Exemplo
# tickers = ['PETR4', 'VALE3', 'ITUB4', 'BBDC4', 'WEGE3']
# comparativo = comparar_acoes(tickers, 'SEU_TOKEN')
# for acao in comparativo:
#     print(acao)

def identificar_tendencia(precos):
    """
    Identifica a tendência de um ativo
    
    Args:
        precos: Lista de preços de fechamento
    """
    if len(precos) < 20:
        return 'Dados insuficientes'
    
    # Médias móveis simples
    mm9 = sum(precos[-9:]) / 9
    mm21 = sum(precos[-21:]) / 21
    preco_atual = precos[-1]
    
    # Determinar tendência
    if preco_atual > mm9 > mm21:
        tendencia = 'ALTA FORTE'
    elif preco_atual > mm21:
        tendencia = 'ALTA'
    elif preco_atual < mm9 < mm21:
        tendencia = 'BAIXA FORTE'
    elif preco_atual < mm21:
        tendencia = 'BAIXA'
    else:
        tendencia = 'LATERAL'
    
    return {
        'preco_atual': preco_atual,
        'mm9': round(mm9, 2),
        'mm21': round(mm21, 2),
        'tendencia': tendencia
    }

def calcular_medias_moveis(precos, periodos=[9, 21, 50, 200]):
    """
    Calcula múltiplas médias móveis
    """
    medias = {}
    
    for periodo in periodos:
        if len(precos) >= periodo:
            media = sum(precos[-periodo:]) / periodo
            medias[f'MM{periodo}'] = round(media, 2)
    
    return medias

# Interpretação das médias
def interpretar_medias(preco_atual, medias):
    """
    Interpreta a posição do preço em relação às médias
    """
    sinais = []
    
    if preco_atual > medias.get('MM9', 0):
        sinais.append('Acima da MM9 (curtíssimo prazo positivo)')
    
    if preco_atual > medias.get('MM21', 0):
        sinais.append('Acima da MM21 (curto prazo positivo)')
    
    if preco_atual > medias.get('MM50', 0):
        sinais.append('Acima da MM50 (médio prazo positivo)')
    
    if preco_atual > medias.get('MM200', 0):
        sinais.append('Acima da MM200 (longo prazo positivo)')
    
    # Cruzamentos
    if medias.get('MM9', 0) > medias.get('MM21', 0):
        sinais.append('MM9 > MM21: Tendência de alta')
    else:
        sinais.append('MM9 < MM21: Tendência de baixa')
    
    return sinais

def calcular_ifr(precos, periodo=14):
    """
    Calcula o IFR (RSI em inglês)
    
    IFR < 30: Sobrevendido (possível reversão para alta)
    IFR > 70: Sobrecomprado (possível reversão para baixa)
    """
    if len(precos) < periodo + 1:
        return None
    
    ganhos = []
    perdas = []
    
    for i in range(1, periodo + 1):
        diff = precos[-i] - precos[-i-1]
        if diff > 0:
            ganhos.append(diff)
            perdas.append(0)
        else:
            ganhos.append(0)
            perdas.append(abs(diff))
    
    media_ganhos = sum(ganhos) / periodo
    media_perdas = sum(perdas) / periodo
    
    if media_perdas == 0:
        return 100
    
    rs = media_ganhos / media_perdas
    ifr = 100 - (100 / (1 + rs))
    
    if ifr < 30:
        zona = 'SOBREVENDIDO (possível oportunidade de compra)'
    elif ifr > 70:
        zona = 'SOBRECOMPRADO (possível oportunidade de venda)'
    else:
        zona = 'NEUTRO'
    
    return {
        'ifr': round(ifr, 2),
        'zona': zona
    }

def calcular_macd(precos, rapida=12, lenta=26, sinal=9):
    """
    Calcula o MACD
    
    Sinal de compra: MACD cruza acima da linha de sinal
    Sinal de venda: MACD cruza abaixo da linha de sinal
    """
    def ema(precos, periodo):
        """Média móvel exponencial"""
        if len(precos) < periodo:
            return None
        
        multiplicador = 2 / (periodo + 1)
        ema_valor = sum(precos[:periodo]) / periodo
        
        for preco in precos[periodo:]:
            ema_valor = (preco - ema_valor) * multiplicador + ema_valor
        
        return ema_valor
    
    if len(precos) < lenta + sinal:
        return None
    
    ema_rapida = ema(precos, rapida)
    ema_lenta = ema(precos, lenta)
    
    macd_linha = ema_rapida - ema_lenta
    
    return {
        'ema_rapida': round(ema_rapida, 2),
        'ema_lenta': round(ema_lenta, 2),
        'macd': round(macd_linha, 2),
        'sinal': 'COMPRA' if macd_linha > 0 else 'VENDA'
    }

def valuation_dcf_simplificado(lucro_atual, crescimento_5anos, crescimento_perpetuo, taxa_desconto):
    """
    Valuation simplificado por DCF
    
    Args:
        lucro_atual: Lucro líquido atual (ou FCL)
        crescimento_5anos: Taxa de crescimento esperada para os próximos 5 anos
        crescimento_perpetuo: Taxa de crescimento na perpetuidade
        taxa_desconto: Taxa de desconto (custo de capital)
    
    Returns:
        Valor presente da empresa
    """
    fluxos = []
    lucro = lucro_atual
    
    # Projetar fluxos dos próximos 5 anos
    for ano in range(1, 6):
        lucro = lucro * (1 + crescimento_5anos)
        fluxo_descontado = lucro / ((1 + taxa_desconto) ** ano)
        fluxos.append({
            'ano': ano,
            'lucro_projetado': round(lucro, 2),
            'fluxo_descontado': round(fluxo_descontado, 2)
        })
    
    # Valor na perpetuidade (Gordon Growth)
    valor_terminal = (lucro * (1 + crescimento_perpetuo)) / (taxa_desconto - crescimento_perpetuo)
    valor_terminal_descontado = valor_terminal / ((1 + taxa_desconto) ** 5)
    
    # Valor total
    soma_fluxos = sum(f['fluxo_descontado'] for f in fluxos)
    valor_empresa = soma_fluxos + valor_terminal_descontado
    
    return {
        'fluxos_projetados': fluxos,
        'valor_terminal': round(valor_terminal, 2),
        'valor_terminal_descontado': round(valor_terminal_descontado, 2),
        'soma_fluxos_5anos': round(soma_fluxos, 2),
        'valor_empresa': round(valor_empresa, 2)
    }

# Exemplo: Empresa com lucro de R$ 5 bilhões
resultado = valuation_dcf_simplificado(
    lucro_atual=5_000_000_000,
    crescimento_5anos=0.10,      # 10% a.a.
    crescimento_perpetuo=0.03,   # 3% a.a. (inflação)
    taxa_desconto=0.12           # 12% a.a. (custo de capital)
)

print(f"Valor justo da empresa: R$ {resultado['valor_empresa']:,.0f}")
print(f"Se tem 1 bi de ações: R$ {resultado['valor_empresa'] / 1_000_000_000:.2f} por ação")

def valuation_multiplos(ticker, lpa, vpa, dy, setor):
    """
    Valuation por múltiplos comparativos
    """
    # Múltiplos médios por setor (exemplos)
    multiplos_setor = {
        'bancos': {'pl_medio': 8, 'pvp_medio': 1.2},
        'energia': {'pl_medio': 12, 'pvp_medio': 1.5},
        'varejo': {'pl_medio': 15, 'pvp_medio': 2.5},
        'tecnologia': {'pl_medio': 25, 'pvp_medio': 5.0},
        'commodities': {'pl_medio': 6, 'pvp_medio': 1.0}
    }
    
    multiplos = multiplos_setor.get(setor, {'pl_medio': 12, 'pvp_medio': 1.5})
    
    preco_justo_pl = lpa * multiplos['pl_medio']
    preco_justo_pvp = vpa * multiplos['pvp_medio']
    preco_justo_medio = (preco_justo_pl + preco_justo_pvp) / 2
    
    return {
        'ticker': ticker,
        'setor': setor,
        'preco_justo_por_pl': round(preco_justo_pl, 2),
        'preco_justo_por_pvp': round(preco_justo_pvp, 2),
        'preco_justo_medio': round(preco_justo_medio, 2)
    }

# Exemplo
resultado = valuation_multiplos(
    ticker='ITUB4',
    lpa=4.50,    # Lucro por ação
    vpa=32.00,   # Valor patrimonial por ação
    dy=5.0,      # Dividend Yield
    setor='bancos'
)
print(f"Preço justo de {resultado['ticker']}: R$ {resultado['preco_justo_medio']:.2f}")

def valuation_gordon(dividendo_atual, taxa_crescimento, taxa_desconto):
    """
    Modelo de Gordon para valuation por dividendos
    
    P = D1 / (r - g)
    
    Onde:
    - D1 = Dividendo esperado no próximo ano
    - r = Taxa de desconto (retorno exigido)
    - g = Taxa de crescimento dos dividendos
    """
    if taxa_desconto <= taxa_crescimento:
        return {'erro': 'Taxa de desconto deve ser maior que crescimento'}
    
    dividendo_proximo = dividendo_atual * (1 + taxa_crescimento)
    preco_justo = dividendo_proximo / (taxa_desconto - taxa_crescimento)
    
    return {
        'dividendo_atual': dividendo_atual,
        'dividendo_proximo': round(dividendo_proximo, 2),
        'taxa_crescimento': f"{taxa_crescimento * 100}%",
        'taxa_desconto': f"{taxa_desconto * 100}%",
        'preco_justo': round(preco_justo, 2)
    }

# Exemplo: Ação que paga R$ 3 de dividendos
resultado = valuation_gordon(
    dividendo_atual=3.00,
    taxa_crescimento=0.05,   # 5% de crescimento dos dividendos
    taxa_desconto=0.12       # 12% de retorno exigido
)
print(f"Preço justo pelo modelo de Gordon: R$ {resultado['preco_justo']:.2f}")

def demonstrar_erro_preco():
    """
    Por que preço absoluto não importa
    """
    acoes = [
        {'ticker': 'AÇÃO A', 'preco': 5.00, 'pl': 50, 'lucro': 0.10},
        {'ticker': 'AÇÃO B', 'preco': 100.00, 'pl': 10, 'lucro': 10.00}
    ]
    
    print("=== PREÇO NÃO É INDICADOR DE VALOR ===\n")
    for acao in acoes:
        print(f"{acao['ticker']}:")
        print(f"  Preço: R$ {acao['preco']}")
        print(f"  P/L: {acao['pl']}")
        print(f"  Lucro por ação: R$ {acao['lucro']}")
        print(f"  Anos para 'pagar': {acao['pl']}\n")
    
    print("Conclusão: Ação B de R$ 100 é mais BARATA que Ação A de R$ 5!")

demonstrar_erro_preco()

import requests

def criar_screener_acoes(criterios, token):
    """
    Cria um screener básico de ações
    """
    # Buscar lista de ações
    url = "https://brapi.dev/api/quote/list"
    params = {
        'token': token,
        'limit': 100,
        'type': 'stock'
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    # Filtrar por critérios
    aprovadas = []
    
    for acao in data.get('stocks', []):
        ticker = acao.get('stock')
        
        # Buscar detalhes
        url_detalhe = f"https://brapi.dev/api/quote/{ticker}"
        params_detalhe = {
            'token': token,
            'modules': 'defaultKeyStatistics'
        }
        
        detalhe = requests.get(url_detalhe, params=params_detalhe).json()
        
        if 'results' in detalhe and len(detalhe['results']) > 0:
            resultado = detalhe['results'][0]
            
            pl = resultado.get('priceToEarnings', 999)
            pvp = resultado.get('priceToBook', 999)
            dy = resultado.get('dividendYield', 0)
            
            # Aplicar critérios
            if (pl and pl < criterios.get('pl_max', 20) and
                pvp and pvp < criterios.get('pvp_max', 2) and
                dy and dy > criterios.get('dy_min', 3)):
                aprovadas.append({
                    'ticker': ticker,
                    'pl': pl,
                    'pvp': pvp,
                    'dy': dy
                })
    
    return aprovadas

# Exemplo de uso:
# criterios = {'pl_max': 15, 'pvp_max': 1.5, 'dy_min': 4}
# aprovadas = criar_screener_acoes(criterios, 'SEU_TOKEN')

# Indicadores fundamentalistas
https://brapi.dev/api/quote/PETR4?modules=defaultKeyStatistics&token=TOKEN

# Histórico de preços
https://brapi.dev/api/quote/PETR4?interval=1d&range=1y&token=TOKEN

# Lista de ações para screener
https://brapi.dev/api/quote/list?token=TOKEN