Como Sair das Dívidas e Começar a Investir: Guia Prático 2026

import requests

# Primeiro, vamos consultar a taxa Selic atual para comparação
def obter_selic():
    """Consulta a taxa Selic atual via brapi.dev"""
    url = "https://brapi.dev/api/v2/prime-rate"
    
    try:
        response = requests.get(url)
        dados = response.json()
        
        if 'prime-rate' in dados and len(dados['prime-rate']) > 0:
            selic_atual = float(dados['prime-rate'][0]['value'])
            return selic_atual
    except Exception as e:
        print(f"Erro ao consultar Selic: {e}")
    
    return 13.25  # Valor padrão caso falhe

# Mapeamento das dívidas
def mapear_dividas():
    """Mapeia todas as dívidas e calcula métricas importantes"""
    
    selic = obter_selic()
    print(f"📊 Taxa Selic atual: {selic}% a.a.")
    print("=" * 60)
    
    dividas = [
        {
            "credor": "Cartão de Crédito",
            "valor": 5000,
            "taxa_mensal": 14.0,
            "parcela_minima": 250,
            "tipo": "rotativo"
        },
        {
            "credor": "Empréstimo Pessoal",
            "valor": 15000,
            "taxa_mensal": 5.0,
            "parcela_minima": 850,
            "parcelas_restantes": 24
        },
        {
            "credor": "Cheque Especial",
            "valor": 3000,
            "taxa_mensal": 8.0,
            "parcela_minima": 500,
            "tipo": "rotativo"
        },
        {
            "credor": "Financiamento Carro",
            "valor": 35000,
            "taxa_mensal": 1.8,
            "parcela_minima": 1200,
            "parcelas_restantes": 36
        }
    ]
    
    total_divida = 0
    total_parcelas = 0
    custo_juros_anual = 0
    
    print("\n📋 MAPEAMENTO COMPLETO DAS DÍVIDAS")
    print("-" * 60)
    
    # Ordenar por taxa de juros (maior para menor)
    dividas_ordenadas = sorted(dividas, key=lambda x: x['taxa_mensal'], reverse=True)
    
    for i, d in enumerate(dividas_ordenadas, 1):
        taxa_anual = ((1 + d['taxa_mensal']/100) ** 12 - 1) * 100
        juros_mensal = d['valor'] * (d['taxa_mensal'] / 100)
        juros_anual = d['valor'] * (taxa_anual / 100)
        
        # Comparação com Selic
        spread_vs_selic = taxa_anual - selic
        
        total_divida += d['valor']
        total_parcelas += d['parcela_minima']
        custo_juros_anual += juros_anual
        
        print(f"\n{i}. {d['credor']}")
        print(f"   💰 Valor: R$ {d['valor']:,.2f}")
        print(f"   📈 Taxa: {d['taxa_mensal']:.1f}% a.m. ({taxa_anual:.1f}% a.a.)")
        print(f"   🔥 Juros mensais: R$ {juros_mensal:,.2f}")
        print(f"   ⚠️  Spread vs Selic: +{spread_vs_selic:.1f} p.p.")
        print(f"   💳 Parcela mínima: R$ {d['parcela_minima']:,.2f}")
    
    print("\n" + "=" * 60)
    print("📊 RESUMO GERAL")
    print("=" * 60)
    print(f"💰 Total em dívidas: R$ {total_divida:,.2f}")
    print(f"💳 Total de parcelas mensais: R$ {total_parcelas:,.2f}")
    print(f"🔥 Custo anual em juros: R$ {custo_juros_anual:,.2f}")
    print(f"📉 % da dívida que vai para juros/ano: {(custo_juros_anual/total_divida)*100:.1f}%")
    
    # Índice de comprometimento
    renda_mensal = 6000  # Exemplo
    comprometimento = (total_parcelas / renda_mensal) * 100
    print(f"\n⚠️  Comprometimento da renda (exemplo R$ {renda_mensal:,}): {comprometimento:.1f}%")
    
    if comprometimento > 30:
        print("   🚨 ALERTA: Comprometimento acima do recomendado (30%)")
    
    return dividas_ordenadas

# Executar
dividas = mapear_dividas()

def simular_crescimento_divida():
    """Mostra como a dívida cresce se não for paga"""
    
    divida_inicial = 5000
    cenarios = [
        {"nome": "Cartão Rotativo", "taxa_mensal": 14},
        {"nome": "Cheque Especial", "taxa_mensal": 8},
        {"nome": "Empréstimo Pessoal", "taxa_mensal": 5},
        {"nome": "Consignado", "taxa_mensal": 2},
    ]
    
    print("🔥 CRESCIMENTO DA DÍVIDA SEM PAGAMENTO")
    print(f"Dívida inicial: R$ {divida_inicial:,.2f}")
    print("=" * 70)
    
    meses = [6, 12, 24]
    
    for cenario in cenarios:
        taxa = cenario['taxa_mensal'] / 100
        print(f"\n📊 {cenario['nome']} ({cenario['taxa_mensal']}% a.m.):")
        
        for m in meses:
            valor_futuro = divida_inicial * ((1 + taxa) ** m)
            juros_pagos = valor_futuro - divida_inicial
            print(f"   Em {m:2d} meses: R$ {valor_futuro:>12,.2f} (juros: R$ {juros_pagos:>10,.2f})")

simular_crescimento_divida()

🔥 CRESCIMENTO DA DÍVIDA SEM PAGAMENTO
Dívida inicial: R$ 5.000,00
======================================================================

📊 Cartão Rotativo (14% a.m.):
   Em  6 meses: R$   11.066,29 (juros: R$   6.066,29)
   Em 12 meses: R$   24.493,28 (juros: R$  19.493,28)
   Em 24 meses: R$  119.972,78 (juros: R$ 114.972,78)

📊 Cheque Especial (8% a.m.):
   Em  6 meses: R$    7.934,37 (juros: R$   2.934,37)
   Em 12 meses: R$   12.590,85 (juros: R$   7.590,85)
   Em 24 meses: R$   31.705,12 (juros: R$  26.705,12)

def comparar_metodos():
    """Compara os métodos Avalanche e Bola de Neve"""
    
    dividas = [
        {"nome": "Cartão Crédito", "valor": 5000, "taxa": 14, "minimo": 250},
        {"nome": "Cheque Especial", "valor": 3000, "taxa": 8, "minimo": 150},
        {"nome": "Empréstimo", "valor": 15000, "taxa": 5, "minimo": 500},
        {"nome": "Loja Varejo", "valor": 1500, "taxa": 6, "minimo": 100},
    ]
    
    orcamento_total = 1500  # Valor disponível para dívidas
    
    def simular(dividas_ordenadas, metodo_nome):
        """Simula pagamento das dívidas"""
        dividas_sim = [d.copy() for d in dividas_ordenadas]
        mes = 0
        juros_total = 0
        quitacoes = []
        
        while any(d['valor'] > 0 for d in dividas_sim):
            mes += 1
            if mes > 120:  # Limite de 10 anos
                break
            
            # Calcular juros do mês
            for d in dividas_sim:
                if d['valor'] > 0:
                    juros = d['valor'] * (d['taxa'] / 100)
                    d['valor'] += juros
                    juros_total += juros
            
            # Pagar mínimo em todas
            sobra = orcamento_total
            for d in dividas_sim:
                if d['valor'] > 0:
                    pagamento = min(d['minimo'], d['valor'])
                    d['valor'] -= pagamento
                    sobra -= pagamento
            
            # Direcionar extra para a primeira dívida ativa
            for d in dividas_sim:
                if d['valor'] > 0 and sobra > 0:
                    pagamento = min(sobra, d['valor'])
                    d['valor'] -= pagamento
                    sobra -= pagamento
                    
                    if d['valor'] <= 0:
                        quitacoes.append((mes, d['nome']))
                    break
        
        return mes, juros_total, quitacoes
    
    # Método Avalanche (ordenar por taxa, maior primeiro)
    dividas_avalanche = sorted(dividas, key=lambda x: x['taxa'], reverse=True)
    meses_av, juros_av, quit_av = simular(dividas_avalanche, "Avalanche")
    
    # Método Bola de Neve (ordenar por valor, menor primeiro)
    dividas_bolaneve = sorted(dividas, key=lambda x: x['valor'])
    meses_bn, juros_bn, quit_bn = simular(dividas_bolaneve, "Bola de Neve")
    
    print("=" * 60)
    print("📊 COMPARATIVO: AVALANCHE vs BOLA DE NEVE")
    print("=" * 60)
    print(f"\nOrçamento mensal para dívidas: R$ {orcamento_total:,.2f}")
    print(f"Total inicial em dívidas: R$ {sum(d['valor'] for d in dividas):,.2f}")
    
    print("\n🏔️  MÉTODO AVALANCHE (maior taxa primeiro)")
    print(f"   Ordem: {' → '.join([d['nome'] for d in dividas_avalanche])}")
    print(f"   Tempo para quitar tudo: {meses_av} meses ({meses_av/12:.1f} anos)")
    print(f"   Total pago em juros: R$ {juros_av:,.2f}")
    
    print("\n⛄ MÉTODO BOLA DE NEVE (menor valor primeiro)")
    print(f"   Ordem: {' → '.join([d['nome'] for d in dividas_bolaneve])}")
    print(f"   Tempo para quitar tudo: {meses_bn} meses ({meses_bn/12:.1f} anos)")
    print(f"   Total pago em juros: R$ {juros_bn:,.2f}")
    
    diferenca = juros_bn - juros_av
    print(f"\n💰 Economia do Avalanche: R$ {diferenca:,.2f}")
    print(f"⚡ Diferença de tempo: {meses_bn - meses_av} meses")
    
    # Recomendação
    print("\n" + "=" * 60)
    print("🎯 RECOMENDAÇÃO:")
    if diferenca > 1000:
        print("   Use AVALANCHE se você é disciplinado e quer economizar.")
    else:
        print("   A diferença é pequena. Escolha o que te motiva mais!")

comparar_metodos()

import requests
from datetime import datetime, timedelta

def calculadora_quitacao():
    """Calculadora completa de quitação de dívidas"""
    
    # Consultar taxa Selic para referência
    try:
        response = requests.get("https://brapi.dev/api/v2/prime-rate")
        dados = response.json()
        selic = dados['prime-rate'][0]['value'] if 'prime-rate' in dados else 13.25
    except:
        selic = 13.25
    
    print("=" * 60)
    print("🧮 CALCULADORA DE QUITAÇÃO DE DÍVIDAS")
    print("=" * 60)
    print(f"Taxa Selic atual: {selic}% a.a. (referência)")
    
    # Dados da dívida
    divida_total = 24500  # R$ 24.500
    taxa_media_mensal = 8  # 8% ao mês (média ponderada)
    pagamento_mensal = 1500  # Quanto você pode pagar por mês
    
    print(f"\n📋 DADOS DA DÍVIDA:")
    print(f"   Valor total: R$ {divida_total:,.2f}")
    print(f"   Taxa média: {taxa_media_mensal}% a.m.")
    print(f"   Pagamento mensal: R$ {pagamento_mensal:,.2f}")
    
    # Verificar viabilidade
    juros_primeiro_mes = divida_total * (taxa_media_mensal / 100)
    if pagamento_mensal <= juros_primeiro_mes:
        print(f"\n🚨 ALERTA: Pagamento de R$ {pagamento_mensal:,.2f} é menor que")
        print(f"   os juros do primeiro mês (R$ {juros_primeiro_mes:,.2f})!")
        print("   A dívida nunca será quitada. Aumente o pagamento!")
        return
    
    # Simular pagamento
    saldo = divida_total
    mes = 0
    juros_total = 0
    historico = []
    
    while saldo > 0:
        mes += 1
        juros_mes = saldo * (taxa_media_mensal / 100)
        juros_total += juros_mes
        saldo += juros_mes
        
        pagamento = min(pagamento_mensal, saldo)
        saldo -= pagamento
        
        historico.append({
            "mes": mes,
            "juros": juros_mes,
            "pagamento": pagamento,
            "saldo": max(0, saldo)
        })
        
        if mes > 360:  # Limite de 30 anos
            print("\n🚨 ERRO: Dívida não será quitada em 30 anos!")
            return
    
    # Resultados
    print("\n📊 PROJEÇÃO DE QUITAÇÃO:")
    print("-" * 60)
    
    total_pago = sum(h['pagamento'] for h in historico)
    data_quitacao = datetime.now() + timedelta(days=mes*30)
    
    print(f"⏱️  Tempo para quitar: {mes} meses ({mes/12:.1f} anos)")
    print(f"📅 Data estimada de quitação: {data_quitacao.strftime('%B/%Y')}")
    print(f"💰 Total que você vai pagar: R$ {total_pago:,.2f}")
    print(f"🔥 Total em juros: R$ {juros_total:,.2f}")
    print(f"📈 Juros representam: {(juros_total/divida_total)*100:.1f}% da dívida original")
    
    # Mostrar primeiros e últimos meses
    print("\n📆 EVOLUÇÃO:")
    print("-" * 60)
    print("Mês  | Juros        | Pagamento    | Saldo")
    print("-" * 60)
    
    for h in historico[:3]:
        print(f"{h['mes']:3d}  | R$ {h['juros']:>9,.2f} | R$ {h['pagamento']:>9,.2f} | R$ {h['saldo']:>10,.2f}")
    
    print("...")
    
    for h in historico[-3:]:
        print(f"{h['mes']:3d}  | R$ {h['juros']:>9,.2f} | R$ {h['pagamento']:>9,.2f} | R$ {h['saldo']:>10,.2f}")
    
    # Cenários alternativos
    print("\n" + "=" * 60)
    print("🎯 CENÁRIOS ALTERNATIVOS:")
    print("-" * 60)
    
    for aumento in [200, 500, 1000]:
        novo_pagamento = pagamento_mensal + aumento
        saldo_sim = divida_total
        mes_sim = 0
        juros_sim = 0
        
        while saldo_sim > 0:
            mes_sim += 1
            juros_mes = saldo_sim * (taxa_media_mensal / 100)
            juros_sim += juros_mes
            saldo_sim = saldo_sim + juros_mes - novo_pagamento
        
        economia = juros_total - juros_sim
        print(f"   +R$ {aumento}: Quita em {mes_sim} meses | Economiza R$ {economia:,.2f} em juros")

calculadora_quitacao()

"Olá, meu nome é [NOME] e tenho uma dívida de R$ [VALOR] com vocês.
Estou passando por dificuldades financeiras e gostaria de negociar.

Qual o melhor desconto que vocês podem oferecer para quitação à vista?
E para parcelamento em [X] vezes, qual seria o valor?"

def simular_portabilidade():
    """Simula economia com portabilidade de crédito"""
    
    divida = 20000
    parcelas_restantes = 24
    
    # Situação atual
    taxa_atual = 5  # 5% a.m.
    parcela_atual = 1400
    
    # Nova proposta
    taxa_nova = 2.5  # 2.5% a.m.
    
    print("=" * 60)
    print("🔄 SIMULAÇÃO DE PORTABILIDADE DE CRÉDITO")
    print("=" * 60)
    
    # Calcular total atual
    total_atual = parcela_atual * parcelas_restantes
    juros_atual = total_atual - divida
    
    print(f"\n📊 SITUAÇÃO ATUAL:")
    print(f"   Saldo devedor: R$ {divida:,.2f}")
    print(f"   Taxa: {taxa_atual}% a.m.")
    print(f"   Parcela: R$ {parcela_atual:,.2f}")
    print(f"   Parcelas restantes: {parcelas_restantes}")
    print(f"   Total a pagar: R$ {total_atual:,.2f}")
    
    # Calcular nova parcela (usando fórmula Price)
    taxa_nova_decimal = taxa_nova / 100
    parcela_nova = divida * (taxa_nova_decimal * (1 + taxa_nova_decimal)**parcelas_restantes) / \
                   ((1 + taxa_nova_decimal)**parcelas_restantes - 1)
    
    total_novo = parcela_nova * parcelas_restantes
    juros_novo = total_novo - divida
    economia = total_atual - total_novo
    
    print(f"\n📊 COM PORTABILIDADE:")
    print(f"   Nova taxa: {taxa_nova}% a.m.")
    print(f"   Nova parcela: R$ {parcela_nova:,.2f}")
    print(f"   Total a pagar: R$ {total_novo:,.2f}")
    
    print(f"\n💰 ECONOMIA:")
    print(f"   Na parcela: R$ {parcela_atual - parcela_nova:,.2f}/mês")
    print(f"   Total economizado: R$ {economia:,.2f}")
    print(f"   Redução de juros: {((juros_atual - juros_novo)/juros_atual)*100:.1f}%")

simular_portabilidade()

import requests

def comparar_divida_vs_investimento():
    """Compara custo da dívida vs rendimento de investimentos"""
    
    # Consultar taxa Selic
    try:
        response = requests.get("https://brapi.dev/api/v2/prime-rate")
        dados = response.json()
        selic_anual = dados['prime-rate'][0]['value']
    except:
        selic_anual = 13.25
    
    selic_mensal = ((1 + selic_anual/100) ** (1/12) - 1) * 100
    
    print("=" * 70)
    print("⚖️  DÍVIDA vs INVESTIMENTO: ONDE COLOCAR SEU DINHEIRO?")
    print("=" * 70)
    
    # Rendimentos de investimentos conservadores
    investimentos = [
        {"nome": "Poupança", "rendimento_anual": 6.17 + 0.5},  # TR + 0.5% a.m.
        {"nome": "Tesouro Selic", "rendimento_anual": selic_anual * 0.85},  # Selic - IR
        {"nome": "CDB 100% CDI", "rendimento_anual": selic_anual * 0.85},  # CDI - IR
        {"nome": "CDB 120% CDI", "rendimento_anual": selic_anual * 1.20 * 0.85},
    ]
    
    # Taxas de dívidas comuns
    dividas = [
        {"nome": "Cartão Rotativo", "taxa_mensal": 14, "cor": "🔴"},
        {"nome": "Cheque Especial", "taxa_mensal": 8, "cor": "🔴"},
        {"nome": "Empréstimo Pessoal", "taxa_mensal": 5, "cor": "🟡"},
        {"nome": "Consignado", "taxa_mensal": 2, "cor": "🟢"},
        {"nome": "Financiamento Imóvel", "taxa_mensal": 0.9, "cor": "🟢"},
    ]
    
    print(f"\n📈 Taxa Selic atual: {selic_anual}% a.a. ({selic_mensal:.2f}% a.m.)")
    
    print("\n📊 RENDIMENTO DOS INVESTIMENTOS (líquido de IR):")
    print("-" * 70)
    for inv in investimentos:
        rend_mensal = ((1 + inv['rendimento_anual']/100) ** (1/12) - 1) * 100
        print(f"   {inv['nome']:<20}: {inv['rendimento_anual']:.2f}% a.a. ({rend_mensal:.2f}% a.m.)")
    
    melhor_investimento = max(investimentos, key=lambda x: x['rendimento_anual'])
    melhor_rend_mensal = ((1 + melhor_investimento['rendimento_anual']/100) ** (1/12) - 1) * 100
    
    print("\n📊 CUSTO DAS DÍVIDAS:")
    print("-" * 70)
    
    for div in dividas:
        taxa_anual = ((1 + div['taxa_mensal']/100) ** 12 - 1) * 100
        diferenca = div['taxa_mensal'] - melhor_rend_mensal
        
        if diferenca > 0:
            recomendacao = "PAGUE A DÍVIDA"
        else:
            recomendacao = "PODE INVESTIR"
        
        print(f"   {div['cor']} {div['nome']:<20}: {div['taxa_mensal']:.1f}% a.m. ({taxa_anual:.0f}% a.a.) → {recomendacao}")
    
    print("\n" + "=" * 70)
    print("📋 RESUMO:")
    print(f"   Melhor investimento conservador: {melhor_investimento['nome']} ({melhor_rend_mensal:.2f}% a.m.)")
    print(f"\n   ✅ PAGUE PRIMEIRO dívidas com taxa > {melhor_rend_mensal:.2f}% a.m.")
    print(f"   💰 Após quitar dívidas caras, comece a investir!")

comparar_divida_vs_investimento()

import requests
from datetime import datetime

def criar_dashboard_evolucao():
    """Cria dashboard para acompanhar evolução financeira"""
    
    # Dados do usuário (exemplo)
    historico = {
        "inicio": {
            "data": "2024-01-01",
            "dividas": 50000,
            "reserva": 0,
            "investimentos": 0
        },
        "atual": {
            "data": datetime.now().strftime("%Y-%m-%d"),
            "dividas": 15000,
            "reserva": 8000,
            "investimentos": 2000
        }
    }
    
    # Consultar inflação para contexto
    try:
        response = requests.get("https://brapi.dev/api/v2/inflation")
        dados = response.json()
        inflacao = dados['inflation'][0]['value'] if 'inflation' in dados else 4.5
    except:
        inflacao = 4.5
    
    print("=" * 60)
    print("📊 DASHBOARD DE EVOLUÇÃO FINANCEIRA")
    print("=" * 60)
    print(f"Período: {historico['inicio']['data']} → {historico['atual']['data']}")
    print(f"Inflação (IPCA) no período: ~{inflacao}%")
    
    # Calcular progresso
    dividas_pagas = historico['inicio']['dividas'] - historico['atual']['dividas']
    patrimonio_atual = historico['atual']['reserva'] + historico['atual']['investimentos']
    
    print("\n📈 PROGRESSO:")
    print("-" * 60)
    print(f"💳 Dívidas pagas: R$ {dividas_pagas:,.2f} ({(dividas_pagas/historico['inicio']['dividas'])*100:.0f}%)")
    print(f"🏦 Reserva construída: R$ {historico['atual']['reserva']:,.2f}")
    print(f"📈 Investimentos: R$ {historico['atual']['investimentos']:,.2f}")
    print(f"💰 Patrimônio líquido: R$ {patrimonio_atual - historico['atual']['dividas']:,.2f}")
    
    # Status
    print("\n🎯 STATUS:")
    if historico['atual']['dividas'] > 0:
        print(f"   📋 Fase atual: QUITANDO DÍVIDAS")
        print(f"   🎯 Faltam: R$ {historico['atual']['dividas']:,.2f}")
    elif historico['atual']['reserva'] < 15000:  # Exemplo: 6 meses = R$15k
        print(f"   📋 Fase atual: CONSTRUINDO RESERVA")
        print(f"   🎯 Faltam: R$ {15000 - historico['atual']['reserva']:,.2f}")
    else:
        print(f"   📋 Fase atual: INVESTINDO")
        print(f"   🎯 Próximo objetivo: Definir metas de longo prazo")
    
    # Projeção
    velocidade_mensal = dividas_pagas / 12  # Supondo 12 meses
    if historico['atual']['dividas'] > 0:
        meses_restantes = historico['atual']['dividas'] / velocidade_mensal
        print(f"\n⏱️  Projeção: dívidas quitadas em ~{meses_restantes:.0f} meses")

criar_dashboard_evolucao()