Cómo Automatizar Excel con IA: ChatGPT + Python [Guía 2026]

1Tengo una tabla en Excel:
2- Columna A: Nombres (John, Jane, Bob)
3- Columna B: Ventas (1000, 2500, 1200)
4- Columna C: Comisión (5%)
5 
6¿Qué fórmula calcula la comisión de cada persona?

1=B2*C$2
2 
3En la celda D2, escribe: =B2*$C$2
4Luego copia hacia abajo.
5 
6O si quieres una sola fórmula array:
7=B2:B4*C$2

1Tengo ventas por producto (columna A) y cantidades (columna B).
2Quiero un VLOOKUP que busque en una tabla "producto" : "precio"
3en el rango E2:F100, y calcule el total.
4 
5La tabla lookup es:
6Producto | Precio
7iPhone   | 800
8Samsung  | 600
9Pixel    | 500

1=VLOOKUP(A2,$E$2:$F$100,2,FALSE)*B2

1Quiero buscar el nombre en A2 en la tabla E:G
2(Nombre, Edad, Salario) y retornar el Salario.

1=INDEX($G$2:$G$100,MATCH(A2,$E$2:$E$100,0))

1pip install openpyxl pandas openpyxl requests python-dotenv

1from openpyxl import load_workbook
2 
3# Cargar archivo existente
4wb = load_workbook('ventas.xlsx')
5ws = wb.active
6 
7# Leer datos
8for row in ws.iter_rows(min_row=2, max_row=10, min_col=1, max_col=3):
9    nombre, ventas, comisión = row[0].value, row[1].value, row[2].value
10    print(f"{nombre}: {ventas} (comisión: {comisión})")
11 
12# Escribir datos
13ws['D2'] = 'Nueva columna'
14wb.save('ventas_actualizado.xlsx')

1from openpyxl import Workbook
2from openpyxl.styles import Font, PatternFill, Alignment
3from openpyxl.utils import get_column_letter
4import pandas as pd
5from datetime import datetime
6 
7class ReporteVentas:
8    def __init__(self, datos: list):
9        self.datos = datos
10        self.wb = Workbook()
11        self.ws = self.wb.active
12        self.ws.title = "Ventas"
13 
14    def crear_encabezados(self):
15        """Crea encabezados con estilo."""
16        headers = ["Fecha", "Producto", "Cantidad", "Precio Unitario", "Total"]
17 
18        for col_num, header in enumerate(headers, 1):
19            cell = self.ws.cell(row=1, column=col_num)
20            cell.value = header
21            cell.font = Font(bold=True, size=12, color="FFFFFF")
22            cell.fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid")
23            cell.alignment = Alignment(horizontal="center")
24 
25        # Ancho de columnas
26        self.ws.column_dimensions['A'].width = 12
27        self.ws.column_dimensions['B'].width = 20
28        self.ws.column_dimensions['C'].width = 10
29        self.ws.column_dimensions['D'].width = 15
30        self.ws.column_dimensions['E'].width = 12
31 
32    def agregar_datos(self):
33        """Agrega datos y fórmulas."""
34        for idx, row_data in enumerate(self.datos, start=2):
35            fecha, producto, cantidad, precio = row_data
36 
37            self.ws[f'A{idx}'] = fecha
38            self.ws[f'B{idx}'] = producto
39            self.ws[f'C{idx}'] = cantidad
40            self.ws[f'D{idx}'] = precio
41 
42            # Fórmula para Total (cantidad × precio)
43            self.ws[f'E{idx}'] = f'=C{idx}*D{idx}'
44 
45            # Formato moneda
46            self.ws[f'E{idx}'].number_format = '$#,##0.00'
47            self.ws[f'D{idx}'].number_format = '$#,##0.00'
48 
49    def agregar_totales(self):
50        """Agrega fila de totales al final."""
51        last_row = len(self.datos) + 2
52 
53        self.ws[f'B{last_row}'] = 'TOTAL'
54        self.ws[f'B{last_row}'].font = Font(bold=True)
55 
56        # Suma del total
57        self.ws[f'E{last_row}'] = f'=SUM(E2:E{last_row-1})'
58        self.ws[f'E{last_row}'].font = Font(bold=True)
59        self.ws[f'E{last_row}'].number_format = '$#,##0.00'
60 
61    def exportar(self, filename: str = None):
62        """Guarda el reporte."""
63        if filename is None:
64            filename = f"reporte_ventas_{datetime.now().strftime('%Y%m%d')}.xlsx"
65 
66        self.wb.save(filename)
67        print(f"✓ Reporte guardado: {filename}")
68 
69# Uso
70datos_ventas = [
71    (datetime(2026, 2, 8), "iPhone 15", 5, 999),
72    (datetime(2026, 2, 8), "Samsung Galaxy", 3, 799),
73    (datetime(2026, 2, 8), "Pixel 9", 2, 599),
74]
75 
76reporte = ReporteVentas(datos_ventas)
77reporte.crear_encabezados()
78reporte.agregar_datos()
79reporte.agregar_totales()
80reporte.exportar()

1import pandas as pd
2import numpy as np
3 
4# Cargar Excel
5df = pd.read_excel('datos_sucios.xlsx')
6 
7# Eliminar duplicados
8df = df.drop_duplicates()
9 
10# Eliminar espacios en blanco
11df['nombre'] = df['nombre'].str.strip()
12 
13# Rellenar valores faltantes
14df['comisión'] = df['comisión'].fillna(0)
15 
16# Conversión de tipos
17df['fecha'] = pd.to_datetime(df['fecha'])
18df['ventas'] = pd.to_numeric(df['ventas'], errors='coerce')
19 
20# Filtrado
21df_filtrado = df[df['ventas'] > 1000]
22 
23# Agregaciones
24resumen = df.groupby('producto')['ventas'].sum()
25 
26# Guardar
27df.to_excel('datos_limpios.xlsx', index=False)

1import openpyxl
2from openai import OpenAI
3import os
4from dotenv import load_dotenv
5 
6load_dotenv()
7client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
8 
9def consulta_chatgpt(prompt: str) -> str:
10    """Consulta ChatGPT y retorna respuesta."""
11    response = client.chat.completions.create(
12        model="gpt-4o",
13        messages=[
14            {
15                "role": "system",
16                "content": "Eres un asistente de análisis de datos Excel experto. Responde brevemente."
17            },
18            {"role": "user", "content": prompt}
19        ],
20        temperature=0.7
21    )
22    return response.choices[0].message.content
23 
24class ExcelConChatGPT:
25    def __init__(self, filepath: str):
26        self.wb = openpyxl.load_workbook(filepath)
27        self.ws = self.wb.active
28 
29    def generar_insight(self, fila_inicio: int, fila_fin: int):
30        """Usa ChatGPT para generar insights sobre datos."""
31        datos = []
32        for row in self.ws.iter_rows(
33            min_row=fila_inicio,
34            max_row=fila_fin,
35            min_col=1,
36            max_col=3,
37            values_only=True
38        ):
39            datos.append(row)
40 
41        prompt = f"""Analiza estos datos de ventas: {datos}
42        Proporciona 2-3 insights clave en una oración cada uno."""
43 
44        insight = consulta_chatgpt(prompt)
45 
46        # Inserta insight en Excel
47        self.ws['D2'] = "Insights de IA:"
48        self.ws['D3'] = insight
49 
50        self.wb.save('resultado.xlsx')
51        return insight
52 
53# Uso
54excel_ai = ExcelConChatGPT('ventas.xlsx')
55excel_ai.generar_insight(2, 10)

1import re
2 
3def extraer_datos_inteligentes(texto: str) -> dict:
4    """
5    Usa ChatGPT para extraer datos estructurados de texto no estructurado.
6    Ej: email, factura, contrato
7    """
8    prompt = f"""Extrae los siguientes datos del texto y responde en JSON:
9    - nombre
10    - email
11    - monto
12    - fecha
13    - producto
14 
15    Texto: {texto}
16 
17    Responde SOLO con JSON, sin explicación."""
18 
19    respuesta = consulta_chatgpt(prompt)
20 
21    # Parsear JSON
22    import json
23    try:
24        return json.loads(respuesta)
25    except:
26        print("Error parseando JSON")
27        return {}
28 
29# Uso
30email = """
31Hola, soy Juan Pérez (juan@empresa.com).
32Quiero una licencia de Software Pro.
33El monto es $99.99
34La fecha de activación es 2026-02-10
35"""
36 
37datos_extraidos = extraer_datos_inteligentes(email)
38print(datos_extraidos)
39# Output: {'nombre': 'Juan Pérez', 'email': 'juan@empresa.com', ...}

1"Analiza los datos de ventas y créame una tabla con totales por producto"
2 
3"Encuentra valores atípicos en la columna de precios"
4 
5"Crea una fórmula que calcule la comisión del 5% si ventas > 1000"

1import openpyxl
2from openpyxl.utils import get_column_letter
3import json
4 
5class FacturaAutomatica:
6    def __init__(self):
7        self.wb = openpyxl.Workbook()
8        self.ws = self.wb.active
9        self.setup_template()
10 
11    def setup_template(self):
12        """Crea template de factura."""
13        # Header
14        self.ws['A1'] = 'FACTURA'
15        self.ws['A1'].font = openpyxl.styles.Font(size=16, bold=True)
16 
17        # Datos cliente
18        self.ws['A3'] = 'Cliente:'
19        self.ws['B3'] = ''  # Rellenar con input
20 
21        # Tabla de items
22        headers = ['Item', 'Descripción', 'Cantidad', 'Precio Unitario', 'Total']
23        for col, header in enumerate(headers, 1):
24            self.ws.cell(row=6, column=col).value = header
25            self.ws.cell(row=6, column=col).font = openpyxl.styles.Font(bold=True)
26 
27        # Rows de items (pre-formateados)
28        for row in range(7, 17):
29            # Fórmula para Total (col D * col E)
30            self.ws[f'E{row}'] = f'=C{row}*D{row}'
31            self.ws[f'E{row}'].number_format = '$#,##0.00'
32 
33        # Totales
34        self.ws['D18'] = 'SUBTOTAL:'
35        self.ws['E18'] = '=SUM(E7:E17)'
36 
37        self.ws['D19'] = 'IVA (21%):'
38        self.ws['E19'] = '=E18*0.21'
39 
40        self.ws['D20'] = 'TOTAL:'
41        self.ws['E20'] = '=E18+E19'
42        self.ws['E20'].font = openpyxl.styles.Font(bold=True, size=12)
43 
44    def generar_factura(self, cliente: str, items: list):
45        """
46        items: [
47            {'descripcion': 'Servicio A', 'cantidad': 2, 'precio': 100},
48            {'descripcion': 'Servicio B', 'cantidad': 1, 'precio': 250},
49        ]
50        """
51        self.ws['B3'] = cliente
52 
53        for idx, item in enumerate(items, start=7):
54            self.ws[f'B{idx}'] = item['descripcion']
55            self.ws[f'C{idx}'] = item['cantidad']
56            self.ws[f'D{idx}'] = item['precio']
57            self.ws[f'D{idx}'].number_format = '$#,##0.00'
58 
59        filename = f"factura_{cliente}_{len(items)}_items.xlsx"
60        self.wb.save(filename)
61        print(f"✓ Factura generada: {filename}")
62 
63# Uso
64factura = FacturaAutomatica()
65factura.generar_factura(
66    cliente="Empresa XYZ",
67    items=[
68        {'descripcion': 'Consultoría IA', 'cantidad': 10, 'precio': 150},
69        {'descripcion': 'Desarrollo Python', 'cantidad': 40, 'precio': 100},
70    ]
71)

1import pandas as pd
2from datetime import datetime
3import requests
4 
5def monitor_precios_amazon(urls: list):
6    """
7    Monitorea precios de productos Amazon.
8    En producción, usa BeautifulSoup + Selenium.
9    Este es pseudo-código.
10    """
11    datos = []
12 
13    for url in urls:
14        # En realidad, harías scraping con Selenium
15        # Aquí es simulado
16        nombre_producto = "iPhone 15 Pro"
17        precio_actual = 999
18        fecha = datetime.now().strftime('%Y-%m-%d')
19 
20        # Consulta a ChatGPT si el precio es "bueno"
21        prompt = f"El {nombre_producto} cuesta ${precio_actual}. ¿Es buen precio en 2026?"
22        recomendacion = consulta_chatgpt(prompt)
23 
24        datos.append({
25            'Producto': nombre_producto,
26            'Precio': precio_actual,
27            'Fecha': fecha,
28            'Recomendación IA': recomendacion[:50]  # Primeros 50 caracteres
29        })
30 
31    # Guarda en Excel
32    df = pd.DataFrame(datos)
33    df.to_excel('monitoreo_precios.xlsx', index=False)
34    print("✓ Monitoreo completado")
35 
36# Uso
37monitor_precios_amazon([
38    "https://amazon.es/iPhone-15-Pro",
39    "https://amazon.es/Samsung-Galaxy-S24",
40])

1import shutil
2from datetime import datetime
3 
4filename = 'datos.xlsx'
5backup = f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
6shutil.copy(filename, backup)

1try:
2    df = pd.read_excel('datos.xlsx')
3except FileNotFoundError:
4    print("Archivo no encontrado")
5except Exception as e:
6    print(f"Error: {e}")

1# Ejecutar script cada día a las 8am (Linux/Mac)
20 8 * * * /usr/bin/python3 /path/to/script.py
3 
4# Windows: Usa Task Scheduler

1from apscheduler.schedulers.background import BackgroundScheduler
2 
3scheduler = BackgroundScheduler()
4scheduler.add_job(mi_funcion_automatizacion, 'cron', hour=8)
5scheduler.start()
6 
7# Mantén el programa corriendo
8import time
9while True:
10    time.sleep(1)

1from dotenv import load_dotenv
2import os
3 
4load_dotenv()  # Lee .env
5api_key = os.getenv("OPENAI_API_KEY")

1import requests
2 
3def consulta_ollama(prompt: str):
4    response = requests.post(
5        "http://localhost:11434/api/generate",
6        json={"model": "mistral", "prompt": prompt, "stream": False}
7    )
8    return response.json()["response"]

1for chunk in pd.read_excel('huge_file.xlsx', chunksize=10000):
2    # Procesa chunk
3    procesar(chunk)

1# Fórmula: Suma de ventas si fecha > 2026-01-01
2self.ws[f'E{row}'] = f'=SUMIF(A:A,">="&DATE(2026,1,1),E:E)'