Como Ler um Balanço Patrimonial: Guia Completo para Investidores 2026

┌─────────────────────────────────────────────────────────────────┐
│                    EQUAÇÃO FUNDAMENTAL                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│              ATIVOS = PASSIVOS + PATRIMÔNIO LÍQUIDO            │
│                                                                 │
│   ┌─────────────┐   ┌─────────────┐   ┌─────────────────────┐  │
│   │   O que a   │ = │  O que a    │ + │  O que pertence     │  │
│   │   empresa   │   │  empresa    │   │  aos acionistas     │  │
│   │   possui    │   │  deve       │   │                     │  │
│   └─────────────┘   └─────────────┘   └─────────────────────┘  │
│                                                                 │
│   Exemplo: Casa de R$ 500 mil                                  │
│   Ativo: R$ 500.000 (casa)                                     │
│   Passivo: R$ 300.000 (financiamento)                          │
│   PL: R$ 200.000 (sua parte)                                   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                     BALANÇO PATRIMONIAL                         │
├────────────────────────────┬────────────────────────────────────┤
│          ATIVOS            │     PASSIVOS + PATRIMÔNIO         │
├────────────────────────────┼────────────────────────────────────┤
│                            │                                    │
│  ATIVO CIRCULANTE          │  PASSIVO CIRCULANTE               │
│  ├── Caixa e Equivalentes  │  ├── Fornecedores                 │
│  ├── Aplicações Financ.    │  ├── Empréstimos CP               │
│  ├── Contas a Receber      │  ├── Salários a Pagar             │
│  ├── Estoques              │  ├── Impostos a Pagar             │
│  └── Outros                │  └── Outros                       │
│                            │                                    │
│  ATIVO NÃO CIRCULANTE      │  PASSIVO NÃO CIRCULANTE           │
│  ├── Realizável LP         │  ├── Empréstimos LP               │
│  ├── Investimentos         │  ├── Debêntures                   │
│  ├── Imobilizado           │  ├── Provisões                    │
│  ├── Intangível            │  └── Outros                       │
│  └── Diferido              │                                    │
│                            │  PATRIMÔNIO LÍQUIDO               │
│                            │  ├── Capital Social               │
│                            │  ├── Reservas de Capital          │
│                            │  ├── Reservas de Lucros           │
│                            │  ├── Ações em Tesouraria          │
│                            │  └── Lucros Acumulados            │
│                            │                                    │
├────────────────────────────┼────────────────────────────────────┤
│      TOTAL ATIVOS          │   TOTAL PASSIVOS + PL             │
│      (sempre iguais)       │   (sempre iguais)                 │
└────────────────────────────┴────────────────────────────────────┘

def analisar_ativo_circulante(dados_balanco):
    """
    Analisa a composição e qualidade do ativo circulante
    """
    caixa = dados_balanco.get("caixa_equivalentes", 0)
    aplicacoes = dados_balanco.get("aplicacoes_financeiras", 0)
    contas_receber = dados_balanco.get("contas_receber", 0)
    estoques = dados_balanco.get("estoques", 0)
    outros = dados_balanco.get("outros_circulantes", 0)
    
    total_circulante = caixa + aplicacoes + contas_receber + estoques + outros
    
    # Qualidade do ativo circulante
    liquidez_imediata = (caixa + aplicacoes) / total_circulante * 100
    
    analise = {
        "total": total_circulante,
        "composicao": {
            "caixa_pct": round(caixa / total_circulante * 100, 1),
            "aplicacoes_pct": round(aplicacoes / total_circulante * 100, 1),
            "receber_pct": round(contas_receber / total_circulante * 100, 1),
            "estoques_pct": round(estoques / total_circulante * 100, 1)
        },
        "liquidez_imediata": round(liquidez_imediata, 1),
        "qualidade": "Alta" if liquidez_imediata > 30 else "Média" if liquidez_imediata > 15 else "Baixa"
    }
    
    return analise

dados = {
    "caixa_equivalentes": 5_000_000,
    "aplicacoes_financeiras": 10_000_000,
    "contas_receber": 15_000_000,
    "estoques": 20_000_000,
    "outros_circulantes": 5_000_000
}

resultado = analisar_ativo_circulante(dados)
print(f"Total Ativo Circulante: R$ {resultado['total']:,.0f}")
print(f"Liquidez Imediata: {resultado['liquidez_imediata']}%")
print(f"Qualidade: {resultado['qualidade']}")

def analisar_ativo_nao_circulante(dados_balanco):
    """
    Analisa ativos de longo prazo e sua produtividade
    """
    realizavel_lp = dados_balanco.get("realizavel_lp", 0)
    investimentos = dados_balanco.get("investimentos", 0)
    imobilizado = dados_balanco.get("imobilizado", 0)
    intangivel = dados_balanco.get("intangivel", 0)
    
    total_nao_circulante = realizavel_lp + investimentos + imobilizado + intangivel
    receita_liquida = dados_balanco.get("receita_liquida", 1)
    
    # Giro do ativo imobilizado (eficiência)
    giro_imobilizado = receita_liquida / imobilizado if imobilizado > 0 else 0
    
    # Intensidade de capital
    intensidade_capital = (imobilizado / receita_liquida) * 100 if receita_liquida > 0 else 0
    
    # Peso do intangível (goodwill, marcas)
    peso_intangivel = (intangivel / total_nao_circulante) * 100 if total_nao_circulante > 0 else 0
    
    return {
        "total": total_nao_circulante,
        "giro_imobilizado": round(giro_imobilizado, 2),
        "intensidade_capital": round(intensidade_capital, 1),
        "peso_intangivel": round(peso_intangivel, 1),
        "tipo_empresa": "Asset Light" if intensidade_capital < 30 else "Asset Heavy"
    }

TIPOS DE EMPRESAS POR ESTRUTURA DE ATIVOS

ASSET LIGHT (Baixo Imobilizado)
├── Tecnologia
├── Serviços
├── Consultorias
└── Características:
    • Baixo CAPEX
    • Alta margem
    • Escalável
    • Exemplos: TOTS3, LWSA3

ASSET HEAVY (Alto Imobilizado)
├── Indústrias
├── Utilities
├── Mineração
└── Características:
    • Alto CAPEX
    • Margens menores
    • Barreiras de entrada
    • Exemplos: VALE3, ELET3

def analisar_passivo_circulante(dados_balanco):
    """
    Analisa obrigações de curto prazo
    """
    fornecedores = dados_balanco.get("fornecedores", 0)
    emprestimos_cp = dados_balanco.get("emprestimos_cp", 0)
    salarios = dados_balanco.get("salarios_pagar", 0)
    impostos = dados_balanco.get("impostos_pagar", 0)
    dividendos = dados_balanco.get("dividendos_pagar", 0)
    outros = dados_balanco.get("outros_passivos_cp", 0)
    
    total_passivo_cp = fornecedores + emprestimos_cp + salarios + impostos + dividendos + outros
    
    # Passivo oneroso (gera juros) vs operacional
    passivo_oneroso = emprestimos_cp
    passivo_operacional = fornecedores + salarios + impostos
    
    pct_oneroso = (passivo_oneroso / total_passivo_cp) * 100 if total_passivo_cp > 0 else 0
    
    return {
        "total": total_passivo_cp,
        "passivo_oneroso": passivo_oneroso,
        "passivo_operacional": passivo_operacional,
        "pct_oneroso": round(pct_oneroso, 1),
        "risco": "Alto" if pct_oneroso > 50 else "Moderado" if pct_oneroso > 25 else "Baixo"
    }

PASSIVO OPERACIONAL (Bom - Faz parte do negócio)
├── Fornecedores → Prazo para pagar compras
├── Salários → Folha do mês
├── Impostos → Tributos do período
└── Característica: Não paga juros!

PASSIVO ONEROSO (Atenção - Paga juros)
├── Empréstimos bancários
├── Debêntures
├── Financiamentos
└── Característica: Custo financeiro!

DICA: Prefira empresas com mais passivo operacional
      que oneroso (financiam-se com operação)

def analisar_estrutura_divida(dados_balanco):
    """
    Analisa o perfil de endividamento da empresa
    """
    divida_cp = dados_balanco.get("emprestimos_cp", 0)
    divida_lp = dados_balanco.get("emprestimos_lp", 0)
    caixa = dados_balanco.get("caixa_equivalentes", 0)
    ebitda = dados_balanco.get("ebitda", 1)
    patrimonio = dados_balanco.get("patrimonio_liquido", 1)
    
    divida_bruta = divida_cp + divida_lp
    divida_liquida = divida_bruta - caixa
    
    # Indicadores de endividamento
    divida_pl = divida_bruta / patrimonio if patrimonio > 0 else 0
    divida_liq_ebitda = divida_liquida / ebitda if ebitda > 0 else 0
    
    # Perfil de vencimento
    pct_curto_prazo = (divida_cp / divida_bruta) * 100 if divida_bruta > 0 else 0
    
    # Avaliação
    if divida_liq_ebitda < 1:
        situacao = "Excelente - Baixo endividamento"
    elif divida_liq_ebitda < 2:
        situacao = "Saudável - Endividamento controlado"
    elif divida_liq_ebitda < 3:
        situacao = "Atenção - Endividamento moderado"
    else:
        situacao = "Alerta - Endividamento elevado"
    
    return {
        "divida_bruta": divida_bruta,
        "divida_liquida": divida_liquida,
        "divida_pl": round(divida_pl, 2),
        "divida_liq_ebitda": round(divida_liq_ebitda, 2),
        "pct_curto_prazo": round(pct_curto_prazo, 1),
        "situacao": situacao
    }

def analisar_patrimonio_liquido(dados_balanco):
    """
    Analisa a composição do patrimônio líquido
    """
    capital_social = dados_balanco.get("capital_social", 0)
    reservas_capital = dados_balanco.get("reservas_capital", 0)
    reservas_lucros = dados_balanco.get("reservas_lucros", 0)
    lucros_acumulados = dados_balanco.get("lucros_acumulados", 0)
    acoes_tesouraria = dados_balanco.get("acoes_tesouraria", 0)
    
    patrimonio_total = capital_social + reservas_capital + reservas_lucros + lucros_acumulados - acoes_tesouraria
    
    # Qualidade do PL
    lucros_retidos = reservas_lucros + lucros_acumulados
    pct_lucros_retidos = (lucros_retidos / patrimonio_total) * 100 if patrimonio_total > 0 else 0
    
    return {
        "patrimonio_total": patrimonio_total,
        "capital_social": capital_social,
        "lucros_retidos": lucros_retidos,
        "pct_lucros_retidos": round(pct_lucros_retidos, 1),
        "qualidade": "Alta" if pct_lucros_retidos > 50 else "Média"
    }

COMPOSIÇÃO DO PATRIMÔNIO LÍQUIDO

┌─────────────────────────────────────────────────────────────────┐
│                     PATRIMÔNIO LÍQUIDO                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  CAPITAL SOCIAL                                                 │
│  └── Dinheiro que os sócios colocaram na empresa               │
│                                                                 │
│  RESERVAS DE CAPITAL                                            │
│  └── Ágio na emissão de ações, doações                         │
│                                                                 │
│  RESERVAS DE LUCROS ⭐ (O que mais interessa!)                  │
│  ├── Reserva Legal (5% do lucro, até 20% do CS)                │
│  ├── Reserva Estatutária                                       │
│  ├── Reserva para Contingências                                │
│  └── Reserva de Lucros a Realizar                              │
│                                                                 │
│  LUCROS/PREJUÍZOS ACUMULADOS                                   │
│  └── Resultado ainda não distribuído                           │
│                                                                 │
│  (-) AÇÕES EM TESOURARIA                                       │
│  └── Ações recompradas pela empresa                            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

DICA: Patrimônio crescendo via lucros retidos é ÓTIMO sinal!
      Significa que a empresa gera valor consistentemente.

def calcular_indicadores_liquidez(dados_balanco):
    """
    Calcula todos os indicadores de liquidez
    """
    # Ativos
    caixa = dados_balanco.get("caixa", 0)
    aplicacoes = dados_balanco.get("aplicacoes", 0)
    receber = dados_balanco.get("contas_receber", 0)
    estoques = dados_balanco.get("estoques", 0)
    ativo_circulante = dados_balanco.get("ativo_circulante", 0)
    realizavel_lp = dados_balanco.get("realizavel_lp", 0)
    
    # Passivos
    passivo_circulante = dados_balanco.get("passivo_circulante", 1)
    passivo_nao_circulante = dados_balanco.get("passivo_nao_circulante", 0)
    
    indicadores = {
        # Liquidez Imediata: Só caixa / PC
        "liquidez_imediata": round(caixa / passivo_circulante, 2),
        
        # Liquidez Seca: (AC - Estoques) / PC
        "liquidez_seca": round((ativo_circulante - estoques) / passivo_circulante, 2),
        
        # Liquidez Corrente: AC / PC
        "liquidez_corrente": round(ativo_circulante / passivo_circulante, 2),
        
        # Liquidez Geral: (AC + RLP) / (PC + PNC)
        "liquidez_geral": round(
            (ativo_circulante + realizavel_lp) / (passivo_circulante + passivo_nao_circulante), 2
        )
    }
    
    # Interpretação
    interpretacao = []
    
    if indicadores["liquidez_corrente"] > 1.5:
        interpretacao.append("✅ Boa capacidade de pagar dívidas de curto prazo")
    elif indicadores["liquidez_corrente"] > 1:
        interpretacao.append("⚠️ Liquidez adequada, mas apertada")
    else:
        interpretacao.append("🚨 Risco de liquidez - AC menor que PC")
    
    indicadores["interpretacao"] = interpretacao
    
    return indicadores

# Exemplo prático
dados = {
    "caixa": 500_000,
    "aplicacoes": 1_000_000,
    "contas_receber": 2_000_000,
    "estoques": 3_000_000,
    "ativo_circulante": 7_000_000,
    "realizavel_lp": 1_000_000,
    "passivo_circulante": 4_000_000,
    "passivo_nao_circulante": 3_000_000
}

liquidez = calcular_indicadores_liquidez(dados)
print("\n=== INDICADORES DE LIQUIDEZ ===")
print(f"Liquidez Imediata: {liquidez['liquidez_imediata']}")
print(f"Liquidez Seca: {liquidez['liquidez_seca']}")
print(f"Liquidez Corrente: {liquidez['liquidez_corrente']}")
print(f"Liquidez Geral: {liquidez['liquidez_geral']}")

RÉGUA DE LIQUIDEZ CORRENTE

0.0   0.5   1.0   1.5   2.0   2.5   3.0+
 │     │     │     │     │     │     │
 ▼     ▼     ▼     ▼     ▼     ▼     ▼
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│🚨🚨 │ 🚨  │ ⚠️  │ ✅  │ ✅✅│ ⚠️  │ ⚠️  │
│Crise│Risco│Alert│ Bom │Excel│Ocio-│Muito│
│     │     │     │     │     │so?  │alto │
└─────┴─────┴─────┴─────┴─────┴─────┴─────┘

< 1.0: Passivo > Ativo - Problema de solvência
1.0-1.5: Apertado mas viável
1.5-2.0: Faixa ideal para maioria
> 2.5: Pode indicar caixa ocioso

def calcular_indicadores_endividamento(dados_balanco):
    """
    Calcula indicadores de estrutura de capital
    """
    passivo_total = dados_balanco.get("passivo_total", 0)
    patrimonio = dados_balanco.get("patrimonio_liquido", 1)
    ativo_total = dados_balanco.get("ativo_total", 1)
    divida_bruta = dados_balanco.get("divida_bruta", 0)
    caixa = dados_balanco.get("caixa", 0)
    ebitda = dados_balanco.get("ebitda", 1)
    despesa_financeira = dados_balanco.get("despesa_financeira", 1)
    
    indicadores = {
        # Endividamento Geral: Passivo / Ativo
        "endividamento_geral": round((passivo_total / ativo_total) * 100, 1),
        
        # Dívida / Patrimônio
        "divida_patrimonio": round(divida_bruta / patrimonio, 2),
        
        # Dívida Líquida / EBITDA
        "divida_liq_ebitda": round((divida_bruta - caixa) / ebitda, 2),
        
        # Cobertura de Juros: EBITDA / Despesa Financeira
        "cobertura_juros": round(ebitda / despesa_financeira, 2) if despesa_financeira > 0 else float('inf'),
        
        # Grau de Alavancagem
        "alavancagem": round(ativo_total / patrimonio, 2)
    }
    
    # Avaliação consolidada
    score = 0
    if indicadores["divida_liq_ebitda"] < 2:
        score += 30
    if indicadores["cobertura_juros"] > 3:
        score += 30
    if indicadores["divida_patrimonio"] < 1:
        score += 20
    if indicadores["endividamento_geral"] < 60:
        score += 20
    
    indicadores["score_saude_financeira"] = score
    indicadores["classificacao"] = (
        "Excelente" if score >= 80 else
        "Boa" if score >= 60 else
        "Regular" if score >= 40 else
        "Fraca"
    )
    
    return indicadores

def analisar_capital_giro(dados_balanco):
    """
    Analisa necessidade de capital de giro
    """
    contas_receber = dados_balanco.get("contas_receber", 0)
    estoques = dados_balanco.get("estoques", 0)
    fornecedores = dados_balanco.get("fornecedores", 0)
    receita_dia = dados_balanco.get("receita_liquida", 0) / 365
    cmv_dia = dados_balanco.get("cmv", 0) / 365
    compras_dia = dados_balanco.get("compras", 0) / 365 if dados_balanco.get("compras") else cmv_dia
    
    # Prazos médios
    pmr = contas_receber / receita_dia if receita_dia > 0 else 0  # Prazo médio recebimento
    pme = estoques / cmv_dia if cmv_dia > 0 else 0  # Prazo médio estoque
    pmp = fornecedores / compras_dia if compras_dia > 0 else 0  # Prazo médio pagamento
    
    # Ciclo operacional e financeiro
    ciclo_operacional = pmr + pme
    ciclo_financeiro = ciclo_operacional - pmp
    
    # Necessidade de Capital de Giro (NCG)
    ncg = contas_receber + estoques - fornecedores
    
    return {
        "pmr_dias": round(pmr, 0),
        "pme_dias": round(pme, 0),
        "pmp_dias": round(pmp, 0),
        "ciclo_operacional": round(ciclo_operacional, 0),
        "ciclo_financeiro": round(ciclo_financeiro, 0),
        "ncg": ncg,
        "eficiencia": "Alta" if ciclo_financeiro < 30 else "Média" if ciclo_financeiro < 60 else "Baixa"
    }

CICLO FINANCEIRO EXPLICADO

     ┌──────────────────────────────────────────────────────────┐
     │                    CICLO OPERACIONAL                      │
     │  ┌─────────────────────┐    ┌─────────────────────────┐  │
     │  │   Prazo Médio de    │    │    Prazo Médio de       │  │
     │  │   Estoque (PME)     │ +  │    Recebimento (PMR)    │  │
     │  │   45 dias           │    │    30 dias              │  │
     │  └─────────────────────┘    └─────────────────────────┘  │
     │                = 75 dias                                  │
     └──────────────────────────────────────────────────────────┘
                              │
                              │  - Prazo Médio Pagamento (PMP)
                              │    40 dias
                              ▼
     ┌──────────────────────────────────────────────────────────┐
     │                    CICLO FINANCEIRO                       │
     │                       35 dias                             │
     │                                                           │
     │  = Quantos dias a empresa precisa FINANCIAR              │
     │    com capital próprio ou dívida                         │
     └──────────────────────────────────────────────────────────┘

QUANTO MENOR O CICLO FINANCEIRO, MELHOR!

Empresas com ciclo negativo (PMP > PMR + PME):
- Recebem antes de pagar
- Financiam-se com fornecedores
- Exemplos: Supermercados, e-commerce

import requests

API_TOKEN = "seu_token_aqui"
BASE_URL = "https://brapi.dev/api"

def obter_balanco_patrimonial(ticker):
    """
    Obtém dados do balanço patrimonial via brapi.dev
    """
    url = f"{BASE_URL}/quote/{ticker}"
    params = {
        "fundamental": "true",
        "modules": "balanceSheetHistory"
    }
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    
    if response.status_code == 200:
        dados = response.json()["results"][0]
        return dados
    return None

def analisar_balanco_completo(ticker):
    """
    Análise completa do balanço patrimonial
    """
    dados = obter_balanco_patrimonial(ticker)
    
    if not dados:
        return None
    
    # Extrair dados do balanço
    balanco = dados.get("balanceSheetHistory", {}).get("balanceSheetStatements", [])
    
    if not balanco:
        return None
    
    ultimo_balanco = balanco[0]  # Mais recente
    
    # Montar análise
    ativo_total = ultimo_balanco.get("totalAssets", 0)
    ativo_circulante = ultimo_balanco.get("totalCurrentAssets", 0)
    passivo_circulante = ultimo_balanco.get("totalCurrentLiabilities", 0)
    passivo_total = ultimo_balanco.get("totalLiab", 0)
    patrimonio = ultimo_balanco.get("totalStockholderEquity", 0)
    caixa = ultimo_balanco.get("cash", 0)
    divida_lp = ultimo_balanco.get("longTermDebt", 0)
    divida_cp = ultimo_balanco.get("shortTermDebt", 0)
    
    # Calcular indicadores
    liquidez_corrente = ativo_circulante / passivo_circulante if passivo_circulante else 0
    endividamento = passivo_total / ativo_total * 100 if ativo_total else 0
    divida_pl = (divida_lp + divida_cp) / patrimonio if patrimonio else 0
    
    return {
        "ticker": ticker,
        "data_balanco": ultimo_balanco.get("endDate", {}).get("fmt", "N/A"),
        "resumo": {
            "ativo_total": ativo_total,
            "passivo_total": passivo_total,
            "patrimonio_liquido": patrimonio,
            "caixa": caixa,
            "divida_total": divida_lp + divida_cp
        },
        "indicadores": {
            "liquidez_corrente": round(liquidez_corrente, 2),
            "endividamento_pct": round(endividamento, 1),
            "divida_pl": round(divida_pl, 2)
        },
        "saude": avaliar_saude_financeira(liquidez_corrente, endividamento, divida_pl)
    }

def avaliar_saude_financeira(liquidez, endividamento, divida_pl):
    """
    Avalia saúde financeira baseado nos indicadores
    """
    pontos = 0
    
    if liquidez > 1.5:
        pontos += 25
    elif liquidez > 1:
        pontos += 15
    
    if endividamento < 50:
        pontos += 25
    elif endividamento < 70:
        pontos += 15
    
    if divida_pl < 0.5:
        pontos += 25
    elif divida_pl < 1:
        pontos += 15
    
    # Bônus se todos positivos
    if liquidez > 1 and endividamento < 60 and divida_pl < 1:
        pontos += 25
    
    if pontos >= 80:
        return "🟢 Excelente saúde financeira"
    elif pontos >= 60:
        return "🟡 Boa saúde financeira"
    elif pontos >= 40:
        return "🟠 Saúde financeira regular"
    else:
        return "🔴 Atenção: Indicadores preocupantes"

# Analisar empresa
resultado = analisar_balanco_completo("WEGE3")

if resultado:
    print(f"\n=== ANÁLISE DO BALANÇO: {resultado['ticker']} ===")
    print(f"Data: {resultado['data_balanco']}")
    print(f"\nResumo:")
    for k, v in resultado['resumo'].items():
        print(f"  {k}: R$ {v:,.0f}")
    print(f"\nIndicadores:")
    for k, v in resultado['indicadores'].items():
        print(f"  {k}: {v}")
    print(f"\nAvaliação: {resultado['saude']}")

def analisar_evolucao_balanco(ticker, periodos=4):
    """
    Analisa evolução do balanço nos últimos períodos
    """
    dados = obter_balanco_patrimonial(ticker)
    
    if not dados:
        return None
    
    balancos = dados.get("balanceSheetHistory", {}).get("balanceSheetStatements", [])[:periodos]
    
    evolucao = []
    
    for b in balancos:
        periodo = {
            "data": b.get("endDate", {}).get("fmt", "N/A"),
            "ativo_total": b.get("totalAssets", 0),
            "patrimonio": b.get("totalStockholderEquity", 0),
            "divida": b.get("longTermDebt", 0) + b.get("shortTermDebt", 0),
            "caixa": b.get("cash", 0)
        }
        
        # Calcular variações se não for o primeiro
        if evolucao:
            anterior = evolucao[-1]
            periodo["var_ativo"] = round((periodo["ativo_total"] / anterior["ativo_total"] - 1) * 100, 1)
            periodo["var_patrimonio"] = round((periodo["patrimonio"] / anterior["patrimonio"] - 1) * 100, 1) if anterior["patrimonio"] else 0
        
        evolucao.append(periodo)
    
    # Inverter para ordem cronológica
    evolucao.reverse()
    
    return {
        "ticker": ticker,
        "periodos_analisados": len(evolucao),
        "evolucao": evolucao,
        "tendencia_patrimonio": "Crescente" if evolucao[-1]["patrimonio"] > evolucao[0]["patrimonio"] else "Decrescente"
    }

# Exemplo
evolucao = analisar_evolucao_balanco("ITUB4", periodos=4)

if evolucao:
    print(f"\n=== EVOLUÇÃO DO BALANÇO: {evolucao['ticker']} ===")
    print(f"Tendência do Patrimônio: {evolucao['tendencia_patrimonio']}")
    print("\nHistórico:")
    for p in evolucao["evolucao"]:
        print(f"  {p['data']}: PL R$ {p['patrimonio']:,.0f}")

def identificar_red_flags(dados_balanco):
    """
    Identifica sinais de alerta no balanço
    """
    red_flags = []
    
    # 1. Patrimônio Líquido negativo
    pl = dados_balanco.get("patrimonio_liquido", 0)
    if pl < 0:
        red_flags.append({
            "severidade": "CRÍTICO",
            "item": "Patrimônio Líquido Negativo",
            "descricao": "Passivos maiores que ativos - insolvência técnica"
        })
    
    # 2. Liquidez corrente < 1
    ac = dados_balanco.get("ativo_circulante", 0)
    pc = dados_balanco.get("passivo_circulante", 1)
    if ac / pc < 1:
        red_flags.append({
            "severidade": "ALTO",
            "item": "Liquidez Corrente < 1",
            "descricao": "Pode ter dificuldade para pagar dívidas de curto prazo"
        })
    
    # 3. Dívida de curto prazo muito alta
    divida_cp = dados_balanco.get("divida_cp", 0)
    divida_total = dados_balanco.get("divida_total", 1)
    if divida_cp / divida_total > 0.5:
        red_flags.append({
            "severidade": "MÉDIO",
            "item": "Concentração de Dívida no CP",
            "descricao": "Mais de 50% da dívida vence em 12 meses"
        })
    
    # 4. Intangível muito alto
    intangivel = dados_balanco.get("intangivel", 0)
    ativo_total = dados_balanco.get("ativo_total", 1)
    if intangivel / ativo_total > 0.5:
        red_flags.append({
            "severidade": "MÉDIO",
            "item": "Intangível Elevado",
            "descricao": "Mais de 50% do ativo é intangível (goodwill, etc.)"
        })
    
    # 5. Estoques crescendo mais que vendas
    var_estoques = dados_balanco.get("variacao_estoques_pct", 0)
    var_vendas = dados_balanco.get("variacao_vendas_pct", 0)
    if var_estoques > var_vendas + 10:
        red_flags.append({
            "severidade": "MÉDIO",
            "item": "Acúmulo de Estoques",
            "descricao": "Estoques crescendo mais que vendas - possível obsolescência"
        })
    
    # 6. Contas a receber crescendo demais
    var_receber = dados_balanco.get("variacao_receber_pct", 0)
    if var_receber > var_vendas + 15:
        red_flags.append({
            "severidade": "MÉDIO",
            "item": "Contas a Receber Elevadas",
            "descricao": "Recebíveis crescendo mais que vendas - risco de inadimplência"
        })
    
    return red_flags

CHECKLIST DE RED FLAGS NO BALANÇO

🚨 CRÍTICOS (Evitar investimento)
□ Patrimônio Líquido negativo
□ Dívida Líquida/EBITDA > 5x
□ Cobertura de juros < 1x
□ Prejuízos acumulados corroendo capital

⚠️ ALTOS (Investigar profundamente)
□ Liquidez corrente < 1
□ Dívida concentrada no curto prazo
□ Goodwill > 50% do ativo
□ Capital de giro negativo

🔶 MÉDIOS (Monitorar)
□ Estoques crescendo mais que vendas
□ Prazo de recebimento aumentando
□ Ações em tesouraria relevantes
□ Provisões crescentes

1. VISÃO GERAL
   └── Conferir se Ativo = Passivo + PL

2. LIQUIDEZ
   └── Empresa consegue pagar dívidas de CP?

3. ENDIVIDAMENTO  
   └── Quanto da empresa é financiado por dívida?

4. QUALIDADE DOS ATIVOS
   └── Ativos são produtivos? Geram retorno?

5. PATRIMÔNIO LÍQUIDO
   └── Está crescendo via lucros?

6. EVOLUÇÃO
   └── Como os indicadores evoluíram no tempo?

7. RED FLAGS
   └── Existe algum sinal de alerta?