Gestion des formats de fichiers : CSV, JSON et TXT
Module csv, json.load/dump et encodage sécurisé du texte pour les outils d’agents.
Gestion des formats de fichiers : CSV, JSON et TXT est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.
Les trois formats de fichiers d’agents les plus courants
Les agents lisent et écrivent constamment trois formats de fichiers : CSV pour les données tabulaires, JSON pour les objets structurés et le texte brut pour les journaux, les invites et les rapports. Chacun possède des exigences d’analyse, des cas particuliers et des bonnes pratiques qui lui sont propres. Python prend parfaitement en charge ces trois formats.
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 — Analyse CSV de base
csv.reader analyse un fichier CSV ligne par ligne et renvoie chaque ligne sous forme de liste de chaînes de caractères. Il gère correctement les champs entre guillemets, les virgules intégrées et les nouvelles lignes à l’intérieur des valeurs entre guillemets, contrairement à une séparation manuelle sur les virgules, qui échoue dans certains cas particuliers.
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 — Ligne sous forme de dictionnaire
csv.DictReader lit chaque ligne sous forme d’OrderedDict (ou de dictionnaire standard avec Python 3.8 et les versions ultérieures), avec les en-têtes de colonnes comme clés. Cette approche est beaucoup plus facile à utiliser qu’un indexage positionnel : votre code reste lisible même si les colonnes sont réordonnées.
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 et DictWriter — Écriture de CSV
Utilisez csv.writer pour écrire des lignes sous forme de listes, ou csv.DictWriter pour écrire des lignes sous forme de dictionnaires. Passez toujours newline='' lors de l’ouverture du fichier : le module csv gère lui-même les fins de ligne afin d’éviter les doubles nouvelles lignes sous 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() et json.dump() — E/S de fichiers
Utilisez json.load(file) pour analyser un fichier JSON et json.dump(obj, file) pour en écrire un. Ces fonctions utilisent des objets fichier. Utilisez json.loads(string) et json.dumps(obj) pour les chaînes de caractères. Utilisez toujours indent=2 pour obtenir une sortie lisible.
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')Gestion des erreurs de décodage JSON
Les fichiers JSON mal formés sont courants dans les pipelines d’agents : écritures incomplètes, téléchargements tronqués ou problèmes d’encodage. Entourez toujours json.load() d’un bloc try/except et fournissez des messages d’erreur clairs qui incluent le chemin du fichier pour faciliter le débogage.
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'))
Lecture du format JSONL (JSON Lines)
De nombreuses API d’IA et pipelines de données utilisent le JSONL (JSON Lines), avec un objet JSON par ligne. Ce format prend en charge le traitement en continu et se traite facilement ligne par ligne sans charger tout le fichier en mémoire. Chaque ligne constitue un objet JSON complet et autonome.
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')Lecture de fichiers texte brut
Le texte brut est le format le plus simple : journaux, invites, rapports et fichiers de configuration. Lisez le fichier entier avec .read() ou traitez-le ligne par ligne. Pour les fichiers volumineux, utilisez toujours l’approche ligne par ligne afin de maintenir une utilisation constante de la mémoire.
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')Gestion du BOM (marque d’ordre des octets)
Les fichiers exportés depuis Excel ou des outils Windows commencent souvent par un BOM (marque d’ordre des octets), c’est-à-dire un caractère \ufeff invisible. S’il n’est pas géré, il altère le nom du premier champ lors de l’analyse CSV. Utilisez encoding='utf-8-sig' pour le supprimer automatiquement.
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)Gestion des erreurs d’encodage
Lors de la lecture de fichiers provenant de sources inconnues, les erreurs d’encodage sont courantes. Le paramètre errors de open() contrôle le comportement : 'replace' remplace les caractères incorrects par ?, 'ignore' les supprime et 'backslashreplace' les échappe. Pour une validation stricte, utilisez 'strict' (la valeur par défaut).
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}')
Gestion des fichiers CSV mal formés
Les fichiers CSV du monde réel présentent souvent des problèmes : virgules supplémentaires, champs manquants, guillemets incohérents ou délimiteurs mélangés. Utilisez les options quoting et error_bad_lines, et entourez l’analyse des lignes d’un bloc try/except afin d’ignorer les lignes incorrectes avec élégance.
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}')Vérification rapide : CSV DictReader contre reader
Testez votre compréhension des options d’analyse CSV.
Récapitulatif de la gestion des formats de fichiers
Vous pouvez maintenant analyser et écrire tous les principaux formats de fichiers utilisés par les agents :
- CSV : utilisez
csv.DictReaderpour les lignes sous forme de dictionnaires etcsv.DictWriterpour la sortie ; utilisez toujoursnewline=''à l’ouverture - JSON :
json.load(f)pour analyser,json.dump(obj, f, indent=2)pour écrire ; interceptezJSONDecodeError - JSONL : lisez et analysez chaque ligne avec
json.loads(line); idéal pour le traitement en continu des données - Texte brut :
.read()pour les petits fichiers, parcours ligne par ligne pour les fichiers volumineux - BOM : utilisez
encoding='utf-8-sig'pour les fichiers exportés depuis Windows - Erreurs d’encodage : essayez UTF-8, utilisez latin-1 en solution de repli ou utilisez
errors='replace'
Questions Fréquemment Posées
La leçon « Gestion des formats de fichiers : CSV, JSON et TXT » est-elle gratuite ?
Oui — le texte complet de « Gestion des formats de fichiers : CSV, JSON et TXT » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Gestion des formats de fichiers : CSV, JSON et TXT » ?
Module csv, json.load/dump et encodage sécurisé du texte pour les outils d’agents. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Agents ?
Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Gestion des formats de fichiers : CSV, JSON et TXT » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?
Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Lire et écrire des fichiers dans le contexte d’un agent
- Parcours des répertoires et découverte de fichiers
- Gestion des formats de fichiers : CSV, JSON et TXT
- Opérations sûres sur les fichiers avec gestion des erreurs