Pandas Read Excel: Como importar arquivos Excel em Python

Name

Soren Atelier

Updated on 09/02/2026

Arquivos Excel continuam sendo o formato mais comum para armazenar dados tabulares em ambientes corporativos, mas importá-los para Python para análise frequentemente cria fricção. Você precisa lidar com múltiplas planilhas, tipos de dados inconsistentes, valores ausentes e restrições de memória, tudo isso mantendo a integridade dos dados. A função read_excel() do pandas resolve esses desafios, mas apenas se você souber como configurar corretamente seus mais de 30 parâmetros.

Este guia mostra como importar arquivos Excel em pandas DataFrames de forma eficiente, desde importações básicas de uma única planilha até cenários avançados como ler múltiplas planilhas simultaneamente, lidar com arquivos grandes e solucionar erros comuns.

Uso básico de pandas read_excel()

A maneira mais simples de ler um arquivo Excel em um pandas DataFrame requer apenas o caminho do arquivo:

import pandas as pd
 
# Ler a primeira planilha de um arquivo Excel
df = pd.read_excel('data.xlsx')
print(df.head())

Isso lê a primeira planilha por padrão, tratando a primeira linha como cabeçalhos de coluna. A função detecta automaticamente o formato do arquivo (.xlsx ou .xls) e usa o motor apropriado.

Para arquivos em diretórios diferentes, use caminhos absolutos ou relativos:

# Caminho absoluto
df = pd.read_excel('/Users/username/Documents/sales_data.xlsx')
 
# Caminho relativo
df = pd.read_excel('../data/sales_data.xlsx')

Entendendo os parâmetros-chave

A função read_excel() fornece controle extensivo sobre como os dados são importados. Aqui está uma tabela de referência dos parâmetros mais importantes:

Trabalhando com múltiplas planilhas

Lendo uma planilha específica

Especifique planilhas por nome ou índice (base 0):

# Ler por nome da planilha
df = pd.read_excel('financial_report.xlsx', sheet_name='Q1 Revenue')
 
# Ler por índice (0 = primeira planilha)
df = pd.read_excel('financial_report.xlsx', sheet_name=0)

Lendo múltiplas planilhas de uma vez

Passe uma lista de nomes de planilhas ou índices para importar múltiplas planilhas em um dicionário de DataFrames:

# Ler múltiplas planilhas específicas
sheets_dict = pd.read_excel('annual_report.xlsx',
                            sheet_name=['Q1', 'Q2', 'Q3', 'Q4'])
 
# Acessar DataFrames individuais
q1_df = sheets_dict['Q1']
q2_df = sheets_dict['Q2']
 
print(f"Q1 shape: {q1_df.shape}")
print(f"Q2 shape: {q2_df.shape}")

Lendo todas as planilhas

Use sheet_name=None para importar cada planilha na pasta de trabalho:

# Ler todas as planilhas em um dicionário
all_sheets = pd.read_excel('company_data.xlsx', sheet_name=None)
 
# Iterar através de todas as planilhas
for sheet_name, df in all_sheets.items():
    print(f"\nSheet: {sheet_name}")
    print(f"Shape: {df.shape}")
    print(f"Columns: {df.columns.tolist()}")

Isso é particularmente útil quando você precisa processar múltiplas planilhas com estruturas semelhantes:

# Combinar todas as planilhas em um único DataFrame
all_sheets = pd.read_excel('monthly_sales.xlsx', sheet_name=None)
combined_df = pd.concat(all_sheets.values(), ignore_index=True)
print(f"Combined shape: {combined_df.shape}")

Controlando importação de dados com cabeçalhos e colunas

Especificando linhas de cabeçalho

Controle qual linha se torna os nomes das colunas:

# Pular primeiras 2 linhas, usar linha 3 como cabeçalho
df = pd.read_excel('data.xlsx', header=2)
 
# Sem linha de cabeçalho - pandas atribui nomes de colunas numéricos
df = pd.read_excel('data.xlsx', header=None)
 
# Cabeçalhos de colunas multinível
df = pd.read_excel('data.xlsx', header=[0, 1])

Pulando linhas

Remova linhas indesejadas do topo do arquivo:

# Pular primeiras 3 linhas
df = pd.read_excel('data.xlsx', skiprows=3)
 
# Pular linhas específicas (indexadas a partir de 0)
df = pd.read_excel('data.xlsx', skiprows=[0, 2, 5])
 
# Pular linhas usando uma função
df = pd.read_excel('data.xlsx', skiprows=lambda x: x % 2 == 0)  # Pular linhas pares

Selecionando colunas específicas

Importe apenas as colunas necessárias para reduzir o uso de memória:

# Selecionar colunas por intervalo de letras
df = pd.read_excel('data.xlsx', usecols='A:D')
 
# Selecionar colunas específicas por letra
df = pd.read_excel('data.xlsx', usecols='A,C,E,G')
 
# Selecionar colunas por índice
df = pd.read_excel('data.xlsx', usecols=[0, 2, 4, 6])
 
# Selecionar colunas por nome
df = pd.read_excel('data.xlsx', usecols=['Name', 'Age', 'Salary'])
 
# Selecionar colunas usando uma função
df = pd.read_excel('data.xlsx', usecols=lambda x: 'total' in x.lower())

Especificação e conversão de tipos de dados

Definindo tipos de dados de colunas

Defina tipos de dados explicitamente para evitar erros de inferência automática:

# Especificar dtypes para múltiplas colunas
df = pd.read_excel('customer_data.xlsx',
                   dtype={
                       'CustomerID': str,
                       'ZipCode': str,
                       'Age': int,
                       'Revenue': float
                   })
 
# Manter IDs numéricos como strings para preservar zeros à esquerda
df = pd.read_excel('products.xlsx', dtype={'ProductID': str})

Manipulando datas

Analise colunas de data automaticamente:

# Analisar coluna de data única
df = pd.read_excel('orders.xlsx', parse_dates=['OrderDate'])
 
# Analisar múltiplas colunas de data
df = pd.read_excel('employee_data.xlsx',
                   parse_dates=['HireDate', 'TerminationDate'])
 
# Combinar colunas em um único datetime
df = pd.read_excel('logs.xlsx',
                   parse_dates={'DateTime': ['Date', 'Time']})
 
# Verificar o resultado
print(df.dtypes)

Gerenciando valores ausentes

Controle como pandas identifica e lida com dados ausentes:

# Reconhecer indicadores personalizados de valores ausentes
df = pd.read_excel('survey_data.xlsx',
                   na_values=['NA', 'N/A', 'null', 'None', '-'])
 
# Valores NA diferentes por coluna
df = pd.read_excel('mixed_data.xlsx',
                   na_values={
                       'Age': ['Unknown', 'N/A'],
                       'Salary': [0, -1, 'Not Disclosed']
                   })
 
# Manter valores NA padrão e adicionar mais
df = pd.read_excel('data.xlsx',
                   na_values=['Missing'],
                   keep_default_na=True)

Manipulando arquivos Excel grandes

Arquivos Excel consomem memória significativa quando carregados inteiramente na RAM. Use estas estratégias para grandes conjuntos de dados:

Limitando linhas

Leia apenas as linhas necessárias:

# Ler primeiras 10.000 linhas
df = pd.read_excel('large_file.xlsx', nrows=10000)
 
# Ler intervalo específico de linhas usando skiprows e nrows
df = pd.read_excel('large_file.xlsx', skiprows=1000, nrows=5000)

Usando conversores para eficiência de memória

Aplique transformações durante a importação para reduzir a pegada de memória:

# Converter colunas durante a leitura
def categorize_status(value):
    return 'Active' if value == 1 else 'Inactive'
 
df = pd.read_excel('users.xlsx',
                   converters={
                       'Status': categorize_status,
                       'Category': lambda x: x.lower().strip()
                   })

Processando planilhas iterativamente

Para pastas de trabalho com múltiplas planilhas grandes, processe uma planilha de cada vez:

import pandas as pd
 
# Obter todos os nomes de planilhas primeiro
xls = pd.ExcelFile('massive_workbook.xlsx')
sheet_names = xls.sheet_names
 
# Processar cada planilha separadamente
for sheet in sheet_names:
    df = pd.read_excel(xls, sheet_name=sheet, nrows=10000)
    # Processar df aqui
    result = df.describe()
    print(f"\n{sheet} Summary:\n{result}")

Alternativa: Usando openpyxl para streaming

Para arquivos extremamente grandes, considere ler linha por linha com openpyxl:

from openpyxl import load_workbook
 
# Carregar pasta de trabalho em modo somente leitura
wb = load_workbook('huge_file.xlsx', read_only=True)
ws = wb['Sheet1']
 
# Processar linhas iterativamente
data = []
for row in ws.iter_rows(min_row=2, max_row=1000, values_only=True):
    data.append(row)
 
# Converter para DataFrame
df = pd.DataFrame(data, columns=['Col1', 'Col2', 'Col3'])
wb.close()

Entendendo os motores Excel

Pandas usa diferentes bibliotecas para ler arquivos Excel dependendo do formato e pacotes instalados:

Especifique o motor explicitamente:

# Forçar motor openpyxl
df = pd.read_excel('data.xlsx', engine='openpyxl')
 
# Ler arquivo .xls legado
df = pd.read_excel('old_data.xls', engine='xlrd')
 
# Ler arquivo Excel binário
df = pd.read_excel('data.xlsb', engine='pyxlsb')

Pandas read_excel vs read_csv: Diferenças principais

Embora ambas as funções criem DataFrames, elas têm diferenças importantes:

Recomendação: Use read_csv() para processamento de dados em grande escala e read_excel() quando precisar trabalhar com pastas de trabalho Excel existentes ou múltiplas planilhas.

Visualize dados Excel instantaneamente com PyGWalker

Após importar dados Excel com pandas, você frequentemente precisa explorá-los visualmente. PyGWalker (opens in a new tab) transforma seu DataFrame em uma interface de visualização interativa semelhante ao Tableau diretamente em seu notebook Jupyter, sem necessidade de escrever código de plotagem.

import pandas as pd
import pygwalker as pyg
 
# Ler dados Excel
df = pd.read_excel('sales_data.xlsx')
 
# Iniciar visualização interativa
pyg.walk(df)

Isso abre uma interface de arrastar e soltar onde você pode:

• Criar gráficos arrastando colunas para canais visuais
• Alternar entre tipos de gráficos (barras, linha, dispersão, mapa de calor) instantaneamente
• Aplicar filtros e agregações interativamente
• Exportar visualizações como imagens ou código

PyGWalker é particularmente útil para análise exploratória de dados após importar arquivos Excel, permitindo entender distribuições de dados e relacionamentos sem escrever código matplotlib ou seaborn.

Erros comuns e solução de problemas

ModuleNotFoundError: No module named 'openpyxl'

Este é o erro mais comum ao ler arquivos .xlsx:

ImportError: Missing optional dependency 'openpyxl'. Use pip or conda to install openpyxl.

Solução: Instale o motor necessário:

# Instalar openpyxl
pip install openpyxl
 
# Ou instalar todas as dependências Excel
pip install pandas[excel]

XLRDError: Excel xlsx file; not supported

Se você ver este erro, xlrd está tentando ler um arquivo .xlsx (suporta apenas .xls desde a versão 2.0):

Solução: Instale openpyxl ou especifique o motor:

df = pd.read_excel('data.xlsx', engine='openpyxl')

FileNotFoundError

Verifique seu caminho de arquivo e diretório de trabalho:

import os
 
# Imprimir diretório atual
print(os.getcwd())
 
# Listar arquivos no diretório
print(os.listdir('.'))
 
# Usar caminho absoluto
df = pd.read_excel('/absolute/path/to/file.xlsx')

Erros de memória com arquivos grandes

Se pandas travar com erros de memória:

# Reduzir memória selecionando colunas
df = pd.read_excel('large_file.xlsx', usecols=['A', 'B', 'C'])
 
# Limitar linhas
df = pd.read_excel('large_file.xlsx', nrows=50000)
 
# Especificar dtypes para reduzir memória
df = pd.read_excel('large_file.xlsx',
                   dtype={'ID': 'int32', 'Category': 'category'})

ValueError: Excel file format cannot be determined

Isso ocorre quando a extensão do arquivo não corresponde ao formato real:

Solução: Especifique o motor explicitamente ou renomeie o arquivo com a extensão correta:

# Tentar diferentes motores
df = pd.read_excel('data.xlsx', engine='openpyxl')

Problemas de análise de datas

Excel armazena datas como números de série. Se as datas não forem analisadas corretamente:

# Forçar análise de datas
df = pd.read_excel('data.xlsx', parse_dates=['DateColumn'])
 
# Conversão manual
df['DateColumn'] = pd.to_datetime(df['DateColumn'])

Técnicas avançadas

Lendo arquivos protegidos por senha

Embora pandas não suporte arquivos protegidos por senha diretamente, use msoffcrypto-tool:

import msoffcrypto
import io
import pandas as pd
 
# Descriptografar o arquivo
decrypted = io.BytesIO()
with open('protected.xlsx', 'rb') as f:
    file = msoffcrypto.OfficeFile(f)
    file.load_key(password='yourpassword')
    file.decrypt(decrypted)
 
# Ler o arquivo descriptografado
df = pd.read_excel(decrypted)

Combinando read_excel com gerenciadores de contexto

Para melhor gerenciamento de recursos:

from contextlib import closing
import pandas as pd
 
with closing(pd.ExcelFile('data.xlsx')) as xls:
    df1 = pd.read_excel(xls, sheet_name='Sheet1')
    df2 = pd.read_excel(xls, sheet_name='Sheet2')
    # Arquivo é automaticamente fechado após este bloco

Trabalhando com URLs

Leia arquivos Excel diretamente de URLs:

url = 'https://example.com/data.xlsx'
df = pd.read_excel(url)

Usando RunCell para depuração de dados Excel

Ao trabalhar com importações Excel complexas em notebooks Jupyter, RunCell (opens in a new tab) fornece assistência alimentada por IA para depurar erros de importação, otimizar parâmetros e corrigir problemas de tipos de dados. O agente de IA pode:

• Diagnosticar por que read_excel() não está analisando datas corretamente
• Sugerir especificações dtype ideais para eficiência de memória
• Depurar problemas de compatibilidade de motor
• Ajudar a solucionar problemas de codificação e formatação

Isso é particularmente valioso ao importar arquivos Excel do mundo real desorganizados com formatação inconsistente ou estruturas complexas de múltiplas planilhas.

FAQ

Como ler um arquivo Excel sem cabeçalhos no pandas?

Defina header=None para dizer ao pandas que a primeira linha são dados, não nomes de colunas. Pandas atribuirá nomes de colunas numéricos (0, 1, 2...):

df = pd.read_excel('data.xlsx', header=None)

Você pode então renomear as colunas manualmente:

df.columns = ['Name', 'Age', 'Salary']

O pandas pode ler múltiplos arquivos Excel de uma vez?

Sim, use um loop ou compreensão de lista para ler múltiplos arquivos e concatená-los:

import pandas as pd
from glob import glob
 
# Ler todos os arquivos Excel em um diretório
files = glob('data/*.xlsx')
dfs = [pd.read_excel(f) for f in files]
combined_df = pd.concat(dfs, ignore_index=True)

Como ler apenas linhas específicas de um arquivo Excel?

Combine os parâmetros skiprows e nrows:

# Ler linhas 100-199 (pular primeiras 100, ler próximas 100)
df = pd.read_excel('data.xlsx', skiprows=100, nrows=100)

Por que read_excel é tão lento comparado a read_csv?

Arquivos Excel são formatos binários que requerem análise complexa, enquanto arquivos CSV são texto simples. Para grandes conjuntos de dados, converta Excel para CSV primeiro:

# Conversão única
df = pd.read_excel('large_file.xlsx')
df.to_csv('large_file.csv', index=False)
 
# Leituras futuras usam CSV
df = pd.read_csv('large_file.csv')  # Muito mais rápido

Como lidar com células mescladas em arquivos Excel?

Pandas lê o valor superior esquerdo de células mescladas e preenche o restante com NaN. Você pode propagar esses valores para frente:

df = pd.read_excel('data.xlsx')
df['MergedColumn'] = df['MergedColumn'].fillna(method='ffill')

Conclusão

A função pandas read_excel() fornece controle abrangente sobre a importação de arquivos Excel em Python, desde importações simples de uma única planilha até cenários complexos envolvendo múltiplas planilhas, tipos de dados personalizados e manipulação de arquivos grandes. Domine os parâmetros-chave – sheet_name, usecols, dtype, parse_dates e skiprows – para importar dados de forma eficiente e precisa.

Para a maioria dos fluxos de trabalho, o pd.read_excel('file.xlsx') básico é suficiente, mas entender opções avançadas como seleção de motor, funções de conversor e técnicas de otimização de memória torna-se crítico ao trabalhar com dados corporativos do mundo real. Lembre-se de instalar o motor apropriado (openpyxl para arquivos .xlsx) e considere converter arquivos Excel grandes para CSV para melhor desempenho.

A combinação de pandas para importação de dados, PyGWalker para visualização instantânea e RunCell para depuração cria um fluxo de trabalho poderoso para análise de dados Excel em Python.