Juros Compostos: O Que São, Como Calcular e Simulador Completo 2026

M = C × (1 + i)^t

M = 5.000 × (1 + 0,12)^5
M = 5.000 × (1,12)^5
M = 5.000 × 1,7623
M = R$ 8.811,71

def calculadora_juros_compostos(
    capital_inicial: float,
    taxa_anual: float,
    anos: int,
    aporte_mensal: float = 0,
    mostrar_evolucao: bool = True
) -> dict:
    """
    Calculadora completa de juros compostos com aportes mensais.
    
    Args:
        capital_inicial: Valor inicial investido
        taxa_anual: Taxa de juros anual (ex: 10 para 10%)
        anos: Período de investimento em anos
        aporte_mensal: Aporte mensal adicional
        mostrar_evolucao: Se True, mostra evolução ano a ano
    
    Returns:
        Dicionário com resultados detalhados
    """
    taxa_mensal = (1 + taxa_anual/100) ** (1/12) - 1
    meses = anos * 12
    
    # Cálculo do montante final
    # Parte 1: Capital inicial crescendo
    montante_capital = capital_inicial * (1 + taxa_mensal) ** meses
    
    # Parte 2: Aportes mensais (fórmula de anuidade)
    if aporte_mensal > 0:
        montante_aportes = aporte_mensal * (((1 + taxa_mensal) ** meses - 1) / taxa_mensal)
    else:
        montante_aportes = 0
    
    montante_final = montante_capital + montante_aportes
    total_investido = capital_inicial + (aporte_mensal * meses)
    juros_ganhos = montante_final - total_investido
    
    print("=" * 60)
    print("📊 CALCULADORA DE JUROS COMPOSTOS")
    print("=" * 60)
    print(f"\n📥 INVESTIMENTO:")
    print(f"   Capital inicial: R$ {capital_inicial:,.2f}")
    print(f"   Aporte mensal: R$ {aporte_mensal:,.2f}")
    print(f"   Taxa anual: {taxa_anual}%")
    print(f"   Período: {anos} anos")
    
    print(f"\n📈 RESULTADO:")
    print(f"   Total investido: R$ {total_investido:,.2f}")
    print(f"   Juros ganhos: R$ {juros_ganhos:,.2f}")
    print(f"   💰 MONTANTE FINAL: R$ {montante_final:,.2f}")
    print(f"\n   Multiplicador: {montante_final/total_investido:.2f}x")
    
    if mostrar_evolucao:
        print(f"\n📅 EVOLUÇÃO ANO A ANO:")
        print("-" * 60)
        print(f"{'Ano':<6}{'Investido':<18}{'Montante':<18}{'Juros':<18}")
        print("-" * 60)
        
        for ano in range(1, anos + 1):
            meses_ano = ano * 12
            mont_cap = capital_inicial * (1 + taxa_mensal) ** meses_ano
            if aporte_mensal > 0:
                mont_ap = aporte_mensal * (((1 + taxa_mensal) ** meses_ano - 1) / taxa_mensal)
            else:
                mont_ap = 0
            mont_ano = mont_cap + mont_ap
            inv_ano = capital_inicial + (aporte_mensal * meses_ano)
            juros_ano = mont_ano - inv_ano
            
            print(f"{ano:<6}R$ {inv_ano:>12,.0f}   R$ {mont_ano:>12,.0f}   R$ {juros_ano:>12,.0f}")
    
    print("=" * 60)
    
    return {
        "montante_final": montante_final,
        "total_investido": total_investido,
        "juros_ganhos": juros_ganhos,
        "taxa_mensal": taxa_mensal * 100,
        "multiplicador": montante_final / total_investido
    }

# Exemplos de uso
print("\n🎯 EXEMPLO 1: Investimento único")
calculadora_juros_compostos(
    capital_inicial=10000,
    taxa_anual=10,
    anos=20
)

print("\n🎯 EXEMPLO 2: Com aportes mensais")
calculadora_juros_compostos(
    capital_inicial=1000,
    taxa_anual=10,
    anos=30,
    aporte_mensal=500
)

def comparar_investidores(investidores: list, idade_final: int = 65, taxa: float = 8):
    """
    Compara diferentes perfis de investidores
    """
    print("=" * 70)
    print("📊 COMPARATIVO DE INVESTIDORES")
    print(f"   Idade de aposentadoria: {idade_final} anos | Taxa: {taxa}% a.a.")
    print("=" * 70)
    
    for inv in investidores:
        nome = inv['nome']
        idade_inicio = inv['idade_inicio']
        aporte = inv['aporte_mensal']
        
        anos = idade_final - idade_inicio
        meses = anos * 12
        taxa_mensal = (1 + taxa/100) ** (1/12) - 1
        
        montante = aporte * (((1 + taxa_mensal) ** meses - 1) / taxa_mensal)
        total_investido = aporte * meses
        
        print(f"\n👤 {nome}")
        print(f"   Começa: {idade_inicio} anos | Aporte: R$ {aporte:,.0f}/mês")
        print(f"   Investe por: {anos} anos")
        print(f"   Total aportado: R$ {total_investido:,.0f}")
        print(f"   💰 Patrimônio final: R$ {montante:,.0f}")

investidores = [
    {"nome": "Ana (começa cedo)", "idade_inicio": 25, "aporte_mensal": 500},
    {"nome": "Bruno (começa tarde)", "idade_inicio": 35, "aporte_mensal": 500},
    {"nome": "Carlos (compensa atraso)", "idade_inicio": 35, "aporte_mensal": 1000},
]

comparar_investidores(investidores)

def regra_dos_72(taxa: float) -> float:
    """
    Calcula em quantos anos o capital dobra usando a Regra dos 72
    """
    anos = 72 / taxa
    print(f"Com taxa de {taxa}% a.a., seu dinheiro dobra em {anos:.1f} anos")
    return anos

# Exemplos
regra_dos_72(6)   # Poupança
regra_dos_72(8)   # Tesouro IPCA+
regra_dos_72(10)  # Carteira mista
regra_dos_72(12)  # Ações

import requests

def simular_investimentos_brasil(valor_inicial, aporte_mensal, anos):
    """
    Simula investimentos com taxas reais do mercado brasileiro
    """
    # Buscar taxa Selic atual
    response = requests.get("https://brapi.dev/api/v2/prime-rate")
    selic = response.json()['primeRate'][0]['value']
    
    # Buscar inflação
    response = requests.get("https://brapi.dev/api/v2/inflation")
    inflacao_12m = sum([item['value'] for item in response.json()['inflation'][:12]])
    
    print("=" * 65)
    print("📊 SIMULADOR DE INVESTIMENTOS BRASIL")
    print(f"   Capital: R$ {valor_inicial:,.0f} | Aporte: R$ {aporte_mensal:,.0f}/mês | Prazo: {anos} anos")
    print(f"   Selic atual: {selic}% | Inflação 12m: {inflacao_12m:.2f}%")
    print("=" * 65)
    
    investimentos = {
        "Poupança": 0.5 * 12 + 6.17,  # Aproximado
        "Tesouro Selic": selic,
        "CDB 110% CDI": selic * 1.10,
        "Tesouro IPCA+ 6%": inflacao_12m + 6,
        "Carteira Mista (60/40)": (selic * 0.4) + (12 * 0.6),  # Estimativa
        "Ações (histórico Ibovespa)": 12,  # Média histórica
    }
    
    meses = anos * 12
    
    print(f"\n{'Investimento':<30}{'Taxa':<12}{'Montante Final':<18}")
    print("-" * 65)
    
    for nome, taxa in investimentos.items():
        taxa_mensal = (1 + taxa/100) ** (1/12) - 1
        
        # Montante do capital inicial
        mont_cap = valor_inicial * (1 + taxa_mensal) ** meses
        
        # Montante dos aportes
        if aporte_mensal > 0:
            mont_ap = aporte_mensal * (((1 + taxa_mensal) ** meses - 1) / taxa_mensal)
        else:
            mont_ap = 0
        
        montante = mont_cap + mont_ap
        
        print(f"{nome:<30}{taxa:>6.1f}% a.a.   R$ {montante:>14,.0f}")
    
    print("=" * 65)

# Simular
simular_investimentos_brasil(
    valor_inicial=10000,
    aporte_mensal=500,
    anos=20
)

def simular_divida(valor, taxa_anual, meses):
    """
    Simula crescimento de dívida com juros compostos
    """
    taxa_mensal = (1 + taxa_anual/100) ** (1/12) - 1
    
    print(f"⚠️ SIMULAÇÃO DE DÍVIDA")
    print(f"Valor: R$ {valor:,.2f} | Taxa: {taxa_anual}% a.a.")
    print("-" * 40)
    
    divida_atual = valor
    for mes in range(1, meses + 1):
        divida_atual *= (1 + taxa_mensal)
        if mes <= 12 or mes == meses:
            print(f"Mês {mes:>2}: R$ {divida_atual:>12,.2f}")
    
    print(f"\n❌ Dívida final: R$ {divida_atual:,.2f}")
    print(f"❌ Juros pagos: R$ {divida_atual - valor:,.2f}")

# Cartão de crédito rotativo
simular_divida(5000, 400, 12)

def comparar_reinvestimento_dividendos(valor_inicial, anos, taxa_valorizacao, dividend_yield):
    """
    Compara crescimento com e sem reinvestimento de dividendos
    """
    # Sem reinvestimento
    valor_sem = valor_inicial
    dividendos_sacados = 0
    
    # Com reinvestimento
    valor_com = valor_inicial
    
    for ano in range(anos):
        # Sem reinvestimento
        dividendos_ano = valor_sem * (dividend_yield/100)
        dividendos_sacados += dividendos_ano
        valor_sem *= (1 + taxa_valorizacao/100)
        
        # Com reinvestimento
        valor_com *= (1 + (taxa_valorizacao + dividend_yield)/100)
    
    print("📊 IMPACTO DO REINVESTIMENTO DE DIVIDENDOS")
    print(f"Capital inicial: R$ {valor_inicial:,.0f}")
    print(f"Prazo: {anos} anos")
    print(f"Valorização: {taxa_valorizacao}% a.a. | DY: {dividend_yield}%")
    print("-" * 50)
    print(f"\n❌ SEM reinvestir dividendos:")
    print(f"   Valor final: R$ {valor_sem:,.0f}")
    print(f"   Dividendos sacados: R$ {dividendos_sacados:,.0f}")
    print(f"   Total: R$ {valor_sem + dividendos_sacados:,.0f}")
    print(f"\n✅ COM reinvestimento:")
    print(f"   Valor final: R$ {valor_com:,.0f}")
    print(f"\n💡 Diferença: R$ {valor_com - (valor_sem + dividendos_sacados):,.0f}")

comparar_reinvestimento_dividendos(100000, 20, 8, 5)

def quanto_preciso_aposentar(
    renda_mensal_desejada: float,
    taxa_retirada: float = 4,
    taxa_acumulacao: float = 10,
    anos_para_aposentar: int = 30
):
    """
    Calcula quanto você precisa acumular e aportar para aposentar
    
    Args:
        renda_mensal_desejada: Quanto quer receber por mês na aposentadoria
        taxa_retirada: Taxa de retirada anual segura (geralmente 4%)
        taxa_acumulacao: Taxa de rendimento durante acumulação
        anos_para_aposentar: Anos até a aposentadoria
    """
    renda_anual = renda_mensal_desejada * 12
    patrimonio_necessario = renda_anual / (taxa_retirada / 100)
    
    # Quanto aportar por mês para chegar lá
    taxa_mensal = (1 + taxa_acumulacao/100) ** (1/12) - 1
    meses = anos_para_aposentar * 12
    
    # Fórmula inversa da anuidade
    aporte_mensal = patrimonio_necessario * taxa_mensal / ((1 + taxa_mensal) ** meses - 1)
    
    total_aportado = aporte_mensal * meses
    juros_ganhos = patrimonio_necessario - total_aportado
    
    print("=" * 60)
    print("🎯 CALCULADORA DE APOSENTADORIA")
    print("=" * 60)
    print(f"\n📋 OBJETIVO:")
    print(f"   Renda mensal desejada: R$ {renda_mensal_desejada:,.0f}")
    print(f"   Taxa de retirada: {taxa_retirada}% a.a.")
    print(f"   Patrimônio necessário: R$ {patrimonio_necessario:,.0f}")
    
    print(f"\n📈 ACUMULAÇÃO:")
    print(f"   Anos até aposentar: {anos_para_aposentar}")
    print(f"   Taxa de rendimento: {taxa_acumulacao}% a.a.")
    
    print(f"\n💰 RESULTADO:")
    print(f"   Aporte mensal necessário: R$ {aporte_mensal:,.0f}")
    print(f"   Total que você aportará: R$ {total_aportado:,.0f}")
    print(f"   Juros compostos farão: R$ {juros_ganhos:,.0f}")
    print(f"\n   🔥 Os juros representam {juros_ganhos/patrimonio_necessario*100:.0f}% do seu patrimônio!")
    print("=" * 60)

# Quanto preciso para receber R$ 10.000/mês?
quanto_preciso_aposentar(
    renda_mensal_desejada=10000,
    taxa_retirada=4,
    taxa_acumulacao=10,
    anos_para_aposentar=25
)

import requests
from datetime import datetime

def acompanhar_carteira_longo_prazo(carteira: dict, token: str):
    """
    Acompanha carteira de longo prazo focada em juros compostos
    """
    tickers = list(carteira.keys())
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}"
    
    response = requests.get(url, params={
        "token": token,
        "modules": "dividendsData"
    })
    data = response.json()
    
    print("=" * 60)
    print("📈 CARTEIRA DE LONGO PRAZO - JUROS COMPOSTOS")
    print(f"   Data: {datetime.now().strftime('%d/%m/%Y %H:%M')}")
    print("=" * 60)
    
    patrimonio_total = 0
    dividendos_anuais = 0
    
    for ativo in data['results']:
        symbol = ativo['symbol']
        preco = ativo['regularMarketPrice']
        quantidade = carteira[symbol]['quantidade']
        preco_medio = carteira[symbol]['preco_medio']
        
        valor_atual = preco * quantidade
        valor_investido = preco_medio * quantidade
        lucro = valor_atual - valor_investido
        lucro_percent = (lucro / valor_investido) * 100
        
        patrimonio_total += valor_atual
        
        # Estimar dividendos (simplificado)
        dy = ativo.get('dividendYield', 0) or 0
        div_anual = valor_atual * (dy / 100)
        dividendos_anuais += div_anual
        
        emoji = "🟢" if lucro > 0 else "🔴"
        
        print(f"\n{symbol}:")
        print(f"   Quantidade: {quantidade}")
        print(f"   Preço médio: R$ {preco_medio:.2f} → Atual: R$ {preco:.2f}")
        print(f"   Valor investido: R$ {valor_investido:,.2f}")
        print(f"   Valor atual: R$ {valor_atual:,.2f}")
        print(f"   {emoji} Lucro: R$ {lucro:,.2f} ({lucro_percent:+.1f}%)")
    
    print("\n" + "=" * 60)
    print(f"💰 PATRIMÔNIO TOTAL: R$ {patrimonio_total:,.2f}")
    print(f"💵 Dividendos anuais estimados: R$ {dividendos_anuais:,.2f}")
    print(f"📊 Yield on Cost estimado: {dividendos_anuais/patrimonio_total*100:.2f}%")
    print("=" * 60)

# Exemplo de carteira de longo prazo
minha_carteira = {
    "ITUB4": {"quantidade": 100, "preco_medio": 25.00},
    "VALE3": {"quantidade": 50, "preco_medio": 68.00},
    "WEGE3": {"quantidade": 30, "preco_medio": 35.00},
}

# acompanhar_carteira_longo_prazo(minha_carteira, "SEU_TOKEN")

Tempo + Consistência + Paciência = Patrimônio