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 um site onde coloquei esse algortimo explicado aqui 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.