PricingLoginStart free
AI-agenter · leksjon

Håndtering av filformater: CSV, JSON og TXT

csv-modulen, json.load/dump og sikker tekstkoding for agentverktøy.

Leksjon 3 av 413 trinn

Håndtering av filformater: CSV, JSON og TXT er en gratis leksjon i AI-agenter på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI-agenter, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI-agenter inneholder totalt 4 leksjoner.

De tre vanligste filformatene for agenter

Agenter leser og skriver hele tiden tre filformater: CSV for tabellformede data, JSON for strukturerte objekter og ren tekst for logger, ledetekster og rapporter. Hvert format har ulike krav til tolking, særtilfeller og beste praksis. Python har utmerket innebygd støtte for alle tre.

import csv
import json
from pathlib import Path

# Detect format from extension
def read_data_file(file_path):
    path = Path(file_path)
    if path.suffix == '.csv':
        return read_csv(path)
    elif path.suffix == '.json':
        return read_json(path)
    elif path.suffix == '.txt':
        return path.read_text(encoding='utf-8')
    else:
        raise ValueError(f'Unsupported format: {path.suffix}')

csv.reader — Grunnleggende CSV-tolking

csv.reader tolker en CSV-fil rad for rad og returnerer hver rad som en liste med strenger. Den håndterer felt i anførselstegn, innebygde kommaer og linjeskift inne i verdier i anførselstegn korrekt – i motsetning til manuell splitting på komma, som ikke fungerer for særtilfeller.

import csv

with open('sales.csv', 'w', newline='') as f:
    f.write('product,qty,price\nWidget,3,9.99\nGadget,1,19.99\n')

with open('sales.csv', 'r', encoding='utf-8', newline='') as f:
    reader = csv.reader(f)
    header = next(reader)
    print('Columns:', header)

    for row in reader:
        product = row[0]
        quantity = int(row[1])
        price = float(row[2])
        print(f'{product}: {quantity} units at ${price}')

csv.DictReader — Rad som ordbok

csv.DictReader leser hver rad som en OrderedDict (eller en vanlig dict i Python 3.8+) med kolonneoverskriftene som nøkler. Dette er mye enklere å arbeide med enn posisjonsindeksering – koden forblir lesbar selv om kolonnene får en annen rekkefølge.

import csv

with open('employees.csv', 'w', newline='') as f:
    f.write('name,department,salary\nAlice,Eng,95000\nBob,Sales,70000\n')

with open('employees.csv', 'r', encoding='utf-8', newline='') as f:
    reader = csv.DictReader(f)
    print('Fields:', reader.fieldnames)

    total_salary = 0
    for row in reader:
        name = row['name']
        department = row['department']
        salary = float(row['salary'])
        total_salary += salary
        print(f'{name} ({department}): ${salary:,.2f}')

    print(f'Total payroll: ${total_salary:,.2f}')

csv.writer og DictWriter — Skrive CSV

Bruk csv.writer til å skrive rader som lister eller csv.DictWriter til å skrive rader som ordbøker. Send alltid med newline='' når filen åpnes – csv-modulen håndterer selv linjeskiftene for å unngå doble linjeskift i Windows.

import csv

results = [
    {'task_id': 'T001', 'status': 'completed', 'duration_s': 12.5},
    {'task_id': 'T002', 'status': 'failed', 'duration_s': 3.1},
    {'task_id': 'T003', 'status': 'completed', 'duration_s': 45.8},
]

fieldnames = ['task_id', 'status', 'duration_s']

with open('task_results.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()  # write column names
    writer.writerows(results)

print('Wrote task_results.csv')

json.load() og json.dump() — Fil-I/O

Bruk json.load(file) til å tolke en JSON-fil og json.dump(obj, file) til å skrive en. Disse fungerer med filobjekter. Bruk json.loads(string) og json.dumps(obj) for strenger. Bruk alltid indent=2 for lesbar utskrift.

import json

with open('config.json', 'w', encoding='utf-8') as f:
    json.dump({'api_url': 'https://api.example.com', 'timeout': 15}, f)

with open('config.json', 'r', encoding='utf-8') as f:
    config = json.load(f)

print('API URL:', config.get('api_url'))
print('Timeout:', config.get('timeout', 30))

output_data = {
    'run_id': 'abc123',
    'items': [1, 2, 3],
    'meta': {'agent': 'v2', 'model': 'gpt-4o'}
}

with open('output.json', 'w', encoding='utf-8') as f:
    json.dump(
        output_data, f,
        indent=2,
        ensure_ascii=False
    )
print('Written output.json')

Håndtering av JSON-tolkningsfeil

Feilformaterte JSON-filer er vanlige i agentprosesser – ufullstendige skriveoperasjoner, avkortede nedlastinger eller kodingsproblemer kan være årsaken. Pakk alltid json.load() inn i try/except, og oppgi tydelige feilmeldinger som inkluderer filstien, slik at feilen kan feilsøkes.

import json
from pathlib import Path

def safe_load_json(file_path):
    path = Path(file_path)
    try:
        with open(path, 'r', encoding='utf-8') as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        print(f'Invalid JSON in {path}: line {e.lineno}, col {e.colno}')
        print(f'  Error: {e.msg}')
        # Show the problem area
        content = path.read_text(encoding='utf-8')
        lines = content.split('\n')
        if e.lineno <= len(lines):
            print(f'  Content: {lines[e.lineno-1][:80]}')
        return None
    except FileNotFoundError:
        print(f'File not found: {path}')
        return None

# --- demo ---
Path('good.json').write_text('{"model": "gpt-4o"}', encoding='utf-8')
Path('bad.json').write_text('{"model": "gpt-4o", }', encoding='utf-8')

print('Loading good.json:', safe_load_json('good.json'))
print('Loading bad.json:', safe_load_json('bad.json'))

Lese JSONL-formatet (JSON Lines)

Mange KI-API-er og dataprosesser bruker JSONL (JSON Lines) – ett JSON-objekt per linje. Dette formatet støtter strømming og er enkelt å behandle linje for linje uten å laste hele filen inn i minnet. Hver linje er et komplett, selvstendig JSON-objekt.

import json

with open('events.jsonl', 'w', encoding='utf-8') as f:
    f.write('{"event": "start"}\n{"event": "stop"}\nnot json\n')

results = []
with open('events.jsonl', 'r', encoding='utf-8') as f:
    for line_num, line in enumerate(f, 1):
        line = line.strip()
        if not line:
            continue
        try:
            event = json.loads(line)
            results.append(event)
        except json.JSONDecodeError as e:
            print(f'Bad JSON on line {line_num}: {e}')

print(f'Loaded {len(results)} events')

with open('output.jsonl', 'w', encoding='utf-8') as f:
    for record in results:
        f.write(json.dumps(record, ensure_ascii=False) + '\n')

Lese rene tekstfiler

Ren tekst er det enkleste formatet – logger, ledetekster, rapporter og konfigurasjonsfiler. Les hele filen med .read(), eller behandle den linje for linje. For store filer bør du alltid bruke tilnærmingen med én linje om gangen for å holde minnebruken konstant.

from pathlib import Path

Path('system_prompt.txt').write_text('You are a helpful agent.', encoding='utf-8')
with open('agent.log', 'w', encoding='utf-8') as f:
    f.write('INFO: boot\nERROR: disk full\nCRITICAL: crash\nINFO: recovered\n')

prompt = Path('system_prompt.txt').read_text(encoding='utf-8')
print(f'Prompt length: {len(prompt)} characters')

error_lines = []
with open('agent.log', 'r', encoding='utf-8') as f:
    for line in f:
        line = line.rstrip()
        if not line:
            continue
        if 'ERROR' in line or 'CRITICAL' in line:
            error_lines.append(line)

print(f'Found {len(error_lines)} error lines')

with open('summary.txt', 'w', encoding='utf-8') as f:
    f.write('Agent Run Summary\n')
    f.write('=' * 40 + '\n')
    for error in error_lines[:10]:
        f.write(f'  {error}\n')
print('Summary written')

Håndtering av BOM (byte-rekkefølgemerke)

Filer som eksporteres fra Excel eller Windows-verktøy, begynner ofte med et BOM (byte-rekkefølgemerke) – et usynlig \ufeff-tegn. Hvis det ikke håndteres, ødelegger det det første feltnavnet ved CSV-tolking. Bruk encoding='utf-8-sig' for å fjerne det automatisk.

import csv

with open('windows_export.csv', 'wb') as f:
    f.write('name,email,age\nAlice,alice@x.com,30\n'.encode('utf-8'))
with open('file.txt', 'wb') as f:
    f.write(b'\xef\xbb\xbfhello')

with open('windows_export.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    first = next(reader)
    print(list(first.keys()))

with open('windows_export.csv', 'r', encoding='utf-8-sig') as f:
    reader = csv.DictReader(f)
    first = next(reader)
    print(list(first.keys()))

content = open('file.txt', 'rb').read()
if content.startswith(b'\xef\xbb\xbf'):
    content = content[3:]
text = content.decode('utf-8')
print('Decoded:', text)

Håndtering av kodingsfeil

Ved lesing av filer fra ukjente kilder er kodingsfeil vanlige. Parameteren errors i open() styrer hva som skjer: 'replace' erstatter ugyldige tegn med ?, 'ignore' fjerner dem, og 'backslashreplace' representerer dem med escape-sekvenser. For streng validering bruker du 'strict' (standardverdien).

from pathlib import Path

def read_with_fallback(file_path):
    path = Path(file_path)

    # Try UTF-8 first
    try:
        return path.read_text(encoding='utf-8')
    except UnicodeDecodeError:
        pass

    # Try Latin-1 (handles most European files)
    try:
        return path.read_text(encoding='latin-1')
    except UnicodeDecodeError:
        pass

    # Last resort: replace bad characters
    text = path.read_text(encoding='utf-8', errors='replace')
    print(f'Warning: {path.name} had encoding errors (chars replaced)')
    return text

# --- demo ---
Path('notes_utf8.txt').write_text('Notes: café, naïve, résumé', encoding='utf-8')
text = read_with_fallback('notes_utf8.txt')
print(f'Read {len(text)} chars: {text!r}')

Håndtering av feilformaterte CSV-filer

CSV-filer fra den virkelige verdenen har ofte problemer: ekstra kommaer, manglende felt, uensartet bruk av anførselstegn eller blandede skilletegn. Bruk alternativene quoting og error_bad_lines, og pakk radtolkingen inn i try/except for å hoppe over ugyldige rader på en kontrollert måte.

import csv

with open('messy_data.csv', 'w', newline='') as f:
    f.write('name,email,score\nAlice,alice@x.com,88\nBob,,90\nCarol,carol@x.com,notanumber\n')

valid_rows = []
error_count = 0

with open('messy_data.csv', 'r', encoding='utf-8', newline='') as f:
    reader = csv.DictReader(f)
    expected_fields = {'name', 'email', 'score'}

    for line_num, row in enumerate(reader, start=2):
        try:
            if not all(row.get(f, '').strip() for f in expected_fields):
                raise ValueError(f'Missing required field in row {line_num}')
            score = float(row['score'])
            valid_rows.append({
                'name': row['name'].strip(),
                'email': row['email'].strip().lower(),
                'score': score
            })
        except (ValueError, KeyError) as e:
            error_count += 1
            print(f'Skipping row {line_num}: {e}')

print(f'Valid: {len(valid_rows)}, Errors: {error_count}')

Hurtigsjekk: CSV DictReader kontra reader

Test forståelsen av alternativer for CSV-tolking.

Besvar den i den interaktive leksjonen

Oppsummering av filformatbehandling

Nå kan agenten tolke og skrive alle de viktigste filformatene:

  • CSV: bruk csv.DictReader for rader som ordbøker og csv.DictWriter for utdata; bruk alltid newline='' ved åpning
  • JSON: json.load(f) for tolking og json.dump(obj, f, indent=2) for skriving; fang opp JSONDecodeError
  • JSONL: les og tolk hver linje med json.loads(line); velegnet for strømmende data
  • Ren tekst: .read() for små filer og gjennomgang linje for linje for store filer
  • BOM: bruk encoding='utf-8-sig' for filer som er eksportert fra Windows
  • Kodingsfeil: prøv UTF-8, fall tilbake til latin-1 eller bruk errors='replace'
Gratis å komme i gang

Lær deg AI-agenter med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
60
Leksjoner
239
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Håndtering av filformater: CSV, JSON og TXT» gratis?

Ja – hele teksten i «Håndtering av filformater: CSV, JSON og TXT» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI-agenter-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Hva lærer jeg i «Håndtering av filformater: CSV, JSON og TXT»?

csv-modulen, json.load/dump og sikker tekstkoding for agentverktøy. Du øver på AI-agenter med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI-agenter?

Ingen tidligere erfaring er nødvendig. AI-agenter på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Håndtering av filformater: CSV, JSON og TXT»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI-agenter-leksjonen?

Ja. Alle AI-agenter-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Lese og skrive filer i agentkontekst
  2. Katalogtraversering og filoppdagelse
  3. Håndtering av filformater: CSV, JSON og TXT
  4. Sikre filoperasjoner med feilhåndtering
← Tilbake til AI-agenter