Planejamento Financeiro Pessoal: Guia Completo 2026 para Organizar suas Finanças

1. Diagnóstico → Onde você está?
2. Orçamento → Para onde vai seu dinheiro?
3. Dívidas → Eliminar passivos
4. Reserva → Segurança básica
5. Metas → O que você quer?
6. Investimentos → Fazer o dinheiro trabalhar
7. Revisão → Ajustes constantes

Patrimônio Líquido = Ativos - Passivos

def calcular_patrimonio_liquido(ativos: dict, passivos: dict) -> dict:
    """
    Calcula patrimônio líquido e situação financeira
    """
    total_ativos = sum(ativos.values())
    total_passivos = sum(passivos.values())
    patrimonio = total_ativos - total_passivos
    
    # Determinar situação
    if patrimonio > total_ativos * 0.5:
        situacao = "Excelente"
        recomendacao = "Foque em investimentos e crescimento"
    elif patrimonio > 0:
        situacao = "Bom"
        recomendacao = "Monte reserva de emergência e comece a investir"
    elif patrimonio == 0:
        situacao = "Neutro"
        recomendacao = "Priorize quitar dívidas antes de investir"
    else:
        situacao = "Crítico"
        recomendacao = "Renegocie dívidas urgentemente"
    
    return {
        "total_ativos": total_ativos,
        "total_passivos": total_passivos,
        "patrimonio_liquido": patrimonio,
        "situacao": situacao,
        "recomendacao": recomendacao
    }

# Exemplo
ativos = {
    "conta_corrente": 2000,
    "poupanca": 5000,
    "investimentos": 15000,
    "carro": 30000
}

passivos = {
    "cartao": 1500,
    "financiamento_carro": 18000
}

resultado = calcular_patrimonio_liquido(ativos, passivos)

print(f"Total de ativos: R$ {resultado['total_ativos']:,.2f}")
print(f"Total de passivos: R$ {resultado['total_passivos']:,.2f}")
print(f"Patrimônio líquido: R$ {resultado['patrimonio_liquido']:,.2f}")
print(f"Situação: {resultado['situacao']}")
print(f"Recomendação: {resultado['recomendacao']}")

Renda: R$ 5.000

Alocações:
- Aluguel: R$ 1.200
- Alimentação: R$ 800
- Transporte: R$ 400
- Contas (luz, água, internet): R$ 300
- Saúde: R$ 200
- Lazer: R$ 500
- Streaming/Apps: R$ 100
- Roupas: R$ 200
- Reserva de emergência: R$ 500
- Investimentos: R$ 500
- Metas de curto prazo: R$ 300

Total alocado: R$ 5.000 (sobra R$ 0)

def criar_orcamento_503020(renda_mensal: float) -> dict:
    """
    Cria orçamento baseado na regra 50-30-20
    """
    necessidades = renda_mensal * 0.50
    desejos = renda_mensal * 0.30
    futuro = renda_mensal * 0.20
    
    # Sugestões detalhadas
    orcamento = {
        "renda_mensal": renda_mensal,
        "necessidades": {
            "total": necessidades,
            "sugestao": {
                "moradia": necessidades * 0.50,  # 25% da renda
                "alimentacao": necessidades * 0.24,  # 12% da renda
                "transporte": necessidades * 0.16,  # 8% da renda
                "contas_fixas": necessidades * 0.10,  # 5% da renda
            }
        },
        "desejos": {
            "total": desejos,
            "sugestao": {
                "lazer": desejos * 0.40,
                "streaming_apps": desejos * 0.13,
                "roupas_pessoais": desejos * 0.27,
                "outros": desejos * 0.20,
            }
        },
        "futuro": {
            "total": futuro,
            "sugestao": {
                "reserva_emergencia": futuro * 0.40,
                "investimentos": futuro * 0.40,
                "metas_curto_prazo": futuro * 0.20,
            }
        }
    }
    
    return orcamento

# Criar orçamento para renda de R$ 6.000
orcamento = criar_orcamento_503020(6000)

print("=" * 50)
print("ORÇAMENTO 50-30-20")
print("=" * 50)
print(f"Renda mensal: R$ {orcamento['renda_mensal']:,.2f}")

print("\n--- NECESSIDADES (50%) ---")
for item, valor in orcamento['necessidades']['sugestao'].items():
    print(f"  {item.replace('_', ' ').title()}: R$ {valor:,.2f}")

print("\n--- DESEJOS (30%) ---")
for item, valor in orcamento['desejos']['sugestao'].items():
    print(f"  {item.replace('_', ' ').title()}: R$ {valor:,.2f}")

print("\n--- FUTURO (20%) ---")
for item, valor in orcamento['futuro']['sugestao'].items():
    print(f"  {item.replace('_', ' ').title()}: R$ {valor:,.2f}")

1. Liste todas as dívidas (menor para maior)
2. Pague o mínimo em todas
3. Concentre sobra na menor
4. Quando quitar, passe para a próxima
5. Repita até zerar todas

1. Liste dívidas por taxa de juros (maior para menor)
2. Pague o mínimo em todas
3. Concentre sobra na de maior juros
4. Quando quitar, passe para a próxima
5. Repita até zerar todas

def calcular_quitacao_dividas(dividas: list, aporte_extra: float) -> list:
    """
    Calcula tempo para quitar dívidas usando método avalanche
    
    dividas: [{"nome": "Cartão", "saldo": 5000, "taxa": 0.12, "minimo": 150}]
    aporte_extra: valor mensal extra para pagamento
    """
    # Ordenar por taxa (maior primeiro - avalanche)
    dividas_ordenadas = sorted(dividas, key=lambda x: x["taxa"], reverse=True)
    
    resultados = []
    aporte_acumulado = aporte_extra
    
    for i, divida in enumerate(dividas_ordenadas):
        nome = divida["nome"]
        saldo = divida["saldo"]
        taxa = divida["taxa"]
        minimo = divida["minimo"]
        
        pagamento_total = minimo + (aporte_acumulado if i == 0 else 0)
        meses = 0
        saldo_atual = saldo
        juros_pagos = 0
        
        while saldo_atual > 0:
            juros_mes = saldo_atual * taxa
            juros_pagos += juros_mes
            saldo_atual = saldo_atual + juros_mes - pagamento_total
            meses += 1
            
            if meses > 360:  # Limite de 30 anos
                break
        
        resultados.append({
            "nome": nome,
            "saldo_original": saldo,
            "taxa_mensal": taxa * 100,
            "pagamento_mensal": pagamento_total,
            "meses_quitacao": meses,
            "juros_pagos": juros_pagos,
            "total_pago": saldo + juros_pagos
        })
        
        # Quando quitar, aporte vai para próxima dívida
        aporte_acumulado += minimo
    
    return resultados

# Exemplo
dividas = [
    {"nome": "Cartão de Crédito", "saldo": 5000, "taxa": 0.12, "minimo": 150},
    {"nome": "Empréstimo Pessoal", "saldo": 8000, "taxa": 0.04, "minimo": 300},
    {"nome": "Financiamento Carro", "saldo": 15000, "taxa": 0.015, "minimo": 500},
]

resultado = calcular_quitacao_dividas(dividas, 500)

print("PLANO DE QUITAÇÃO DE DÍVIDAS (Método Avalanche)")
print("=" * 60)
for r in resultado:
    print(f"\n{r['nome']}")
    print(f"  Saldo: R$ {r['saldo_original']:,.2f}")
    print(f"  Taxa: {r['taxa_mensal']:.1f}% a.m.")
    print(f"  Pagamento: R$ {r['pagamento_mensal']:,.2f}/mês")
    print(f"  Tempo: {r['meses_quitacao']} meses")
    print(f"  Juros pagos: R$ {r['juros_pagos']:,.2f}")

import requests

def calcular_reserva_emergencia(
    despesas_mensais: float,
    meses: int,
    token: str
) -> dict:
    """
    Calcula reserva de emergência e rendimento esperado
    """
    valor_reserva = despesas_mensais * meses
    
    # Buscar Selic atual
    url = "https://brapi.dev/api/v2/prime-rate"
    headers = {"Authorization": f"Bearer {token}"}
    
    try:
        response = requests.get(url, headers=headers)
        data = response.json()
        selic = data["prime-rate"][0]["value"]
    except:
        selic = 13.75  # Valor padrão se API falhar
    
    # Rendimento mensal no Tesouro Selic
    taxa_mensal = (1 + selic/100) ** (1/12) - 1
    rendimento_mensal = valor_reserva * taxa_mensal
    rendimento_anual = valor_reserva * (selic/100)
    
    return {
        "despesas_mensais": despesas_mensais,
        "meses_cobertura": meses,
        "valor_reserva": valor_reserva,
        "selic_atual": selic,
        "rendimento_mensal": rendimento_mensal,
        "rendimento_anual": rendimento_anual
    }

# Exemplo: despesas de R$ 4.000, reserva de 6 meses
reserva = calcular_reserva_emergencia(4000, 6, "SEU_TOKEN")

print("RESERVA DE EMERGÊNCIA")
print("=" * 40)
print(f"Despesas mensais: R$ {reserva['despesas_mensais']:,.2f}")
print(f"Cobertura: {reserva['meses_cobertura']} meses")
print(f"Valor necessário: R$ {reserva['valor_reserva']:,.2f}")
print(f"\nSelic atual: {reserva['selic_atual']}% a.a.")
print(f"Rendimento mensal: R$ {reserva['rendimento_mensal']:,.2f}")
print(f"Rendimento anual: R$ {reserva['rendimento_anual']:,.2f}")

import requests
from datetime import datetime

def calcular_meta_financeira(
    nome_meta: str,
    valor_meta: float,
    prazo_meses: int,
    valor_inicial: float = 0,
    token: str = None
) -> dict:
    """
    Calcula aporte mensal necessário para atingir meta
    """
    # Definir taxa baseada no prazo
    if prazo_meses <= 24:
        taxa_anual = 11.0  # CDI aproximado
        investimento = "Renda fixa (CDB, Tesouro Selic)"
    elif prazo_meses <= 60:
        taxa_anual = 12.0  # CDI + spread
        investimento = "Renda fixa (LCI/LCA, CDB)"
    else:
        taxa_anual = 10.0  # Conservador para RV
        investimento = "Renda variável (ações, FIIs, ETFs)"
    
    taxa_mensal = (1 + taxa_anual/100) ** (1/12) - 1
    
    # Valor futuro do aporte inicial
    vf_inicial = valor_inicial * ((1 + taxa_mensal) ** prazo_meses)
    
    # Valor que falta acumular
    valor_faltante = valor_meta - vf_inicial
    
    # Aporte mensal necessário (fórmula PMT)
    if taxa_mensal > 0:
        fator = ((1 + taxa_mensal) ** prazo_meses - 1) / taxa_mensal
        aporte_mensal = valor_faltante / fator
    else:
        aporte_mensal = valor_faltante / prazo_meses
    
    total_aportado = valor_inicial + (aporte_mensal * prazo_meses)
    rendimentos = valor_meta - total_aportado
    
    return {
        "nome": nome_meta,
        "valor_meta": valor_meta,
        "prazo_meses": prazo_meses,
        "prazo_anos": prazo_meses / 12,
        "valor_inicial": valor_inicial,
        "aporte_mensal": max(0, aporte_mensal),
        "total_aportado": total_aportado,
        "rendimentos": rendimentos,
        "taxa_anual": taxa_anual,
        "investimento_sugerido": investimento
    }

# Exemplo de metas
metas = [
    {"nome": "Viagem Europa", "valor": 20000, "prazo": 24, "inicial": 2000},
    {"nome": "Entrada Apartamento", "valor": 80000, "prazo": 48, "inicial": 10000},
    {"nome": "Aposentadoria", "valor": 1000000, "prazo": 240, "inicial": 50000},
]

print("PLANEJAMENTO DE METAS FINANCEIRAS")
print("=" * 60)

for meta in metas:
    resultado = calcular_meta_financeira(
        meta["nome"], meta["valor"], meta["prazo"], meta["inicial"]
    )
    
    print(f"\n{resultado['nome'].upper()}")
    print("-" * 40)
    print(f"Meta: R$ {resultado['valor_meta']:,.2f}")
    print(f"Prazo: {resultado['prazo_meses']} meses ({resultado['prazo_anos']:.1f} anos)")
    print(f"Valor inicial: R$ {resultado['valor_inicial']:,.2f}")
    print(f"Aporte mensal: R$ {resultado['aporte_mensal']:,.2f}")
    print(f"Rendimentos estimados: R$ {resultado['rendimentos']:,.2f}")
    print(f"Investimento: {resultado['investimento_sugerido']}")

                    /\
                   /  \
                  / RV \     <- Alto risco, alto retorno (ações, cripto)
                 /______\
                /        \
               / Renda    \   <- Médio risco (FIIs, ETFs, debêntures)
              / Variável   \
             /______________\
            /                \
           /   Renda Fixa     \  <- Baixo risco (CDB, Tesouro, LCI)
          /____________________\
         /                      \
        /  Reserva de Emergência \ <- Segurança (Tesouro Selic)
       /__________________________\

import requests

def acompanhar_carteira(
    ativos: dict,
    token: str
) -> dict:
    """
    Acompanha carteira de investimentos em tempo real
    
    ativos: {"PETR4": 100, "VALE3": 50, "BOVA11": 20}  # ticker: quantidade
    """
    tickers = list(ativos.keys())
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    carteira = []
    total = 0
    
    for resultado in data["results"]:
        ticker = resultado["symbol"]
        preco = resultado["regularMarketPrice"]
        variacao = resultado.get("regularMarketChangePercent", 0)
        quantidade = ativos[ticker]
        valor = preco * quantidade
        total += valor
        
        carteira.append({
            "ticker": ticker,
            "quantidade": quantidade,
            "preco": preco,
            "valor": valor,
            "variacao": variacao
        })
    
    # Calcular percentuais
    for ativo in carteira:
        ativo["percentual"] = (ativo["valor"] / total) * 100
    
    return {
        "carteira": carteira,
        "total": total
    }

# Exemplo de carteira
minha_carteira = {
    "BOVA11": 50,    # 50 cotas de ETF Ibovespa
    "IVVB11": 30,    # 30 cotas de ETF S&P 500
    "XPLG11": 100,   # 100 cotas de FII logística
}

resultado = acompanhar_carteira(minha_carteira, "SEU_TOKEN")

print("MINHA CARTEIRA DE INVESTIMENTOS")
print("=" * 60)
print(f"{'Ativo':<10} {'Qtd':<8} {'Preço':<12} {'Valor':<15} {'%':<8}")
print("-" * 60)

for ativo in resultado["carteira"]:
    print(f"{ativo['ticker']:<10} {ativo['quantidade']:<8} "
          f"R$ {ativo['preco']:<9.2f} R$ {ativo['valor']:<12,.2f} "
          f"{ativo['percentual']:.1f}%")

print("-" * 60)
print(f"{'TOTAL':<10} {'':<8} {'':<12} R$ {resultado['total']:,.2f}")

=== ABA: RECEITAS ===
| Data | Descrição | Valor | Categoria |

=== ABA: DESPESAS ===
| Data | Descrição | Valor | Categoria | Forma Pgto |

=== ABA: RESUMO MENSAL ===
| Mês | Receita | Despesa | Saldo | Investido |

=== ABA: PATRIMÔNIO ===
| Tipo | Descrição | Valor | Atualização |