Gestión de formatos de archivo: CSV, JSON y TXT
Módulo csv, json.load/dump y codificación segura de texto para las herramientas del agente.
Gestión de formatos de archivo: CSV, JSON y TXT es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.
Los tres formatos de archivo más habituales de los agentes
Los agentes leen y escriben constantemente tres formatos de archivo: CSV para datos tabulares, JSON para objetos estructurados y texto plano para registros, prompts e informes. Cada uno tiene requisitos de análisis, casos límite y prácticas recomendadas diferentes. Python ofrece una excelente compatibilidad integrada con los tres.
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 — Análisis básico de CSV
csv.reader analiza un archivo CSV fila por fila y devuelve cada fila como una lista de cadenas. Gestiona correctamente los campos entrecomillados, las comas incrustadas y los saltos de línea dentro de valores entrecomillados, a diferencia de dividir manualmente por comas, lo que falla en casos límite.
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 — Fila como diccionario
csv.DictReader lee cada fila como un OrderedDict (o como un diccionario normal en Python 3.8 o posterior), con los encabezados de columna como claves. Es mucho más fácil de utilizar que el acceso posicional por índices: el código sigue siendo legible aunque se reordenen las columnas.
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 y DictWriter — Escritura de CSV
Utilice csv.writer para escribir filas como listas o csv.DictWriter para escribir filas como diccionarios. Pase siempre newline='' al abrir el archivo; el módulo csv gestiona los finales de línea por sí mismo para evitar saltos de línea duplicados en 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() y json.dump() — E/S de archivos
Utilice json.load(file) para analizar un archivo JSON y json.dump(obj, file) para escribirlo. Funcionan con objetos de archivo. Utilice json.loads(string) y json.dumps(obj) para cadenas. Utilice siempre indent=2 para obtener una salida legible.
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')Gestión de errores de decodificación JSON
Los archivos JSON mal formados son habituales en las canalizaciones de agentes: escrituras incompletas, descargas truncadas o problemas de codificación. Rodee siempre json.load() con un bloque try/except y proporcione mensajes de error claros que incluyan la ruta del archivo para facilitar la depuración.
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'))
Lectura del formato JSONL (JSON Lines)
Muchas API de IA y canalizaciones de datos utilizan JSONL (JSON Lines): un objeto JSON por línea. Este formato permite la transmisión de datos y es fácil de procesar línea por línea sin cargar todo el archivo en memoria. Cada línea es un objeto JSON completo e independiente.
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')Lectura de archivos de texto plano
El texto plano es el formato más sencillo: registros, prompts, informes y archivos de configuración. Lea el archivo completo con .read() o procéselo línea por línea. Para archivos grandes, utilice siempre el procesamiento línea por línea para mantener constante el uso de memoria.
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')Gestión de BOM (marca de orden de bytes)
Los archivos exportados desde Excel o herramientas de Windows suelen comenzar con una BOM (marca de orden de bytes), un carácter \ufeff invisible. Si no se gestiona, corrompe el nombre del primer campo al analizar CSV. Utilice encoding='utf-8-sig' para eliminarla automáticamente.
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)Gestión de errores de codificación
Al leer archivos de fuentes desconocidas, los errores de codificación son habituales. El parámetro errors de open() controla lo que ocurre: 'replace' sustituye los caracteres incorrectos por ?, 'ignore' los omite y 'backslashreplace' los escapa. Para una validación estricta, utilice 'strict' (el valor predeterminado).
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}')
Gestión de archivos CSV mal formados
Los archivos CSV del mundo real presentan problemas: comas adicionales, campos ausentes, entrecomillado incoherente o delimitadores mezclados. Utilice las opciones quoting y error_bad_lines, y rodee el análisis de cada fila con un bloque try/except para omitir las filas incorrectas de forma controlada.
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}')Comprobación rápida: CSV DictReader frente a reader
Compruebe su comprensión de las opciones de análisis de CSV.
Resumen de la gestión de formatos de archivo
Ahora puede analizar y escribir los principales formatos de archivo de los agentes:
- CSV: utilice
csv.DictReaderpara las filas como diccionarios ycsv.DictWriterpara la salida; use siemprenewline=''al abrir el archivo - JSON:
json.load(f)para analizar yjson.dump(obj, f, indent=2)para escribir; captureJSONDecodeError - JSONL: lea y analice cada línea con
json.loads(line); es ideal para la transmisión de datos - Texto plano:
.read()para archivos pequeños e iteración por líneas para los grandes - BOM: utilice
encoding='utf-8-sig'para archivos exportados desde Windows - Errores de codificación: pruebe UTF-8, recurra a latin-1 o utilice
errors='replace'
Preguntas frecuentes
¿La lección «Gestión de formatos de archivo: CSV, JSON y TXT» es gratis?
Sí — el texto completo de «Gestión de formatos de archivo: CSV, JSON y TXT» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.
¿Qué aprenderé en «Gestión de formatos de archivo: CSV, JSON y TXT»?
Módulo csv, json.load/dump y codificación segura de texto para las herramientas del agente. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Agents?
No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Gestión de formatos de archivo: CSV, JSON y TXT»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Agents?
Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Lectura y escritura de archivos en el contexto de un agente
- Recorrido de directorios y descubrimiento de archivos
- Gestión de formatos de archivo: CSV, JSON y TXT
- Operaciones seguras con archivos y gestión de errores