Calcular Retornos de Ações com Python: Guia Prático

No mundo das finanças quantitativas, calcular o retorno de um ativo é a tarefa mais fundamental. É o primeiro bloco de construção para qualquer estratégia de backtesting, análise de risco ou otimização de portfólio. Sem entender o retorno, estamos navegando no escuro.

Felizmente, o ecossistema Python moderno torna essa tarefa incrivelmente simples.

No Qoda Labs, nosso foco é aplicar a ciência de dados ao mercado financeiro. Hoje, vamos cobrir o essencial: como buscar dados de preços e calcular retornos diários e acumulados.

Neste guia, você aprenderá:

• Como obter dados históricos de ações com a biblioteca yfinance.
• Como calcular retornos diários usando o método pct_change() do Pandas.
• Como calcular e interpretar retornos acumulados com cumprod().
• Como escalar essa análise para múltiplas ações de uma só vez.

Vamos começar.

Configuração de ambiente

Primeiro, precisamos das ferramentas certas. Para este tutorial, usaremos três bibliotecas principais:

1. yfinance – para baixar dados históricos de preços do Yahoo Finance.
2. pandas – principal biblioteca para análise de dados em python.
3. matplotlib – ferramenta para visualização de dados (gráficos).

Para instalar as bibliotecas, rode o seguinte comando:

pip install finance pandas matplotlib

Agora, vamos importá-las em nosso script ou Notebook:

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

# Configuração para melhor visualização dos gráficos no notebook (opcional)
%matplotlib inline
plt.style.use('seaborn-v0_8-darkgrid')

Retorno de uma ação

Vamos começar com um único ativo para entender a lógica. Usaremos uma das ações mais conhecidas da B3, o Banco do Brasil (BBAS3).

Usamos o yfinance para baixar os dados. Vamos pegar os dados dos últimos 5 anos.

Importante: Para ações da B3 (Bolsa de Valores brasileira), o Yahoo Finance exige que adicionemos o sufixo .SA ao ticker.

# Definir o ticker e o período
# Note o '.SA' para ações listadas em São Paulo (B3)
ticker = 'BBAS3.SA'
start_date = '2020-01-01'
end_date = '2024-12-31'

# Baixar os dados
acao = yf.download(ticker, start=start_date, end=end_date)

acao.head()

Output:

Nota Importante: Sempre usaremos a coluna Close (Preço de Fechamento). Ela ajusta o preço para eventos corporativos como dividendos e desdobramentos (splits), dando uma medida muito mais precisa do retorno real do investidor.

Calculando Retornos Diários

O retorno diário é simplesmente a variação percentual do preço de um dia para o outro.

A fórmula é: 

Com o Pandas, isso é trivial usando o método .pct_change():

# Calcular o retorno diário sobre o 'Close'
acao['retorno_diario'] = acao['Close'].pct_change()

# Exibir os primeiros registros com o retorno
# Note que o primeiro valor será 'NaN' (Not a Number) pois não há dia anterior para comparar
acao.head()

Output:

Calculando Retornos Acumulados

O retorno diário é útil, mas muitas vezes queremos saber: “Quanto R$ 1,00 investido no início do período valeria hoje?”. Isso é o retorno acumulado.

Não podemos simplesmente somar os retornos diários. Em vez disso, devemos “compor” os retornos (produto cumulativo).

# Primeiro, limpamos o valor NaN para evitar erros (podemos preencher com 0)
# Isso não afeta o cálculo pois (1+0) * ... não muda o resultado.
acao['retorno_diario'] = acao['retorno_diario'].fillna(0)

# Calcular o retorno acumulado
# Adicionamos 1 para refletir o principal (R$ 1,00) antes de calcular o produto
acao['retorno_acumulado'] = (1 + acao['retorno_diario']).cumprod()

acao.tail()

Output:

Teste com Múltiplas Ações

O verdadeiro poder do Pandas brilha quando escalamos. Vamos agora fazer o mesmo cálculo para um portfólio de blue chips brasileiras: Banco do Brasil (BBAS3.SA), Vale (VALE3.SA), Petrobras (PETR4.SA) e Itaú Unibanco (ITUB4.SA).

A biblioteca yfinance aceita uma lista de tickers diretamente.

# Lista de tickers da B3
tickers = ['BBAS3.SA', 'VALE3.SA', 'PETR4.SA', 'ITUB4.SA']
start_date = '2020-01-01'

# Baixar dados
dados_multiplos = yf.download(tickers, start=start_date)

dados_multiplos.head()

O resultado é um DataFrame com MultiIndex (colunas agrupadas). Para nossos cálculos, só nos interessa o Close.

# Vamos isolar apenas os preços de fechamento ajustados
precos_adj = dados_multiplos['Close']

precos_adj.head()

Output:

Calculando Retornos Diários (para todos)

Aqui está a mágica do Pandas: podemos aplicar o .pct_change() diretamente ao DataFrame inteiro. Ele calculará o retorno para cada coluna (cada ação) de uma só vez.

# Calcular retornos diários para todas as ações
retornos_diarios_multiplos = precos_adj.pct_change()

retornos_diarios_multiplos.head()

Output:

Calculando Retornos Acumulados (para todos)

A mesma lógica se aplica. Adicionamos 1 e usamos .cumprod().

# Calcular retornos acumulados
retornos_acumulados_multiplos = (1 + retornos_diarios_multiplos.fillna(0)).cumprod()

retornos_acumulados_multiplos.tail()

Output:

Agora temos uma tabela limpa mostrando o crescimento de R$ 1,00 em cada um desses ativos desde o início de 2020.

Visualizando os Resultados

Dados são ótimos, mas gráficos contam a história. Vamos plotar os retornos acumulados que acabamos de calcular para ver qual ação teve o melhor desempenho.

# Plotar os retornos acumulados
retornos_acumulados_multiplos.plot(figsize=(12, 7),
                                   title='Retorno Acumulado de Ações Brasileiras (Desde 2020)')

# Configurar labels
plt.xlabel('Data')
plt.ylabel('Crescimento de R$ 1,00')
plt.legend(title='Ticker')

# Mostrar o gráfico
plt.show()

Output:

(Resultado esperado: um gráfico mostrando as linhas de BBAS3.SA, VALE3.SA, PETR4.SA e ITUB4.SA divergindo ao longo do tempo.)

Com esta visualização, podemos ver instantaneamente como cada ativo se comportou e qual teria dado o maior retorno no período analisado.

Conclusão: O Ponto de Partida

Vimos como usar Python, yfinance e pandas para mover da obtenção de dados brutos de ações da B3 para uma análise de desempenho comparativa em poucas linhas de código. Aprendemos a importância do Close, a simplicidade do .pct_change() e o poder do .cumprod().

Este é o alicerce. A partir daqui, o Qoda Labs irá explorar como usar esses retornos para calcular métricas de risco (como volatilidade e Índice de Sharpe), testar estratégias de investimento (backtesting) e construir portfólios otimizados.

Código-Fonte no GitHub

Para facilitar seus estudos, todo o código-fonte utilizado neste tutorial, incluindo um Notebook Jupyter (.ipynb) pronto para ser executado, está disponível no repositório oficial do Qoda Labs.

Sinta-se à vontade para clonar, testar e adaptar!

Link do Repositório: https://github.com/QodaLabs/calculando_retornos_python