Processar dados: CSV, Excel, imagens
Nesta página
Atualizado em 2 de novembro de 2026 com base na documentação da OpenAI: a ferramenta Code Interpreter requer um parâmetro
container(adicionado a todos os exemplos), as partes de texto de entrada utilizam o tipoinput_texte a pesquisa na web usa a ferramentaweb_search(web_search_previewé agora uma ferramenta legada sem filtros de domínio). Os ficheiros gerados são recuperados utilizando as funçõesfichiers_generesetelechargerda Lição 10. Os ficheiros anexados a uma mensagem são carregados com a utilizaçãouser_data, que a OpenAI recomenda para entradas do modelo (File inputs). Fontes: Code Interpreter · Web search.
Processar dados: CSV, Excel, imagens
O Code Interpreter altera a natureza do que pede ao modelo para fazer. Sem ele, obtém uma descrição do que precisa de ser feito; com ele, o modelo escreve código Python, executa-o numa sandbox, verifica o resultado e corrige o seu próprio código se cometer um erro. Para um ficheiro de dados, a diferença é decisiva: ninguém consegue adivinhar a estrutura de um CSV sem o abrir, e é exatamente isso que a execução de código permite.
O raciocínio desta lição aplica-se aos três formatos que se seguem. Carrega o ficheiro, descreve o resultado esperado em linguagem natural e recupera quer uma análise quer um novo ficheiro. O que separa um bom uso de um mau resume-se à precisão da sua instrução: «analisar este ficheiro» produz um resumo genérico, enquanto um pedido numerado como os abaixo produz um resultado que pode utilizar tal como está.
Processamento de ficheiros CSV
Análise exploratória
Comece sempre aqui, mesmo quando pensa conhecer o ficheiro. Um CSV exportado de uma ferramenta de gestão guarda surpresas que a especificação não menciona: uma coluna numérica armazenada como texto devido a um separador decimal, datas em três formatos diferentes ou uma linha de totais infiltrada no meio dos dados. Os cinco pontos solicitados abaixo — dimensões, tipos, valores em falta, estatísticas e uma pré-visualização — são o mínimo antes de qualquer transformação, pois determinam o que pode pedir a seguir.
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": (
"Analyze this CSV file: "
"1. Number of rows and columns "
"2. Data types for each column "
"3. Missing values per column "
"4. Descriptive statistics for numeric columns "
"5. The first 5 rows"
)},
{"type": "input_file", "file_id": fichier.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)
Limpeza e transformação
A limpeza é a etapa onde as decisões importam e onde as deve tomar explicitamente, em vez de as deixar ao critério do modelo. Preencher valores em falta com a mediana para números e a moda para categorias é uma escolha defensável, mas é uma escolha: numa coluna de receitas onde um terço dos valores falta, cria-se uma distribuição artificialmente estreita que enviesará qualquer análise subsequente. Declare a regra no seu prompt, como mostrado abaixo, e saberá o que foi feito; seja vago e terá de reabrir o ficheiro para o descobrir.
response = client.responses.create(
model="gpt-5.6-terra",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": (
"Clean this CSV: "
"- Remove duplicates "
"- Fill missing values (median for numbers, "
" mode for categories) "
"- Normalize city names (title case) "
"- Convert dates to ISO format "
"- Export the result as a cleaned CSV"
)},
{"type": "input_file", "file_id": fichier.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# Retrieve the cleaned file
for ann in fichiers_generes(response):
telecharger(client, ann, "clients_nettoye.csv")
Processamento de ficheiros Excel
O Code Interpreter lida nativamente com ficheiros Excel graças ao openpyxl. Duas diferenças face ao CSV merecem a sua atenção. Primeiro, um livro de trabalho contém várias folhas, e um prompt que não especifique uma fará com que o modelo trabalhe naquela que escolher primeiro; comece, portanto, por pedir uma lista das folhas, como no exemplo. Segundo, o Excel contém fórmulas, células mescladas e linhas de cabeçalho decorativas — elementos que parecem dados mas não o são, e que o modelo deve saber ignorar porque lho disse.
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": (
"This Excel file contains multiple sheets. "
"1. List all available sheets "
"2. For each sheet, provide a summary of the content "
"3. Create a pivot table: total expenses "
" by department and by quarter "
"4. Export the result to a new Excel file"
)},
{"type": "input_file", "file_id": fichier_excel.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
Fusão de múltiplos ficheiros
A fusão é o caso em que a execução de código supera mais claramente o processamento manual: quatro trimestres significam quatro ficheiros cujas colunas têm nomes quase iguais e uma ordem quase idêntica. Esse «quase» é o problema, e é precisamente o que um programa deteta enquanto o copiar-colar o mascara. Peça uma folha de resumo para além dos dados fundidos: serve de controlo, pois um total que não corresponda à soma dos quatro ficheiros revela imediatamente uma coluna desalinhada.
# Upload multiple files
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": (
"These 4 Excel files contain sales data by quarter. "
"Merge them into a single file with: "
"- A 'Data' sheet with all sales "
"- A 'Summary' sheet with totals by quarter "
"- A 'Trends' sheet with quarter-over-quarter variations"
)}
]
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"}}]
)
Processamento de imagens
O Code Interpreter manipula imagens com a Pillow, e precisa de ver claramente o que isso abrange. Isto é processamento de imagem — redimensionar, converter, medir, compor — e não compreensão visual: para descrever o que uma foto mostra, são as capacidades de visão do modelo que estão em ação, não a sandbox. As duas combinam-se muito bem numa única chamada, com o modelo a observar a imagem enquanto o código a transforma.
Análise e transformação
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": (
"Analyze this image: "
"1. Dimensions, format, file size "
"2. Color histogram "
"3. Create 3 versions: "
" - Thumbnail 200x200 "
" - Black and white version "
" - Version with contrast increased by 30%"
)},
{"type": "input_file", "file_id": fichier_image.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
Processamento em lote
O processamento em lote desloca a questão para o custo e os limites. Cada imagem carregada consome armazenamento e ocupa a sandbox, cujo espaço e tempo de vida são limitados: além de algumas dezenas de ficheiros, um script local com a Pillow custa menos e executa mais rápido. Reserve o processamento em lote para casos em que a decisão é difícil de codificar — um recorte que depende do conteúdo, uma marca d’água a colocar onde a imagem é mais uniforme — e deixe as transformações mecânicas para a sua própria máquina.
# Upload multiple images
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": (
"Resize all these images to 800x600 pixels, "
"add a semi-transparent 'DRAFT' watermark, "
"and compress as JPEG quality 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"}}]
)
Padrão: Pipeline ETL completo
def pipeline_etl(fichier_source: str, transformations: str) -> dict:
"""Extract-Transform-Load pipeline with Code Interpreter."""
# Extract: upload source file
with open(fichier_source, "rb") as f:
fichier = client.files.create(file=f, purpose="user_data")
# Transform: apply transformations
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=(
"Execute each transformation step by step. "
"Display a summary after each step: "
"number of rows before/after, modified columns. "
"Export the final result as CSV and Excel."
)
)
# Load: retrieve generated files
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
}
# Usage
resultat = pipeline_etl(
"donnees_brutes.csv",
"1. Remove empty columns "
"2. Convert amounts from cents to euros "
"3. Add a 'quarter' column based on the date "
"4. Aggregate sales by quarter and category "
"5. Calculate percentage variations"
)
Formatos suportados
| Formato | Extensões | Leitura | Escrita |
|---|---|---|---|
| CSV | .csv | Sim | Sim |
| Excel | .xlsx, .xls | Sim | Sim |
| JSON | .json | Sim | Sim |
| Imagens | .png, .jpg, .gif, .bmp | Sim | Sim |
| Texto | .txt, .md | Sim | Sim |
| Leitura limitada | Não |
Pontos-chave
- Carregue ficheiros com
purpose="user_data"e passe-os viainput_file - O modelo lida nativamente com CSV, Excel multifoldas e imagens
- Recupere os ficheiros gerados a partir das anotações
container_file_citatione transfira-os através da API de contentores (Lição 10) - Para ficheiros grandes, solicite processamento em lote
- Combine vários ficheiros numa única chamada para fusões e comparações