Procesar datos: CSV, Excel, imágenes
En esta página
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 tipoinput_text, y la búsqueda web utiliza la herramientaweb_search(web_search_previewes ahora una herramienta heredada sin filtros de dominio). Los archivos generados se recuperan mediante las funcionesfichiers_generesytelechargerde la Lección 10. Los archivos adjuntos a un mensaje se suben con el usouser_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
| Formato | Extensiones | Lectura | Escritura |
|---|---|---|---|
| CSV | .csv | Sí | Sí |
| Excel | .xlsx, .xls | Sí | Sí |
| JSON | .json | Sí | Sí |
| Imágenes | .png, .jpg, .gif, .bmp | Sí | Sí |
| Texto | .txt, .md | Sí | Sí |
| Lectura limitada | No |
Puntos clave
- Sube archivos con
purpose="user_data"y pásalos medianteinput_file - El modelo gestiona nativamente CSV, Excel con varias hojas e imágenes
- Recupera los archivos generados a partir de las anotaciones
container_file_citationy 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