No mundo dos investimentos, informação é poder — mas velocidade e precisão podem ser ainda mais valiosas. É aqui que a programação entra como aliada estratégica. Enquanto planilhas e aplicativos prontos oferecem soluções genéricas, o código permite criar ferramentas sob medida para suas necessidades, integrando dados em tempo real, cálculos automáticos e visualizações personalizadas.

Neste artigo, vou mostrar como unir o universo dos investimentos à flexibilidade do Python, usando um Jupyter Notebook para gerenciar e acompanhar sua carteira de forma prática, automatizada e personalizável. Seja você iniciante ou experiente, vai perceber como alguns blocos de código podem transformar a maneira como você toma decisões financeiras.

Por que usar Python para investimentos?

No mercado financeiro, cada segundo conta — e cada decisão é tão boa quanto a informação que a sustenta. A maioria dos investidores começa com planilhas ou aplicativos prontos, mas logo percebe as limitações: dados desatualizados, pouca flexibilidade e dificuldade para testar novas estratégias. É nesse ponto que o Python se destaca.

Em resumo: usar Python para investimentos é como construir sua própria “central de comando” financeira, onde você controla cada detalhe e adapta tudo ao seu perfil e objetivos.

Agora que você já viu como o Python pode transformar a forma de acompanhar seus investimentos, é hora de colocar a mão na massa. Antes de abrir o editor de código, vamos garantir que você tenha as ferramentas certas instaladas.

Ferramentas necessárias

Para acompanhar este tutorial, você vai precisar de três elementos principais:

Com esse kit básico, você já estará pronto para construir seu primeiro sistema de acompanhamento de carteira — sem depender de planilhas engessadas ou aplicativos caros.

Estrutura do projeto

💡 Dica: Sempre verifique se o kernel selecionado é o mesmo onde você instalou as bibliotecas, para evitar erros como ModuleNotFoundError.

Passo a passo de implementação

1. Importando as bibliotecas

import pandas as pd
import seaborn as sns
import yfinance as yf
import matplotlib.pyplot as plt

2. Ocultando avisos (opcional)

import warnings
warnings.filterwarnings('ignore')

3. Criando a estrutura da carteira

assets = {
    'BTC': {'type': 'CRYPTO', 'shares': 1, 'value_invested': 1_000, 'currency': 'BRL'},
    'VOO': {'type': 'ETF', 'shares': 100, 'value_invested': 600, 'currency': 'USD'},
    'MXRF11': {'type': 'FII', 'shares': 1_000, 'value_invested': 1_200.8, 'currency': 'BRL'},
}

df = pd.DataFrame(assets).T.reset_index()

4. Distribuição por tipo de ativo

asset_type_counts = df['type'].value_counts()
plt.figure(figsize=(8, 5))
sns.barplot(x=asset_type_counts.index, y=asset_type_counts.values, palette='viridis')
plt.title('Distribuição por Tipo de Ativo')
plt.xlabel('Tipo de Ativo')
plt.ylabel('Quantidade')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

5. Conversão para BRL e composição da carteira

def convert_to_brl(value, currency):
    conversion_rates = {
        'BRL': 1,
        'USD': yf.download('USDBRL=X', period='1d', progress=False)['Close'].values[-1][0],
    }
    return value * conversion_rates.get(currency, 1)

df['value_invested_brl'] = df.apply(lambda row: convert_to_brl(row['value_invested'], row['currency']), axis=1)
total_value_invested_brl = df['value_invested_brl'].sum()

fig, axes = plt.subplots(1, 2, figsize=(14, 6))
grouped = df.groupby('type')['value_invested_brl'].sum()
axes[0].pie(grouped.values, labels=grouped.index, autopct='%1.1f%%', startangle=140, colors=sns.color_palette('Set2', n_colors=len(grouped)))
axes[0].set_title('Por Tipo de Ativo (BRL)')
axes[0].axis('equal')

axes[1].pie(df['value_invested_brl'], labels=df['index'], autopct='%1.1f%%', startangle=140, colors=sns.color_palette('Set3', n_colors=len(df)))
axes[1].set_title('Por Ativo (BRL)')
axes[1].axis('equal')

plt.tight_layout()
plt.show()

6. Cálculo de lucro/prejuízo

def get_crypto_value(symbol, shares):
    return yf.download(f'{symbol}-USD', period='1d', progress=False)['Close'].values[-1][0] * shares

def get_current_value(type, symbol, shares):
    usd_val = yf.download('USDBRL=X', period='1d', progress=False)['Close'].values[-1][0]
    if type == 'CRYPTO':
        return get_crypto_value(symbol, shares) * usd_val
    elif type in ('FII', 'STOCK'):
        return yf.download(symbol + '.SA', period='1d', progress=False)['Close'].values[-1][0] * shares
    elif type == 'ETF':
        return yf.download(symbol, period='1d', progress=False)['Close'].values[-1][0] * shares * usd_val

current_value_brl = {row['index']: get_current_value(row['type'], row['index'], row['shares']) for _, row in df.iterrows()}
df['current_value_brl'] = df['index'].map(current_value_brl)

df['profit_loss_brl'] = df['current_value_brl'] - df['value_invested_brl']

plt.figure(figsize=(12, 6))
sns.barplot(x=df['index'], y=df['profit_loss_brl'], palette='coolwarm')
plt.title('Lucro/Prejuízo por Ativo (BRL)')
plt.xlabel('Ativo')
plt.ylabel('Lucro/Prejuízo (BRL)')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Conclusão e próximos passos

Ao longo deste artigo, vimos como unir a versatilidade do Python com a praticidade do Jupyter Notebook para criar uma ferramenta personalizada de acompanhamento de investimentos. Esse tipo de solução coloca você no controle total dos dados, dos cálculos e das visualizações, permitindo que suas decisões financeiras se baseiem em informações precisas e atualizadas.

O mais interessante é que o que construímos aqui é apenas o ponto de partida. A partir dessa base, você pode:

• Adicionar mais métricas como volatilidade, drawdown ou índice de Sharpe
• Integrar com APIs de corretoras para atualização em tempo real
• Automatizar alertas para oportunidades ou riscos
• Criar dashboards interativos com Streamlit ou Dash

Lembre-se: a força de unir programação e investimentos está na personalização. Cada investidor tem objetivos, prazos e tolerância ao risco diferentes — e seu código pode (e deve) refletir isso.

Agora que você já tem as ferramentas, abra seu notebook, teste, experimente e adapte. Investir bem também é construir sistemas que funcionem para você — e o Python é a chave para isso.