Archivos y manejo de excepciones

📐 Fundamento

Forma básica:

f = open("archivo.txt", "r")
contenido = f.read()
f.close()

open() devuelve un objeto archivo. f.read() lee TODO el contenido. f.close() libera el recurso.

Modos:

encoding="utf-8" es buena costumbre — evita sorpresas con caracteres especiales:

f = open("archivo.txt", "r", encoding="utf-8")

El problema del olvido

Si tu programa crashea entre open y close, el archivo queda abierto y posiblemente sin escribirse. Eso es bug.

Solución idiomática: with (context manager).

with open("archivo.txt", "r") as f:
    contenido = f.read()
# acá afuera, f ya está cerrado, GARANTIZADO

with garantiza que f.close() se llame al salir del bloque, incluso si hay excepción. Es la forma moderna y siempre la preferida.

📐 Fundamento

Tres formas principales de leer:

1. Todo de una vez

with open("archivo.txt") as f:
    texto = f.read()      # devuelve un string completo

OK para archivos chicos. Mal para archivos grandes (carga todo a RAM).

2. Línea por línea

with open("archivo.txt") as f:
    for linea in f:
        print(linea.rstrip())   # rstrip quita el \n

Eficiente. Procesa una línea, descarta, sigue. Funciona para archivos enormes.

3. readlines (devuelve lista de líneas)

with open("archivo.txt") as f:
    lineas = f.readlines()    # ["linea1\n", "linea2\n", ...]

OK si necesités acceso aleatorio por índice.

Path

Aceptar paths absolutos o relativos. Buenas prácticas modernas usan pathlib:

from pathlib import Path

p = Path("datos") / "archivo.txt"
texto = p.read_text(encoding="utf-8")

Path es portable (Windows/Linux/Mac), tiene operadores cómodos (/ para concatenar), y métodos como .read_text(), .write_text(), .exists(), .glob().

📐 Fundamento

with open("salida.txt", "w") as f:
    f.write("Hola\n")
    f.write("Mundo\n")

f.write no agrega \n automáticamente (a diferencia de print).

Escribir varias líneas con print redirigido:

with open("salida.txt", "w") as f:
    print("Hola", file=f)
    print("Mundo", file=f)

Más cómodo si querés print normal.

Append (agregar sin borrar):

with open("log.txt", "a") as f:
    f.write(f"{fecha} - usuario inició sesión\n")

Modo binario. Para imágenes, ZIPs, archivos no-texto:

with open("foto.jpg", "rb") as f:
    bytes_imagen = f.read()

with open("copia.jpg", "wb") as f:
    f.write(bytes_imagen)

Modo binario te da bytes, no str. Para conversión: bytes.decode("utf-8") y str.encode("utf-8").

📐 Fundamento

JSON (JavaScript Object Notation) es el formato estándar para datos estructurados, web APIs, configuración.

Leer:

import json

with open("datos.json", encoding="utf-8") as f:
    datos = json.load(f)

print(datos)   # un dict o lista, según el archivo

Escribir:

datos = {
    "estudiantes": ["ana", "beto"],
    "promedios": {"ana": 8.5, "beto": 7.0},
}

with open("datos.json", "w", encoding="utf-8") as f:
    json.dump(datos, f, indent=2, ensure_ascii=False)

indent=2 formatea bonito. ensure_ascii=False permite tildes y eñes.

Conversión Python → JSON:

De string (no archivo):

texto = '{"nombre": "ana", "edad": 19}'
datos = json.loads(texto)        # carga desde string
texto = json.dumps(datos, indent=2)   # serializa a string

JSON no soporta: datetime, set, función, NaN. Para esos hay extensiones o serialización custom.

📐 Fundamento

Una excepción es un evento anormal: archivo no existe, división por cero, índice fuera de rango, RAM agotada. Si no la manejás, tu programa muere (con un traceback).

Sintaxis:

try:
    f = open("inexistente.txt")
    contenido = f.read()
except FileNotFoundError:
    print("Archivo no existe")

try ejecuta el código riesgoso. Si dentro se levanta una excepción del tipo capturado, salta al except correspondiente.

Capturar varios tipos:

try:
    n = int(input("Número: "))
    r = 100 / n
except ValueError:
    print("No es un número")
except ZeroDivisionError:
    print("No se puede dividir por 0")

Capturar todos (con cuidado):

try:
    # algo
except Exception as e:
    print(f"Error: {e}")

Exception captura casi todas (no KeyboardInterrupt ni SystemExit, que son señales). as e te da el objeto para inspección.

else y finally

Forma completa:

try:
    # código riesgoso
except SomeError:
    # manejo
else:
    # ejecuta si NO hubo excepción
finally:
    # SIEMPRE ejecuta (con o sin excepción)

finally es para liberar recursos que tomaste. Es lo que hace with por dentro:

f = open("archivo.txt")
try:
    contenido = f.read()
finally:
    f.close()        # cierra incluso si hay error

else se usa menos. Va donde el código exitoso "principal" sin estorbar el try.

Jerarquía

Las excepciones forman jerarquía. FileNotFoundError hereda de OSError que hereda de Exception que hereda de BaseException.

BaseException
 └── Exception
      ├── ValueError
      ├── TypeError
      ├── KeyError
      ├── IndexError
      ├── ArithmeticError
      │    └── ZeroDivisionError
      ├── OSError
      │    ├── FileNotFoundError
      │    ├── PermissionError
      │    └── ...
      └── ...

Capturar la superclase captura todas las subclases. Por eso except Exception atrapa casi todo.

Lo más específico arriba:

try:
    ...
except FileNotFoundError:
    ...        # más específico
except OSError:
    ...        # más general
except Exception:
    ...        # último recurso

📐 Fundamento

Tu propio código puede levantar errores con raise:

def dividir(a, b):
    if b == 0:
        raise ValueError("Divisor no puede ser cero")
    return a / b

Definir tus propias:

class StockInsuficiente(Exception):
    """Stock no alcanza para el pedido."""
    def __init__(self, producto, pedido, disponible):
        self.producto = producto
        self.pedido = pedido
        self.disponible = disponible
        super().__init__(f"{producto}: pedidas {pedido}, disponibles {disponible}")


def vender(producto, cantidad, inventario):
    if inventario.get(producto, 0) < cantidad:
        raise StockInsuficiente(producto, cantidad, inventario.get(producto, 0))
    inventario[producto] -= cantidad

try:
    vender("queso", 100, {"queso": 5})
except StockInsuficiente as e:
    print(f"Lo siento: {e}")
    print(f"  Disponible: {e.disponible}")

Por qué crear excepciones propias:

1. Diferenciar errores de tu dominio del resto. Un ValueError genérico es ambiguo; un StockInsuficiente es claro.
2. Llevar info estructurada. Atributos del objeto excepción.
3. Manejo selectivo. Distintos handlers para distintos errores.

📐 Fundamento

Dos estilos para manejar errores:

LBYL (Look Before You Leap) — chequear antes:

import os
if os.path.exists("archivo.txt"):
    with open("archivo.txt") as f:
        contenido = f.read()
else:
    contenido = ""

EAFP (Easier to Ask Forgiveness than Permission) — intentar y atrapar:

try:
    with open("archivo.txt") as f:
        contenido = f.read()
except FileNotFoundError:
    contenido = ""

Python prefiere EAFP por:

1. Race conditions. Entre el check y el uso, el archivo puede aparecer/desaparecer. EAFP no tiene ese problema.
2. Más rápido en el caso feliz (la verificación tiene costo siempre, aunque rara vez falle).
3. Más legible — el código del happy path no se contamina con chequeos.

Cuándo LBYL: chequeos baratos antes de operaciones caras. Por ejemplo, validar input del usuario antes de mandarlo a la base de datos.