Aller au contenu principal

Traiter des données : CSV, Excel, images

Traiter des données : CSV, Excel, images

Code Interpreter change la nature de ce que vous demandez au modèle. Sans lui, vous obtenez une description de ce qu’il faudrait faire ; avec lui, le modèle écrit du Python, l’exécute dans un bac à sable, regarde le résultat et corrige son propre code s’il se trompe. Pour un fichier de données, la différence est décisive : personne ne peut deviner la structure d’un CSV sans l’ouvrir, et c’est exactement ce que l’exécution permet.

Le raisonnement de cette leçon vaut pour les trois formats qui suivent. Vous téléversez le fichier, vous décrivez le résultat attendu en langage naturel, et vous récupérez soit une analyse, soit un nouveau fichier. Ce qui distingue un bon usage d’un mauvais tient dans la précision de la consigne : « analyse ce fichier » produit un résumé générique, tandis qu’une demande numérotée comme celles ci-dessous produit un résultat exploitable tel quel.

Traitement de fichiers CSV

Analyse exploratoire

Commencez toujours par là, même quand vous croyez connaître le fichier. Un CSV exporté d’un outil métier réserve des surprises que la spécification ne mentionne pas : une colonne numérique stockée en texte à cause d’un séparateur décimal, des dates dans trois formats différents, une ligne de total glissée au milieu des données. Les cinq points demandés ci-dessous — dimensions, types, valeurs manquantes, statistiques, aperçu — sont le minimum avant toute transformation, parce qu’ils déterminent ce que vous pourrez demander ensuite.

from openai import OpenAI

client = OpenAI()

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

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "text", "text": (
                "Analyse ce fichier CSV : "
                "1. Nombre de lignes et colonnes "
                "2. Types de données de chaque colonne "
                "3. Valeurs manquantes par colonne "
                "4. Statistiques descriptives des colonnes numériques "
                "5. Les 5 premières lignes"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter"}]
)

print(response.output_text)

Nettoyage et transformation

Le nettoyage est l’étape où les décisions comptent, et où il faut les prendre explicitement plutôt que de les laisser au modèle. Remplir les valeurs manquantes par la médiane pour les nombres et par le mode pour les catégories est un choix défendable, mais c’en est un : sur une colonne de revenus dont un tiers des valeurs manquent, il fabrique une distribution artificiellement resserrée qui faussera toute analyse ultérieure. Formulez la règle dans le prompt, comme ci-dessous, et vous saurez ce qui a été fait ; restez vague, et vous devrez rouvrir le fichier pour le découvrir.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "text", "text": (
                "Nettoie ce CSV : "
                "- Supprime les doublons "
                "- Remplis les valeurs manquantes (médiane pour les nombres, "
                "  mode pour les catégories) "
                "- Normalise les noms de villes (majuscule initiale) "
                "- Convertis les dates au format ISO "
                "- Exporte le résultat en CSV nettoyé"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter"}]
)

# Recuperer le fichier nettoye
for item in response.output:
    if item.type == "code_interpreter_call":
        for result in item.results:
            if hasattr(result, "files"):
                for f in result.files:
                    contenu = client.files.content(f.file_id)
                    with open("clients_nettoye.csv", "wb") as out:
                        out.write(contenu.read())

Traitement de fichiers Excel

Code Interpreter gère nativement les fichiers Excel grâce à openpyxl. Deux différences avec le CSV méritent votre attention. D’abord, un classeur contient plusieurs onglets, et un prompt qui ne le précise pas fera travailler le modèle sur le premier venu ; commencez donc par demander la liste des onglets, comme dans l’exemple. Ensuite, Excel porte des formules, des cellules fusionnées et des lignes d’en-tête décoratives — autant d’éléments qui ressemblent à des données sans en être, et que le modèle doit savoir ignorer parce que vous le lui avez dit.

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

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "text", "text": (
                "Ce fichier Excel contient plusieurs onglets. "
                "1. Liste tous les onglets disponibles "
                "2. Pour chaque onglet, donne un résumé du contenu "
                "3. Fais un tableau croisé dynamique : total des dépenses "
                "   par département et par trimestre "
                "4. Exporte le résultat dans un nouveau fichier Excel"
            )},
            {"type": "input_file", "file_id": fichier_excel.id}
        ]
    }],
    tools=[{"type": "code_interpreter"}]
)

Fusionner plusieurs fichiers

La fusion est le cas où l’exécution de code prend le plus d’avance sur un traitement manuel : quatre trimestres, c’est quatre fichiers dont les colonnes ont presque le même nom et presque le même ordre. Le presque est le problème, et c’est précisément ce qu’un programme détecte alors qu’un copier-coller le masque. Demandez un onglet de synthèse en plus des données fusionnées : il vous sert de contrôle, puisqu’un total qui ne correspond pas à la somme des quatre fichiers révèle immédiatement une colonne mal alignée.

# Upload de plusieurs fichiers
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="assistants")
        fichiers_ids.append(fichier.id)

content = [
    {"type": "text", "text": (
        "Ces 4 fichiers Excel contiennent les ventes par trimestre. "
        "Fusionne-les en un seul fichier avec : "
        "- Un onglet 'Données' avec toutes les ventes "
        "- Un onglet 'Résumé' avec les totaux par trimestre "
        "- Un onglet 'Tendances' avec les variations d'un trimestre à l'autre"
    )}
]
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"}]
)

Traitement d’images

Code Interpreter manipule les images avec Pillow, et il faut bien voir ce que cela recouvre. Il s’agit de traitement d’image — redimensionner, convertir, mesurer, composer — et non de compréhension visuelle : pour décrire ce que montre une photo, c’est la vision du modèle qui travaille, pas le bac à sable. Les deux se combinent d’ailleurs très bien dans un même appel, le modèle regardant l’image pendant que le code la transforme.

Analyse et transformation

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

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "text", "text": (
                "Analyse cette image : "
                "1. Dimensions, format, taille "
                "2. Histogramme des couleurs "
                "3. Crée 3 versions : "
                "   - Miniature 200x200 "
                "   - Version noir et blanc "
                "   - Version avec contraste augmenté de 30%"
            )},
            {"type": "input_file", "file_id": fichier_image.id}
        ]
    }],
    tools=[{"type": "code_interpreter"}]
)

Traitement par lot

Le lot déplace la question vers le coût et les limites. Chaque image téléversée consomme du stockage et occupe le bac à sable, dont l’espace et la durée de vie sont bornés : au-delà de quelques dizaines de fichiers, un script local avec Pillow revient moins cher et va plus vite. Réservez le traitement par lot aux cas où la décision est difficile à coder — un recadrage qui dépend du contenu, un filigrane à placer là où l’image est la plus uniforme — et gardez les transformations mécaniques pour votre propre machine.

# Upload de plusieurs 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="assistants")
        images_ids.append(fichier.id)

content = [
    {"type": "text", "text": (
        "Redimensionne toutes ces images à 800x600 pixels, "
        "ajoute un filigrane 'BROUILLON' en semi-transparent, "
        "et compresse en JPEG qualité 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"}]
)

Pattern : pipeline ETL complet

def pipeline_etl(fichier_source: str, transformations: str) -> dict:
    """Pipeline Extract-Transform-Load avec Code Interpreter."""
    # Extract : upload du fichier source
    with open(fichier_source, "rb") as f:
        fichier = client.files.create(file=f, purpose="assistants")

    # Transform : appliquer les transformations
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=[{
            "role": "user",
            "content": [
                {"type": "text", "text": transformations},
                {"type": "input_file", "file_id": fichier.id}
            ]
        }],
        tools=[{"type": "code_interpreter"}],
        instructions=(
            "Exécute chaque transformation étape par étape. "
            "Affiche un resume apres chaque étape : "
            "nombre de lignes avant/apres, colonnes modifiées. "
            "Exporte le résultat final en CSV et en Excel."
        )
    )

    # Load : récupérer les fichiers générés
    fichiers_sortie = []
    for item in response.output:
        if item.type == "code_interpreter_call":
            for result in item.results:
                if hasattr(result, "files"):
                    for f in result.files:
                        contenu = client.files.content(f.file_id)
                        with open(f.name, "wb") as out:
                            out.write(contenu.read())
                        fichiers_sortie.append(f.name)

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

# Utilisation
resultat = pipeline_etl(
    "donnees_brutes.csv",
    "1. Supprime les colonnes vides "
    "2. Convertis les montants de centimes en euros "
    "3. Ajoute une colonne 'trimestre' basée sur la date "
    "4. Agrege les ventes par trimestre et categorie "
    "5. Calcule les variations en pourcentage"
)

Formats supportés

FormatExtensionsLectureÉcriture
CSV.csvOuiOui
Excel.xlsx, .xlsOuiOui
JSON.jsonOuiOui
Images.png, .jpg, .gif, .bmpOuiOui
Texte.txt, .mdOuiOui
PDF.pdfLecture limitéeNon

Points clés à retenir

  • Uploadez les fichiers avec purpose="assistants" et passez-les via input_file
  • Le modèle gère CSV, Excel multi-onglets et images nativement
  • Récupérez les fichiers générés via client.files.content()
  • Pour les gros fichiers, demandez un traitement par lots
  • Combinez plusieurs fichiers dans un même appel pour des fusions et comparaisons
← Lecon precedenteSandboxing et limitations de sécuritéLecon suivante →Générer des graphiques et visualisations