Pandas Read Excel: Cómo importar archivos Excel en Python

Name

Soren Atelier

Updated on 9/2/2026

Los archivos Excel siguen siendo el formato más común para almacenar datos tabulares en entornos empresariales, sin embargo, importarlos a Python para análisis a menudo crea fricción. Necesitas manejar múltiples hojas, tipos de datos inconsistentes, valores faltantes y restricciones de memoria, todo mientras mantienes la integridad de los datos. La función read_excel() de pandas resuelve estos desafíos, pero solo si sabes cómo configurar correctamente sus más de 30 parámetros.

Esta guía te muestra cómo importar archivos Excel a pandas DataFrames de manera eficiente, desde importaciones básicas de una sola hoja hasta escenarios avanzados como leer múltiples hojas simultáneamente, manejar archivos grandes y solucionar errores comunes.

Uso básico de pandas read_excel()

La forma más simple de leer un archivo Excel en un pandas DataFrame requiere solo la ruta del archivo:

import pandas as pd
 
# Leer la primera hoja de un archivo Excel
df = pd.read_excel('data.xlsx')
print(df.head())

Esto lee la primera hoja por defecto, tratando la primera fila como encabezados de columna. La función detecta automáticamente el formato del archivo (.xlsx o .xls) y usa el motor apropiado.

Para archivos en diferentes directorios, usa rutas absolutas o relativas:

# Ruta absoluta
df = pd.read_excel('/Users/username/Documents/sales_data.xlsx')
 
# Ruta relativa
df = pd.read_excel('../data/sales_data.xlsx')

Entendiendo los parámetros clave

La función read_excel() proporciona un control extenso sobre cómo se importan los datos. Aquí está una tabla de referencia de los parámetros más importantes:

Trabajando con múltiples hojas

Leer una hoja específica

Especifica hojas por nombre o índice (base 0):

# Leer por nombre de hoja
df = pd.read_excel('financial_report.xlsx', sheet_name='Q1 Revenue')
 
# Leer por índice (0 = primera hoja)
df = pd.read_excel('financial_report.xlsx', sheet_name=0)

Leer múltiples hojas a la vez

Pasa una lista de nombres de hojas o índices para importar múltiples hojas en un diccionario de DataFrames:

# Leer múltiples hojas específicas
sheets_dict = pd.read_excel('annual_report.xlsx',
                            sheet_name=['Q1', 'Q2', 'Q3', 'Q4'])
 
# Acceder a DataFrames individuales
q1_df = sheets_dict['Q1']
q2_df = sheets_dict['Q2']
 
print(f"Q1 shape: {q1_df.shape}")
print(f"Q2 shape: {q2_df.shape}")

Leer todas las hojas

Usa sheet_name=None para importar cada hoja en el libro de trabajo:

# Leer todas las hojas en un diccionario
all_sheets = pd.read_excel('company_data.xlsx', sheet_name=None)
 
# Iterar a través de todas las hojas
for sheet_name, df in all_sheets.items():
    print(f"\nSheet: {sheet_name}")
    print(f"Shape: {df.shape}")
    print(f"Columns: {df.columns.tolist()}")

Esto es particularmente útil cuando necesitas procesar múltiples hojas con estructuras similares:

# Combinar todas las hojas en un solo 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 la importación de datos con encabezados y columnas

Especificar filas de encabezado

Controla qué fila se convierte en los nombres de columna:

# Omitir primeras 2 filas, usar fila 3 como encabezado
df = pd.read_excel('data.xlsx', header=2)
 
# Sin fila de encabezado - pandas asigna nombres de columna numéricos
df = pd.read_excel('data.xlsx', header=None)
 
# Encabezados de columna multinivel
df = pd.read_excel('data.xlsx', header=[0, 1])

Omitir filas

Elimina filas no deseadas desde la parte superior del archivo:

# Omitir primeras 3 filas
df = pd.read_excel('data.xlsx', skiprows=3)
 
# Omitir filas específicas (indexadas desde 0)
df = pd.read_excel('data.xlsx', skiprows=[0, 2, 5])
 
# Omitir filas usando una función
df = pd.read_excel('data.xlsx', skiprows=lambda x: x % 2 == 0)  # Omitir filas pares

Seleccionar columnas específicas

Importa solo las columnas que necesitas para reducir el uso de memoria:

# Seleccionar columnas por rango de letras
df = pd.read_excel('data.xlsx', usecols='A:D')
 
# Seleccionar columnas específicas por letra
df = pd.read_excel('data.xlsx', usecols='A,C,E,G')
 
# Seleccionar columnas por índice
df = pd.read_excel('data.xlsx', usecols=[0, 2, 4, 6])
 
# Seleccionar columnas por nombre
df = pd.read_excel('data.xlsx', usecols=['Name', 'Age', 'Salary'])
 
# Seleccionar columnas usando una función
df = pd.read_excel('data.xlsx', usecols=lambda x: 'total' in x.lower())

Especificación y conversión de tipos de datos

Establecer tipos de datos de columna

Define tipos de datos explícitamente para prevenir errores de inferencia automática:

# Especificar dtypes para múltiples columnas
df = pd.read_excel('customer_data.xlsx',
                   dtype={
                       'CustomerID': str,
                       'ZipCode': str,
                       'Age': int,
                       'Revenue': float
                   })
 
# Mantener IDs numéricos como cadenas para preservar ceros iniciales
df = pd.read_excel('products.xlsx', dtype={'ProductID': str})

Manejo de fechas

Analiza columnas de fecha automáticamente:

# Analizar una sola columna de fecha
df = pd.read_excel('orders.xlsx', parse_dates=['OrderDate'])
 
# Analizar múltiples columnas de fecha
df = pd.read_excel('employee_data.xlsx',
                   parse_dates=['HireDate', 'TerminationDate'])
 
# Combinar columnas en un solo datetime
df = pd.read_excel('logs.xlsx',
                   parse_dates={'DateTime': ['Date', 'Time']})
 
# Verificar el resultado
print(df.dtypes)

Gestionar valores faltantes

Controla cómo pandas identifica y maneja datos faltantes:

# Reconocer indicadores personalizados de valores faltantes
df = pd.read_excel('survey_data.xlsx',
                   na_values=['NA', 'N/A', 'null', 'None', '-'])
 
# Diferentes valores NA por columna
df = pd.read_excel('mixed_data.xlsx',
                   na_values={
                       'Age': ['Unknown', 'N/A'],
                       'Salary': [0, -1, 'Not Disclosed']
                   })
 
# Mantener valores NA predeterminados y agregar más
df = pd.read_excel('data.xlsx',
                   na_values=['Missing'],
                   keep_default_na=True)

Manejo de archivos Excel grandes

Los archivos Excel consumen memoria significativa cuando se cargan completamente en RAM. Usa estas estrategias para conjuntos de datos grandes:

Limitar filas

Lee solo las filas que necesitas:

# Leer primeras 10,000 filas
df = pd.read_excel('large_file.xlsx', nrows=10000)
 
# Leer rango específico de filas usando skiprows y nrows
df = pd.read_excel('large_file.xlsx', skiprows=1000, nrows=5000)

Usar convertidores para eficiencia de memoria

Aplica transformaciones durante la importación para reducir la huella de memoria:

# Convertir columnas durante la lectura
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()
                   })

Procesar hojas iterativamente

Para libros de trabajo con múltiples hojas grandes, procesa una hoja a la vez:

import pandas as pd
 
# Obtener primero todos los nombres de hojas
xls = pd.ExcelFile('massive_workbook.xlsx')
sheet_names = xls.sheet_names
 
# Procesar cada hoja por separado
for sheet in sheet_names:
    df = pd.read_excel(xls, sheet_name=sheet, nrows=10000)
    # Procesar df aquí
    result = df.describe()
    print(f"\n{sheet} Summary:\n{result}")

Alternativa: Usar openpyxl para streaming

Para archivos extremadamente grandes, considera leer fila por fila con openpyxl:

from openpyxl import load_workbook
 
# Cargar libro de trabajo en modo solo lectura
wb = load_workbook('huge_file.xlsx', read_only=True)
ws = wb['Sheet1']
 
# Procesar filas iterativamente
data = []
for row in ws.iter_rows(min_row=2, max_row=1000, values_only=True):
    data.append(row)
 
# Convertir a DataFrame
df = pd.DataFrame(data, columns=['Col1', 'Col2', 'Col3'])
wb.close()

Entendiendo los motores Excel

Pandas usa diferentes bibliotecas para leer archivos Excel dependiendo del formato y paquetes instalados:

Especifica el motor explícitamente:

# Forzar motor openpyxl
df = pd.read_excel('data.xlsx', engine='openpyxl')
 
# Leer archivo .xls heredado
df = pd.read_excel('old_data.xls', engine='xlrd')
 
# Leer archivo Excel binario
df = pd.read_excel('data.xlsb', engine='pyxlsb')

Pandas read_excel vs read_csv: Diferencias clave

Aunque ambas funciones crean DataFrames, tienen diferencias importantes:

Recomendación: Usa read_csv() para procesamiento de datos a gran escala y read_excel() cuando necesites trabajar con libros de trabajo Excel existentes o múltiples hojas.

Visualiza datos Excel instantáneamente con PyGWalker

Después de importar datos Excel con pandas, a menudo necesitas explorarlos visualmente. PyGWalker (opens in a new tab) transforma tu DataFrame en una interfaz de visualización interactiva similar a Tableau directamente en tu notebook Jupyter, sin necesidad de escribir código de gráficos.

import pandas as pd
import pygwalker as pyg
 
# Leer datos Excel
df = pd.read_excel('sales_data.xlsx')
 
# Lanzar visualización interactiva
pyg.walk(df)

Esto abre una interfaz de arrastrar y soltar donde puedes:

• Crear gráficos arrastrando columnas a canales visuales
• Cambiar entre tipos de gráficos (barras, línea, dispersión, mapa de calor) instantáneamente
• Aplicar filtros y agregaciones interactivamente
• Exportar visualizaciones como imágenes o código

PyGWalker es particularmente útil para análisis exploratorio de datos después de importar archivos Excel, permitiéndote entender distribuciones de datos y relaciones sin escribir código de matplotlib o seaborn.

Errores comunes y solución de problemas

ModuleNotFoundError: No module named 'openpyxl'

Este es el error más común al leer archivos .xlsx:

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

Solución: Instala el motor requerido:

# Instalar openpyxl
pip install openpyxl
 
# O instalar todas las dependencias Excel
pip install pandas[excel]

XLRDError: Excel xlsx file; not supported

Si ves este error, xlrd está intentando leer un archivo .xlsx (solo soporta .xls desde la versión 2.0):

Solución: Instala openpyxl o especifica el motor:

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

FileNotFoundError

Verifica tu ruta de archivo y directorio de trabajo:

import os
 
# Imprimir directorio actual
print(os.getcwd())
 
# Listar archivos en directorio
print(os.listdir('.'))
 
# Usar ruta absoluta
df = pd.read_excel('/absolute/path/to/file.xlsx')

Errores de memoria con archivos grandes

Si pandas falla con errores de memoria:

# Reducir memoria seleccionando columnas
df = pd.read_excel('large_file.xlsx', usecols=['A', 'B', 'C'])
 
# Limitar filas
df = pd.read_excel('large_file.xlsx', nrows=50000)
 
# Especificar dtypes para reducir memoria
df = pd.read_excel('large_file.xlsx',
                   dtype={'ID': 'int32', 'Category': 'category'})

ValueError: Excel file format cannot be determined

Esto ocurre cuando la extensión del archivo no coincide con el formato real:

Solución: Especifica el motor explícitamente o renombra el archivo con la extensión correcta:

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

Problemas de análisis de fechas

Excel almacena fechas como números de serie. Si las fechas no se analizan correctamente:

# Forzar análisis de fechas
df = pd.read_excel('data.xlsx', parse_dates=['DateColumn'])
 
# Conversión manual
df['DateColumn'] = pd.to_datetime(df['DateColumn'])

Técnicas avanzadas

Leer archivos protegidos con contraseña

Aunque pandas no soporta archivos protegidos con contraseña directamente, usa msoffcrypto-tool:

import msoffcrypto
import io
import pandas as pd
 
# Descifrar el archivo
decrypted = io.BytesIO()
with open('protected.xlsx', 'rb') as f:
    file = msoffcrypto.OfficeFile(f)
    file.load_key(password='yourpassword')
    file.decrypt(decrypted)
 
# Leer el archivo descifrado
df = pd.read_excel(decrypted)

Combinar read_excel con Context Managers

Para mejor gestión 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')
    # El archivo se cierra automáticamente después de este bloque

Trabajar con URLs

Lee archivos Excel directamente desde URLs:

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

Usar RunCell para depuración de datos Excel

Cuando trabajas con importaciones Excel complejas en notebooks Jupyter, RunCell (opens in a new tab) proporciona asistencia impulsada por IA para depurar errores de importación, optimizar parámetros y corregir problemas de tipos de datos. El agente de IA puede:

• Diagnosticar por qué read_excel() no está analizando fechas correctamente
• Sugerir especificaciones óptimas de dtype para eficiencia de memoria
• Depurar problemas de compatibilidad de motores
• Ayudar a solucionar problemas de codificación y formateo

Esto es particularmente valioso al importar archivos Excel del mundo real desordenados con formato inconsistente o estructuras complejas de múltiples hojas.

FAQ

¿Cómo leo un archivo Excel sin encabezados en pandas?

Establece header=None para decirle a pandas que la primera fila es datos, no nombres de columna. Pandas asignará nombres de columna numéricos (0, 1, 2...):

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

Luego puedes renombrar columnas manualmente:

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

¿Puede pandas leer múltiples archivos Excel a la vez?

Sí, usa un bucle o comprensión de lista para leer múltiples archivos y concatenarlos:

import pandas as pd
from glob import glob
 
# Leer todos los archivos Excel en un directorio
files = glob('data/*.xlsx')
dfs = [pd.read_excel(f) for f in files]
combined_df = pd.concat(dfs, ignore_index=True)

¿Cómo leo solo filas específicas de un archivo Excel?

Combina los parámetros skiprows y nrows:

# Leer filas 100-199 (omitir primeras 100, leer siguientes 100)
df = pd.read_excel('data.xlsx', skiprows=100, nrows=100)

¿Por qué read_excel es tan lento comparado con read_csv?

Los archivos Excel son formatos binarios que requieren análisis complejo, mientras que los archivos CSV son texto plano. Para conjuntos de datos grandes, convierte Excel a CSV primero:

# Conversión única
df = pd.read_excel('large_file.xlsx')
df.to_csv('large_file.csv', index=False)
 
# Lecturas futuras usan CSV
df = pd.read_csv('large_file.csv')  # Mucho más rápido

¿Cómo manejo celdas combinadas en archivos Excel?

Pandas lee el valor superior izquierdo de las celdas combinadas y llena el resto con NaN. Puedes rellenar estos valores hacia adelante:

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

Conclusión

La función pandas read_excel() proporciona control completo sobre la importación de archivos Excel en Python, desde importaciones simples de una sola hoja hasta escenarios complejos que involucran múltiples hojas, tipos de datos personalizados y manejo de archivos grandes. Domina los parámetros clave – sheet_name, usecols, dtype, parse_dates y skiprows – para importar datos eficiente y precisamente.

Para la mayoría de los flujos de trabajo, el pd.read_excel('file.xlsx') básico es suficiente, pero entender opciones avanzadas como selección de motor, funciones de convertidor y técnicas de optimización de memoria se vuelve crítico cuando trabajas con datos empresariales del mundo real. Recuerda instalar el motor apropiado (openpyxl para archivos .xlsx) y considera convertir archivos Excel grandes a CSV para mejor rendimiento.

La combinación de pandas para importación de datos, PyGWalker para visualización instantánea y RunCell para depuración crea un flujo de trabajo poderoso para análisis de datos Excel en Python.