Uma carteira de investimentos é algo que muitas pessoas tem, porém nem sempre sabem como organiza-lá de forma eficiente. Essa organização requer tempo, planejamento e compreensão das escolhas. Pensando nisso, esse artigo propõe uma ferramenta para auxiliar nessa organização e planejamento: O Python ! Por isso, esse post tem como objetivo ensinar você a como usar o python para otimizar seus investimentos. Este artigo tem fins estritamente educacionais de programação em Python e não constitui recomendação de investimento.

O que é uma carteira de investimentos ?

Uma carteira de investimentos é o conjunto de ativos financeiros que uma pessoa ou instituição possui, como ações, fundos imobiliários, renda fixa, criptomoedas ou outros instrumentos disponíveis no mercado. O objetivo de uma carteira não é apenas acumular ativos, mas organizar esses investimentos de forma estratégica, considerando fatores como perfil de risco, horizonte de tempo e objetivos financeiros. Ao combinar diferentes tipos de ativos, o investidor busca equilibrar segurança e rentabilidade, reduzindo a dependência de um único investimento ou classe de ativos.

Por que balancear uma carteira de investimentos é importante ?

Dentro desse contexto, surge a importância de balancear uma carteira de investimentos. Com o passar do tempo, os ativos não se valorizam ou desvalorizam de maneira uniforme. Alguns podem crescer rapidamente, enquanto outros permanecem estáveis ou até perdem valor. Esse movimento altera a proporção original da carteira, podendo aumentar o risco além do que o investidor está disposto a assumir ou afastá-lo de seus objetivos iniciais. O balanceamento consiste em ajustar periodicamente essas proporções, comprando ou vendendo ativos para que a carteira volte à alocação desejada, mantendo o nível de risco e a estratégia alinhados ao plano original.

Onde o python se encaixa nisso ?

É nesse ponto que o Python se torna uma ferramenta extremamente útil. Por ser uma linguagem versátil e acessível, o Python permite automatizar cálculos, analisar grandes volumes de dados e simular diferentes cenários de investimento com facilidade.

Com o auxílio de bibliotecas especializadas, é possível calcular retornos, volatilidade, correlação entre ativos e até sugerir novas alocações com base em critérios matemáticos e estatísticos. Dessa forma, o balanceamento da carteira deixa de ser um processo manual e sujeito a erros, passando a ser mais preciso, reproduzível e baseado em dados, o que ajuda o investidor a tomar decisões mais conscientes e eficientes. Gosta de python ? Veja também como buscar informações de um ativo na B3 usando Python.

Criando um algoritmo

A ideia do algoritmo é simular o balanceamento de uma carteira a partir de um novo aporte, respeitando limites máximos de alocação para cada ativo que também iremos definir. Para isso, iremos criar uma carteira definindo ativos e qual a portcentagens para cada deles. Os ativos serão:

• CDB
• Ações
• Fundos Imobiliários
• Criptomoedas

A partir daí, o gráfico abaixo apresenta a carteira de investimento com os ativos mencionados acima com sua respectiva porcentagem

Definido esses parâmetros temos todas as informações necessárias para criar o algoritmo. Para isso, vamos iniciar criando a função main do nosso programa.

    

def main():
    #Na lista de porcentagens segue a ordem CDB, Ações, FII's e Cripto
    porcentagens = [0.50, 0.30, 0.15, 0.05]
    valoresAtuais = [0, 0, 0, 0, 0]
    valorAporte = 2753   

main()
    
  

Na função main definimos os valores de cada ativo na variável porcentagens, o valor que já temos investidos fica armezanado na variável valoresAtuais, eu deixei zero pois estou considerando que não há nada investido ainda. Um ponto importante a se atentar aqui é que se houvesse 100 reais investidos em fundos imobiliários(FII’s), a lista deveria estar assim:

valoresAtuais = [0, 0, 0, 100, 0]

Isso porque a 4ª posição representa o ativo FII’s. Essas posições seguem as mesmas definidas na variável porcentagens.

Agora, iremos criar um método que recebe os parâmetros já definidos e calcula essa distribuição.

    

def distribuir_com_limite(valores, porcentagens, total):
    soma_existente = sum(valores)
    soma_final = soma_existente + total
    
    limites_absolutos = [p * soma_final for p in porcentagens]
    
    limites_disponiveis = [max(0, limite - atual) for limite, atual in zip(limites_absolutos, valores)]

    soma_disponivel = sum(limites_disponiveis)

    if total <= soma_disponivel:
        return [(disp / soma_disponivel) * total for disp in limites_disponiveis]
    else:
        return limites_disponiveis
    
  

A função distribuir_com_limite é responsável por decidir como o valor do aporte será distribuído entre os ativos da carteira, levando em conta os valores atuais, as porcentagens alvo e o valor total que será investido. A função recebe três parâmetros: valores, que representa quanto já está investido em cada ativo; porcentagens, que define a alocação ideal de cada ativo na carteira; e total, que é o valor do novo aporte a ser distribuído.

Logo no início da função, o código calcula quanto a carteira já possui e quanto ela terá após o aporte. O somatório é guardado nas variáveis soma_existente e soma_final. Essas duas variáveis são importantes porque o balanceamento é feito com base no valor total final da carteira, e não apenas no valor atual. Em seguida, o código transforma as porcentagens alvo em valores absolutos, ou seja, quanto cada ativo deveria ter em reais após o aporte.

Depois disso, o código calcula quanto ainda pode ser investido em cada ativo sem ultrapassar esse limite. Para isso, o zip percorre simultaneamente os limites calculados e os valores atuais. Se um ativo já estiver acima do limite desejado, o valor disponível para ele será zero. Caso contrário, será a diferença entre o limite e o valor atual. O próximo passo é somar todos esses espaços disponíveis para representar o quanto a carteira ainda pode receber de aporte sem quebrar as porcentagens alvo

Seguindo a lógica do método precisamos verificar se o aporte for menor ou igual ao espaço disponível, ele é distribuído proporcionalmente entre os ativos que ainda têm margem para crescer. Isso garante que nenhum ativo ultrapasse sua porcentagem máxima e que o balanceamento seja feito de forma equilibrada. Caso contrário, se o aporte for maior do que o espaço disponível, o código simplesmente preenche todos os limites possíveis. É importante lembrar que, nesse cenário, nem todo o aporte consegue ser alocado sem quebrar as regras da carteira, então a função retorna apenas o máximo que cada ativo pode receber.

Agora, precisamos voltar a função main e chamar essa outra função criada passando todos os parâmetros e criar também uma forma de mostrar essas informações para o usuário.

    


def distribuir_com_limite(valores, porcentagens, total):
    soma_existente = sum(valores)
    soma_final = soma_existente + total
    
    limites_absolutos = [p * soma_final for p in porcentagens]
    
    limites_disponiveis = [max(0, limite - atual) for limite, atual in zip(limites_absolutos, valores)]

    soma_disponivel = sum(limites_disponiveis)

    if total <= soma_disponivel:
        return [(disp / soma_disponivel) * total for disp in limites_disponiveis]
    else:
        return limites_disponiveis

def main():
    #Na lista de porcentagens segue a ordem CDB, Ações, FII's e Cripto
    porcentagens = [0.50, 0.30, 0.15, 0.05]
    valoresAtuais = [0, 0, 0, 0, 0]
    valorAporte = 2753   
    
    distribuicao = distribuir_com_limite(list(map(float, valoresAtuais)), porcentagens, valorAporte)
    novos_valores = [v + d for v, d in zip(list(map(float, valoresAtuais)), distribuicao)]
    total_novo = sum(novos_valores)
    
    print("Distribuição:", ', '.join(f"{v:.2f}" for v in distribuicao))
    print("Novos valores:", ', '.join(f"{v:.2f}" for v in novos_valores))
    print(f"Total final: {total_novo:.2f}")
    print("Porcentagens finais:", ', '.join(f"{(v / total_novo):.2f}" for v in novos_valores))

main()

    
  

Nessa última parte do código foi adicionado a chamada para a função que criamos na linha 25, contudo se atentando nas converções de valores para float para evitar problemas de tipo. Além disso, cada valor atual é somado à sua respectiva parcela do aporte, e o total final da carteira é recalculado. Por fim, o código exibe os quanto foi investido em cada ativo, os novos valores individuais, o total da carteira e as porcentagens finais após o balanceamento.

Ao final se exercutarmos esse código teremos uma saída como mostrado abaixo.

Distribuição: 1376.50, 825.90, 412.95, 137.65
Novos valores: 1376.50, 825.90, 412.95, 137.65
Total final: 2753.00
Porcentagens finais: 0.50, 0.30, 0.15, 0.05

Plataforma de balanceamento de carteira online

Pensando em facilitar para os estudantes de python como também os entusiastas do mercado financeiro, eu desenvolvi uma calculadora online e pode ser usado por qualquer pessoa gratuitamente. A aplicação permite que você insira o tipo de ativo, a porcentagem atual que possui alocada, quanto deseja ter e qual o valor de aporte. A partir disso, o site apresenta quanto deve ser alocado em cada investimento de maneira mais amigável. Confira esse site clicando no link.

Assista o vídeo com explicação passo a passo

Se ficou alguma dúvida, assista também o vídeo onde eu explico o que foi feito e a aplicação no mundo dos investimentos.