Tres lecciones de persistencia han dejado la carpeta de Papyrus hecha un bazar: registro_altas.txt, catalogo.csv, ventas.csv, catalogo.json, socios.json, config.json… todo amontonado junto a los .py. Y hay tareas pendientes que no son de contenido sino de gestión: crear carpetas, comprobar qué existe, listar los informes de un mes, renombrar en lote, copiar el catálogo a una copia de seguridad con la fecha en el nombre. De todo eso se ocupa esta lección, con pathlib.Path como protagonista — la forma moderna y orientada a objetos de trabajar con rutas —, el módulo os que el módulo 3 dejó prometido (hoy entenderás por qué lo aplazamos), y shutil para copiar y mover. Al final, Papyrus tendrá una estructura de proyecto profesional y una copia de seguridad nocturna automática. El módulo cierra donde empezó: Ana apaga el ordenador — y ya no pierde nada.

1. Rutas: el dato que parece cadena pero no lo es
2. pathlib.Path: rutas orientadas a objetos
3. Rutas relativas vs absolutas y Path.cwd()
4. Anatomía de una ruta: name, stem, suffix, parent
5. Preguntar y crear: exists(), is_file(), is_dir(), mkdir()
6. Buscar archivos con glob()
7. os y os.path: el legado (tabla de equivalencias)
8. shutil: copiar, mover y borrar árboles
9. La estructura definitiva del proyecto papyrus/
10. Copia de seguridad nocturna con fecha
11. Renombrado en lote: los informes diarios
12. Errores comunes y consejos
13. Ejercicios con soluciones

Hasta ahora hemos pasado a open() cadenas como "catalogo.json", y para el archivo suelto junto al script bastaba. Pero una ruta real tiene estructura (carpetas, nombre, extensión), operaciones propias (unir, subir un nivel, cambiar la extensión) y un problema incómodo: el separador cambia según el sistema — \ en Windows, / en macOS/Linux. Manipular rutas concatenando cadenas (carpeta + "\\" + nombre) produce código frágil y no portable. Python tiene desde siempre os.path para esto (funciones sobre cadenas) y, desde hace años, algo mejor: tratar la ruta como un objeto con métodos — exactamente la filosofía del módulo 5.

Path (del módulo pathlib, biblioteca estándar) ya hizo un cameo en 06-01 con exists(); ahora le toca el papel principal:

La estrella es el operador /: Path sobrecarga la división (un método mágico más, __truediv__ — 05-05 en acción en la biblioteca estándar) para unir tramos de ruta con el separador correcto de cada sistema. Nunca más "datos" + "\\" + "catalogo.json".

Crear un Path no crea nada en disco: es un valor que describe una ruta, exista o no. Y encaja con todo lo aprendido: open() (y por tanto csv y json) acepta objetos Path donde antes pasábamos cadenas — incluso tiene atajos que ya conoces implícitamente:

Los atajos read_text/write_text son cómodos para archivos pequeños de una sola operación; para todo lo demás, el with open(...) de 06-01 sigue siendo el patrón.

• Una ruta absoluta parte de la raíz del sistema: C:\tiendas\papyrus\datos\catalogo.json. Inequívoca, pero atada a una máquina concreta.
• Una ruta relativa (datos/catalogo.json) se resuelve desde el directorio de trabajo actual (current working directory), que consultas con Path.cwd().

La trampa clásica: el directorio de trabajo es desde donde ejecutas, no donde está el script. Si ejecutas python papyrus\caja.py desde C:\tiendas, las rutas relativas del programa se resuelven desde C:\tiendas — y de repente "no encuentra" un datos/ que sí existe, pero un nivel más abajo. El antídoto profesional es anclar las rutas al propio archivo con la variable __file__ (prima de la __name__ de 03-04):

Este par de líneas encabezará los programas de Papyrus a partir de ahora.

Un Path se deja diseccionar con atributos de solo lectura:

Y para derivar rutas nuevas sin tocar cadenas: ruta.with_name("otro.json") cambia el nombre completo y ruta.with_suffix(".csv") solo la extensión. Estas cuatro piezas — stem, suffix, with_name, glob — son el kit completo del renombrado en lote que harás al final.

Los dos argumentos de mkdir() merecen párrafo propio, porque sin ellos el método es quisquilloso:

• parents=True: crea también las carpetas intermedias que falten (datos/copias/2026 de una vez). Sin él, si falta un tramo intermedio: FileNotFoundError.
• exist_ok=True: no protesta si la carpeta ya existe. Sin él, segunda ejecución del programa: FileExistsError.

Juntos hacen mkdir idempotente — puedes llamarlo mil veces con el mismo resultado —, ideal para el arranque de un programa: "asegúrate de que mis carpetas existen". Y sí: exists() es el paliativo que venimos usando desde 06-01 para archivos que quizá no estén; sigue siendo un apaño con grietas, y el módulo 7 (ya inminente) trae la herramienta de verdad.

glob(patron) devuelve los archivos de una carpeta que encajan con un patrón de comodines — * significa "cualquier cosa":

Detalles de uso: devuelve objetos Path (con todos sus atributos listos), en orden no garantizado — de ahí el sorted() —, y con rglob(patron) la búsqueda desciende recursivamente por las subcarpetas. Fíjate en el dividendo de nombrar con fechas ISO (yyyy-mm-dd, como las LineaVenta de 05-06): los nombres ordenan cronológicamente por sí solos y los patrones por mes o por año salen gratis.

El módulo 3 mencionó os («interacción con el sistema operativo») y prometió desarrollarlo aquí. Cumplido — con matiz: para rutas y archivos, os/os.path son la API veterana, anterior a pathlib, basada en funciones que reciben y devuelven cadenas. La encontrarás en millones de líneas de código existente y en respuestas antiguas de internet, así que debes saber leerla; para escribir código nuevo, este curso usa pathlib.

La diferencia de fondo es la del módulo 5: os.path son funciones sueltas operando sobre cadenas pasivas; pathlib empaqueta datos y comportamiento en un objeto. La misma evolución que vivió el catálogo. (os sigue siendo insustituible para otras cosas — variables de entorno con os.environ, procesos — que quedan fuera de este curso de momento.)

pathlib no copia archivos; para eso está shutil (shell utilities), su compañero natural:

• copy2() copia el archivo conservando metadatos como la fecha de modificación (su hermana copy() no los conserva; para copias de seguridad, copy2).
• move() sirve tanto para mover entre carpetas como para renombrar.
• rmtree() merece letras rojas: borra la carpeta y todo su contenido, recursivamente, sin papelera de reciclaje y sin confirmación. Un rmtree sobre la ruta equivocada es irrecuperable. Regla de oro: jamás sobre una ruta construida con datos del usuario, y siempre tras un is_dir() sobre una ruta que puedas leer en voz alta sin sudar.

Con carpetas, rutas ancladas y mkdir idempotente, ordenamos por fin el bazar:

Y el arranque que la garantiza, listo para encabezar caja.py:

A partir de aquí, cargar_catalogo_json(RUTA_CATALOGO) y compañía (06-02/06-03) reciben objetos Path y todo funciona igual — pero ordenado y portable.

Ana ya no pierde el catálogo al apagar… pero ¿y si un día se guarda un catálogo corrupto encima del bueno? Un solo archivo es un solo punto de fallo. La solución clásica: al cierre de caja, copiar el catálogo a copias/ con la fecha en el nombre — datetime (03-05) fabrica el nombre y shutil.copy2 hace el trabajo:

Disecciona la línea del destino: stem (catalogo) + fecha ISO + suffix (.json) = catalogo-2026-07-13.json. Cada noche, un archivo nuevo; ninguna copia pisa a la anterior; y sorted(COPIAS.glob("catalogo-*.json"))[-1] — glob + orden ISO — devuelve siempre la copia más reciente. Tres lecciones de este módulo colaborando en una expresión.

Último encargo de Ana. Antes de automatizar la caja, los informes se guardaban a mano como informe-13-07-2026.csv — fecha "a la europea", que ordenada alfabéticamente mezcla los meses (el 13-07 queda antes que el 02-08... y después que el 01-01 de cualquier año). Hay docenas. Renombrarlos a mano, ni hablar: glob + stem + rename lo hacen en lote:

El patrón informe-??-??-????.csv (cada ? casa un único carácter) evita capturar los informes ya normalizados — que tienen el año, de cuatro cifras, justo después del guion. Es la receta general del renombrado en lote: glob para seleccionar, stem/split para desmontar el nombre, with_name para montarlo, exists para no pisar, rename para ejecutar. Memorízala: la usarás con fotos, descargas y logs el resto de tu vida.

• Concatenar rutas como cadenas (carpeta + "/" + nombre): frágil y no portable. El operador / de Path existe para esto y elige el separador correcto en cada sistema.
• Confiar en el directorio de trabajo: "en mi terminal funcionaba" es el síntoma. Las rutas relativas dependen de desde dónde se ejecuta; ancla con BASE = Path(__file__).parent.
• mkdir() pelado: sin parents=True falla si falta un tramo; sin exist_ok=True falla a la segunda ejecución. La forma canónica lleva ambos, casi siempre.
• Olvidar que glob() no ordena: el orden depende del sistema de archivos. Si el orden importa — y con nombres fechados casi siempre importa — envuelve en sorted().
• rename() hacia un nombre que ya existe: en algunos sistemas sobrescribe silenciosamente el destino. Comprueba exists() antes, como en normalizar_informes().
• rmtree() alegre: borra árboles enteros sin papelera. Verifica la ruta (imprímela antes en una ejecución de prueba), nunca la construyas con entrada del usuario, y pregúntate si move() a una carpeta papelera/ propia no es mejor política.
• Rutas de Windows en cadenas con \: "datos\nuevo.txt" esconde un \n (¡salto de línea!, 01-03). Si escribes rutas literales, usa / — Windows también lo acepta — o mejor, constrúyelas con Path y el operador /.
• Consejo: nombra los archivos fechados siempre en ISO (aaaa-mm-dd). Orden alfabético = orden cronológico, los glob por mes salen solos y te ahorras el renombrado en lote que acabas de tener que hacer.

Escribe inventario(base) que reciba la ruta de papyrus/ y recorra datos/, copias/ e informes/ imprimiendo, por carpeta, cada archivo con su extensión y su tamaño en bytes (ruta.stat().st_size), y al final el total de archivos. Usa glob("*") e is_file() para ignorar posibles subcarpetas. Extra: agrupa los totales por suffix con un Counter (04-06).

Las copias nocturnas se acumulan sin límite. Escribe limpiar_copias(carpeta, conservar=7) que liste las catalogo-*.json de copias/, las ordene por nombre (fecha ISO: el orden alfabético es cronológico) y borre con unlink() todas menos las conservar más recientes, imprimiendo cada borrado. Pruébala creando a mano diez copias falsas con write_text().

Junta el módulo entero en cierre_de_caja(base): (1) asegura las carpetas con la línea canónica de mkdir; (2) guarda el catálogo con guardar_catalogo_json() (06-03) en datos/catalogo.json; (3) haz la copia fechada con copia_de_seguridad(); (4) genera informes/informe-<hoy>.csv con informe_caja() (06-02) leyendo datos/ventas.csv; y (5) imprime un resumen con los nombres de los archivos creados. Ejecútala dos veces seguidas y comprueba que no falla ni duplica nada raro.

Solución 1:

stat() da acceso a los metadatos del archivo (tamaño, fechas); st_size es el tamaño en bytes.

Solución 2:

El slicing negativo de 04-01 hace la política de retención en una línea. Fíjate en {dia:02d}: sin el cero de relleno (catalogo-2026-07-1.json), el orden alfabético dejaría de ser cronológico y la limpieza borraría las copias equivocadas.

Solución 3:

Segunda ejecución en el mismo día: las carpetas ya existen (exist_ok), el catálogo y la copia se regeneran con el mismo nombre y el informe se reescribe — todo estable. Este cierre_de_caja() es, en miniatura, el módulo 6 entero funcionando como una sola pieza.

El módulo 6 salda la deuda que dejó abierta el cierre del módulo 5: el estado de Papyrus ya no muere con el proceso. En 06-01, open() con sus modos, el with que garantiza el cierre y el encoding="utf-8" innegociable dieron a la tienda su primera memoria — registro_altas.txt cumplió la promesa que ficha_libro.py arrastraba desde el módulo 1; el CSV convirtió el catálogo y las ventas en tablas que Excel y la distribuidora entienden, con DictReader/DictWriter y el round-trip dict[str, Libro] → catalogo.csv → dict[str, Libro] pagando el peaje str→float en un único lugar (06-02); JSON aportó tipos que sobreviven al viaje, anidamiento para los socios con sus compras, el puente asdict()/Libro(**datos) y un config.json que saca las constantes del código (06-03); y pathlib ordenó el bazar en datos/, copias/ e informes/, con rutas ancladas a __file__, glob para encontrar, shutil.copy2 para la copia nocturna fechada y el renombrado en lote como receta general (06-04). Ana apaga el ordenador y, por primera vez desde el módulo 1, no pierde nada. Pero fíjate en cuántas veces este módulo dijo "paliativo": Path.exists() antes de leer, "no edites mal el JSON", "reza para que el CSV traiga números". ¿Y si el archivo no está, si la copia está corrupta, si float(fila["precio"]) recibe "gratis", si Júlia teclea un precio imposible? Hoy, cualquiera de esas cosas detiene el programa con un error a media pantalla. El módulo 7 enseña a Papyrus a encajar los golpes: excepciones — detectarlas, manejarlas con try/except, lanzarlas con intención y hasta diseñar las tuyas. Tus objetos ya saben pensar y recordar; ahora aprenderán a equivocarse con elegancia.