Python · Lección 24 de 27

Archivos

Hasta ahora tus datos vivían solo en memoria — al cerrar el programa, desaparecían. Con archivos, podés leer datos de CSVs y JSONs, guardar resultados, y construir pipelines que procesen datos reales del disco.

90–110 min Prerrequisitos: 20 Módulos stdlib, 23 Strings avanzado

Concepto teórico

open() y el context manager with

La función open() abre un archivo y devuelve un objeto que podés leer o escribir. El patrón with garantiza que el archivo se cierre correctamente incluso si hay un error:

# ✅ SIEMPRE usá with (cierra automáticamente)
with open("datos.txt", "r", encoding="utf-8") as f:
    contenido = f.read()

# ❌ NUNCA hagas esto (puede no cerrar si hay error)
# f = open("datos.txt")
# contenido = f.read()
# f.close()

Regla absoluta: SIEMPRE usá with open(...) as f:. Nunca abras archivos sin with. El context manager garantiza que el archivo se cierra al salir del bloque, incluso si el código lanza una excepción. Archivos no cerrados pueden corromper datos o consumir recursos del sistema.

Modos de apertura

Modo	Significado	Si el archivo no existe	Contenido previo
`"r"`	Read (lectura)	Error (FileNotFoundError)	Se lee
`"w"`	Write (escritura)	Se crea	SE BORRA TODO
`"a"`	Append (agregar al final)	Se crea	Se conserva
`"r+"`	Lectura + escritura	Error	Se conserva
`"rb"` / `"wb"`	Binario (imágenes, PDFs)	Según r/w	Según r/w

PELIGRO con modo "w": open("datos.csv", "w") BORRA TODO el contenido del archivo existente al abrirlo. Si querés agregar sin borrar, usá "a". Este error ha destruido datos de producción en empresas reales.

Métodos de lectura

.read() — lee TODO el archivo como un solo string. Cuidado con archivos grandes (carga todo en RAM).
.readline() — lee UNA línea (hasta el \n).
.readlines() — lee TODAS las líneas como lista de strings.
for linea in f: — itera línea por línea SIN cargar todo en memoria (lo más eficiente para archivos grandes).

CSV con el módulo csv

CSV (Comma-Separated Values) es el formato más común en análisis de datos. Python tiene un módulo csv incorporado, pero en la práctica casi siempre usás pandas.read_csv() que es más poderoso.

import csv
# Leer CSV
with open("datos.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)  # cada fila es un dict
    for fila in reader:
        print(fila["nombre"], fila["saldo"])

# Escribir CSV
with open("salida.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["nombre", "saldo"])
    writer.writeheader()
    writer.writerow({"nombre": "García", "saldo": 150000})

JSON con archivos

import json
# Leer JSON
with open("config.json", "r") as f:
    datos = json.load(f)       # archivo → dict

# Escribir JSON
with open("resultado.json", "w") as f:
    json.dump(datos, f, indent=2, ensure_ascii=False)

pathlib — manejo moderno de rutas

pathlib es la forma moderna y recomendada de trabajar con rutas de archivos (reemplaza os.path):

from pathlib import Path

ruta = Path("datos") / "clientes" / "2025" / "q1.csv"  # construir rutas con /
print(ruta.exists())       # ¿existe?
print(ruta.suffix)         # extensión: .csv
print(ruta.stem)           # nombre sin extensión: q1
print(ruta.parent)         # directorio padre
list(Path(".").glob("*.py"))  # todos los .py en directorio actual

En el trabajo: un pipeline típico de datos es: (1) leer CSVs de una carpeta, (2) limpiar y procesar con pandas, (3) guardar resultados en CSV/JSON/Excel. Con pathlib manejás las rutas, con open() los archivos de texto, con pandas los DataFrames. Entender archivos "a mano" con open/csv/json te da control total cuando pandas no alcanza.

Encoding para datos argentinos: siempre especificá encoding="utf-8" al abrir archivos. Si falla (UnicodeDecodeError), probá encoding="latin-1". Los exports de sistemas bancarios legacy, MERCAP y SINENSUP suelen venir en Latin-1.

Ejemplos explicados paso a paso

Ejemplo 1: Escribir y leer un archivo de texto

Nota: en Pyodide (navegador) los archivos se crean en memoria virtual. En tu PC, se crean en disco real.

ejemplo_01_texto.pyPython

# ESCRIBIR un archivo
with open("reporte.txt", "w", encoding="utf-8") as f:
    f.write("=== REPORTE DIARIO ===\n")
    f.write(f"Fecha: 2025-03-15\n")
    f.write(f"Total clientes: 5\n")
    f.write(f"Saldo total: $1,477,000\n")
    f.write(f"{'─'*25}\n")
    
    clientes = [("García", 150000), ("López", 320000), ("Pérez", 890000)]
    for nombre, saldo in clientes:
        f.write(f"{nombre}: ${saldo:,}\n")

print("Archivo escrito ✅")

# LEER el archivo completo
with open("reporte.txt", "r", encoding="utf-8") as f:
    contenido = f.read()
print(contenido)

# LEER línea por línea (más eficiente para archivos grandes)
print("=== Línea por línea ===")
with open("reporte.txt", "r", encoding="utf-8") as f:
    for i, linea in enumerate(f, 1):
        print(f"  L{i}: {linea.rstrip()}")  # rstrip quita el \n

Hacé clic en ▶ Ejecutar

Ejemplo 2: CSV — leer y escribir con csv.DictReader/DictWriter

ejemplo_02_csv.pyPython

import csv

# ESCRIBIR CSV
clientes = [
    {"nombre": "García", "score": 720, "saldo": 150000},
    {"nombre": "López", "score": 680, "saldo": 320000},
    {"nombre": "Martínez", "score": 590, "saldo": 45000},
    {"nombre": "Pérez", "score": 810, "saldo": 890000},
]

with open("clientes.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["nombre", "score", "saldo"])
    writer.writeheader()
    writer.writerows(clientes)
print("CSV escrito ✅")

# LEER CSV
print("\n=== Lectura del CSV ===")
with open("clientes.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    datos = list(reader)  # convertir a lista de dicts

for d in datos:
    print(f"  {d['nombre']}: score {d['score']}, ${int(d['saldo']):,}")

# Nota: csv.DictReader devuelve strings — hay que convertir tipos
total = sum(int(d["saldo"]) for d in datos)
print(f"\nTotal: ${total:,}")
print(f"(En la práctica usás pd.read_csv() que convierte tipos automáticamente)")

Hacé clic en ▶ Ejecutar

Ejemplo 3: JSON — persistir datos estructurados

ejemplo_03_json_archivo.pyPython

import json

# ESCRIBIR JSON
config = {
    "proyecto": "Análisis de cartera",
    "version": "1.0",
    "parametros": {
        "score_minimo": 650,
        "tasa_iva": 0.21,
        "moneda": "ARS"
    },
    "sucursales": ["Centro", "Norte", "Sur"]
}

with open("config.json", "w", encoding="utf-8") as f:
    json.dump(config, f, indent=2, ensure_ascii=False)
print("JSON escrito ✅")

# LEER JSON
with open("config.json", "r", encoding="utf-8") as f:
    datos = json.load(f)

print(f"\nProyecto: {datos['proyecto']}")
print(f"Score mínimo: {datos['parametros']['score_minimo']}")
print(f"Sucursales: {', '.join(datos['sucursales'])}")

# Modificar y volver a guardar
datos["parametros"]["score_minimo"] = 700
datos["version"] = "1.1"

with open("config.json", "w", encoding="utf-8") as f:
    json.dump(datos, f, indent=2, ensure_ascii=False)
print(f"\nActualizado a v{datos['version']} con score mínimo {datos['parametros']['score_minimo']}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Append — agregar al final sin perder datos

ejemplo_04_append.pyPython

from datetime import datetime

# Simular un log de operaciones
def registrar_operacion(tipo, monto, archivo="operaciones.log"):
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    linea = f"[{timestamp}] {tipo.upper():>15}: ${monto:>12,.0f}\n"
    with open(archivo, "a", encoding="utf-8") as f:  # "a" = append
        f.write(linea)

# Registrar varias operaciones
registrar_operacion("depósito", 250000)
registrar_operacion("extracción", 50000)
registrar_operacion("transferencia", 80000)
registrar_operacion("depósito", 150000)
print("Operaciones registradas ✅")

# Leer el log completo
print("\n=== Log de operaciones ===")
with open("operaciones.log", "r", encoding="utf-8") as f:
    print(f.read())

# Contar operaciones por tipo
with open("operaciones.log", "r", encoding="utf-8") as f:
    lineas = f.readlines()
    depositos = sum(1 for l in lineas if "DEPÓSITO" in l.upper())
    print(f"Total líneas: {len(lineas)}")
    print(f"Depósitos: {depositos}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: pathlib + procesamiento de múltiples archivos

ejemplo_05_pathlib.pyPython

from pathlib import Path
import json

# Crear estructura de directorios
datos_dir = Path("proyecto_datos")
datos_dir.mkdir(exist_ok=True)

# Crear varios archivos JSON (simulando exports mensuales)
meses = {
    "enero": [150000, 320000, 45000],
    "febrero": [180000, 290000, 52000],
    "marzo": [210000, 350000, 48000],
}

for mes, saldos in meses.items():
    archivo = datos_dir / f"saldos_{mes}.json"
    with open(archivo, "w") as f:
        json.dump({"mes": mes, "saldos": saldos}, f)

print(f"Directorio: {datos_dir}")
print(f"Existe: {datos_dir.exists()}")

# Listar archivos JSON del directorio
print(f"\nArchivos JSON:")
archivos_json = sorted(datos_dir.glob("*.json"))
for a in archivos_json:
    print(f"  {a.name} ({a.stat().st_size} bytes)")

# Procesar todos los archivos
print(f"\n=== Consolidado ===")
total_general = 0
for archivo in archivos_json:
    with open(archivo, "r") as f:
        datos = json.load(f)
    total_mes = sum(datos["saldos"])
    total_general += total_mes
    print(f"  {datos['mes'].title()}: ${total_mes:,} ({len(datos['saldos'])} clientes)")

print(f"  {'─'*35}")
print(f"  Total general: ${total_general:,}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Código	Nota
Leer todo	`f.read()`	Cuidado con archivos grandes
Leer líneas	`f.readlines()`	Devuelve lista con \n
Iterar líneas	`for linea in f:`	Más eficiente en memoria
Escribir	`f.write(texto)`	No agrega \n automático
CSV leer	`csv.DictReader(f)`	Filas como dicts (strings)
CSV escribir	`csv.DictWriter(f, fields)`	Usar `newline=""`
JSON leer	`json.load(f)`	Archivo → dict/list
JSON escribir	`json.dump(d, f, indent=2)`	Dict → archivo
Ruta	`Path("a") / "b" / "c.csv"`	pathlib moderno
Listar	`Path(".").glob("*.csv")`	Buscar archivos

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Escribir y leer texto

Escribí 3 líneas en saludo.txt y después leé e imprimí el contenido. Debe incluir Hola.

ejercicio_01.pyDebe incluir "Hola"

# Escribí y después leé:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Contar líneas de un archivo

Escribí 5 líneas en un archivo y después contá cuántas tiene con readlines(). Debe incluir 5.

ejercicio_02.pyDebe incluir "5"

# Escribí 5 líneas y contá:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Escribir y leer JSON

Guardá un diccionario como JSON y después leelo. Debe incluir García.

ejercicio_03.pyDebe incluir "García"

import json
cliente = {"nombre": "García", "score": 720}

# Guardá y leé:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: CSV con DictWriter y DictReader

Escribí 3 clientes en un CSV y después leelos e imprimí el total de saldos. Debe incluir 515000.

ejercicio_04.pyDebe incluir "515000"

import csv
clientes = [
    {"nombre": "García", "saldo": 150000},
    {"nombre": "López", "saldo": 320000},
    {"nombre": "Pérez", "saldo": 45000},
]

# Escribí CSV, leé y sumá saldos:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Append al log

Creá una función log(mensaje) que agregue al final de app.log con timestamp. Llamala 3 veces. Debe incluir log.

ejercicio_05.pyDebe incluir "registros"

from datetime import datetime

def log(mensaje):
    pass  # completá con mode "a"

log("Inicio del proceso")
log("Datos cargados")
log("3 registros procesados")

# Leé e imprimí:
with open("app.log") as f:
    print(f.read())

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: pathlib para listar archivos

Creá 3 archivos .txt en un directorio y después listalos con Path.glob(). Debe incluir .txt.

ejercicio_06.pyDebe incluir ".txt"

from pathlib import Path

carpeta = Path("mis_datos")
carpeta.mkdir(exist_ok=True)

# Creá 3 archivos y listalos:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Pipeline leer CSV → procesar → guardar JSON

Escribí un CSV de 4 clientes, leelo, filtrá score >= 650, y guardá los aprobados como JSON. Debe incluir aprobados.

ejercicio_07.pyDebe incluir "aprobados"

import csv, json

clientes = [
    {"nombre": "García", "score": "720", "saldo": "150000"},
    {"nombre": "López", "score": "580", "saldo": "320000"},
    {"nombre": "Pérez", "score": "810", "saldo": "890000"},
    {"nombre": "Sosa", "score": "620", "saldo": "72000"},
]

# CSV → filtrar → JSON:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Leer archivo línea por línea y procesar

Creá un archivo con 1000 números (uno por línea), después leelo línea por línea calculando suma y promedio SIN cargar todo en memoria. Debe incluir promedio.

ejercicio_08.pyDebe incluir "promedio"

import random
random.seed(42)

# Escribí 1000 números:
with open("numeros.txt", "w") as f:
    for _ in range(1000):
        f.write(f"{random.randint(1, 100)}\n")

# Leé línea por línea sin cargar todo:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Consolidar múltiples JSONs

Creá 3 archivos JSON (uno por mes con lista de saldos). Después leé los 3 con glob y consolidá el total. Debe incluir consolidado.

ejercicio_09.pyDebe incluir "consolidado"

import json
from pathlib import Path

datos_dir = Path("consolidar")
datos_dir.mkdir(exist_ok=True)

# Creá 3 JSONs y consolidá:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Sistema de persistencia completo

Creá un mini sistema CRUD que guarde clientes en un JSON: funciones cargar(), guardar(), agregar_cliente(), listar(). Los datos deben persistir entre llamadas. Debe incluir PERSISTENCIA.

ejercicio_10_desafio.pyDebe incluir "PERSISTENCIA"

import json
ARCHIVO = "clientes_db.json"

def cargar():
    """Carga clientes desde JSON. Si no existe, devuelve lista vacía."""
    pass

def guardar(clientes):
    """Guarda la lista de clientes en JSON."""
    pass

def agregar(nombre, score, saldo):
    """Agrega un cliente y guarda."""
    pass

# Probá:
agregar("García", 720, 150000)
agregar("López", 680, 320000)

datos = cargar()
print(f"=== PERSISTENCIA ({len(datos)} clientes) ===")
for c in datos:
    print(f"  {c['nombre']}: score {c['score']}")

Hacé clic en ▶ Ejecutar

Resumen y conexión

SIEMPRE usá with open(...) as f: — nunca open() sin context manager.
Modos: "r" (leer), "w" (escribir — BORRA), "a" (append).
csv.DictReader/DictWriter para CSV. json.load/dump para JSON.
for linea in f: es la forma más eficiente de leer archivos grandes.
pathlib.Path es la forma moderna de manejar rutas (reemplaza os.path).
Siempre especificá encoding="utf-8". Si falla, probá "latin-1".

En la siguiente lección (25 · Excepciones y errores) vas a aprender a manejar errores de forma profesional: try/except, tipos de errores, raise y patrones EAFP vs LBYL.

Recursos: Python docs — Files · pathlib

Hecho con ❤️ por Rodri Gonzalez