Ir al contenido principal
Español— Elegir un idioma
Menú

Procesar datos: CSV, Excel, imágenes

Lección 12 de 20 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Procesar datos: CSV, Excel, imágenes
  2. Procesar archivos CSV
  3. Procesar archivos Excel
  4. Procesar imágenes
  5. Patrón: Canalización ETL completa
  6. Formatos admitidos
  7. Puntos clave

Actualizado el 2 de noviembre de 2026 según la documentación de OpenAI: la herramienta Code Interpreter requiere un parámetro container (añadido a todos los ejemplos), las partes de texto de entrada usan el tipo input_text, y la búsqueda web utiliza la herramienta web_search (web_search_preview es ahora una herramienta heredada sin filtros de dominio). Los archivos generados se recuperan mediante las funciones fichiers_generes y telecharger de la Lección 10. Los archivos adjuntos a un mensaje se suben con el uso user_data, que OpenAI recomienda para las entradas del modelo (Entradas de archivo). Fuentes: Code Interpreter · Búsqueda web.

Procesar datos: CSV, Excel, imágenes

Code Interpreter cambia la naturaleza de lo que le pides al modelo. Sin él, obtienes una descripción de lo que hay que hacer; con él, el modelo escribe código Python, lo ejecuta en un entorno aislado (sandbox), comprueba el resultado y corrige su propio código si comete un error. Para un archivo de datos, la diferencia es decisiva: nadie puede adivinar la estructura de un CSV sin abrirlo, y eso es exactamente lo que permite la ejecución de código.

El razonamiento de esta lección se aplica a los tres formatos siguientes. Subes el archivo, describes el resultado esperado en lenguaje natural y recuperas ya sea un análisis o un nuevo archivo. Lo que separa un buen uso de uno malo reside en la precisión de tu instrucción: «analiza este archivo» produce un resumen genérico, mientras que una solicitud numerada como las de abajo genera un resultado utilizable tal cual.

Procesar archivos CSV

Análisis exploratorio

Empieza siempre aquí, incluso cuando creas conocer el archivo. Un CSV exportado desde una herramienta empresarial guarda sorpresas que la especificación no menciona: una columna numérica almacenada como texto debido a un separador decimal, fechas en tres formatos distintos o una fila de totales colada en medio de los datos. Los cinco puntos solicitados a continuación —dimensiones, tipos, valores faltantes, estadísticas y una vista previa— son el mínimo antes de cualquier transformación, pues determinan qué puedes pedir después.

from openai import OpenAI

client = OpenAI()

with open("clients_2025.csv", "rb") as f:
    fichier = client.files.create(file=f, purpose="user_data")

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Analiza este archivo CSV: "
                "1. Número de filas y columnas "
                "2. Tipos de datos de cada columna "
                "3. Valores faltantes por columna "
                "4. Estadísticas descriptivas para columnas numéricas "
                "5. Las primeras 5 filas"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Limpieza y transformación

La limpieza es el paso donde las decisiones importan, y donde debes tomarlas explícitamente en lugar de dejarlas al modelo. Rellenar valores faltantes con la mediana para números y la moda para categorías es una elección defendible, pero es una elección: en una columna de ingresos donde falta un tercio de los valores, se crea una distribución artificialmente estrecha que sesgará cualquier análisis posterior. Establece la regla en tu prompt, como se muestra abajo, y sabrás qué se ha hecho; sé vago y tendrás que volver a abrir el archivo para averiguarlo.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Limpia este CSV: "
                "- Eliminar duplicados "
                "- Rellenar valores faltantes (mediana para números, "
                "  moda para categorías) "
                "- Normalizar nombres de ciudades (tipo título) "
                "- Convertir fechas a formato ISO "
                "- Exportar el resultado como un CSV limpio"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Recuperar el archivo limpio
for ann in fichiers_generes(response):
    telecharger(client, ann, "clients_nettoye.csv")

Procesar archivos Excel

Code Interpreter gestiona archivos Excel de forma nativa gracias a openpyxl. Dos diferencias respecto al CSV merecen tu atención. Primero, un libro de trabajo contiene varias hojas, y un prompt que no especifique una hará que el modelo trabaje sobre la que elija primero; por tanto, empieza pidiendo una lista de hojas, como en el ejemplo. Segundo, Excel contiene fórmulas, celdas combinadas y filas de cabecera decorativas: elementos que parecen datos pero no lo son, y que el modelo debe saber ignorar porque tú se lo has indicado.

with open("budget_2026.xlsx", "rb") as f:
    fichier_excel = client.files.create(file=f, purpose="user_data")

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Este archivo Excel contiene varias hojas. "
                "1. Listar todas las hojas disponibles "
                "2. Para cada hoja, proporcionar un resumen del contenido "
                "3. Crear una tabla dinámica: gastos totales "
                "   por departamento y por trimestre "
                "4. Exportar el resultado a un nuevo archivo Excel"
            )},
            {"type": "input_file", "file_id": fichier_excel.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Combinar varios archivos

Combinar es el caso donde la ejecución de código saca más ventaja al procesamiento manual: cuatro trimestres significan cuatro archivos cuyas columnas tienen nombres casi iguales y un orden casi idéntico. Ese «casi» es el problema, y es precisamente lo que detecta un programa mientras que el copiar y pegar lo enmascara. Pide una hoja de resumen además de los datos combinados: sirve de control, ya que un total que no coincide con la suma de los cuatro archivos revela de inmediato una columna desalineada.

# Subir varios archivos
fichiers_ids = []
for nom in ["ventes_q1.xlsx", "ventes_q2.xlsx", "ventes_q3.xlsx", "ventes_q4.xlsx"]:
    with open(nom, "rb") as f:
        fichier = client.files.create(file=f, purpose="user_data")
        fichiers_ids.append(fichier.id)

content = [
    {"type": "input_text", "text": (
        "Estos 4 archivos Excel contienen datos de ventas por trimestre. "
        "Combínalos en un único archivo con: "
        "- Una hoja 'Data' con todas las ventas "
        "- Una hoja 'Summary' con totales por trimestre "
        "- Una hoja 'Trends' con variaciones trimestre a trimestre"
    )}
]
for fid in fichiers_ids:
    content.append({"type": "input_file", "file_id": fid})

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{"role": "user", "content": content}],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Procesar imágenes

Code Interpreter manipula imágenes con Pillow, y necesitas ver claramente qué abarca esto. Se trata de procesamiento de imágenes —cambio de tamaño, conversión, medición, composición—, no de comprensión visual: para describir qué muestra una foto, están en juego las capacidades de visión del modelo, no el entorno aislado. Ambas se combinan muy bien en una única llamada, con el modelo observando la imagen mientras el código la transforma.

Análisis y transformación

with open("photo_produit.jpg", "rb") as f:
    fichier_image = client.files.create(file=f, purpose="user_data")

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Analiza esta imagen: "
                "1. Dimensiones, formato, tamaño de archivo "
                "2. Histograma de color "
                "3. Crear 3 versiones: "
                "   - Miniatura 200x200 "
                "   - Versión en blanco y negro "
                "   - Versión con contraste aumentado un 30%"
            )},
            {"type": "input_file", "file_id": fichier_image.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Procesamiento por lotes

El procesamiento por lotes desplaza la cuestión al coste y los límites. Cada imagen subida consume almacenamiento y ocupa el entorno aislado, cuyo espacio y vida útil están acotados: más allá de unas pocas decenas de archivos, un script local con Pillow cuesta menos y se ejecuta más rápido. Reserva el procesamiento por lotes para casos donde la decisión es difícil de codificar —un recorte que depende del contenido, una marca de agua que colocar donde la imagen sea más uniforme— y deja las transformaciones mecánicas para tu propia máquina.

# Subir varias imágenes
images_ids = []
for img_path in ["img1.png", "img2.png", "img3.png"]:
    with open(img_path, "rb") as f:
        fichier = client.files.create(file=f, purpose="user_data")
        images_ids.append(fichier.id)

content = [
    {"type": "input_text", "text": (
        "Redimensiona todas estas imágenes a 800x600 píxeles, "
        "añade una marca de agua semitransparente 'DRAFT', "
        "y comprime como JPEG con calidad 85."
    )}
]
for fid in images_ids:
    content.append({"type": "input_file", "file_id": fid})

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{"role": "user", "content": content}],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Patrón: Canalización ETL completa

def pipeline_etl(fichier_source: str, transformations: str) -> dict:
    """Canalización Extract-Transform-Load con Code Interpreter."""
    # Extract: subir archivo fuente
    with open(fichier_source, "rb") as f:
        fichier = client.files.create(file=f, purpose="user_data")

    # Transform: aplicar transformaciones
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": transformations},
                {"type": "input_file", "file_id": fichier.id}
            ]
        }],
        tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
        instructions=(
            "Ejecuta cada paso de transformación uno a uno. "
            "Muestra un resumen tras cada paso: "
            "número de filas antes/después, columnas modificadas. "
            "Exporta el resultado final como CSV y Excel."
        )
    )

    # Load: recuperar archivos generados
    fichiers_sortie = []
    for ann in fichiers_generes(response):
        telecharger(client, ann, ann.filename)
        fichiers_sortie.append(ann.filename)

    return {
        "rapport": response.output_text,
        "fichiers_generes": fichiers_sortie
    }

# Uso
resultat = pipeline_etl(
    "donnees_brutes.csv",
    "1. Eliminar columnas vacías "
    "2. Convertir importes de céntimos a euros "
    "3. Añadir una columna 'quarter' basada en la fecha "
    "4. Agregar ventas por trimestre y categoría "
    "5. Calcular variaciones porcentuales"
)

Formatos admitidos

FormatoExtensionesLecturaEscritura
CSV.csvSíSí
Excel.xlsx, .xlsSíSí
JSON.jsonSíSí
Imágenes.png, .jpg, .gif, .bmpSíSí
Texto.txt, .mdSíSí
PDF.pdfLectura limitadaNo

Puntos clave

  • Sube archivos con purpose="user_data" y pásalos mediante input_file
  • El modelo gestiona nativamente CSV, Excel con varias hojas e imágenes
  • Recupera los archivos generados a partir de las anotaciones container_file_citation y descárgalos mediante la API de contenedores (Lección 10)
  • Para archivos grandes, solicita procesamiento por lotes
  • Combina varios archivos en una única llamada para fusiones y comparaciones