Como Montar uma Carteira de Ações 2026: Guia Completo de Diversificação

"Não coloque todos os ovos na mesma cesta."
- Sabedoria popular de investimentos

"Diversificação é a única estratégia grátis em investimentos."
- Harry Markowitz, Nobel de Economia

┌─────────────────────────────────────────────────────────────┐
│              DIMENSÕES DA DIVERSIFICAÇÃO                     │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. POR CLASSE DE ATIVO                                      │
│     ├── Ações                                                │
│     ├── Fundos Imobiliários (FIIs)                          │
│     ├── Renda Fixa                                           │
│     └── Internacional                                        │
│                                                              │
│  2. POR SETOR                                                │
│     ├── Financeiro, Energia, Consumo                        │
│     ├── Tecnologia, Saúde, Commodities                      │
│     └── Utilities, Construção, Varejo                       │
│                                                              │
│  3. POR CAPITALIZAÇÃO                                        │
│     ├── Large Caps (Blue Chips)                             │
│     ├── Mid Caps                                             │
│     └── Small Caps                                           │
│                                                              │
│  4. POR GEOGRAFIA                                            │
│     ├── Brasil                                               │
│     ├── EUA (via BDRs ou ETFs)                              │
│     └── Global                                               │
│                                                              │
│  5. POR ESTRATÉGIA                                           │
│     ├── Crescimento (Growth)                                │
│     ├── Valor (Value)                                        │
│     └── Dividendos (Income)                                  │
│                                                              │
└─────────────────────────────────────────────────────────────┘

import requests
import pandas as pd
from typing import Dict, List

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

def get_stock_data(ticker: str) -> dict:
    """Busca dados de uma ação na brapi.dev"""
    url = f"{BASE_URL}/quote/{ticker}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    response.raise_for_status()
    return response.json()["results"][0]

def define_asset_allocation(profile: str, capital: float) -> Dict[str, float]:
    """
    Define alocação de ativos baseada no perfil
    """
    allocations = {
        "conservador": {
            "renda_fixa": 0.65,
            "acoes_brasil": 0.18,
            "fiis": 0.12,
            "internacional": 0.05
        },
        "moderado": {
            "renda_fixa": 0.35,
            "acoes_brasil": 0.35,
            "fiis": 0.17,
            "internacional": 0.13
        },
        "arrojado": {
            "renda_fixa": 0.15,
            "acoes_brasil": 0.45,
            "fiis": 0.18,
            "internacional": 0.22
        }
    }
    
    allocation = allocations.get(profile, allocations["moderado"])
    
    return {
        classe: capital * percentual 
        for classe, percentual in allocation.items()
    }

# Exemplo
capital = 100000
perfil = "moderado"

alocacao = define_asset_allocation(perfil, capital)

print(f"ALOCAÇÃO DE ATIVOS - Perfil {perfil.upper()}")
print(f"Capital Total: R$ {capital:,.0f}")
print("=" * 40)

for classe, valor in alocacao.items():
    percentual = (valor / capital) * 100
    print(f"  {classe.replace('_', ' ').title()}: R$ {valor:,.0f} ({percentual:.0f}%)")

def allocate_by_sector(capital_acoes: float) -> Dict[str, Dict]:
    """
    Aloca capital em ações por setor
    """
    # Alocação sugerida por setor
    sector_allocation = {
        "Financeiro": {
            "peso": 0.20,
            "acoes": ["ITUB4", "BBAS3", "BBDC4"]
        },
        "Energia": {
            "peso": 0.18,
            "acoes": ["TAEE11", "EGIE3", "CMIG4"]
        },
        "Commodities": {
            "peso": 0.15,
            "acoes": ["VALE3", "PETR4"]
        },
        "Consumo": {
            "peso": 0.12,
            "acoes": ["ABEV3", "LREN3"]
        },
        "Saúde": {
            "peso": 0.12,
            "acoes": ["RADL3", "FLRY3"]
        },
        "Tecnologia/Indústria": {
            "peso": 0.13,
            "acoes": ["WEGE3", "TOTS3"]
        },
        "Construção/Varejo": {
            "peso": 0.10,
            "acoes": ["CYRE3", "RENT3"]
        }
    }
    
    result = {}
    for setor, config in sector_allocation.items():
        valor_setor = capital_acoes * config["peso"]
        valor_por_acao = valor_setor / len(config["acoes"])
        
        result[setor] = {
            "valor_total": valor_setor,
            "acoes": {acao: valor_por_acao for acao in config["acoes"]}
        }
    
    return result

# Exemplo: R$ 35.000 para ações
capital_acoes = 35000

alocacao_setores = allocate_by_sector(capital_acoes)

print("\nALOCAÇÃO POR SETOR")
print("=" * 50)

for setor, dados in alocacao_setores.items():
    print(f"\n{setor}: R$ {dados['valor_total']:,.0f}")
    for acao, valor in dados['acoes'].items():
        print(f"  └── {acao}: R$ {valor:,.0f}")

┌─────────────────────────────────────────────────────────────┐
│               CRITÉRIOS DE SELEÇÃO DE AÇÕES                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  QUALIDADE                                                   │
│  ☐ ROE consistente > 15%                                    │
│  ☐ Margens estáveis ou crescentes                           │
│  ☐ Dívida controlada (Dív/PL < 1.5)                        │
│  ☐ Histórico de lucros positivos                            │
│                                                              │
│  VALUATION                                                   │
│  ☐ P/L razoável para o setor                                │
│  ☐ P/VP aceitável                                           │
│  ☐ EV/EBITDA não esticado                                   │
│                                                              │
│  DIVIDENDOS (para estratégia de renda)                      │
│  ☐ Dividend Yield atrativo                                  │
│  ☐ Histórico de pagamentos consistente                      │
│  ☐ Payout sustentável                                       │
│                                                              │
│  GOVERNANÇA                                                  │
│  ☐ Listagem Novo Mercado preferível                         │
│  ☐ Controlador alinhado                                     │
│  ☐ Transparência nas comunicações                           │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def quality_screener(tickers: List[str]) -> pd.DataFrame:
    """
    Filtra ações por critérios de qualidade
    """
    results = []
    
    for ticker in tickers:
        try:
            data = get_stock_data(ticker)
            
            roe = (data.get("returnOnEquity", 0) or 0) * 100
            pl = data.get("priceToEarnings", 0) or 0
            pvp = data.get("priceToBook", 0) or 0
            dy = data.get("dividendYield", 0) or 0
            debt_equity = data.get("debtToEquity", 0) or 0
            margem = (data.get("profitMargin", 0) or 0) * 100
            
            # Score de qualidade
            score = 0
            
            # ROE
            if roe > 20: score += 25
            elif roe > 15: score += 20
            elif roe > 10: score += 10
            
            # P/L
            if 5 < pl < 12: score += 20
            elif pl < 18 and pl > 0: score += 10
            
            # Margem
            if margem > 15: score += 20
            elif margem > 10: score += 15
            elif margem > 5: score += 10
            
            # Dívida
            if debt_equity < 0.5: score += 20
            elif debt_equity < 1: score += 15
            elif debt_equity < 1.5: score += 10
            
            # Dividendos
            if dy > 5: score += 15
            elif dy > 3: score += 10
            
            results.append({
                "ticker": ticker,
                "setor": data.get("sector", "N/A"),
                "roe": roe,
                "pl": pl,
                "dy": dy,
                "margem": margem,
                "divida_pl": debt_equity,
                "score": score
            })
            
        except Exception as e:
            continue
    
    df = pd.DataFrame(results)
    
    if not df.empty:
        df = df.sort_values("score", ascending=False)
    
    return df

# Lista ampla de ações para análise
todas_acoes = [
    "WEGE3", "ITUB4", "BBDC4", "PETR4", "VALE3", "RENT3",
    "RADL3", "EQTL3", "SUZB3", "JBSS3", "PRIO3", "CSAN3",
    "VIVT3", "CMIG4", "TAEE11", "TRPL4", "BBAS3", "BPAC11",
    "EGIE3", "ABEV3", "LREN3", "FLRY3", "TOTS3", "CYRE3"
]

print("\nSCREENER DE QUALIDADE")
print("=" * 70)

df_quality = quality_screener(todas_acoes)

if not df_quality.empty:
    print("\nTop 15 Ações por Score de Qualidade:")
    print(df_quality.head(15).to_string(index=False))

def size_positions_equal_weight(
    tickers: List[str],
    capital: float
) -> Dict[str, float]:
    """
    Dimensiona posições com peso igual
    """
    peso_por_acao = capital / len(tickers)
    
    return {ticker: peso_por_acao for ticker in tickers}

def size_positions_by_quality(
    df_quality: pd.DataFrame,
    capital: float,
    top_n: int = 15
) -> Dict[str, float]:
    """
    Dimensiona posições proporcional ao score de qualidade
    """
    top_stocks = df_quality.head(top_n)
    total_score = top_stocks["score"].sum()
    
    positions = {}
    for _, row in top_stocks.iterrows():
        peso = row["score"] / total_score
        positions[row["ticker"]] = capital * peso
    
    return positions

def size_positions_risk_parity(
    tickers: List[str],
    capital: float
) -> Dict[str, float]:
    """
    Dimensiona posições por paridade de risco (simplificado)
    Ações mais voláteis recebem menor peso
    """
    volatilities = {}
    
    for ticker in tickers:
        try:
            # Busca dados históricos
            url = f"{BASE_URL}/quote/{ticker}"
            params = {"range": "6mo", "interval": "1d"}
            headers = {"Authorization": f"Bearer {API_TOKEN}"}
            
            response = requests.get(url, params=params, headers=headers)
            data = response.json()["results"][0]
            
            historical = data.get("historicalDataPrice", [])
            
            if len(historical) > 20:
                # Calcula volatilidade (desvio padrão dos retornos)
                prices = [h["close"] for h in historical]
                returns = [(prices[i] / prices[i-1] - 1) for i in range(1, len(prices))]
                volatility = (sum(r**2 for r in returns) / len(returns)) ** 0.5 * (252 ** 0.5)  # Anualizada
                volatilities[ticker] = volatility
        except:
            volatilities[ticker] = 0.30  # Default 30%
    
    # Peso inverso à volatilidade
    inv_vol = {t: 1/v if v > 0 else 1 for t, v in volatilities.items()}
    total_inv_vol = sum(inv_vol.values())
    
    return {
        ticker: capital * (inv_vol[ticker] / total_inv_vol)
        for ticker in tickers
    }

# Exemplo: Dimensionamento por qualidade
print("\nDIMENSIONAMENTO POR SCORE DE QUALIDADE")
print("=" * 50)

capital_acoes = 50000
posicoes = size_positions_by_quality(df_quality, capital_acoes, top_n=12)

total = 0
for ticker, valor in sorted(posicoes.items(), key=lambda x: -x[1]):
    peso = (valor / capital_acoes) * 100
    total += valor
    print(f"  {ticker}: R$ {valor:,.0f} ({peso:.1f}%)")

print(f"\n  Total: R$ {total:,.0f}")

def build_complete_portfolio(capital: float, profile: str = "moderado") -> Dict:
    """
    Constrói carteira completa diversificada
    """
    # 1. Alocação por classe
    alocacao = define_asset_allocation(profile, capital)
    
    portfolio = {
        "perfil": profile,
        "capital_total": capital,
        "alocacao_classes": alocacao,
        "detalhamento": {}
    }
    
    # 2. Detalhamento da Renda Fixa
    rf = alocacao.get("renda_fixa", 0)
    portfolio["detalhamento"]["renda_fixa"] = {
        "Tesouro Selic": rf * 0.40,
        "Tesouro IPCA+ 2035": rf * 0.35,
        "CDB 120% CDI": rf * 0.25
    }
    
    # 3. Detalhamento das Ações Brasil
    acoes = alocacao.get("acoes_brasil", 0)
    portfolio["detalhamento"]["acoes_brasil"] = {
        # Financeiro (20%)
        "ITUB4": acoes * 0.08,
        "BBAS3": acoes * 0.07,
        "BBDC4": acoes * 0.05,
        # Energia (18%)
        "TAEE11": acoes * 0.08,
        "EGIE3": acoes * 0.05,
        "CMIG4": acoes * 0.05,
        # Commodities (15%)
        "VALE3": acoes * 0.08,
        "PETR4": acoes * 0.07,
        # Consumo (12%)
        "ABEV3": acoes * 0.06,
        "LREN3": acoes * 0.06,
        # Saúde (12%)
        "RADL3": acoes * 0.07,
        "FLRY3": acoes * 0.05,
        # Tecnologia/Indústria (13%)
        "WEGE3": acoes * 0.08,
        "TOTS3": acoes * 0.05,
        # Outros (10%)
        "RENT3": acoes * 0.05,
        "CYRE3": acoes * 0.05
    }
    
    # 4. Detalhamento dos FIIs
    fiis = alocacao.get("fiis", 0)
    portfolio["detalhamento"]["fiis"] = {
        "HGLG11": fiis * 0.18,  # Logístico
        "XPLG11": fiis * 0.15,  # Logístico
        "KNCR11": fiis * 0.18,  # Papel
        "MXRF11": fiis * 0.17,  # Híbrido
        "VISC11": fiis * 0.16,  # Shopping
        "BCFF11": fiis * 0.16   # FOF
    }
    
    # 5. Detalhamento Internacional (via BDRs)
    intl = alocacao.get("internacional", 0)
    portfolio["detalhamento"]["internacional"] = {
        "AAPL34": intl * 0.15,  # Apple
        "MSFT34": intl * 0.15,  # Microsoft
        "AMZO34": intl * 0.12,  # Amazon
        "GOGL34": intl * 0.12,  # Google
        "IVVB11": intl * 0.46   # ETF S&P 500
    }
    
    return portfolio

def print_portfolio(portfolio: Dict) -> None:
    """
    Imprime carteira formatada
    """
    print(f"\n{'='*70}")
    print(f"CARTEIRA COMPLETA - Perfil {portfolio['perfil'].upper()}")
    print(f"Capital Total: R$ {portfolio['capital_total']:,.0f}")
    print("="*70)
    
    for classe, valor in portfolio["alocacao_classes"].items():
        percentual = (valor / portfolio["capital_total"]) * 100
        print(f"\n📁 {classe.replace('_', ' ').upper()} - R$ {valor:,.0f} ({percentual:.0f}%)")
        print("-" * 50)
        
        if classe in portfolio["detalhamento"]:
            for ativo, valor_ativo in portfolio["detalhamento"][classe].items():
                peso = (valor_ativo / portfolio["capital_total"]) * 100
                print(f"  └── {ativo}: R$ {valor_ativo:,.0f} ({peso:.1f}%)")

# Montar e exibir carteira
carteira = build_complete_portfolio(100000, "moderado")
print_portfolio(carteira)

def check_rebalancing_need(
    portfolio_atual: Dict[str, float],
    alocacao_alvo: Dict[str, float],
    threshold: float = 0.05
) -> Dict:
    """
    Verifica necessidade de rebalanceamento
    """
    total_atual = sum(portfolio_atual.values())
    
    rebalancing = {
        "necessario": False,
        "desvios": {},
        "acoes": {}
    }
    
    for classe, valor_atual in portfolio_atual.items():
        peso_atual = valor_atual / total_atual
        peso_alvo = alocacao_alvo.get(classe, 0)
        
        desvio = peso_atual - peso_alvo
        desvio_absoluto = abs(desvio)
        
        rebalancing["desvios"][classe] = {
            "peso_atual": peso_atual * 100,
            "peso_alvo": peso_alvo * 100,
            "desvio": desvio * 100
        }
        
        if desvio_absoluto > threshold:
            rebalancing["necessario"] = True
            
            valor_alvo = total_atual * peso_alvo
            ajuste = valor_alvo - valor_atual
            
            rebalancing["acoes"][classe] = {
                "acao": "COMPRAR" if ajuste > 0 else "VENDER",
                "valor": abs(ajuste)
            }
    
    return rebalancing

# Exemplo: Verificar rebalanceamento
portfolio_atual = {
    "renda_fixa": 32000,    # Era 35%
    "acoes_brasil": 40000,  # Era 35%
    "fiis": 18000,          # Era 17%
    "internacional": 15000  # Era 13%
}

alocacao_alvo = {
    "renda_fixa": 0.35,
    "acoes_brasil": 0.35,
    "fiis": 0.17,
    "internacional": 0.13
}

resultado = check_rebalancing_need(portfolio_atual, alocacao_alvo)

print("\nANÁLISE DE REBALANCEAMENTO")
print("=" * 50)

print(f"\nRebalanceamento necessário: {'SIM' if resultado['necessario'] else 'NÃO'}")

print("\nDesvios por classe:")
for classe, dados in resultado["desvios"].items():
    status = "⚠️" if abs(dados["desvio"]) > 5 else "✅"
    print(f"  {status} {classe}: {dados['peso_atual']:.1f}% (alvo: {dados['peso_alvo']:.1f}%, desvio: {dados['desvio']:+.1f}%)")

if resultado["acoes"]:
    print("\nAções de rebalanceamento:")
    for classe, acao in resultado["acoes"].items():
        print(f"  {classe}: {acao['acao']} R$ {acao['valor']:,.0f}")

def portfolio_dashboard(portfolio: Dict[str, float]) -> None:
    """
    Gera dashboard de monitoramento da carteira
    """
    print("\n" + "=" * 70)
    print("📊 DASHBOARD DA CARTEIRA")
    print("=" * 70)
    
    total = sum(portfolio.values())
    
    # Busca dados atualizados
    dados_atuais = {}
    for ticker, quantidade in portfolio.items():
        try:
            data = get_stock_data(ticker)
            preco = data.get("regularMarketPrice", 0)
            variacao = data.get("regularMarketChangePercent", 0)
            dy = data.get("dividendYield", 0)
            
            dados_atuais[ticker] = {
                "preco": preco,
                "variacao": variacao,
                "dy": dy,
                "valor_atual": quantidade * preco if isinstance(quantidade, int) else quantidade
            }
        except:
            continue
    
    # Resumo
    valor_total = sum(d["valor_atual"] for d in dados_atuais.values())
    variacao_total = sum(d["variacao"] * d["valor_atual"] for d in dados_atuais.values()) / valor_total if valor_total > 0 else 0
    
    print(f"\n💰 Valor Total: R$ {valor_total:,.0f}")
    print(f"📈 Variação do Dia: {variacao_total:+.2f}%")
    
    # Maiores altas
    ordenado = sorted(dados_atuais.items(), key=lambda x: x[1]["variacao"], reverse=True)
    
    print("\n🟢 Maiores Altas:")
    for ticker, dados in ordenado[:3]:
        print(f"  {ticker}: {dados['variacao']:+.2f}%")
    
    print("\n🔴 Maiores Baixas:")
    for ticker, dados in ordenado[-3:]:
        print(f"  {ticker}: {dados['variacao']:+.2f}%")
    
    # Dividendos esperados
    dividendos_anuais = sum(
        d["valor_atual"] * (d["dy"] / 100) 
        for d in dados_atuais.values() 
        if d["dy"] > 0
    )
    
    print(f"\n💸 Dividendos Anuais Estimados: R$ {dividendos_anuais:,.0f}")
    print(f"   Yield Médio da Carteira: {(dividendos_anuais / valor_total * 100):.2f}%")

# Exemplo de carteira para monitorar (valores em reais)
minha_carteira = {
    "ITUB4": 8000,
    "TAEE11": 8000,
    "VALE3": 8000,
    "WEGE3": 8000,
    "RADL3": 7000,
    "PETR4": 7000,
    "BBAS3": 7000,
    "ABEV3": 6000,
    "EGIE3": 5000,
    "LREN3": 6000
}

# Executar dashboard (descomentar para usar)
# portfolio_dashboard(minha_carteira)

┌─────────────────────────────────────────────────────────────┐
│            ERROS COMUNS NA MONTAGEM DE CARTEIRA              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. ❌ CONCENTRAÇÃO EXCESSIVA                                │
│     → Mais de 10% em uma única ação                         │
│     → Mais de 30% em um único setor                         │
│                                                              │
│  2. ❌ DIVERSIFICAÇÃO EXCESSIVA                              │
│     → Mais de 30 ativos (diluição)                          │
│     → Posições tão pequenas que não fazem diferença         │
│                                                              │
│  3. ❌ IGNORAR CORRELAÇÕES                                   │
│     → Ter ITUB4, BBDC4, SANB11 e BBAS3 (todos bancos)       │
│     → "Diversificar" com ativos muito correlacionados       │
│                                                              │
│  4. ❌ NÃO REBALANCEAR                                       │
│     → Deixar vencedores dominarem a carteira                │
│     → Perder a alocação alvo ao longo do tempo              │
│                                                              │
│  5. ❌ SEGUIR MODAS                                          │
│     → Comprar o que está "na moda"                          │
│     → Entrar em IPOs sem análise                            │
│                                                              │
│  6. ❌ IGNORAR CUSTOS                                        │
│     → Muitas operações = muitas taxas                       │
│     → IR sobre ganhos frequentes                            │
│                                                              │
└─────────────────────────────────────────────────────────────┘