Dollar Cost Averaging (DCA) 2026: Estratégia de Aportes Mensais que Reduz Riscos

import random

def simular_dca_vs_lump_sum(valor_total: float, meses: int, volatilidade: float):
    """
    Simula DCA vs investir tudo de uma vez
    """
    # Preços simulados com volatilidade
    precos = [100]
    for _ in range(meses - 1):
        variacao = random.uniform(-volatilidade, volatilidade)
        novo_preco = precos[-1] * (1 + variacao)
        precos.append(novo_preco)
    
    # Lump Sum (tudo no primeiro mês)
    acoes_lump = valor_total / precos[0]
    valor_final_lump = acoes_lump * precos[-1]
    
    # DCA (dividido igualmente)
    aporte_mensal = valor_total / meses
    total_acoes_dca = sum(aporte_mensal / p for p in precos)
    valor_final_dca = total_acoes_dca * precos[-1]
    preco_medio_dca = valor_total / total_acoes_dca
    
    return {
        "lump_sum": {
            "acoes": acoes_lump,
            "preco_compra": precos[0],
            "valor_final": valor_final_lump,
            "retorno": (valor_final_lump / valor_total - 1) * 100
        },
        "dca": {
            "acoes": total_acoes_dca,
            "preco_medio": preco_medio_dca,
            "valor_final": valor_final_dca,
            "retorno": (valor_final_dca / valor_total - 1) * 100
        },
        "precos": precos
    }

resultados_lump = []
resultados_dca = []

for _ in range(100):
    sim = simular_dca_vs_lump_sum(12000, 12, 0.08)
    resultados_lump.append(sim["lump_sum"]["retorno"])
    resultados_dca.append(sim["dca"]["retorno"])

print("Simulação: R$ 12.000 em 12 meses")
print("=" * 45)
print(f"Lump Sum - Retorno médio: {sum(resultados_lump)/len(resultados_lump):.1f}%")
print(f"DCA - Retorno médio: {sum(resultados_dca)/len(resultados_dca):.1f}%")
print(f"\nDCA teve menor variância nos resultados!")

def calcular_aporte_ideal(renda_liquida: float, perfil: str) -> float:
    """
    Sugere valor de aporte baseado no perfil
    """
    percentuais = {
        "conservador": 0.10,   # 10%
        "moderado": 0.20,      # 20%
        "agressivo": 0.30,     # 30%
        "fire": 0.50           # 50% (Financial Independence)
    }
    
    percentual = percentuais.get(perfil, 0.15)
    aporte = renda_liquida * percentual
    
    print(f"Renda líquida: R$ {renda_liquida:,.2f}")
    print(f"Perfil: {perfil.title()}")
    print(f"Percentual sugerido: {percentual*100:.0f}%")
    print(f"Aporte mensal: R$ {aporte:,.2f}")
    
    return aporte

# Exemplo
calcular_aporte_ideal(8000, "moderado")

# Carteira simples para DCA
carteira_dca = {
    # Renda Variável Brasil (50%)
    "BOVA11": 0.30,   # ETF Ibovespa
    "SMAL11": 0.10,   # Small Caps
    "DIVO11": 0.10,   # Dividendos
    
    # Internacional (30%)
    "IVVB11": 0.30,   # S&P 500
    
    # Proteção (20%)
    "GOLD11": 0.10,   # Ouro
    "Tesouro IPCA+": 0.10  # Renda Fixa
}

from datetime import datetime, timedelta

def criar_cronograma_dca(
    valor_mensal: float,
    carteira: dict,
    inicio: datetime,
    meses: int
):
    """
    Cria cronograma de aportes DCA
    """
    cronograma = []
    data_atual = inicio
    
    for mes in range(1, meses + 1):
        aportes_mes = {}
        for ativo, peso in carteira.items():
            aportes_mes[ativo] = valor_mensal * peso
        
        cronograma.append({
            "mes": mes,
            "data": data_atual.strftime("%d/%m/%Y"),
            "aportes": aportes_mes,
            "total": valor_mensal
        })
        
        # Próximo mês (dia 5 de cada mês)
        if data_atual.month == 12:
            data_atual = datetime(data_atual.year + 1, 1, 5)
        else:
            data_atual = datetime(data_atual.year, data_atual.month + 1, 5)
    
    return cronograma

# Criar cronograma para 12 meses
cronograma = criar_cronograma_dca(
    valor_mensal=2000,
    carteira={"BOVA11": 0.5, "IVVB11": 0.3, "GOLD11": 0.2},
    inicio=datetime(2026, 2, 5),
    meses=12
)

print("Cronograma DCA - 12 meses")
print("=" * 60)
for c in cronograma[:3]:  # Mostrar primeiros 3 meses
    print(f"\nMês {c['mes']} - {c['data']}:")
    for ativo, valor in c['aportes'].items():
        print(f"  {ativo}: R$ {valor:.2f}")
print("\n...")

import requests
from datetime import datetime

def executar_aporte_dca(carteira: dict, valor_total: float, token: str):
    """
    Calcula e executa aporte DCA do mês
    """
    symbols = [s for s in carteira.keys() if not s.startswith("Tesouro")]
    
    if symbols:
        url = f"https://brapi.dev/api/quote/{','.join(symbols)}"
        headers = {"Authorization": f"Bearer {token}"}
        response = requests.get(url, headers=headers)
        data = response.json()
        precos = {r["symbol"]: r["regularMarketPrice"] for r in data["results"]}
    else:
        precos = {}
    
    print(f"=== APORTE DCA - {datetime.now().strftime('%B/%Y')} ===")
    print(f"Valor total: R$ {valor_total:,.2f}")
    print("-" * 50)
    
    total_alocado = 0
    ordens = []
    
    for ativo, peso in carteira.items():
        valor_alvo = valor_total * peso
        
        if ativo in precos:
            preco = precos[ativo]
            qtd = int(valor_alvo // preco)
            valor_real = qtd * preco
            total_alocado += valor_real
            
            ordens.append({
                "ativo": ativo,
                "qtd": qtd,
                "preco": preco,
                "valor": valor_real
            })
            
            print(f"{ativo}: {qtd} cotas x R$ {preco:.2f} = R$ {valor_real:.2f}")
        else:
            print(f"{ativo}: R$ {valor_alvo:.2f} (aplicar manualmente)")
            total_alocado += valor_alvo
    
    print("-" * 50)
    print(f"Total alocado: R$ {total_alocado:,.2f}")
    print(f"Sobra (próximo mês): R$ {valor_total - total_alocado:.2f}")
    
    return ordens

# Executar aporte do mês
carteira = {
    "BOVA11": 0.30,
    "IVVB11": 0.25,
    "SMAL11": 0.15,
    "GOLD11": 0.10,
    "Tesouro IPCA+": 0.20
}

executar_aporte_dca(carteira, 2000, "SEU_TOKEN")

import requests
from datetime import datetime
import matplotlib.pyplot as plt

class CalculadoraDCA:
    def __init__(self, token: str):
        self.token = token
        self.historico = []
    
    def simular_dca_historico(
        self,
        symbol: str,
        aporte_mensal: float,
        meses: int
    ) -> dict:
        """
        Simula DCA usando dados históricos reais
        """
        # Buscar histórico
        url = f"https://brapi.dev/api/quote/{symbol}"
        params = {"range": f"{meses}mo", "interval": "1mo"}
        headers = {"Authorization": f"Bearer {self.token}"}
        
        response = requests.get(url, params=params, headers=headers)
        data = response.json()
        
        historico = data["results"][0].get("historicalDataPrice", [])
        
        if not historico:
            print("Sem dados históricos disponíveis")
            return {}
        
        # Simular aportes
        total_cotas = 0
        total_investido = 0
        compras = []
        
        for h in historico[-meses:]:
            preco = h["close"]
            cotas = aporte_mensal / preco
            total_cotas += cotas
            total_investido += aporte_mensal
            
            compras.append({
                "data": h["date"],
                "preco": preco,
                "cotas": cotas,
                "total_cotas": total_cotas,
                "investido": total_investido
            })
        
        preco_atual = data["results"][0]["regularMarketPrice"]
        valor_atual = total_cotas * preco_atual
        preco_medio = total_investido / total_cotas
        
        resultado = {
            "symbol": symbol,
            "meses": len(compras),
            "aporte_mensal": aporte_mensal,
            "total_investido": total_investido,
            "total_cotas": total_cotas,
            "preco_medio": preco_medio,
            "preco_atual": preco_atual,
            "valor_atual": valor_atual,
            "lucro": valor_atual - total_investido,
            "retorno_pct": ((valor_atual / total_investido) - 1) * 100,
            "compras": compras
        }
        
        return resultado
    
    def imprimir_resultado(self, resultado: dict):
        """
        Exibe resultado da simulação
        """
        print(f"\n{'='*55}")
        print(f"SIMULAÇÃO DCA - {resultado['symbol']}")
        print(f"{'='*55}")
        print(f"Período: {resultado['meses']} meses")
        print(f"Aporte mensal: R$ {resultado['aporte_mensal']:,.2f}")
        print(f"\n--- RESULTADO ---")
        print(f"Total investido: R$ {resultado['total_investido']:,.2f}")
        print(f"Total de cotas: {resultado['total_cotas']:,.2f}")
        print(f"Preço médio: R$ {resultado['preco_medio']:.2f}")
        print(f"Preço atual: R$ {resultado['preco_atual']:.2f}")
        print(f"Valor atual: R$ {resultado['valor_atual']:,.2f}")
        print(f"\nLucro/Prejuízo: R$ {resultado['lucro']:,.2f}")
        print(f"Retorno: {resultado['retorno_pct']:+.2f}%")
        print(f"{'='*55}")

# Usar a calculadora
calc = CalculadoraDCA("SEU_TOKEN")

# Simular DCA de R$ 1.000/mês por 24 meses no BOVA11
resultado = calc.simular_dca_historico("BOVA11", 1000, 24)
calc.imprimir_resultado(resultado)

def value_averaging(
    meta_crescimento_mensal: float,
    patrimonio_atual: float,
    valor_meta: float,
    preco_atual: float
) -> float:
    """
    Calcula aporte para Value Averaging
    """
    valor_necessario = valor_meta - patrimonio_atual
    cotas_necessarias = valor_necessario / preco_atual
    
    print(f"Meta de patrimônio: R$ {valor_meta:,.2f}")
    print(f"Patrimônio atual: R$ {patrimonio_atual:,.2f}")
    print(f"Aporte necessário: R$ {valor_necessario:,.2f}")
    
    return valor_necessario

# Exemplo: Meta de crescer R$ 1.000/mês
# Se ações subiram, aporta menos. Se caíram, aporta mais.
meta = 10000  # Meta para este mês
atual = 9200  # Patrimônio atual
preco = 120   # Preço da ação

aporte = value_averaging(1000, atual, meta, preco)

def dca_com_rebalanceamento(
    alocacao_alvo: dict,
    carteira_atual: dict,
    aporte: float,
    precos: dict
) -> dict:
    """
    DCA que considera a alocação atual da carteira
    """
    # Calcular valor total atual
    valor_total = sum(
        carteira_atual.get(a, 0) * precos.get(a, 0) 
        for a in alocacao_alvo
    )
    valor_total += aporte
    
    # Calcular quanto deveria ter de cada ativo
    compras = {}
    
    for ativo, peso_alvo in alocacao_alvo.items():
        valor_alvo = valor_total * peso_alvo
        valor_atual = carteira_atual.get(ativo, 0) * precos.get(ativo, 1)
        diferenca = valor_alvo - valor_atual
        
        if diferenca > 0:
            # Precisa comprar
            qtd = int(diferenca // precos.get(ativo, 1))
            compras[ativo] = max(0, qtd)
        else:
            compras[ativo] = 0
    
    return compras

# Exemplo
alocacao = {"BOVA11": 0.4, "IVVB11": 0.4, "GOLD11": 0.2}
carteira = {"BOVA11": 50, "IVVB11": 30, "GOLD11": 20}  # Quantidade de cotas
precos = {"BOVA11": 120, "IVVB11": 150, "GOLD11": 12}

compras = dca_com_rebalanceamento(alocacao, carteira, 2000, precos)
print("Compras para rebalancear:")
for ativo, qtd in compras.items():
    print(f"  {ativo}: {qtd} cotas")

def dca_antifragil(
    aporte_base: float,
    queda_mercado_pct: float,
    max_multiplicador: float = 2.0
) -> float:
    """
    Aumenta aporte proporcionalmente à queda do mercado
    """
    if queda_mercado_pct >= 0:
        # Mercado subindo ou estável = aporte normal
        return aporte_base
    
    # Mercado caindo = aumenta aporte
    # Queda de 10% = 1.5x, Queda de 20% = 2x
    multiplicador = 1 + (abs(queda_mercado_pct) / 20)
    multiplicador = min(multiplicador, max_multiplicador)
    
    aporte_ajustado = aporte_base * multiplicador
    
    print(f"Queda do mercado: {queda_mercado_pct:.1f}%")
    print(f"Multiplicador: {multiplicador:.2f}x")
    print(f"Aporte base: R$ {aporte_base:,.2f}")
    print(f"Aporte ajustado: R$ {aporte_ajustado:,.2f}")
    
    return aporte_ajustado

# Mercado caiu 15% este mês
aporte = dca_antifragil(1000, -15)

carteira_iniciante = {
    "BOVA11": 0.60,   # Simplicidade, diversificação
    "IVVB11": 0.30,   # Exposição internacional
    "Tesouro Selic": 0.10  # Reserva de emergência
}

# Aporte: 15-20% da renda
# Foco: Aprender e criar hábito

carteira_intermediario = {
    # Brasil (45%)
    "BOVA11": 0.20,
    "SMAL11": 0.10,
    "DIVO11": 0.15,
    
    # Internacional (35%)
    "IVVB11": 0.25,
    "EURP11": 0.10,
    
    # Proteção (20%)
    "GOLD11": 0.10,
    "Tesouro IPCA+": 0.10
}

# Aporte: 20-30% da renda
# Foco: Diversificação e crescimento

carteira_avancado = {
    # Brasil - Ações (35%)
    "Ações individuais": 0.25,
    "FIIs": 0.10,
    
    # Internacional (30%)
    "Corretora exterior": 0.30,
    
    # Alternativos (15%)
    "Criptomoedas": 0.05,
    "Private Equity": 0.10,
    
    # Proteção (20%)
    "Renda Fixa": 0.15,
    "Ouro físico": 0.05
}

# Aporte: 30-50% da renda
# Foco: Preservação e otimização fiscal

import requests
from datetime import datetime
import json

class ControleDCA:
    def __init__(self, token: str):
        self.token = token
        self.aportes = []
    
    def registrar_aporte(
        self,
        data: str,
        symbol: str,
        quantidade: float,
        preco: float
    ):
        """
        Registra um aporte realizado
        """
        self.aportes.append({
            "data": data,
            "symbol": symbol,
            "quantidade": quantidade,
            "preco": preco,
            "valor": quantidade * preco
        })
    
    def calcular_posicao(self, symbol: str) -> dict:
        """
        Calcula posição atual de um ativo
        """
        aportes_ativo = [a for a in self.aportes if a["symbol"] == symbol]
        
        if not aportes_ativo:
            return {}
        
        total_qtd = sum(a["quantidade"] for a in aportes_ativo)
        total_valor = sum(a["valor"] for a in aportes_ativo)
        preco_medio = total_valor / total_qtd
        
        # Buscar preço atual
        url = f"https://brapi.dev/api/quote/{symbol}"
        headers = {"Authorization": f"Bearer {self.token}"}
        response = requests.get(url, headers=headers)
        data = response.json()
        preco_atual = data["results"][0]["regularMarketPrice"]
        
        valor_atual = total_qtd * preco_atual
        lucro = valor_atual - total_valor
        
        return {
            "symbol": symbol,
            "quantidade": total_qtd,
            "preco_medio": preco_medio,
            "preco_atual": preco_atual,
            "valor_investido": total_valor,
            "valor_atual": valor_atual,
            "lucro": lucro,
            "retorno_pct": (lucro / total_valor) * 100,
            "num_aportes": len(aportes_ativo)
        }
    
    def relatorio_completo(self) -> None:
        """
        Gera relatório de todos os ativos
        """
        symbols = list(set(a["symbol"] for a in self.aportes))
        
        print("\n" + "=" * 70)
        print("RELATÓRIO DCA - POSIÇÃO ATUAL")
        print("=" * 70)
        
        total_investido = 0
        total_atual = 0
        
        for symbol in symbols:
            pos = self.calcular_posicao(symbol)
            if pos:
                print(f"\n{pos['symbol']}:")
                print(f"  Quantidade: {pos['quantidade']:.2f}")
                print(f"  PM: R$ {pos['preco_medio']:.2f} → Atual: R$ {pos['preco_atual']:.2f}")
                print(f"  Investido: R$ {pos['valor_investido']:,.2f}")
                print(f"  Valor Atual: R$ {pos['valor_atual']:,.2f}")
                print(f"  Lucro: R$ {pos['lucro']:,.2f} ({pos['retorno_pct']:+.1f}%)")
                
                total_investido += pos['valor_investido']
                total_atual += pos['valor_atual']
        
        print("\n" + "=" * 70)
        print(f"TOTAL INVESTIDO: R$ {total_investido:,.2f}")
        print(f"VALOR ATUAL: R$ {total_atual:,.2f}")
        print(f"LUCRO TOTAL: R$ {total_atual - total_investido:,.2f}")
        print(f"RETORNO: {((total_atual/total_investido)-1)*100:+.2f}%")
        print("=" * 70)

# Exemplo de uso
controle = ControleDCA("SEU_TOKEN")

# Registrar aportes históricos
controle.registrar_aporte("2024-01-05", "BOVA11", 10, 128.50)
controle.registrar_aporte("2024-02-05", "BOVA11", 8, 132.20)
controle.registrar_aporte("2024-03-05", "BOVA11", 9, 125.80)
controle.registrar_aporte("2024-01-05", "IVVB11", 5, 280.00)
controle.registrar_aporte("2024-02-05", "IVVB11", 4, 295.00)

# Gerar relatório
controle.relatorio_completo()