Análise do Setor de Saúde Brasil 2026: HAPV3, RDOR3, FLRY3 e Mais

┌─────────────────────────────────────────────────────────────────┐
│                  ECOSSISTEMA DE SAÚDE NA B3                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   OPERADORAS DE         HOSPITAIS E         DIAGNÓSTICOS       │
│   PLANOS DE SAÚDE       CLÍNICAS            E LABS             │
│   ┌─────────────┐       ┌─────────────┐     ┌─────────────┐    │
│   │ HAPV3       │       │ RDOR3       │     │ FLRY3       │    │
│   │ QUAL3       │       │ MATD3       │     │ AALR3       │    │
│   │ GNDI3*      │       │ ONCO3       │     │ PARD3       │    │
│   └─────────────┘       └─────────────┘     └─────────────┘    │
│                                                                 │
│   FARMÁCIAS             ODONTOLOGIA         OUTROS             │
│   ┌─────────────┐       ┌─────────────┐     ┌─────────────┐    │
│   │ RADL3       │       │ ODPV3       │     │ HYPE3       │    │
│   │ PNVL3       │       │             │     │ BLAU3       │    │
│   │ PGMN3       │       │             │     │ VVEO3       │    │
│   └─────────────┘       └─────────────┘     └─────────────┘    │
│                                                                 │
│   * GNDI3 fundiu com HAPV3                                     │
└─────────────────────────────────────────────────────────────────┘

FATORES QUE IMPULSIONAM O SETOR

📈 DEMOGRÁFICOS
├── Envelhecimento populacional
├── Aumento da expectativa de vida
├── Maior incidência de doenças crônicas
└── População 60+ cresce 3x mais que média

💰 ECONÔMICOS
├── Crescimento da renda média
├── Expansão da classe média
├── Maior capacidade de pagar planos
└── Formalização do emprego

🏥 ESTRUTURAIS
├── Subpenetração de planos de saúde
├── SUS sobrecarregado
├── Migração para planos privados
└── Consolidação do setor

📊 NÚMEROS DO SETOR
├── ~50 milhões com plano de saúde
├── ~25% da população coberta
├── Gasto per capita cresce 8% a.a.
└── Mercado de R$ 300+ bilhões

def calcular_sinistralidade(despesas_medicas, receita_operacional):
    """
    Calcula a taxa de sinistralidade (quanto da receita vai para custos médicos)
    Ideal: 70-80%
    """
    sinistralidade = (despesas_medicas / receita_operacional) * 100
    
    if sinistralidade < 70:
        avaliacao = "Excelente - Alta margem operacional"
    elif sinistralidade < 75:
        avaliacao = "Boa - Margem saudável"
    elif sinistralidade < 80:
        avaliacao = "Regular - Margem apertada"
    elif sinistralidade < 85:
        avaliacao = "Ruim - Margens pressionadas"
    else:
        avaliacao = "Crítico - Prejuízo operacional provável"
    
    return {
        "sinistralidade": round(sinistralidade, 2),
        "avaliacao": avaliacao,
        "margem_bruta": round(100 - sinistralidade, 2)
    }

resultado = calcular_sinistralidade(
    despesas_medicas=7_500_000_000,
    receita_operacional=10_000_000_000
)
print(f"Sinistralidade: {resultado['sinistralidade']}%")
print(f"Avaliação: {resultado['avaliacao']}")

BENCHMARK DE SINISTRALIDADE

< 70%   ████████████████████████████████  Excelente
70-75%  ██████████████████████████        Bom
75-80%  ████████████████████              Regular
80-85%  ██████████████                    Ruim
> 85%   ████████                          Crítico

HAPV3 (Hapvida+GNDI): ~73-78%
Médias de mercado: ~75-82%

def analisar_hospital(dados):
    """
    Analisa indicadores operacionais de hospital
    """
    leitos = dados.get("total_leitos", 0)
    leitos_ocupados = dados.get("leitos_ocupados_media", 0)
    receita = dados.get("receita_liquida", 0)
    
    # Taxa de ocupação (ideal: 75-85%)
    ocupacao = (leitos_ocupados / leitos) * 100 if leitos else 0
    
    # Receita por leito (produtividade)
    receita_leito = receita / leitos if leitos else 0
    
    # Ticket médio por internação
    internacoes = dados.get("total_internacoes", 1)
    ticket_medio = receita / internacoes if internacoes else 0
    
    return {
        "taxa_ocupacao": round(ocupacao, 1),
        "receita_por_leito": round(receita_leito, 0),
        "ticket_medio": round(ticket_medio, 0),
        "eficiencia": "Alta" if ocupacao > 80 else "Média" if ocupacao > 70 else "Baixa"
    }

def analisar_laboratorio(dados):
    """
    Analisa indicadores de laboratório/diagnóstico
    """
    receita = dados.get("receita_liquida", 0)
    unidades = dados.get("total_unidades", 1)
    exames = dados.get("total_exames", 1)
    
    # Receita por unidade
    receita_unidade = receita / unidades
    
    # Ticket médio por exame
    ticket_exame = receita / exames
    
    # Exames por unidade (produtividade)
    exames_unidade = exames / unidades
    
    return {
        "receita_por_unidade": round(receita_unidade / 1_000_000, 2),  # Em milhões
        "ticket_medio_exame": round(ticket_exame, 2),
        "exames_por_unidade": round(exames_unidade, 0),
        "escala": "Alta" if exames_unidade > 50000 else "Média"
    }

import requests

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

def comparar_sinistralidade_operadoras():
    """
    Compara sinistralidade entre operadoras de saúde
    """
    # Dados aproximados (em caso real, viriam de demonstrativos)
    operadoras = {
        "HAPV3": {"sinistralidade": 73.5, "beneficiarios_milhoes": 15.2},
        "QUAL3": {"sinistralidade": 82.0, "beneficiarios_milhoes": 4.1},
        # Adicionar outras conforme dados disponíveis
    }
    
    print("\n=== COMPARATIVO DE SINISTRALIDADE ===\n")
    
    for ticker, dados in sorted(operadoras.items(), key=lambda x: x[1]["sinistralidade"]):
        sinistro = dados["sinistralidade"]
        benef = dados["beneficiarios_milhoes"]
        barra = "█" * int(sinistro / 5)
        print(f"{ticker}: {barra} {sinistro}% | {benef}M beneficiários")
    
    return operadoras

def analisar_crescimento_organico(dados_empresa):
    """
    Analisa crescimento orgânico vs inorgânico
    """
    receita_atual = dados_empresa.get("receita_atual", 0)
    receita_anterior = dados_empresa.get("receita_anterior", 1)
    receita_aquisicoes = dados_empresa.get("receita_aquisicoes", 0)
    
    # Crescimento total
    crescimento_total = ((receita_atual / receita_anterior) - 1) * 100
    
    # Crescimento orgânico (sem aquisições)
    receita_organica = receita_atual - receita_aquisicoes
    crescimento_organico = ((receita_organica / receita_anterior) - 1) * 100
    
    # Contribuição das aquisições
    contribuicao_ma = crescimento_total - crescimento_organico
    
    return {
        "crescimento_total": round(crescimento_total, 1),
        "crescimento_organico": round(crescimento_organico, 1),
        "contribuicao_aquisicoes": round(contribuicao_ma, 1),
        "qualidade": "Alta" if crescimento_organico > 10 else "Média"
    }

def obter_dados_setor_saude():
    """
    Obtém dados fundamentalistas do setor de saúde
    """
    tickers = ["HAPV3", "RDOR3", "FLRY3", "RADL3", "PNVL3", "ODPV3", "QUAL3"]
    
    url = f"{BASE_URL}/quote/{','.join(tickers)}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    
    if response.status_code == 200:
        return response.json()["results"]
    return None

def criar_ranking_saude(dados):
    """
    Cria ranking de empresas de saúde por múltiplos critérios
    """
    ranking = []
    
    for empresa in dados:
        if not empresa:
            continue
            
        info = {
            "ticker": empresa.get("symbol"),
            "nome": empresa.get("shortName", "")[:25],
            "preco": empresa.get("regularMarketPrice", 0),
            "pl": empresa.get("priceEarnings", 0),
            "pvp": empresa.get("priceToBook", 0),
            "roe": empresa.get("returnOnEquity", 0),
            "margem": empresa.get("netMargin", 0),
            "dy": empresa.get("dividendYield", 0)
        }
        
        # Score composto
        score = 0
        roe = info["roe"] or 0
        pl = info["pl"] or 0
        margem = info["margem"] or 0
        
        if roe > 15: score += 25
        elif roe > 10: score += 15
        
        if 0 < pl < 15: score += 25
        elif 15 <= pl < 25: score += 15
        
        if margem > 10: score += 25
        elif margem > 5: score += 15
        
        info["score"] = score
        ranking.append(info)
    
    return sorted(ranking, key=lambda x: x["score"], reverse=True)

dados = obter_dados_setor_saude()
if dados:
    ranking = criar_ranking_saude(dados)
    
    print("\n=== RANKING SETOR SAÚDE ===\n")
    for i, emp in enumerate(ranking, 1):
        print(f"{i}. {emp['ticker']}: Score {emp['score']} | P/L {emp['pl']} | ROE {emp['roe']}%")

RISCOS REGULATÓRIOS NO SETOR DE SAÚDE

ANS (Agência Nacional de Saúde Suplementar)
├── Controle de reajustes de planos individuais
├── Fiscalização de sinistralidade
├── Rol de procedimentos obrigatórios
└── Penalidades e multas

ANVISA
├── Regulação de medicamentos
├── Registro de produtos
└── Fiscalização sanitária

CADE
├── Aprovação de fusões/aquisições
├── Análise de concentração de mercado
└── Remédios para aprovação de deals

def simular_impacto_sinistralidade(receita, sinistralidade_atual, variacao_pp):
    """
    Simula impacto de variação na sinistralidade
    """
    custo_atual = receita * (sinistralidade_atual / 100)
    lucro_bruto_atual = receita - custo_atual
    
    nova_sinistralidade = sinistralidade_atual + variacao_pp
    novo_custo = receita * (nova_sinistralidade / 100)
    novo_lucro_bruto = receita - novo_custo
    
    impacto_absoluto = novo_lucro_bruto - lucro_bruto_atual
    impacto_percentual = (impacto_absoluto / lucro_bruto_atual) * 100
    
    return {
        "sinistralidade_atual": sinistralidade_atual,
        "nova_sinistralidade": nova_sinistralidade,
        "variacao_pp": variacao_pp,
        "impacto_lucro_bruto": round(impacto_absoluto / 1_000_000, 1),
        "impacto_percentual": round(impacto_percentual, 1)
    }

# Exemplo: Impacto de +2pp na sinistralidade
impacto = simular_impacto_sinistralidade(
    receita=10_000_000_000,
    sinistralidade_atual=75,
    variacao_pp=2
)

print(f"Variação de {impacto['variacao_pp']}pp na sinistralidade:")
print(f"Impacto no Lucro Bruto: R$ {impacto['impacto_lucro_bruto']}M ({impacto['impacto_percentual']}%)")

def selecionar_lideres_saude(dados_empresas):
    """
    Seleciona líderes de cada subsegmento
    """
    subsegmentos = {
        "operadoras": ["HAPV3", "QUAL3"],
        "hospitais": ["RDOR3", "MATD3"],
        "diagnosticos": ["FLRY3", "AALR3"],
        "farmacias": ["RADL3", "PNVL3"],
        "odonto": ["ODPV3"]
    }
    
    lideres = {}
    
    for segmento, tickers in subsegmentos.items():
        melhores = []
        for empresa in dados_empresas:
            if empresa.get("symbol") in tickers:
                melhores.append({
                    "ticker": empresa.get("symbol"),
                    "market_cap": empresa.get("marketCap", 0),
                    "roe": empresa.get("returnOnEquity", 0)
                })
        
        if melhores:
            # Ordenar por market cap (líder)
            lideres[segmento] = sorted(melhores, key=lambda x: x["market_cap"], reverse=True)[0]
    
    return lideres

# Exemplo de uso
# lideres = selecionar_lideres_saude(dados)

def encontrar_value_saude(dados_empresas):
    """
    Busca empresas de saúde com valuation atrativo
    """
    candidatas = []
    
    for empresa in dados_empresas:
        pl = empresa.get("priceEarnings", 0) or 0
        pvp = empresa.get("priceToBook", 0) or 0
        roe = empresa.get("returnOnEquity", 0) or 0
        dy = empresa.get("dividendYield", 0) or 0
        
        # Critérios value em setor defensivo
        if (0 < pl < 18 and 
            0 < pvp < 3 and 
            roe > 10):
            
            candidatas.append({
                "ticker": empresa.get("symbol"),
                "pl": pl,
                "pvp": pvp,
                "roe": roe,
                "dy": dy,
                "upside_potencial": round((18 / pl - 1) * 100, 1) if pl > 0 else 0
            })
    
    return sorted(candidatas, key=lambda x: x["pl"])

EV/EBITDA MÉDIO POR SUBSEGMENTO

Operadoras       ██████████████        8-12x
Hospitais        ████████████████████  12-18x
Diagnósticos     ████████████████      10-14x
Farmácias        ████████████          8-12x

def comparar_multiplos_internacionais():
    """
    Compara múltiplos de saúde Brasil vs mundo
    """
    multiplos = {
        "Brasil - Hospitais": 14,
        "EUA - HCA (hospitais)": 10,
        "EUA - UNH (operadora)": 16,
        "Brasil - Operadoras": 10,
        "Brasil - Labs": 12,
        "EUA - Quest (labs)": 11
    }
    
    print("\n=== P/L MÉDIO: BRASIL VS EUA ===\n")
    for nome, pl in sorted(multiplos.items(), key=lambda x: x[1]):
        barra = "█" * int(pl)
        print(f"{nome:25} {barra} {pl}x")

comparar_multiplos_internacionais()

def gerar_dashboard_saude():
    """
    Gera dashboard completo do setor de saúde
    """
    tickers = ["HAPV3", "RDOR3", "FLRY3", "RADL3", "PNVL3", "ODPV3", "QUAL3"]
    
    url = f"{BASE_URL}/quote/{','.join(tickers)}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    
    if response.status_code != 200:
        return None
    
    dados = response.json()["results"]
    
    # Métricas consolidadas
    dashboard = {
        "data": datetime.now().strftime("%Y-%m-%d %H:%M"),
        "empresas_analisadas": len(dados),
        "variacao_media_dia": round(
            sum(d.get("regularMarketChangePercent", 0) or 0 for d in dados) / len(dados), 2
        ),
        "maior_alta": max(dados, key=lambda x: x.get("regularMarketChangePercent", 0) or 0),
        "maior_queda": min(dados, key=lambda x: x.get("regularMarketChangePercent", 0) or 0),
        "melhor_roe": max(dados, key=lambda x: x.get("returnOnEquity", 0) or 0),
        "menor_pl": min([d for d in dados if (d.get("priceEarnings") or 0) > 0], 
                        key=lambda x: x.get("priceEarnings", float('inf')))
    }
    
    return dashboard

# Gerar dashboard
# dashboard = gerar_dashboard_saude()