Przejdź do głównej treści
Polski— Wybierz język
Menu

Przetwarzanie danych: CSV, Excel, obrazy

Lekcja 12 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Przetwarzanie danych: CSV, Excel, obrazy
  2. Przetwarzanie plików CSV
  3. Przetwarzanie plików Excel
  4. Przetwarzanie obrazów
  5. Wzorzec: Kompletny potok ETL
  6. Obsługiwane formaty
  7. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga parametru container (dodanego do wszystkich przykładów), części tekstowe wejścia używają typu input_text, a wyszukiwanie w sieci korzysta z narzędzia web_search (web_search_preview jest obecnie narzędziem przestarzałym bez filtrów domenowych). Wygenerowane pliki pobiera się za pomocą funkcji fichiers_generes i telecharger z Lekcji 10. Pliki dołączone do wiadomości są przesyłane z użyciem user_data, co OpenAI rekomenduje jako dane wejściowe dla modelu (File inputs). Źródła: Code Interpreter · Wyszukiwanie w sieci.

Przetwarzanie danych: CSV, Excel, obrazy

Code Interpreter zmienia charakter zadań, które powierzasz modelowi. Bez niego otrzymujesz jedynie opis tego, co należy zrobić; z nim model pisze kod w Pythonie, wykonuje go w piaskownicy, sprawdza wynik i w razie błędu samodzielnie poprawia swój kod. W przypadku plików z danymi różnica jest decydująca: nikt nie odgadnie struktury pliku CSV bez jego otwarcia, a właśnie na to pozwala wykonywanie kodu.

Logika przedstawiona w tej lekcji dotyczy trzech następujących formatów. Przesyłasz plik, opisujesz oczekiwany rezultat językiem naturalnym, a następnie otrzymujesz analizę lub nowy plik. O tym, czy wykorzystanie narzędzia będzie skuteczne, decyduje precyzja Twojej instrukcji: polecenie „przeanalizuj ten plik“ da jedynie ogólnikowe podsumowanie, podczas gdy sformułowane punktowo żądanie, jak w poniższych przykładach, przyniesie wynik gotowy do natychmiastowego użycia.

Przetwarzanie plików CSV

Analiza eksploracyjna

Zawsze zaczynaj od tego etapu, nawet jeśli wydaje Ci się, że znasz strukturę pliku. Plik CSV wyeksportowany z narzędzia biznesowego kryje niespodzianki, o których specyfikacja nie wspomina: kolumna liczbowa zapisana jako tekst z powodu separatora dziesiętnego, daty w trzech różnych formatach albo wiersz sumy wpleciony w środek danych. Pięć poniższych punktów – wymiary, typy danych, brakujące wartości, statystyki i podgląd – to absolutne minimum przed jakąkolwiek transformacją, ponieważ determinują one, o co możesz poprosić dalej.

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)

Czyszczenie i transformacja

Czyszczenie to etap, w którym decyzje mają znaczenie i musisz je podjąć explicite, zamiast zostawiać je modelowi. Uzupełnienie brakujących wartości medianą dla liczb i dominantą dla kategorii to wybór, którego można bronić, ale nadal jest to wybór: w kolumnie przychodów, gdzie brakuje jednej trzeciej wartości, stworzy to sztucznie zawężony rozkład, który zniekształci każdą późniejszą analizę. Określ regułę w swoim prompcie, tak jak pokazano poniżej, a będziesz wiedział, co zostało zrobione; jeśli pozostaniesz nieprecyzyjny, będziesz musiał ponownie otworzyć plik, aby to sprawdzić.

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")

Przetwarzanie plików Excel

Code Interpreter obsługuje pliki Excel natywnie dzięki bibliotece openpyxl. Dwie różnice względem CSV zasługują na Twoją uwagę. Po pierwsze, skoroszyt zawiera wiele arkuszy, a prompt, który nie precyzuje konkretnego arkusza, sprawi, że model zacznie pracować na tym, który wybierze jako pierwszy; dlatego zacznij od poproszenia o listę arkuszy, jak w przykładzie. Po drugie, Excel zawiera formuły, scalone komórki i dekoracyjne wiersze nagłówków – elementy, które wyglądają jak dane, ale nimi nie są, i które model musi ignorować, ponieważ mu to polecisz.

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"}}]
)

Łączenie wielu plików

Łączenie to przypadek, w którym wykonywanie kodu najbardziej wyprzedza przetwarzanie ręczne: cztery kwartały oznaczają cztery pliki, których kolumny mają prawie takie same nazwy i prawie taki sam porządek. To „prawie“ stanowi problem i właśnie to program wykrywa, podczas gdy kopiowanie i wklejanie to maskuje. Poproś dodatkowo o arkusz podsumowujący oprócz scalonych danych: pełni on funkcję kontrolną, ponieważ suma niezgodna z sumą czterech plików natychmiast ujawnia niewłaściwe wyrównanie kolumn.

# 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"}}]
)

Przetwarzanie obrazów

Code Interpreter manipuluje obrazami za pomocą biblioteki Pillow i musisz wyraźnie rozumieć, co to obejmuje. Jest to przetwarzanie obrazu – zmiana rozmiaru, konwersja, pomiary, komponowanie – a nie rozumienie wizualne: aby opisać, co przedstawia zdjęcie, pracują możliwości wizyjne modelu, a nie piaskownica. Obie funkcje świetnie współgrają w ramach jednego wywołania: model patrzy na obraz, podczas gdy kod go przekształca.

Analiza i transformacja

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"}}]
)

Przetwarzanie wsadowe

Przetwarzanie wsadowe przenosi ciężar zagadnienia na koszty i limity. Każdy przesłany obraz zużywa miejsce w pamięci i zajmuje piaskownicę, której przestrzeń i czas życia są ograniczone: przy kilkudziesięciu plikach lokalny skrypt z Pillow będzie tańszy i szybszy. Zarezerwuj przetwarzanie wsadowe dla przypadków, w których decyzję trudno zakodować – kadrowanie zależne od zawartości, znak wodny umieszczany tam, gdzie obraz jest najbardziej jednolity – a mechaniczne transformacje zostaw swojemu komputerowi.

# 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"}}]
)

Wzorzec: Kompletny potok ETL

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"
)

Obsługiwane formaty

FormatRozszerzeniaOdczytZapis
CSV.csvTakTak
Excel.xlsx, .xlsTakTak
JSON.jsonTakTak
Obrazy.png, .jpg, .gif, .bmpTakTak
Tekst.txt, .mdTakTak
PDF.pdfOgraniczony odczytNie

Kluczowe wnioski

  • Przesyłaj pliki z parametrem purpose="user_data" i przekazuj je przez input_file
  • Model natywnie obsługuje pliki CSV, wieloarkuszowe Excel i obrazy
  • Pobieraj wygenerowane pliki z adnotacji container_file_citation i ściągaj je przez API kontenerów (Lekcja 10)
  • W przypadku dużych plików żądaj przetwarzania wsadowego
  • Łącz wiele plików w jednym wywołaniu, aby scalać dane i przeprowadzać porównania