Introducción a la Automatización del Procesamiento de Datos de Excel: Guía Completa para Principiantes
Índice
Primeros Pasos: Lo que Necesitas Saber
¿Buscas optimizar tus tareas en Excel pero no estás seguro por dónde empezar? Este completo tutorial proporciona instrucciones paso a paso que garantizan el éxito, incluso para principiantes. Hemos actualizado esta guía para 2025 con las últimas versiones de paquetes y mejores prácticas.
⚠️ Actualizaciones Importantes (Septiembre 2025)
Utiliza pandas 2.3.2 (lanzado el 21 de agosto de 2025)
Compatible con openpyxl 3.1.4 (última versión estable)
Incluye manejo detallado de errores y solución de problemas
Probado en Windows 11, macOS Ventura/Sonoma y Ubuntu 22.04/24.04
Lo que Aprenderás en Este Tutorial
Configuración del Entorno con Verificación: Guía completa de configuración con scripts de verificación
Creación y Uso de Datos de Muestra: Genera tus propios conjuntos de datos o descarga los pre-hechos
Fundamentos de la Automatización de Excel: Entendiendo la integración de pandas y openpyxl
Técnicas de Limpieza de Datos: Métodos profesionales para la preparación de datos
Prevención de Errores y Solución de Problemas: Soluciones para problemas comunes
Parte 1: Configurando tu Entorno de Python
Paso 1.1: Instalar Python y Verificar la Instalación
Para Usuarios de Windows:
# Abrir Símbolo del sistema como Administrador# Comprobar si Python está instalado
python --version
# Si no está instalado, descargar desde python.org# Asegúrate de marcar "Add Python to PATH" durante la instalación
Para Usuarios de macOS/Linux:
# Abrir Terminal
python3 --version
# Si no está instalado:# macOS: brew install python3# Ubuntu/Debian: sudo apt-get install python3 python3-pip
Paso 1.2: Crear un Entorno Virtual (Altamente Recomendado)
Crear un entorno virtual previene conflictos de paquetes:
Paquetes esenciales para la automatización de Excel:
# Instalar todos los paquetes requeridos a la vez
pip install pandas==2.3.2 openpyxl==3.1.4 numpy xlsxwriter
# Verificar instalación
pip list | grep -E "pandas|openpyxl|numpy|xlsxwriter"
Paso 1.4: Script de Verificación
Crea un archivo llamado verify_installation.py:
"""
Script de Verificación de Instalación
Guarda esto como verify_installation.py y ejecútalo
"""
import sys
import importlib
def check_package(package_name, min_version=None):
"""Comprueba si un paquete está instalado y cumple con la versión mínima"""
try:
module = importlib.import_module(package_name)
version = getattr(module, '__version__', 'Unknown')
# Manejo especial para xlsxwriter
if package_name == 'xlsxwriter':
import xlsxwriter
version = xlsxwriter.__version__
print(f"✅ {package_name}: Versión {version}")
if min_version and version != 'Unknown':
# Comparación simple de versiones (puede necesitar mejoras para versiones complejas)
if version >= min_version:
print(f" La versión cumple el requisito (>= {min_version})")
else:
print(f" ⚠️ Advertencia: La versión {version} es más antigua que la recomendada {min_version}")
return True
except ImportError:
print(f"❌ {package_name}: No instalado")
return False
def main():
print("=" * 60)
print("Verificación del Entorno de Automatización de Excel")
print("=" * 60)
# Comprobar la versión de Python
print(f"Python: {sys.version}")
python_version = sys.version_info
if python_version.major >= 3 and python_version.minor >= 8:
print("✅ La versión de Python es adecuada (3.8+)")
else:
print("⚠️ Se recomienda Python 3.8+")
print("-" * 60)
print("Comprobando paquetes requeridos...")
# Definir paquetes requeridos con versiones mínimas
packages = {
'pandas': '2.0.0',
'openpyxl': '3.1.0',
'numpy': None,
'xlsxwriter': None
}
all_installed = True
for package, min_version in packages.items():
if not check_package(package, min_version):
all_installed = False
print("=" * 60)
if all_installed:
print("✨ ¡Todos los paquetes están instalados correctamente!")
print("Puedes proceder al siguiente paso.")
else:
print("⚠️ Faltan algunos paquetes.")
print("Por favor, instálalos usando:")
print("pip install pandas openpyxl numpy xlsxwriter")
return all_installed
if __name__ == "__main__":
success = main()
sys.exit(0 if success else 1)
Ejecuta la verificación:
python verify_installation.py
Parte 2: Creando Datos de Muestra
Opción 1: Genera Tus Propios Datos de Muestra con Python
Guarda este script mejorado como generate_sample_data.py:
"""
Generador de Datos de Muestra para el Tutorial de Automatización de Excel
Este script crea datos de muestra realistas para pruebas
"""
import pandas as pd
import numpy as np
import datetime
import os
import sys
def ensure_directory_exists(directory):
"""Crea el directorio si no existe"""
if not os.path.exists(directory):
os.makedirs(directory)
print(f"📁 Directorio creado: {directory}")
return True
return False
def generate_sales_data():
"""Genera datos de ventas completos para 2024"""
print("\n📊 Generando datos de ventas...")
# Establecer semilla aleatoria para reproducibilidad
np.random.seed(42)
# Generar fechas para 2024
start_date = datetime.datetime(2024, 1, 1)
dates = [start_date + datetime.timedelta(days=x) for x in range(365)]
# Categorías de productos
categories = ['Papelería', 'Electrónica', 'Alimentos', 'Ropa', 'Hogar']
# Representantes de ventas
sales_reps = [f'Rep {i}' for i in range(1, 6)]
# Generar datos
data = []
for date in dates:
# Generar de 3 a 7 transacciones por día
num_transactions = np.random.randint(3, 8)
for _ in range(num_transactions):
record = {
'Date': date,
'Year-Month': date.strftime('%Y-%m'),
'Product Category': np.random.choice(categories),
'Sales Amount': np.random.randint(1000, 100000),
'Sales Rep': np.random.choice(sales_reps),
'Transaction ID': f"TXN{date.strftime('%Y%m%d')}{np.random.randint(1000, 9999)}"
}
data.append(record)
# Crear DataFrame
df = pd.DataFrame(data)
# Añadir columnas calculadas
df['Quarter'] = df['Date'].dt.quarter
df['Day of Week'] = df['Date'].dt.day_name()
print(f" Generados {len(df)} registros")
# Dividir datos en tres archivos
ensure_directory_exists('excel_files')
# Calcular puntos de división
split_size = len(df) // 3
splits = [
df.iloc[:split_size],
df.iloc[split_size:split_size*2],
df.iloc[split_size*2:]
]
# Guardar cada división
for i, split_df in enumerate(splits, 1):
filename = f'excel_files/sales_data_{i}.xlsx'
# Usar ExcelWriter para un mejor control
with pd.ExcelWriter(filename, engine='openpyxl') as writer:
split_df.to_excel(writer, sheet_name='Sales Data', index=False)
print(f" ✅ Guardado: {filename} ({len(split_df)} filas)")
# Guardar datos consolidados originales
with pd.ExcelWriter('sales_data_original.xlsx', engine='openpyxl') as writer:
df.to_excel(writer, sheet_name='All Sales', index=False)
# Añadir una hoja de resumen
summary = pd.DataFrame({
'Metric': ['Total Records', 'Date Range', 'Categories', 'Sales Reps'],
'Value': [
len(df),
f"{df['Date'].min().date()} to {df['Date'].max().date()}",
len(df['Product Category'].unique()),
len(df['Sales Rep'].unique())
]
})
summary.to_excel(writer, sheet_name='Summary', index=False)
print(f" ✅ Guardado: sales_data_original.xlsx ({len(df)} filas)")
return df
def generate_messy_data():
"""Genera datos con problemas comunes de calidad para practicar la limpieza"""
print("\n🧹 Generando datos desordenados para práctica de limpieza...")
# Crear datos intencionadamente desordenados
data = {
'Customer Name': [
'John Doe ', # Espacio al final
' Jane Smith', # Espacio al principio
'Robert Brown ', # Múltiples espacios al final
'John Doe', # Duplicado (limpio)
' Jane Smith ', # Espacios al principio y al final
'mary johnson', # Minúsculas
'PETER WILSON', # Mayúsculas
None, # Valor faltante
'Alice-Cooper', # Carácter especial
'Bob Smith' # Múltiples espacios en medio
],
'Age': [30, np.nan, 45, 30, 28, 35, np.nan, 42, 25, 50],
'Email': [
'john@example.com',
'jane@example.com',
'', # Cadena vacía
'john@example.com', # Duplicado
'jane_h@example.com',
'MARY@EXAMPLE.COM', # Mayúsculas
'peter@', # Formato inválido
None, # Faltante
'alice@example', # Falta extensión de dominio
'bob@example.com'
],
'Purchase Amount': [5000, 3000, 4000, 5000, 3000, 2500, 4500, None, 3500, 6000],
'Registration Date': [
'2024-01-15',
'2024/02/20', # Formato diferente
'15-03-2024', # Formato diferente
'2024-01-15', # Fecha duplicada
'2024-04-10',
'05/15/2024', # Formato de EE. UU.
'2024-06-30',
None, # Faltante
'2024-07-20',
'Invalid Date' # Inválido
]
}
df = pd.DataFrame(data)
# Guardar en Excel con problemas de formato
with pd.ExcelWriter('messy_data.xlsx', engine='openpyxl') as writer:
df.to_excel(writer, sheet_name='Customer Data', index=False)
print(f" ✅ Guardado: messy_data.xlsx ({len(df)} filas con varios problemas de calidad de datos)")
# Crear una versión limpia de referencia para comparación
clean_data = {
'Customer Name': [
'John Doe',
'Jane Smith',
'Robert Brown',
'John Doe',
'Jane Smith',
'Mary Johnson',
'Peter Wilson',
'Unknown',
'Alice Cooper',
'Bob Smith'
],
'Age': [30, 35, 45, 30, 28, 35, 40, 42, 25, 50], # Rellenado faltante con promedio
'Email': [
'john@example.com',
'jane@example.com',
'robert@example.com',
'john@example.com',
'jane_h@example.com',
'mary@example.com',
'peter@example.com',
'unknown@example.com',
'alice@example.com',
'bob@example.com'
],
'Purchase Amount': [5000, 3000, 4000, 5000, 3000, 2500, 4500, 3900, 3500, 6000],
'Registration Date': pd.to_datetime([
'2024-01-15', '2024-02-20', '2024-03-15', '2024-01-15',
'2024-04-10', '2024-05-15', '2024-06-30', '2024-07-01',
'2024-07-20', '2024-08-01'
])
}
clean_df = pd.DataFrame(clean_data)
with pd.ExcelWriter('messy_data_reference.xlsx', engine='openpyxl') as writer:
clean_df.to_excel(writer, sheet_name='Clean Reference', index=False)
print(f" ✅ Guardado: messy_data_reference.xlsx (versión limpia de referencia)")
return df, clean_df
def main():
"""Función principal de ejecución"""
print("=" * 70)
print("Tutorial de Automatización de Excel - Generador de Datos de Muestra")
print("=" * 70)
try:
# Generar datos de ventas
sales_df = generate_sales_data()
# Generar datos desordenados
messy_df, clean_df = generate_messy_data()
# Resumen
print("\n" + "=" * 70)
print("📋 Resumen de Archivos Generados:")
print("=" * 70)
print("\n📁 excel_files/")
print(" ├── sales_data_1.xlsx (Datos de ventas divididos - Parte 1)")
print(" ├── sales_data_2.xlsx (Datos de ventas divididos - Parte 2)")
print(" └── sales_data_3.xlsx (Datos de ventas divididos - Parte 3)")
print("\n📄 Directorio raíz:")
print(" ├── sales_data_original.xlsx (Conjunto de datos de ventas completo)")
print(" ├── messy_data.xlsx (Datos con problemas de calidad)")
print(" └── messy_data_reference.xlsx (Versión limpia de referencia)")
# Explicación del marcador de posición de la imagen
print("\n📸 Nota: El artículo original mostraba capturas de pantalla de Excel aquí.")
print(" Abre los archivos generados para ver:")
print(" - Datos de ventas bien estructurados con fechas, categorías y montos")
print(" - Datos de clientes intencionadamente desordenados para la práctica de limpieza")
print(" - Datos limpios de referencia para comparación")
print("\n✨ ¡Generación de datos de muestra completa!")
print("Siguiente paso: Ejecuta excel_automation.py para procesar estos datos")
return True
except Exception as e:
print(f"\n❌ Ocurrió un error: {str(e)}")
print("\nSolución de problemas:")
print("1. Asegúrate de que todos los paquetes requeridos estén instalados")
print("2. Comprueba los permisos de escritura en el directorio actual")
print("3. Cierra cualquier archivo de Excel que pueda estar abierto")
return False
if __name__ == "__main__":
success = main()
sys.exit(0 if success else 1)
Opción 2: Descargar Datos de Muestra
Para los principiantes que prefieren omitir el proceso de creación de scripts, pueden descargar directamente los conjuntos de datos de muestra:
Este archivo contiene datos intencionadamente “desordenados” con problemas comunes:
Entradas duplicadas: El mismo cliente aparece varias veces
Valores faltantes: Celdas vacías y valores NaN
Formato inconsistente: Formatos de fecha mixtos, diferentes mayúsculas y minúsculas en el texto
Espacios extra: Espacios al principio, al final y múltiples
Datos inválidos: Formatos de correo electrónico incorrectos, fechas inválidas
3. Datos de Referencia (sales_data_original.xlsx y messy_data_reference.xlsx)
Versiones limpias y completas de los conjuntos de datos utilizadas para:
Validar los resultados de la automatización
Comparar antes y después de la limpieza
Servir como el “estándar de oro” para la calidad de los datos
Parte 3: Script de Automatización de Excel
Script de Automatización Completo con Manejo de Errores
Guarda esto como excel_automation.py:
"""
Script Principal de Automatización de Excel
Procesamiento de datos completo con retroalimentación detallada
Ejecuta esto después de generar los datos de muestra
"""
import pandas as pd
import os
import glob
import sys
from datetime import datetime
import warnings
# Suprimir advertencias de openpyxl para una salida más limpia
warnings.filterwarnings('ignore', category=UserWarning, module='openpyxl')
class ExcelAutomation:
"""Clase principal para tareas de automatización de Excel"""
def __init__(self):
"""Inicializa la clase de automatización"""
self.combined_sales = None
self.monthly_summary = None
self.category_summary = None
self.cleaned_data = None
def verify_prerequisites(self):
"""Comprueba si existen todos los archivos requeridos"""
print("\n🔍 Verificando archivos requeridos...")
required_files = [
('excel_files/sales_data_1.xlsx', 'Datos de ventas divididos parte 1'),
('excel_files/sales_data_2.xlsx', 'Datos de ventas divididos parte 2'),
('excel_files/sales_data_3.xlsx', 'Datos de ventas divididos parte 3'),
('messy_data.xlsx', 'Datos de clientes para limpieza')
]
missing_files = []
for filepath, description in required_files:
if os.path.exists(filepath):
print(f" ✅ Encontrado: {description}")
else:
print(f" ❌ Faltante: {description} ({filepath})")
missing_files.append(filepath)
if missing_files:
print("\n⚠️ ¡Se detectaron archivos faltantes!")
print("Por favor, ejecuta 'python generate_sample_data.py' primero")
return False
print(" ¡Todos los archivos requeridos están presentes!")
return True
def combine_excel_files(self, folder_path):
"""
Fusiona todos los archivos de Excel en la carpeta especificada
Parámetros:
-----------
folder_path : str
Ruta a la carpeta que contiene los archivos de Excel
Devuelve:
--------
pd.DataFrame: DataFrame combinado
"""
print(f"\n📂 Combinando archivos de Excel de: {folder_path}")
# Encontrar todos los archivos sales_data_*.xlsx
pattern = os.path.join(folder_path, "sales_data_*.xlsx")
all_files = sorted(glob.glob(pattern))
if not all_files:
raise FileNotFoundError(f"No se encontraron archivos que coincidan con el patrón: {pattern}")
print(f" Se encontraron {len(all_files)} archivos para combinar")
# Leer y combinar archivos
df_list = []
total_rows = 0
for i, filepath in enumerate(all_files, 1):
filename = os.path.basename(filepath)
print(f" Leyendo archivo {i}/{len(all_files)}: {filename}")
try:
# Leer con motor explícito
df = pd.read_excel(filepath, engine='openpyxl')
rows = len(df)
print(f" → Cargadas {rows:,} filas")
df_list.append(df)
total_rows += rows
except Exception as e:
print(f" ❌ Error al leer {filename}: {e}")
raise
# Combinar todos los dataframes
print(f" Combinando {len(df_list)} dataframes...")
combined_df = pd.concat(df_list, ignore_index=True)
# Verificar combinación
if len(combined_df) != total_rows:
print(f" ⚠️ Advertencia: Se esperaban {total_rows} filas, se obtuvieron {len(combined_df)}")
else:
print(f" ✅ Se combinaron exitosamente {total_rows:,} filas")
# Ordenar por fecha para una mejor organización
if 'Date' in combined_df.columns:
combined_df = combined_df.sort_values('Date')
print(" ✅ Datos ordenados por fecha")
self.combined_sales = combined_df
return combined_df
def analyze_sales(self, df):
"""
Realiza un análisis de ventas completo
Parámetros:
-----------
df : pd.DataFrame
DataFrame de ventas para analizar
Devuelve:
--------
tuple: (monthly_summary, category_summary, statistics)
"""
print("\n📊 Analizando datos de ventas...")
# Asegurarse de que tenemos las columnas requeridas
required_cols = ['Year-Month', 'Sales Amount', 'Product Category']
missing_cols = [col for col in required_cols if col not in df.columns]
if missing_cols:
raise ValueError(f"Faltan columnas requeridas: {missing_cols}")
# Análisis mensual
print(" Calculando estadísticas mensuales...")
monthly_summary = df.groupby('Year-Month')['Sales Amount'].agg([
('Total Sales', 'sum'),
('Average Sale', 'mean'),
('Transaction Count', 'count'),
('Min Sale', 'min'),
('Max Sale', 'max')
]).round(2)
print(f" → Analizados {len(monthly_summary)} meses")
# Análisis de categoría
print(" Analizando categorías de productos...")
category_summary = df.groupby('Product Category').agg({
'Sales Amount': ['sum', 'mean', 'count']
}).round(2)
category_summary.columns = ['Total Sales', 'Average Sale', 'Transaction Count']
category_summary = category_summary.sort_values('Total Sales', ascending=False)
print(f" → Analizadas {len(category_summary)} categorías")
# Estadísticas generales
print("\n 📈 Estadísticas Clave:")
total_sales = df['Sales Amount'].sum()
avg_sale = df['Sales Amount'].mean()
print(f" Ventas Totales: ${total_sales:,.2f}")
print(f" Venta Promedio: ${avg_sale:,.2f}")
print(f" Total de Transacciones: {len(df):,}")
# Categoría con mejor rendimiento
top_category = category_summary.index[0]
top_sales = category_summary.iloc[0]['Total Sales']
print(f" Categoría Principal: {top_category} (${top_sales:,.2f})")
self.monthly_summary = monthly_summary
self.category_summary = category_summary
return monthly_summary, category_summary
def clean_customer_data(self, df):
"""
Limpia los datos de los clientes con informes detallados
Parámetros:
-----------
df : pd.DataFrame
DataFrame de clientes para limpiar
Devuelve:
--------
pd.DataFrame: DataFrame limpio
"""
print("\n🧹 Limpiando datos de clientes...")
# Registrar estado inicial
initial_rows = len(df)
initial_nulls = df.isnull().sum().sum()
# Crear copia de trabajo
cleaned = df.copy()
# Paso 1: Recortar espacios en blanco
print(" Paso 1: Eliminando espacios en blanco extra...")
text_columns = cleaned.select_dtypes(include=['object']).columns
for col in text_columns:
if col in cleaned.columns:
# Manejar valores None
cleaned[col] = cleaned[col].fillna('')
# Quitar espacios en blanco
cleaned[col] = cleaned[col].str.strip()
# Reemplazar múltiples espacios con un solo espacio
cleaned[col] = cleaned[col].str.replace(r'\s+', ' ', regex=True)
# Reemplazar cadenas vacías con None
cleaned[col] = cleaned[col].replace('', None)
print(f" → Limpiadas {len(text_columns)} columnas de texto")
# Paso 2: Estandarizar mayúsculas y minúsculas del texto
print(" Paso 2: Estandarizando formato de texto...")
if 'Customer Name' in cleaned.columns:
cleaned['Customer Name'] = cleaned['Customer Name'].str.title()
if 'Email' in cleaned.columns:
cleaned['Email'] = cleaned['Email'].str.lower()
# Paso 3: Eliminar duplicados
print(" Paso 3: Eliminando filas duplicadas...")
before_dedup = len(cleaned)
cleaned = cleaned.drop_duplicates()
duplicates_removed = before_dedup - len(cleaned)
print(f" → Eliminadas {duplicates_removed} filas duplicadas")
# Paso 4: Manejar valores faltantes
print(" Paso 4: Manejando valores faltantes...")
# Rellenar columnas numéricas con valores apropiados
if 'Age' in cleaned.columns:
mean_age = cleaned['Age'].mean()
cleaned['Age'] = cleaned['Age'].fillna(round(mean_age))
print(f" → Rellenadas edades faltantes con el promedio: {mean_age:.0f}")
if 'Purchase Amount' in cleaned.columns:
median_amount = cleaned['Purchase Amount'].median()
cleaned['Purchase Amount'] = cleaned['Purchase Amount'].fillna(median_amount)
print(f" → Rellenados montos faltantes con la mediana: ${median_amount:,.2f}")
# Paso 5: Validar y corregir formatos de correo electrónico
if 'Email' in cleaned.columns:
print(" Paso 5: Validando direcciones de correo electrónico...")
# Validación simple de correo electrónico
email_pattern = r'^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$'
valid_emails = cleaned['Email'].str.match(email_pattern, na=False)
invalid_count = (~valid_emails).sum()
if invalid_count > 0:
print(f" → Se encontraron {invalid_count} direcciones de correo electrónico no válidas")
# Reemplazar correos electrónicos no válidos con un marcador de posición
cleaned.loc[~valid_emails, 'Email'] = 'invalid@example.com'
# Paso 6: Estandarizar formatos de fecha
if 'Registration Date' in cleaned.columns:
print(" Paso 6: Estandarizando formatos de fecha...")
try:
cleaned['Registration Date'] = pd.to_datetime(
cleaned['Registration Date'],
errors='coerce'
)
invalid_dates = cleaned['Registration Date'].isnull().sum()
if invalid_dates > 0:
print(f" → Se encontraron {invalid_dates} fechas no válidas, establecidas en None")
except Exception as e:
print(f" ⚠️ No se pudieron analizar las fechas: {e}")
# Informe de resumen
print("\n 📋 Resumen de Limpieza:")
print(f" Filas originales: {initial_rows}")
print(f" Filas finales: {len(cleaned)}")
print(f" Filas eliminadas: {initial_rows - len(cleaned)}")
print(f" Valores nulos corregidos: {initial_nulls - cleaned.isnull().sum().sum()}")
self.cleaned_data = cleaned
return cleaned
def create_comprehensive_report(self, output_file='analysis_results.xlsx'):
"""
Crea un informe detallado de Excel con múltiples hojas
Parámetros:
-----------
output_file : str
Nombre del archivo de salida para el informe
Devuelve:
--------
bool: Estado de éxito
"""
print(f"\n📝 Creando informe completo: {output_file}")
try:
# Crear escritor de Excel con motor específico
with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
# Hoja 1: Resumen Mensual
if self.monthly_summary is not None:
self.monthly_summary.to_excel(
writer,
sheet_name='Monthly Summary'
)
print(" ✅ Añadida hoja de Resumen Mensual")
# Hoja 2: Análisis de Categoría
if self.category_summary is not None:
self.category_summary.to_excel(
writer,
sheet_name='Category Analysis'
)
print(" ✅ Añadida hoja de Análisis de Categoría")
# Hoja 3: Datos de Clientes Limpios
if self.cleaned_data is not None:
self.cleaned_data.to_excel(
writer,
sheet_name='Cleaned Customers',
index=False
)
print(" ✅ Añadida hoja de Clientes Limpios")
# Hoja 4: Muestra de Datos
if self.combined_sales is not None:
sample_size = min(100, len(self.combined_sales))
self.combined_sales.head(sample_size).to_excel(
writer,
sheet_name='Data Sample',
index=False
)
print(f" ✅ Añadida hoja de Muestra de Datos ({sample_size} filas)")
# Hoja 5: Estadísticas de Resumen
if self.combined_sales is not None:
stats_df = self.combined_sales.describe()
stats_df.to_excel(
writer,
sheet_name='Statistics'
)
print(" ✅ Añadida hoja de Estadísticas")
print(f"\n✅ Informe guardado exitosamente en: {output_file}")
# Explicación del marcador de posición de la imagen
print("\n📸 Nota: El artículo original mostraba capturas de pantalla del informe de Excel aquí.")
print(" Tu informe generado contiene estas hojas:")
print(" 1. Resumen Mensual - Ventas agregadas por mes")
print(" 2. Análisis de Categoría - Rendimiento por categoría de producto")
print(" 3. Clientes Limpios - Datos de clientes procesados")
print(" 4. Muestra de Datos - Primeras 100 filas de datos combinados")
print(" 5. Estadísticas - Resumen estadístico de columnas numéricas")
return True
except Exception as e:
print(f"\n❌ Error al crear el informe: {e}")
return False
def save_combined_data(self, output_file='combined_sales.xlsx'):
"""Guarda los datos de ventas combinados en Excel"""
if self.combined_sales is not None:
print(f"\n💾 Guardando datos combinados en: {output_file}")
self.combined_sales.to_excel(output_file, index=False, engine='openpyxl')
print(f" ✅ Guardadas {len(self.combined_sales):,} filas")
return True
else:
print(" ⚠️ No hay datos combinados para guardar")
return False
def main():
"""Función principal de ejecución"""
print("=" * 70)
print("Script de Automatización de Excel - Procesamiento Principal")
print("=" * 70)
# Inicializar automatización
automation = ExcelAutomation()
# Paso 1: Verificar prerrequisitos
if not automation.verify_prerequisites():
print("\n❌ No se cumplen los prerrequisitos. Saliendo...")
return False
try:
# Paso 2: Combinar archivos de Excel
combined_df = automation.combine_excel_files("excel_files")
# Paso 3: Guardar datos combinados
automation.save_combined_data()
# Paso 4: Analizar datos de ventas
monthly, category = automation.analyze_sales(combined_df)
# Paso 5: Limpiar datos de clientes
print("\n" + "-" * 70)
messy_df = pd.read_excel("messy_data.xlsx", engine='openpyxl')
cleaned_df = automation.clean_customer_data(messy_df)
# Paso 6: Crear informe completo
print("\n" + "-" * 70)
automation.create_comprehensive_report()
# Resumen de éxito
print("\n" + "=" * 70)
print("✨ ¡Todos los procesos se completaron exitosamente!")
print("=" * 70)
print("\n📁 Archivos de Salida Creados:")
print(" • combined_sales.xlsx - Datos de ventas fusionados")
print(" • analysis_results.xlsx - Informe de análisis completo")
print("\n📊 Próximos Pasos:")
print(" 1. Abre analysis_results.xlsx en Excel")
print(" 2. Revisa las diferentes hojas para obtener información")
print(" 3. Personaliza los scripts para tus propios datos")
return True
except Exception as e:
print(f"\n❌ Error crítico: {e}")
print("\nSolución de problemas:")
print("1. Asegúrate de que los datos de muestra se generaron correctamente")
print("2. Comprueba que no haya archivos de Excel abiertos actualmente")
print("3. Verifica que todos los paquetes requeridos estén instalados")
print("4. Comprueba los permisos de archivo en el directorio actual")
# Información de depuración adicional
import traceback
print("\nInformación de Depuración:")
traceback.print_exc()
return False
if __name__ == "__main__":
success = main()
sys.exit(0 if success else 1)
Parte 4: Ejecutando la Automatización Completa
Pasos de Ejecución
Guarda los tres scripts en el mismo directorio:
verify_installation.py
generate_sample_data.py
excel_automation.py
Ejecuta en secuencia:
# Paso 1: Verifica tu entorno
python verify_installation.py
# Paso 2: Genera datos de muestra
python generate_sample_data.py
# Paso 3: Ejecuta la automatización
python excel_automation.py
Qué Sucede Durante la Ejecución
Al Ejecutar generate_sample_data.py:
Crea el directorio excel_files si no existe
Genera datos de ventas de 2024 con ~1,500 registros por archivo
Divide los datos en 3 archivos para la práctica de fusión
Crea datos de clientes desordenados con varios problemas
Genera datos limpios de referencia para comparación
Al Ejecutar excel_automation.py:
Verifica Prerrequisitos
Comprueba que todos los archivos requeridos existan
Proporciona retroalimentación clara sobre los elementos faltantes
Combina Archivos de Excel
Lee todos los archivos divididos de la carpeta excel_files
Los fusiona en un único conjunto de datos
Ordena por fecha para consistencia
Analiza Datos de Ventas
Calcula totales mensuales, promedios y recuentos
Agrega las ventas por categoría de producto
Identifica los de mejor rendimiento
Limpia Datos de Clientes
Elimina espacios en blanco extra
Estandariza el formato del texto
Elimina duplicados
Maneja valores faltantes de forma inteligente
Valida formatos de correo electrónico
Crea Informe Completo
Genera un libro de trabajo de Excel de varias hojas
Incluye resúmenes, análisis y datos limpios
Archivos de Salida Generados
Después de una ejecución exitosa, tendrás:
combined_sales.xlsx
Conjunto de datos de ventas fusionado completo
Todos los registros de los tres archivos divididos
analysis_results.xlsx
Hoja: “Monthly Summary” – Métricas de ventas mensuales
Hoja: “Category Analysis” – Rendimiento del producto
Hoja: “Cleaned Customers” – Datos de clientes procesados
Hoja: “Data Sample” – Primeras 100 filas para revisión
Hoja: “Statistics” – Estadísticas descriptivas
Parte 5: Errores Comunes y Soluciones
Error 1: ModuleNotFoundError: No module named 'pandas'
El archivo de Excel está abierto – Cierra todos los archivos de Excel
Sin permiso de escritura – Comprueba los permisos de la carpeta
Bloqueo por antivirus – Añade una excepción para Python
Error 3: FileNotFoundError: No such file or directory
Solución:
# Asegúrate de estar en el directorio correcto
pwd # Linux/Mac
cd # Windows# Ejecuta los scripts en orden
python generate_sample_data.py # Primero
python excel_automation.py # Segundo
Error 4: ValueError: Excel file format cannot be determined
Solución: Asegúrate de que los archivos sean archivos de Excel reales (.xlsx) y no CSV renombrados a .xlsx
# Añadir al método analyze_sales
def calculate_growth_rate(df):
"""Calcula la tasa de crecimiento mes a mes"""
monthly = df.groupby('Year-Month')['Sales Amount'].sum()
growth = monthly.pct_change() * 100
return growth
Añadir Pronóstico:
# Pronóstico de media móvil simple
def forecast_sales(df, periods=3):
"""Pronóstico de media móvil simple"""
monthly = df.groupby('Year-Month')['Sales Amount'].sum()
forecast = monthly.rolling(window=periods).mean()
return forecast
2. Añadir Validación de Datos
def validate_data(df):
"""Valida la calidad de los datos"""
issues = []
# Comprobar valores negativos
if (df['Sales Amount'] < 0).any():
issues.append("Se encontraron montos de ventas negativos")
# Comprobar fechas futuras
if (df['Date'] > pd.Timestamp.now()).any():
issues.append("Se detectaron fechas futuras")
return issues
3. Añadir Visualización
import matplotlib.pyplot as plt
def create_charts(df):
"""Genera gráficos de visualización"""
# Tendencia de ventas mensuales
monthly = df.groupby('Year-Month')['Sales Amount'].sum()
plt.figure(figsize=(12, 6))
plt.plot(monthly.index, monthly.values)
plt.title('Tendencia de Ventas Mensuales')
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('sales_trend.png')
plt.close()
print(" ✅ Gráfico guardado: sales_trend.png")
4. Añadir Informes por Correo Electrónico
def email_report(file_path, recipient):
"""Envía el informe por correo electrónico (requiere configuración de correo electrónico)"""
# Esta es una plantilla - requiere configuración de SMTP
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
# Configurar con tus ajustes de correo electrónico# ...código de envío de correo electrónico...
Conclusión
¡Has aprendido con éxito cómo automatizar tareas de Excel usando Python y pandas! Esta guía completa ha cubierto:
✅ Configuración del entorno con verificación
✅ Generación de datos de muestra con conjuntos de datos realistas
✅ Fusión y consolidación de archivos
✅ Análisis de datos con múltiples métricas
✅ Limpieza de datos con técnicas profesionales
✅ Generación de informes con múltiples hojas
✅ Manejo de errores y solución de problemas
Próximos Pasos
Aplica a Tus Datos: Modifica los scripts para tus archivos de Excel específicos
Añade Funciones: Implementa los consejos de personalización
Escala: Procesa conjuntos de datos más grandes y múltiples tipos de archivos
Integra: Conecta con bases de datos y APIs
Programa: Usa programadores de tareas para la automatización regular
Mejores Prácticas
Siempre haz una copia de seguridad de tus archivos originales
Verifica que todos los archivos estén en la ubicación correcta
Asegúrate de que no haya archivos de Excel abiertos durante el procesamiento
Usa el script de verificación para comprobar tu entorno
Este tutorial se actualiza continuamente. Última actualización: Septiembre 2025.
Un sitio cualquiera
Análisis de Datos en Excel con Python y SciPyLleva tu automatización de Excel al siguiente nivel. Aprende a realizar análisis de datos avanzados con Python y SciPy, incluyendo tendencias, estadísticas y so…
