Recorrido de directorios y descubrimiento de archivos
os.walk(), patrones glob y filtrado de archivos por tipo o fecha.
Recorrido de directorios y descubrimiento de archivos es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 2 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.
Por qué los agentes necesitan recorrer directorios
Los agentes suelen necesitar encontrar archivos que cumplan determinados criterios: todos los archivos Python de un código base, todos los archivos CSV de un directorio de datos o todos los registros recientes. Python proporciona tres herramientas principales: os.walk(), Path.iterdir() y Path.rglob(). Cada una tiene ventajas diferentes según la profundidad de búsqueda que necesite.
import os
from pathlib import Path
# Count all files in a directory tree
root = Path('/tmp/agent_workspace')
file_count = sum(1 for f in root.rglob('*') if f.is_file())
print(f'Found {file_count} files under {root}')os.walk() — Recorrido recursivo de directorios
os.walk(root) produce una tupla (dirpath, dirnames, filenames) para cada directorio del árbol. Es el enfoque clásico de Python para el recorrido recursivo y ofrece un control detallado sobre los subdirectorios en los que se profundiza.
import os
import tempfile
# --- demo setup: build a small project tree so the walk has something to show ---
root = tempfile.mkdtemp(prefix='project_')
os.makedirs(os.path.join(root, 'src'), exist_ok=True)
os.makedirs(os.path.join(root, '.git'), exist_ok=True)
with open(os.path.join(root, 'README.md'), 'w') as f:
f.write('demo')
with open(os.path.join(root, 'src', 'main.py'), 'w') as f:
f.write('print(1)')
for dirpath, dirnames, filenames in os.walk(root):
# Skip hidden directories (like .git)
dirnames[:] = [d for d in dirnames if not d.startswith('.')]
print(f'In directory: {dirpath}')
print(f' Subdirs: {dirnames}')
print(f' Files: {filenames}')
for filename in filenames:
full_path = os.path.join(dirpath, filename)
print(f' File: {full_path}')
Path.iterdir() — Listado de un solo nivel
Path.iterdir() muestra el contenido inmediato de un directorio; no recorre los subdirectorios. Utilícelo cuando solo necesite los elementos secundarios directos de un directorio y quiera evitar profundizar más.
from pathlib import Path
data_dir = Path('data')
data_dir.mkdir(exist_ok=True)
(data_dir / 'a.csv').write_text('x')
(data_dir / 'sub').mkdir(exist_ok=True)
for item in data_dir.iterdir():
if item.is_file():
print(f'FILE: {item.name} ({item.stat().st_size} bytes)')
elif item.is_dir():
print(f'DIR: {item.name}/')
csv_files = [f for f in data_dir.iterdir()
if f.is_file() and f.suffix == '.csv']
print(f'Found {len(csv_files)} CSV files')Path.rglob() — Búsqueda glob recursiva
Path.rglob(pattern) encuentra recursivamente todos los archivos que coinciden con un patrón glob. Es la forma más concisa de encontrar todos los archivos de un tipo determinado en cualquier ubicación de un árbol de directorios. En glob, ** significa «cualquier cantidad de directorios».
from pathlib import Path
project = Path('/tmp/my_project')
# Find all Python files recursively
python_files = list(project.rglob('*.py'))
print(f'Found {len(python_files)} Python files:')
for f in python_files:
print(f' {f.relative_to(project)}')
# Find all JSON files
json_files = list(project.rglob('*.json'))
# Find files matching a name pattern
test_files = list(project.rglob('test_*.py'))
print(f'Found {len(test_files)} test files')glob.glob() — Coincidencia de patrones
glob.glob(pattern, recursive=True) es la interfaz glob tradicional. Con recursive=True, el comodín ** coincide con cualquier ruta de subdirectorio. Devuelve cadenas, mientras que pathlib.rglob devuelve objetos Path.
import glob
# Find all CSV files recursively
csv_files = glob.glob('data/**/*.csv', recursive=True)
print(f'Found {len(csv_files)} CSV files')
for f in csv_files:
print(f' {f}')
# Find all log files in a specific directory (non-recursive)
logs = glob.glob('/var/log/*.log')
# Find files matching multiple criteria
import fnmatch
all_files = glob.glob('/tmp/**/*', recursive=True)
config_files = [
f for f in all_files
if fnmatch.fnmatch(f, '*.yaml') or fnmatch.fnmatch(f, '*.yml')
]
print(f'Found {len(config_files)} YAML config files')Filtrado por extensión de archivo
Al recorrer directorios, filtre los archivos por su extensión mediante Path.suffix (que incluye el punto, por ejemplo, '.py') o comprobándola con un conjunto de extensiones permitidas. Esto es más rápido y preciso que los patrones glob cuando se filtran varias extensiones.
from pathlib import Path
directory = Path('/tmp/mixed_files')
ALLOWED_EXTENSIONS = {'.py', '.js', '.ts', '.json', '.yaml'}
# Filter by allowed extensions
code_files = [
f for f in directory.rglob('*')
if f.is_file() and f.suffix.lower() in ALLOWED_EXTENSIONS
]
print(f'Found {len(code_files)} code/config files')
# Group files by extension
from collections import defaultdict
by_ext = defaultdict(list)
for f in directory.rglob('*'):
if f.is_file():
by_ext[f.suffix].append(f)
for ext, files in sorted(by_ext.items()):
print(f'{ext}: {len(files)} files')Filtrado por tamaño de archivo
A veces los agentes necesitan encontrar archivos que superen o no alcancen un umbral de tamaño: omitir archivos vacíos diminutos o evitar procesar archivos enormes que saturarían la memoria. Utilice Path.stat().st_size para obtener el tamaño del archivo en bytes.
from pathlib import Path
data_dir = Path('/tmp/data')
MIN_SIZE = 1024 # 1 KB — skip empty/tiny files
MAX_SIZE = 50_000_000 # 50 MB — skip very large files
processable = []
skipped_small = []
skipped_large = []
for f in data_dir.rglob('*.json'):
if not f.is_file():
continue
size = f.stat().st_size
if size < MIN_SIZE:
skipped_small.append(f.name)
elif size > MAX_SIZE:
skipped_large.append(f.name)
else:
processable.append(f)
print(f'Processable: {len(processable)}')
print(f'Too small: {len(skipped_small)}')
print(f'Too large: {len(skipped_large)}')Filtrado por fecha de modificación
Los agentes de canalizaciones incrementales solo necesitan procesar los archivos que han cambiado desde la última ejecución. Utilice stat().st_mtime (la fecha de modificación como marca de tiempo Unix) para encontrar los archivos modificados recientemente.
from pathlib import Path
import time
import datetime
data_dir = Path('/tmp/data')
# Files modified in the last 24 hours
cutoff = time.time() - (24 * 60 * 60)
recent_files = [
f for f in data_dir.rglob('*.log')
if f.is_file() and f.stat().st_mtime > cutoff
]
print(f'Modified in last 24h: {len(recent_files)} files')
# Sort by modification time (newest first)
recent_files.sort(key=lambda f: f.stat().st_mtime, reverse=True)
for f in recent_files[:5]: # top 5 most recent
mtime = datetime.datetime.fromtimestamp(f.stat().st_mtime)
print(f' {f.name}: {mtime.strftime("%Y-%m-%d %H:%M:%S")}')Omisión de archivos ocultos y directorios del sistema
Al recorrer repositorios de código o directorios de usuarios, omita los archivos ocultos (cuyo nombre comienza por .) y los directorios del sistema, como .git, __pycache__, node_modules y .venv. Contienen miles de archivos que son irrelevantes para la mayoría de los agentes.
from pathlib import Path
SKIP_DIRS = {'.git', '__pycache__', 'node_modules', '.venv',
'.env', 'dist', 'build', '.mypy_cache'}
def iter_source_files(root, extensions):
root = Path(root)
for path in root.rglob('*'):
# Skip if any parent is in SKIP_DIRS
if any(part in SKIP_DIRS for part in path.parts):
continue
# Skip hidden files
if path.name.startswith('.'):
continue
if path.is_file() and path.suffix in extensions:
yield path
python_files = list(iter_source_files('/tmp/project', {'.py'}))
print(f'Found {len(python_files)} Python source files')Creación de un inventario de archivos
Un inventario de archivos es un resumen estructurado de un árbol de directorios, útil para los agentes que necesitan planificar el trabajo antes de procesarlo. Recopile el nombre, la ruta, el tamaño, la extensión y la fecha de modificación en una lista de diccionarios que pueda serializarse a JSON.
from pathlib import Path
import datetime
import json
def build_inventory(root_dir, pattern='**/*'):
root = Path(root_dir)
inventory = []
for f in root.glob(pattern):
if not f.is_file():
continue
stat = f.stat()
inventory.append({
'name': f.name,
'path': str(f.relative_to(root)),
'extension': f.suffix,
'size_bytes': stat.st_size,
'modified': datetime.datetime.fromtimestamp(
stat.st_mtime
).isoformat()
})
return sorted(inventory, key=lambda x: x['path'])
inventory = build_inventory('/tmp/data')
with open('file_inventory.json', 'w') as out:
json.dump(inventory, out, indent=2)
print(f'Inventoried {len(inventory)} files')Supervisión de cambios en un directorio
Algunos agentes deben reaccionar cuando aparecen archivos nuevos en un directorio. Aunque una biblioteca completa de supervisión de archivos como watchdog es la mejor opción para producción, un enfoque sencillo consiste en explorar periódicamente el directorio y comparar el resultado con un conjunto conocido de archivos.
from pathlib import Path
import time
def watch_for_new_files(watch_dir, extension='.json', interval=5):
watch_dir = Path(watch_dir)
known_files = set(watch_dir.glob(f'*{extension}'))
print(f'Watching {watch_dir} for new {extension} files...')
while True:
time.sleep(interval)
current_files = set(watch_dir.glob(f'*{extension}'))
new_files = current_files - known_files
for f in new_files:
print(f'New file detected: {f.name}')
process_new_file(f) # handle the new file
known_files = current_files
def process_new_file(file_path):
print(f'Processing: {file_path}')
# --- demo (one polling cycle, without the infinite while True loop) ---
import tempfile
demo_dir = Path(tempfile.mkdtemp())
known_files = set(demo_dir.glob('*.json'))
print(f'Watching {demo_dir} for new .json files...')
(demo_dir / 'result_a.json').write_text('{}', encoding='utf-8')
(demo_dir / 'result_b.json').write_text('{}', encoding='utf-8')
current_files = set(demo_dir.glob('*.json'))
new_files = current_files - known_files
for f in sorted(new_files, key=lambda p: p.name):
print(f'New file detected: {f.name}')
process_new_file(f)
Comprobación rápida: rglob frente a iterdir
Compruebe su comprensión de los métodos para recorrer directorios.
Resumen del recorrido de directorios
Ahora puede encontrar cualquier archivo que necesite su agente:
- os.walk(): control total sobre el recorrido recursivo; modifique
dirnamesin situ para podar subdirectorios - Path.iterdir(): listado de un solo nivel con los elementos secundarios inmediatos
- Path.rglob('*.ext'): búsqueda recursiva por patrón, de forma sencilla
- glob.glob('**/*.ext', recursive=True): alternativa tradicional que devuelve cadenas
- Filtre por
.suffixpara la extensión,.stat().st_sizepara el tamaño y.stat().st_mtimepara la fecha de modificación - Omita siempre los archivos ocultos y los directorios del sistema, como
.gitynode_modules
Preguntas frecuentes
¿La lección «Recorrido de directorios y descubrimiento de archivos» es gratis?
Sí — el texto completo de «Recorrido de directorios y descubrimiento de archivos» 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 «Recorrido de directorios y descubrimiento de archivos»?
os.walk(), patrones glob y filtrado de archivos por tipo o fecha. 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 2 de 4.
¿Cuánto tiempo toma la lección «Recorrido de directorios y descubrimiento de archivos»?
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