Obsługa formatów plików: CSV, JSON i TXT
Moduł csv, json.load/dump oraz bezpieczne kodowanie tekstu dla narzędzi agenta.
Obsługa formatów plików: CSV, JSON i TXT to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.
Trzy najczęściej używane formaty plików w agentach
Agenty stale odczytują i zapisują dane w trzech formatach plików: CSV do danych tabelarycznych, JSON do obiektów strukturalnych oraz zwykły tekst do dzienników, promptów i raportów. Każdy z nich wymaga innego analizowania, uwzględnienia innych przypadków brzegowych i stosowania innych najlepszych praktyk. Python zapewnia doskonałe wbudowane wsparcie dla wszystkich trzech formatów.
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 — podstawowe analizowanie CSV
csv.reader analizuje plik CSV wiersz po wierszu, zwracając każdy wiersz jako listę ciągów znaków. Prawidłowo obsługuje pola w cudzysłowach, przecinki i znaki nowego wiersza wewnątrz wartości w cudzysłowach — w przeciwieństwie do ręcznego dzielenia po przecinkach, które nie radzi sobie z przypadkami brzegowymi.
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 — wiersz jako słownik
csv.DictReader odczytuje każdy wiersz jako OrderedDict (lub zwykły słownik w Pythonie 3.8 i nowszych), używając nagłówków kolumn jako kluczy. Jest to znacznie wygodniejsze niż indeksowanie pozycyjne — kod pozostaje czytelny nawet po zmianie kolejności kolumn.
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 i DictWriter — zapisywanie CSV
Używaj csv.writer do zapisywania wierszy jako list albo csv.DictWriter do zapisywania wierszy jako słowników. Podczas otwierania pliku zawsze przekazuj newline='' — moduł csv sam obsługuje zakończenia wierszy, aby uniknąć podwójnych znaków nowego wiersza w systemie 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() i json.dump() — operacje wejścia-wyjścia na plikach
Używaj json.load(file) do analizowania pliku JSON i json.dump(obj, file) do jego zapisywania. Funkcje te działają na obiektach plików. W przypadku ciągów znaków używaj json.loads(string) i json.dumps(obj). Aby uzyskać czytelny wynik, zawsze używaj indent=2.
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')Obsługa błędów dekodowania JSON
Nieprawidłowo sformatowane pliki JSON są częste w potokach agentów — przyczyną mogą być niekompletne zapisy, obcięte pobrania lub problemy z kodowaniem. Zawsze należy opakować json.load() w blok try/except i podawać jasne komunikaty o błędach zawierające ścieżkę pliku, aby ułatwić debugowanie.
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'))
Odczytywanie formatu JSONL (JSON Lines)
Wiele interfejsów API AI i potoków danych używa formatu JSONL (JSON Lines) — jeden obiekt JSON w każdym wierszu. Ten format obsługuje strumieniowanie i umożliwia łatwe przetwarzanie wiersz po wierszu bez wczytywania całego pliku do pamięci. Każdy wiersz jest kompletnym, niezależnym obiektem JSON.
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')Odczytywanie plików zwykłego tekstu
Zwykły tekst to najprostszy format — używa się go w dziennikach, promptach, raportach i plikach konfiguracyjnych. Cały plik można odczytać za pomocą .read() albo przetwarzać go wiersz po wierszu. W przypadku dużych plików należy zawsze stosować przetwarzanie wiersz po wierszu, aby zużycie pamięci pozostało stałe.
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')Obsługa BOM (znacznika kolejności bajtów)
Pliki eksportowane z programu Excel lub narzędzi systemu Windows często zaczynają się od znacznika BOM (znacznika kolejności bajtów) — niewidocznego znaku \ufeff. Jeśli nie zostanie on obsłużony, zniekształci nazwę pierwszego pola podczas analizowania CSV. Użyj encoding='utf-8-sig', aby automatycznie go usunąć.
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)Obsługa błędów kodowania
Podczas odczytywania plików z nieznanych źródeł często występują błędy kodowania. Parametr errors funkcji open() określa sposób postępowania: 'replace' zastępuje nieprawidłowe znaki znakiem ?, 'ignore' je usuwa, a 'backslashreplace' zapisuje je w postaci sekwencji z ukośnikiem odwrotnym. Do ścisłej walidacji należy użyć 'strict' (wartość domyślna).
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}')
Obsługa nieprawidłowo sformatowanych plików CSV
Pliki CSV z rzeczywistych zastosowań często zawierają problemy: dodatkowe przecinki, brakujące pola, niespójne użycie cudzysłowów lub mieszane separatory. Należy używać opcji quoting i error_bad_lines, a analizowanie wierszy opakować w try/except, aby łagodnie pomijać nieprawidłowe wiersze.
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}')Szybki test: CSV DictReader a reader
Sprawdź swoją znajomość opcji analizowania plików CSV.
Podsumowanie obsługi formatów plików
Możesz teraz analizować i zapisywać wszystkie najważniejsze formaty plików używane przez agenty:
- CSV: używaj
csv.DictReaderdla wierszy w postaci słowników icsv.DictWriterdla danych wyjściowych; podczas otwierania zawsze ustawiajnewline='' - JSON: używaj
json.load(f)do analizowania ijson.dump(obj, f, indent=2)do zapisywania; przechwytujJSONDecodeError - JSONL: odczytuj i analizuj każdy wiersz za pomocą
json.loads(line); format świetnie nadaje się do danych strumieniowych - Zwykły tekst: używaj
.read()dla małych plików, a iteracji po wierszach dla dużych - BOM: w przypadku plików eksportowanych z systemu Windows używaj
encoding='utf-8-sig' - Błędy kodowania: spróbuj użyć UTF-8, w razie potrzeby przejdź na latin-1 albo użyj
errors='replace'
Często zadawane pytania
Czy lekcja „Obsługa formatów plików: CSV, JSON i TXT” jest bezpłatna?
Tak — pełny tekst „Obsługa formatów plików: CSV, JSON i TXT” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.
Co nauczysz się w „Obsługa formatów plików: CSV, JSON i TXT”?
Moduł csv, json.load/dump oraz bezpieczne kodowanie tekstu dla narzędzi agenta. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć AI Agents?
Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Obsługa formatów plików: CSV, JSON i TXT”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?
Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Odczyt i zapis plików w kontekście agenta
- Przechodzenie po katalogach i wyszukiwanie plików
- Obsługa formatów plików: CSV, JSON i TXT
- Bezpieczne operacje na plikach z obsługą błędów