Solucionado (ver solução)
Solucionado
(ver solução)
4
respostas

[Sugestão] Estranhei o tempo de carregamento de Excel no Python — encontrei uma alternativa performática

Olá pessoal,

Como alguém com experiência prévia em R, estou bastante acostumado com a velocidade de carregamento de arquivos .xlsx através do pacote readxl. Recentemente, ao trabalhar com um arquivo grande no Python (pandas.read_excel), estranhei o tempo consideravelmente maior para leitura do mesmo tipo de arquivo:

import pandas as pd
import time

t0 = time.perf_counter()

emissoes_gases = pd.read_excel(
        "dados/1-SEEG10_GERAL-BR_UF_2022.10.27-FINAL-SITE.xlsx",
        sheet_name="GEE Estados"
)

t1 = time.perf_counter()

elapsed = t1 - t0

print(f"Tempo total: {elapsed:.3f} s")

Tempo com pandas.read_excel (engine padrão):

$ python teste.py
Tempo total: 42.017 s

Enquanto no R, usando readxl, o mesmo arquivo foi carregado bem mais rápido:

library(readxl)

t0_carga <- Sys.time()

emissoes_gases <- 
  read_excel("dados/1-SEEG10_GERAL-BR_UF_2022.10.27-FINAL-SITE.xlsx",
             sheet = "GEE Estados")

t1_carga <- Sys.time()

tempo_total_carga <- t1_carga - t0_carga

print(tempo_total_carga)
$ Rscript teste.R
Time difference of 5.053 secs

Isso me chamou atenção, já que vinha de um ambiente mais rápido nesse aspecto. Porém, isso me motivou a investigar alternativas dentro do ecossistema Python — e encontrei uma solução.

A alternativa performática: calamine

Instalei a biblioteca python-calamine, que é uma interface Python para o motor Rust calamine, usado para ler planilhas de forma muito eficiente.

Basta especificar o parâmetro engine="calamine" na função pd.read_excel():

# Instalei primeiro:
pip install python-calamine
import pandas as pd
import time

t0 = time.perf_counter()

emissoes_gases = pd.read_excel(
    "dados/1-SEEG10_GERAL-BR_UF_2022.10.27-FINAL-SITE.xlsx",
    sheet_name="GEE Estados",
    engine="calamine"
)

t1 = time.perf_counter()

print(f"Tempo total: {t1 - t0:.3f} s")

Resultado final:

$ python teste_calamine.py
Tempo total: 7.176 s

Agora o desempenho ficou bem próximo do que eu via no R, o que ajuda a manter a produtividade dentro do Python.

Considerações

O objetivo dessa postagem não é dizer que o R é melhor que o Python, ou vice-versa, mas sim compartilhar minha experiência inicial e uma solução prática que pode ser útil para quem também lida com grandes planilhas Excel no dia a dia.

4 respostas

Olá, Carlos! Como vai?

A sua observação é bem interessante!

De fato o tempo de carregamento de arquivos Excel no Python pode divergir comparado ao R. Por padrão, o pandas.read_excel pode ser mais lento em alguns casos devido ao motor de leitura utilizado, especialmente para arquivos grandes. Sua solução de usar o calamine é uma excelente alternativa para melhorar a performance no Python.

Também é pertinente considerar outras opções para lidar com arquivos grandes, como converter um arquivo Excel para um formato CSV antes de carregá-lo, o CSV geralmente é mais rápido de ser lido pelo Pandas.

Fico à disposição! E se precisar, conte sempre com o apoio do fórum.

Abraço e bons estudos!

AluraConte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!

Olá, Daniel. Obrigado pela resposta!

Sua sugestão de converter arquivos Excel para CSV também faz bastante sentido, especialmente por ser um formato mais leve e rápido de ler. Gostaria de aproveitar para perguntar:

Você recomenda alguma ferramenta ou biblioteca específica para fazer essa conversão de forma prática e confiável?Por exemplo:

  • Algum pacote Python?
  • Ferramentas externas?
  • Outras formatos além do CSV?

Estou curioso para conhecer boas práticas nesse fluxo de trabalho.

solução!

Boa pergunta, Carlos!

De forma prática, no próprio Excel você pode salvar o arquivo no formato CSV. Vá em Arquivo > Salvar como > Escolha a opção CSV

Captura de tela da caixa de diálogo "Salvar como" do Excel, exibindo várias opções de formato de arquivo, incluindo pasta de trabalho do Excel e CSV (delimitado por vírgulas).

Pronto! O arquivo CSV estará disponível no local escolhido:

Captura de tela da pasta Downloads de um computador exibindo dois arquivos do Excel rotulados "produtos_petsho" e "excel 2007".

E também podemos usar o Pandas para a conversão, dessa maneira:

import pandas as pd

# Lê o arquivo Excel
df = pd.read_excel("arquivo.xlsx")

# Salva como CSV
df.to_csv("arquivo_convertido.csv", index=False)

Sobre outro formato, um bem conhecido é o formato JSON. Ele é mais recomendado quando temos dados aninhados ou estruturados, algumas vantagens:

  • Muito usado em leitura por APIs
  • Compatível com a Web

Espero ter ajudado e fico à disposição se precisar.

Caso este post tenha lhe ajudado, por favor, marcar como solucionado

Olá, Daniel.

Muito obrigado pela resposta detalhada e pelas dicas práticas tanto sobre salvar como CSV diretamente no Excel quanto sobre usar o Pandas para automatizar esse processo.

Referência técnica

Para complementar a discussão, encontrei um estudo bem interessante comparando diversos formatos de armazenamento de dados em termos de desempenho (tempo de leitura/escrita), tamanho do arquivo e adequação ao uso em análise de dados:

Comparative Study Among CSV, Feather, Pickle, Parquet...

Esse artigo compara formatos como CSV, Feather, Pickle, Parquet, com bons exemplos de quando cada um pode ser mais indicado. Recomendo a leitura para quem quer otimizar o fluxo de trabalho com grandes volumes de dados.

Exemplos práticos dos formatos

Baseado nesse estudo, seguem alguns exemplos rápidos de como usar os formatos mais performáticos no Pandas:

1. Parquet

Formato binário eficiente, ideal para grandes volumes de dados e análise por colunas.

# Salvando
df.to_parquet("dados.parquet")

# Lendo
df = pd.read_parquet("dados.parquet")

2. Feather

Muito rápido e compatível entre R e Python — ótimo para uso interno ou compartilhamento rápido.

# Salvando
df.to_feather("dados.feather")

# Lendo
df = pd.read_feather("dados.feather")

3. Pickle

Útil para serialização rápida de objetos pandas.

# Salvando
df.to_pickle("dados.pkl")

# Lendo
df = pd.read_pickle("dados.pkl")

Abraço