Posted on Aug 03, 2025· Updated on Aug 03, 2025
10 Operaciones Esenciales del Sistema de Archivos que Todo Desarrollador Debe Conocer
#python #intermediate #file system
Trabajar con archivos y directorios es una parte fundamental del desarrollo en Python, sin embargo, muchos desarrolladores se limitan a operaciones básicas sin explorar todo el poder de las capacidades de manejo de rutas de Python. Ya sea que esté creando aplicaciones web, pipelines de procesamiento de datos o scripts de automatización, dominar estos patrones esenciales del sistema de archivos hará que su código sea más robusto, eficiente y mantenible.
1. Descubrimiento Inteligente de Archivos con Patrones Glob
A menudo necesita encontrar archivos basándose en un patrón, no solo en un nombre exacto. El método glob del objeto Path es una herramienta poderosa e intuitiva para esto.
Búsqueda Básica y Recursiva
Supongamos que tiene un proyecto en una carpeta src/. A continuación, se muestra cómo encontrar todos sus archivos Python.
from pathlib import Path
# El objeto Path es su herramienta principal para operaciones del sistema de archivos.
project_dir = Path("src/")
# 1. Encuentre todos los archivos .py en el nivel superior del directorio 'src'.
# El asterisco (*) es un comodín para "coincidir con cualquier cosa".
print("--- Archivos .py de nivel superior ---")
for f in project_dir.glob("*.py"):
print(f)
# 2. Encuentre todos los archivos .py RECURSIVAMENTE a través de todos los subdirectorios.
# El método 'rglob' es su mejor amigo para búsquedas profundas.
print("\n--- Todos los archivos .py en el proyecto ---")
for f in project_dir.rglob("*.py"):
print(f)
# Salida de ejemplo:
# --- Archivos .py de nivel superior ---
# src/main.py
# --- Todos los archivos .py en el proyecto ---
# src/main.py
# src/utils/helpers.py
# src/api/models.py
Coincidencia de Patrones Avanzada
glob admite más que solo *. Puede usar ? para que coincida con cualquier carácter único y [] para que coincida con un rango de caracteres, al igual que en la shell.
from pathlib import Path
# Para ejecutar esto, cree un directorio 'logs' con los archivos de ejemplo.
logs_dir = Path("logs/")
logs_dir.mkdir(exist_ok=True)
Path("logs/app1.log").touch()
Path("logs/app2.log").touch()
Path("logs/app_extra.log").touch()
Path("logs/2023-10-01.log").touch()
Path("logs/2023-11-01.log").touch()
# Encuentre registros como 'app1.log', 'app2.log', pero no 'app_extra.log'
print("--- Comodín de un solo carácter ---")
for f in logs_dir.glob("app?.log"):
print(f)
# Encuentre registros de octubre o noviembre de 2023
print("\n--- Rango de caracteres ---")
for f in logs_dir.glob("2023-[10-11]-*.log"):
print(f)
# Salida de ejemplo:
# --- Comodín de un solo carácter ---
# logs/app1.log
# logs/app2.log
#
# --- Rango de caracteres ---
# logs/2023-10-01.log
# logs/2023-11-01.log
2. Navegar Directorios con Precisión
A veces se necesita más control del que ofrece rglob, como cuando se necesita omitir directorios específicos. En lugar de recurrir a os.walk, puede escribir una función recursiva limpia utilizando los propios métodos de pathlib.
from pathlib import Path
def smart_directory_walk(root_path, skip_dirs=None, file_patterns=None):
"""
Recorre un árbol de directorios usando pathlib, permitiéndole omitir subárboles
completos y solo generar archivos que coincidan con patrones específicos.
"""
if skip_dirs is None:
# Se utiliza un conjunto (set) para búsquedas rápidas.
skip_dirs = {'.git', '__pycache__', 'node_modules', '.venv'}
if file_patterns is None:
file_patterns = ["*"]
root = Path(root_path)
for item in root.iterdir():
# Si el elemento es un directorio, decida si debe recursar en él.
if item.is_dir() and item.name not in skip_dirs:
# yield from es una forma limpia de pasar los resultados de la llamada recursiva.
yield from smart_directory_walk(item, skip_dirs, file_patterns)
# Si es un archivo, compruebe si coincide con nuestros patrones.
elif item.is_file():
if any(item.match(p) for p in file_patterns):
yield item
if __name__ == "__main__":
print("Buscando archivos Python y de texto, omitiendo entornos virtuales estándar:")
# Para ejecutar esto, cree algunos archivos y carpetas ficticios.
project_root = Path(".")
(project_root / "src").mkdir(exist_ok=True)
(project_root / "src" / "main.py").touch()
(project_root / ".venv").mkdir(exist_ok=True)
(project_root / ".venv" / "ignored.py").touch()
for f in smart_directory_walk(project_root, file_patterns=["*.py", "*.txt"]):
print(f"Encontrado: {f}")
3. Escribir Archivos Atómicamente para la Seguridad de los Datos
¿Qué sucede si su script falla a mitad de la escritura de config.json? Obtiene un archivo corrupto. Una operación atómica evita esto: es una acción de todo o nada. La forma estándar de hacerlo es escribir en un archivo temporal y luego realizar una única operación move atómica.
import tempfile
import shutil
import os
from pathlib import Path
def atomic_write(file_path, content, encoding='utf-8'):
"""
Escribe contenido en un archivo atómicamente para prevenir la corrupción de datos.
"""
target_path = Path(file_path)
target_path.parent.mkdir(parents=True, exist_ok=True)
# Cree un archivo temporal en el mismo directorio que el archivo final.
# Esto es crucial porque mover un archivo en el mismo sistema de archivos es atómico.
with tempfile.NamedTemporaryFile(
mode='w',
encoding=encoding,
dir=target_path.parent,
delete=False,
suffix='.tmp'
) as tmp_file:
tmp_file.write(content)
# Para datos críticos, os.fsync() asegura que los datos se escriban físicamente
# en el disco. Este es uno de los pocos casos en los que el módulo os
# todavía es necesario para el control de bajo nivel.
tmp_file.flush()
os.fsync(tmp_file.fileno())
temp_path = tmp_file.name
# La operación atómica: renombrar el archivo temporal al destino final.
# shutil.move es inteligente y funciona en diferentes sistemas de archivos.
shutil.move(temp_path, target_path)
print(f"Escrito atómicamente en {target_path}")
if __name__ == "__main__":
# Esto creará 'config/settings.json' de forma segura.
atomic_write("config/settings.json", '{"theme": "dark", "retries": 3}')
4. Dominar Archivos y Directorios Temporales
Los archivos temporales son esenciales para el procesamiento intermedio. El módulo tempfile de Python se integra perfectamente con pathlib, creando archivos y directorios seguros que se limpian automáticamente.
import tempfile
import json
from pathlib import Path
# Una función ficticia para simular el trabajo
def process_file(file_path):
print(f"Procesando {file_path}...")
return f"processed_{file_path.name}"
def batch_process_data(list_of_data):
"""
Utiliza un directorio temporal para procesar un lote de datos, asegurando
que todos los archivos intermedios se limpien automáticamente.
"""
# TemporaryDirectory crea un directorio que se elimina cuando sale del bloque 'with'.
with tempfile.TemporaryDirectory() as tmp_dir_str:
tmp_dir = Path(tmp_dir_str)
print(f"Directorio temporal creado: {tmp_dir}")
results = []
for i, data_item in enumerate(list_of_data):
# Cree un objeto Path temporal dentro de nuestro directorio temporal
temp_file = tmp_dir / f"input_{i}.json"
temp_file.write_text(json.dumps(data_item))
result = process_file(temp_file)
results.append(result)
# El 'tmp_dir' y todo su contenido se eliminan automáticamente aquí.
return results
if __name__ == "__main__":
data_to_process = [{"id": 1, "value": "A"}, {"id": 2, "value": "B"}]
final_results = batch_process_data(data_to_process)
print(f"\nResultados finales: {final_results}")
print("El directorio temporal ha sido eliminado.")
5. Validar y Sanitizar Rutas Proporcionadas por el Usuario
Nunca confíe en una ruta de una fuente externa. Un usuario malintencionado podría proporcionar ../../etc/passwd para intentar leer archivos sensibles. Debe validar y sanitizar cualquier entrada de ruta externa utilizando las funciones de seguridad integradas de pathlib.
import re
from pathlib import Path
def sanitize_filename(filename, replacement='_'):
"""
Limpia una cadena para que sea un nombre de archivo válido y seguro para cualquier SO.
"""
invalid_chars = r'[<>:"/\\|?*\x00-\x1f]'
sanitized = re.sub(invalid_chars, replacement, filename)
# Se pueden agregar verificaciones adicionales aquí (ej. para nombres reservados de Windows)
return sanitized.strip(' .')
def validate_and_resolve_path(base_dir, user_path_str):
"""
Resuelve de forma segura una ruta proporcionada por el usuario, asegurando que permanezca
dentro de un directorio base. Esto es CRÍTICO para prevenir ataques de recorrido de directorios.
"""
base_dir = Path(base_dir).resolve()
# resolve() crea una ruta canónica y absoluta, limpiando los segmentos '..'.
resolved_path = (base_dir / user_path_str).resolve()
# La comprobación de seguridad clave: ¿sigue la ruta final dentro de nuestro base_dir seguro?
# Path.is_relative_to() se agregó en Python 3.9 y es perfecta para esto.
if resolved_path.is_relative_to(base_dir):
return resolved_path
else:
raise PermissionError("Intento de recorrido de ruta detectado.")
if __name__ == "__main__":
# 1. Sanitizar un nombre de archivo potencialmente sucio
dirty_name = "My Report: Part 1/2 <Final?>.docx"
clean_name = sanitize_filename(dirty_name)
print(f"Sanitizado '{dirty_name}' a '{clean_name}'")
# 2. Validar una ruta de usuario
upload_dir = "uploads"
Path(upload_dir).mkdir(exist_ok=True)
try:
# Ruta segura
safe_path = validate_and_resolve_path(upload_dir, "images/profile.jpg")
print(f"OK: La ruta es segura: {safe_path}")
# Ruta maliciosa
malicious_path_str = "../../../etc/hosts"
print(f"\nProbando ruta maliciosa: '{malicious_path_str}'")
validate_and_resolve_path(upload_dir, malicious_path_str)
except PermissionError as e:
print(f"ERROR: {e}")
6. Calcular el Tamaño del Directorio con pathlib
Calcular el tamaño de un directorio es una tarea clásica. Si bien os.scandir es conocido por su velocidad, un enfoque puro de pathlib que utiliza rglob es a menudo más legible y conveniente para todas las aplicaciones, excepto las más críticas en cuanto al rendimiento en sistemas de archivos masivos.
from pathlib import Path
def calculate_directory_size(directory):
"""
Calcula el tamaño total de un directorio y todos sus subdirectorios
utilizando un enfoque legible y puramente pathlib.
"""
dir_path = Path(directory)
total_size = 0
# rglob('*') es un generador, por lo que no carga todas las rutas en memoria a la vez.
for path in dir_path.rglob('*'):
# Solo sumamos el tamaño de los archivos.
if path.is_file():
try:
# path.stat().st_size da el tamaño en bytes.
total_size += path.stat().st_size
except (PermissionError, FileNotFoundError):
# Ignorar archivos a los que no podemos acceder.
continue
return total_size
def format_size(size_bytes):
"""Formatea los bytes en una cadena legible por humanos (KB, MB, GB)."""
if size_bytes == 0:
return "0B"
units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
i = 0
while size_bytes >= 1024 and i < len(units) - 1:
size_bytes /= 1024
i += 1
return f"{size_bytes:.2f} {units[i]}"
if __name__ == "__main__":
target_directory = "."
print(f"Calculando el tamaño de '{Path(target_directory).resolve()}'...")
total_bytes = calculate_directory_size(target_directory)
print(f"Tamaño total: {format_size(total_bytes)} ({total_bytes:,} bytes)")
7. Copiar Archivos Grandes con Progreso y Verificación
Al copiar archivos grandes, desea proporcionar comentarios al usuario y asegurarse de que el archivo copiado no esté corrupto. Este patrón combina shutil para copiar, hashlib para la integridad de los datos y la biblioteca tqdm para una hermosa barra de progreso.
Nota: Necesitará instalar tqdm: pip install tqdm
import shutil
import hashlib
import os
from pathlib import Path
from tqdm import tqdm
def calculate_file_hash(file_path, algorithm='sha256', chunk_size=65536):
"""Calcula el hash de un archivo."""
hash_obj = hashlib.new(algorithm)
with Path(file_path).open('rb') as f:
for chunk in iter(lambda: f.read(chunk_size), b""):
hash_obj.update(chunk)
return hash_obj.hexdigest()
def copy_with_verification(src, dst):
"""
Copia un archivo con una barra de progreso y verifica la integridad de la copia.
"""
src_path, dst_path = Path(src), Path(dst)
dst_path.parent.mkdir(parents=True, exist_ok=True)
src_size = src_path.stat().st_size
print(f"Calculando hash para {src_path.name}...")
src_hash = calculate_file_hash(src_path)
print(f"Copiando {src_path.name} a {dst_path}...")
with src_path.open('rb') as fsrc, \
dst_path.open('wb') as fdst, \
tqdm(total=src_size, unit='B', unit_scale=True, desc=src_path.name) as pbar: \
shutil.copyfileobj(fsrc, fdst, length=16*1024*1024)
# Actualizar manualmente la barra de progreso si copyfileobj termina antes de que tqdm se actualice
pbar.n = src_size
pbar.refresh()
print("Verificando copia...")
dst_hash = calculate_file_hash(dst_path)
if src_hash != dst_hash:
dst_path.unlink() # Eliminar la copia corrupta
raise IOError(f"¡La verificación falló! Los hashes no coinciden para {dst_path}")
print(f"Éxito! {dst_path.name} copiado y verificado.")
return dst_path
if __name__ == "__main__":
source_file = Path("large_file.dat")
if not source_file.exists():
print(f"Creando archivo ficticio '{source_file}'...")
# os.urandom se usa aquí simplemente para obtener bytes aleatorios para un archivo ficticio.
source_file.write_bytes(os.urandom(50 * 1024 * 1024)) # 50 MB
try:
copy_with_verification(source_file, Path("backup/large_file.dat"))
except (IOError, FileNotFoundError) as e:
print(f"Ocurrió un error: {e}")
8. Monitorear un Directorio en Busca de Cambios
¿Quiere procesar automáticamente los archivos que se colocan en una carpeta? Necesita un observador del sistema de archivos. Si bien bibliotecas como watchdog son mejores para la producción, es bueno saber cómo crear una simple usted mismo utilizando pathlib y sondeo (polling).
import time
from pathlib import Path
from collections import defaultdict
class SimpleFileWatcher:
"""Un observador de archivos básico que sondea un directorio en busca de cambios."""
def __init__(self, watch_directory, patterns=None):
self.watch_dir = Path(watch_directory)
self.patterns = patterns or ["*"]
self._file_states = {} # Almacena {ruta: mtime}
self.callbacks = defaultdict(list)
def on(self, event_type, callback):
self.callbacks[event_type].append(callback)
def _trigger(self, event_type, file_path):
for callback in self.callbacks[event_type]:
try:
callback(file_path)
except Exception as e:
print(f"Error en el callback: {e}")
def watch(self, poll_interval=1.0):
print(f"Observando {self.watch_dir.resolve()}... (Presione Ctrl+C para detener)")
try:
while True:
self._scan()
time.sleep(poll_interval)
except KeyboardInterrupt:
print("\nDeteniendo observador.")
def _scan(self):
current_files = set()
for pattern in self.patterns:
for path in self.watch_dir.rglob(pattern):
if path.is_file():
current_files.add(path)
try:
mtime = path.stat().st_mtime
if path not in self._file_states:
self._file_states[path] = mtime
self._trigger('created', path)
elif self._file_states[path] != mtime:
self._file_states[path] = mtime
self._trigger('modified', path)
except FileNotFoundError:
continue
deleted_files = set(self._file_states.keys()) - current_files
for path in deleted_files:
del self._file_states[path]
self._trigger('deleted', path)
def log_change(event):
def handler(path):
print(f"[{event.upper()}] - {path.name} a las {time.ctime()}")
return handler
if __name__ == "__main__":
watch_folder = Path("watched_folder")
watch_folder.mkdir(exist_ok=True)
watcher = SimpleFileWatcher(watch_folder, patterns=["*.txt", "*.csv"])
watcher.on('created', log_change('created'))
watcher.on('modified', log_change('modified'))
print("Observador iniciado. Intente crear/editar archivos en 'watched_folder'.")
watcher.watch()
9. Administrar Archivos de Configuración de Forma Flexible
Las aplicaciones necesitan configuración de archivos (JSON, YAML, INI). Este ConfigManager maneja diferentes formatos con elegancia, utilizando pathlib para administrar rutas y nuestra función atomic_write para guardar la configuración de forma segura.
Nota: Necesitará PyYAML: pip install pyyaml
import json
import yaml
import configparser
from pathlib import Path
from typing import Any, Dict
# En un proyecto real, la función 'atomic_write' del Patrón 3 estaría
# en un archivo utils.py compartido. Asumimos que está disponible aquí.
class ConfigManager:
"""Un administrador para cargar y guardar archivos de configuración en varios formatos."""
def __init__(self, config_path: str):
self.path = Path(config_path)
self.type = self.path.suffix.lower().strip('.')
def load(self) -> Dict[str, Any]:
if not self.path.exists():
return {}
try:
with self.path.open('r', encoding='utf-8') as f:
if self.type == 'json':
return json.load(f)
elif self.type in ['yaml', 'yml']:
return yaml.safe_load(f) or {}
# Agregue otros formatos como INI si es necesario
except Exception as e:
raise IOError(f"Fallo al cargar la configuración {self.path}: {e}")
return {}
def save(self, config: Dict[str, Any]):
content = ""
try:
if self.type == 'json':
content = json.dumps(config, indent=2)
elif self.type in ['yaml', 'yml']:
content = yaml.dump(config, default_flow_style=False)
# Usar nuestra función de escritura segura
atomic_write(self.path, content)
except Exception as e:
raise IOError(f"Fallo al guardar la configuración {self.path}: {e}")
if __name__ == "__main__":
json_config = ConfigManager("config.yml")
settings = {
"database": {"host": "db.example.com", "port": 5432},
"features": {"new_ui": True, "beta_access": False}
}
print(f"Guardando configuración en {json_config.path}...")
json_config.save(settings)
loaded = json_config.load()
print("Configuración cargada:")
print(yaml.dump(loaded))
assert settings == loaded
10. Manejar Archivos de Archivo (ZIP, TAR) de Forma Segura
Trabajar con archivos .zip o .tar.gz es común. Este ArchiveManager utiliza pathlib para proporcionar una interfaz simple y segura para crear y extraer archivos, incluidas comprobaciones cruciales para prevenir ataques de recorrido de rutas.
import zipfile
import tarfile
from pathlib import Path
class ArchiveManager:
"""Una interfaz segura y simple para manejar archivos zip y tar."""
def _is_path_safe(self, path_str, target_dir):
target_dir = Path(target_dir).resolve()
resolved_path = (target_dir / path_str).resolve()
return resolved_path.is_relative_to(target_dir)
def extract(self, archive_path, extract_to):
archive_path = Path(archive_path)
extract_to = Path(extract_to)
extract_to.mkdir(parents=True, exist_ok=True)
if archive_path.suffix == '.zip':
with zipfile.ZipFile(archive_path, 'r') as archive:
for member_name in archive.namelist():
if self._is_path_safe(member_name, extract_to):
archive.extract(member_name, extract_to)
else:
print(f"ADVERTENCIA: Ruta insegura omitida en zip: {member_name}")
elif '.tar' in "".join(archive_path.suffixes):
with tarfile.open(archive_path, 'r:*') as archive:
for member in archive.getmembers():
if self._is_path_safe(member.name, extract_to):
archive.extract(member, path=extract_to, set_attrs=False)
else:
print(f"ADVERTENCIA: Ruta insegura omitida en tar: {member.name}")
else:
raise ValueError(f"Tipo de archivo no compatible: {archive_path.suffix}")
print(f"Extracción exitosa de {archive_path.name} a {extract_to}")
def create(self, source_dir, output_path):
source_dir = Path(source_dir)
output_path = Path(output_path)
output_path.parent.mkdir(parents=True, exist_ok=True)
if output_path.suffix == '.zip':
with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as archive:
for path in source_dir.rglob("*"):
archive.write(path, path.relative_to(source_dir))
elif output_path.name.endswith('.tar.gz'):
with tarfile.open(output_path, 'w:gz') as archive:
archive.add(source_dir, arcname='.')
else:
raise ValueError(f"Tipo de archivo no compatible: {output_path.suffix}")
print(f"Creación exitosa del archivo {output_path}")
if __name__ == "__main__":
project_dir = Path("my_project")
(project_dir / "data").mkdir(parents=True, exist_ok=True)
(project_dir / "main.py").write_text("print('hello')")
manager = ArchiveManager()
archive_file = Path("backups/my_project.tar.gz")
manager.create(project_dir, archive_file)
extract_dir = Path("restored_project")
manager.extract(archive_file, extract_dir)
Reflexiones Finales
Acaba de explorar diez patrones potentes y prácticos para operaciones del sistema de archivos utilizando el módulo pathlib de Python.
- Adopte
pathlib: Su enfoque orientado a objetos es más limpio, más seguro y más expresivo que los métodos antiguos basados en cadenas. Conviértalo en su herramienta predeterminada para todas las manipulaciones de rutas. - La Seguridad es lo Primero: Valide siempre la entrada externa con
is_relative_to, escriba archivos críticos atómicamente y extraiga archivos de forma segura. - La Legibilidad Cuenta: El código de
pathlibsuele ser autodocumentado. Una cadena de métodos en un objetoPathes mucho más fácil de seguir que una serie de llamadas anidadas a os.path.join.
Al incorporar estos patrones en su trabajo, escribirá código Python que no solo es más profesional, sino también significativamente más robusto y seguro. ¡Feliz codificación!