Cómo usar os.walk en Python para recorrer directorios de manera recursiva

El os.walk de Python es una herramienta poderosa para recorrer directorios y su contenido de manera recursiva. Al utilizar esta función, puedes obtener de manera eficiente todos los subdirectorios y archivos dentro de un directorio especificado. En este artículo, cubriremos desde el uso básico de os.walk hasta ejemplos prácticos, lo que te permitirá manejar tareas que impliquen operaciones de directorios de manera más eficiente.

Índice

¿Qué es os.walk?

os.walk es una función incluida en el módulo estándar de Python os que recorre un directorio especificado de manera recursiva, generando una lista de los archivos y subdirectorios dentro de ese directorio. Utilizar esta función te permite explorar fácilmente estructuras de directorios complejas, siendo muy útil al obtener listas de archivos o carpetas.

Funcionamiento de os.walk

os.walk funciona como un generador y devuelve una tupla con tres elementos:

Ruta del directorio (dirpath)
Muestra la ruta del directorio que se está explorando actualmente.
Lista de subdirectorios (dirnames)
Una lista con los nombres de los subdirectorios dentro del directorio actual.
Lista de archivos (filenames)
Una lista con los nombres de los archivos dentro del directorio actual.

Características

Búsqueda recursiva: Explora automáticamente los subdirectorios del directorio especificado.
Orden: Puedes configurar el procesamiento de la jerarquía del directorio de arriba hacia abajo o de abajo hacia arriba (topdown=True/False).
Eficiencia: Genera la información sobre la marcha, por lo que es eficiente en cuanto a memoria.

Usos

Búsqueda de nombres de archivos
Creación de listas de archivos con extensiones específicas
Cálculo del tamaño de los subdirectorios
Automatización de tareas de copia de seguridad o movimiento de archivos

Uso básico

Utilizando os.walk, puedes obtener fácilmente los archivos y carpetas dentro de un directorio especificado. A continuación se muestra un ejemplo básico de código.

Ejemplo de código

import os

# Especificar el directorio objetivo
target_directory = "/ruta/a/tu/directorio"

# Usar os.walk para recorrer el directorio
for dirpath, dirnames, filenames in os.walk(target_directory):
    print(f"Ruta actual: {dirpath}")
    print(f"Subdirectorios: {dirnames}")
    print(f"Archivos: {filenames}")
    print("-" * 40)

Ejemplo de salida

Supongamos que la estructura del directorio es la siguiente:

/ruta/a/tu/directorio
├── archivo1.txt
├── archivo2.txt
├── subdir1
│   └── archivo3.txt
└── subdir2
    └── archivo4.txt

Al ejecutar os.walk, la salida será la siguiente:

Ruta actual: /ruta/a/tu/directorio
Subdirectorios: ['subdir1', 'subdir2']
Archivos: ['archivo1.txt', 'archivo2.txt']
----------------------------------------
Ruta actual: /ruta/a/tu/directorio/subdir1
Subdirectorios: []
Archivos: ['archivo3.txt']
----------------------------------------
Ruta actual: /ruta/a/tu/directorio/subdir2
Subdirectorios: []
Archivos: ['archivo4.txt']
----------------------------------------

Explicación

dirpath: Es la ruta del directorio que se está explorando actualmente.
dirnames: Es la lista de subdirectorios dentro del directorio actual.
filenames: Es la lista de archivos dentro del directorio actual.

Consideraciones

os.walk generará un error si el directorio especificado no existe, por lo que es recomendable verificar la existencia del directorio previamente para mayor seguridad.

Manejo de archivos y directorios

Al utilizar os.walk, puedes clasificar de manera eficiente los archivos y carpetas dentro de un directorio. Si deseas aplicar diferentes operaciones para archivos y directorios, puedes agregar condiciones simples para lograrlo fácilmente.

Ejemplo de código

A continuación, se muestra un ejemplo en el que se realiza una operación diferente para archivos y subdirectorios:

import os

# Especificar el directorio objetivo
target_directory = "/ruta/a/tu/directorio"

# Recorrer el directorio y aplicar operaciones
for dirpath, dirnames, filenames in os.walk(target_directory):
    # Operación para subdirectorios
    for dirname in dirnames:
        subdir_path = os.path.join(dirpath, dirname)
        print(f"Directorio: {subdir_path}")

    # Operación para archivos
    for filename in filenames:
        file_path = os.path.join(dirpath, filename)
        print(f"Archivo: {file_path}")

Ejemplo de salida

Si la estructura del directorio es la siguiente:

/ruta/a/tu/directorio
├── archivo1.txt
├── archivo2.txt
├── subdir1
│   └── archivo3.txt
└── subdir2
    └── archivo4.txt

La salida será la siguiente:

Directorio: /ruta/a/tu/directorio/subdir1
Directorio: /ruta/a/tu/directorio/subdir2
Archivo: /ruta/a/tu/directorio/archivo1.txt
Archivo: /ruta/a/tu/directorio/archivo2.txt
Archivo: /ruta/a/tu/directorio/subdir1/archivo3.txt
Archivo: /ruta/a/tu/directorio/subdir2/archivo4.txt

Explicación del código

os.path.join: Se utiliza para combinar dirpath con dirname o filename y generar la ruta absoluta.
Operación en directorios (for dirname in dirnames): Permite realizar una operación específica en los subdirectorios (por ejemplo, obtener la fecha de creación).
Operación en archivos (for filename in filenames): Permite realizar una operación específica en los archivos (por ejemplo, obtener el tamaño del archivo).

Ejemplos avanzados

Crear y gestionar una lista de los subdirectorios.
Filtrar y procesar archivos que sigan una convención de nombres específica.
Filtrar archivos según su tamaño o fecha de creación.

Buscar archivos con una extensión específica

Utilizando os.walk, es posible buscar fácilmente archivos con una extensión específica. Esto es útil si, por ejemplo, deseas extraer archivos de formato .txt o .jpg.

Ejemplo de código

A continuación, se muestra un ejemplo de cómo buscar archivos con la extensión .txt y mostrar su ruta:

import os

# Especificar el directorio objetivo
target_directory = "/ruta/a/tu/directorio"

# Especificar la extensión a buscar
target_extension = ".txt"

# Buscar archivos con la extensión específica
for dirpath, dirnames, filenames in os.walk(target_directory):
    for filename in filenames:
        if filename.endswith(target_extension):
            file_path = os.path.join(dirpath, filename)
            print(f"Encontrado: {file_path}")

Ejemplo de salida

Si la estructura del directorio es la siguiente:

/ruta/a/tu/directorio
├── archivo1.txt
├── archivo2.doc
├── subdir1
│   └── notas.txt
└── subdir2
    └── imagen.png

La salida será la siguiente:

Encontrado: /ruta/a/tu/directorio/archivo1.txt
Encontrado: /ruta/a/tu/directorio/subdir1/notas.txt

Explicación del código

filename.endswith(target_extension): Devuelve True si el nombre del archivo termina con la extensión especificada. Se utiliza para filtrar archivos por su formato.
os.path.join: Se utiliza para generar la ruta completa del archivo.

Buscar múltiples extensiones

Si deseas buscar múltiples extensiones, puedes modificar las condiciones de búsqueda.

# Especificar las extensiones a buscar
target_extensions = [".txt", ".doc"]

for dirpath, dirnames, filenames in os.walk(target_directory):
    for filename in filenames:
        if filename.endswith(tuple(target_extensions)):
            file_path = os.path.join(dirpath, filename)
            print(f"Encontrado: {file_path}")

Ejemplos avanzados

Obtener una lista de los archivos de código fuente en un proyecto (por ejemplo, archivos .py).
Buscar y procesar en lote archivos de imágenes (por ejemplo, .jpg o .png).
Crear estadísticas de archivos por extensión.

Recorrer directorios con límite de profundidad

os.walk recorre por defecto todos los niveles de un directorio de manera recursiva, pero en ocasiones es necesario limitar la búsqueda a una cierta profundidad. En estos casos, puedes hacer un seguimiento de la profundidad actual y limitar la exploración según sea necesario.

Ejemplo de código

A continuación, se muestra un ejemplo de cómo limitar la búsqueda a una profundidad de 2 niveles:

import os

# Especificar el directorio objetivo
target_directory = "/ruta/a/tu/directorio"

# Especificar la profundidad máxima
max_depth = 2

# Rec

orrer el directorio con límite de profundidad
for dirpath, dirnames, filenames in os.walk(target_directory):
    # Calcular la profundidad actual
    current_depth = dirpath.count(os.sep) - target_directory.count(os.sep) + 1

    if current_depth > max_depth:
        # Si se excede la profundidad, omitir los subdirectorios
        del dirnames[:]  # Vaciar dirnames para ignorar los subdirectorios
        continue

    print(f"Profundidad {current_depth}: {dirpath}")
    print(f"Subdirectorios: {dirnames}")
    print(f"Archivos: {filenames}")
    print("-" * 40)

Ejemplo de salida

Si la estructura del directorio es la siguiente:

/ruta/a/tu/directorio
├── archivo1.txt
├── subdir1
│   ├── archivo2.txt
│   └── subsubdir1
│       └── archivo3.txt
└── subdir2
    └── archivo4.txt

Al limitar la búsqueda a una profundidad de 2 niveles, la salida será la siguiente:

Profundidad 1: /ruta/a/tu/directorio
Subdirectorios: ['subdir1', 'subdir2']
Archivos: ['archivo1.txt']
----------------------------------------
Profundidad 2: /ruta/a/tu/directorio/subdir1
Subdirectorios: ['subsubdir1']
Archivos: ['archivo2.txt']
----------------------------------------
Profundidad 2: /ruta/a/tu/directorio/subdir2
Subdirectorios: []
Archivos: ['archivo4.txt']
----------------------------------------

Explicación del código

os.sep: Obtiene el separador de ruta dependiente del sistema operativo (en Windows es \\, en Unix es /).
dirpath.count(os.sep): Cuenta el número de separadores de ruta en el directorio actual y calcula la profundidad en función de eso.
del dirnames[:]: Elimina la lista de subdirectorios para evitar explorar más allá de la profundidad máxima.

Ejemplos avanzados

Explorar solo los directorios principales en un proyecto grande.
Mostrar parte de un árbol de directorios con una búsqueda limitada.
Reducir la carga de las operaciones de disco limitando la profundidad de la búsqueda.

Ignorar archivos y carpetas ocultos

Cuando se recorre un directorio, puede ser necesario ignorar los archivos o carpetas ocultos (que suelen comenzar con un punto .). Puedes filtrar estos elementos usando os.walk para realizar un recorrido más eficiente.

Ejemplo de código

A continuación se muestra un ejemplo de cómo ignorar archivos y carpetas ocultos al recorrer un directorio:

import os

# Especificar el directorio objetivo
target_directory = "/ruta/a/tu/directorio"

# Recorrer y omitir archivos y carpetas ocultos
for dirpath, dirnames, filenames in os.walk(target_directory):
    # Ignorar carpetas ocultas
    dirnames[:] = [d for d in dirnames if not d.startswith(".")]

    # Ignorar archivos ocultos
    visible_files = [f for f in filenames if not f.startswith(".")]

    print(f"Ruta actual: {dirpath}")
    print(f"Subdirectorios: {dirnames}")
    print(f"Archivos: {visible_files}")
    print("-" * 40)

Ejemplo de salida

Si la estructura del directorio es la siguiente:

/ruta/a/tu/directorio
├── archivo1.txt
├── .archivo_oculto.txt
├── subdir1
│   ├── archivo2.txt
│   └── .carpeta_oculta
│       └── archivo3.txt
└── subdir2
    └── archivo4.txt

Al omitir archivos y carpetas ocultos, la salida será la siguiente:

Ruta actual: /ruta/a/tu/directorio
Subdirectorios: ['subdir1', 'subdir2']
Archivos: ['archivo1.txt']
----------------------------------------
Ruta actual: /ruta/a/tu/directorio/subdir1
Subdirectorios: []
Archivos: ['archivo2.txt']
----------------------------------------
Ruta actual: /ruta/a/tu/directorio/subdir2
Subdirectorios: []
Archivos: ['archivo4.txt']
----------------------------------------

Explicación del código

Ignorar carpetas ocultas (dirnames[:] = ...): Se sobrescribe la lista dirnames para excluir las carpetas cuyo nombre comienza con un punto ., evitando que se exploren.
Ignorar archivos ocultos ([f for f in filenames ...]): Se utiliza una comprensión de lista para excluir los archivos cuyo nombre comienza con un punto ..

Consideraciones

Si los archivos o carpetas tienen atributos de sistema que los marcan como ocultos (particularmente en Windows), este código no los detectará. En ese caso, será necesario utilizar módulos adicionales (por ejemplo, ctypes).

Ejemplos avanzados

Excluir archivos de configuración ocultos (por ejemplo, .gitignore o .env) al procesar los archivos.
Crear una lista de directorios visibles para mostrar al usuario.
Realizar una limpieza de datos excluyendo los elementos ocultos.

Ejemplo avanzado: Calcular el tamaño de un directorio

Usando os.walk, es posible calcular el tamaño total de un directorio sumando los tamaños de todos los archivos dentro de él. Este enfoque es útil cuando deseas saber cuánto espacio de almacenamiento está utilizando una carpeta específica.

Ejemplo de código

A continuación se muestra un ejemplo de cómo calcular el tamaño de un directorio:

import os

# Especificar el directorio objetivo
target_directory = "/ruta/a/tu/directorio"

def calculate_directory_size(directory):
    total_size = 0
    # Recorrer el directorio
    for dirpath, dirnames, filenames in os.walk(directory):
        for filename in filenames:
            file_path = os.path.join(dirpath, filename)
            try:
                # Obtener el tamaño del archivo y sumarlo
                total_size += os.path.getsize(file_path)
            except FileNotFoundError:
                # Manejar el caso de archivos eliminados
                pass
    return total_size

# Calcular el tamaño del directorio
directory_size = calculate_directory_size(target_directory)

# Imprimir el resultado (en bytes y en MB)
print(f"Tamaño del directorio: {directory_size} bytes")
print(f"Tamaño del directorio: {directory_size / (1024 ** 2):.2f} MB")

Ejemplo de salida

Si la estructura del directorio es la siguiente:

/ruta/a/tu/directorio
├── archivo1.txt (500 bytes)
├── subdir1
│   ├── archivo2.txt (1500 bytes)
│   └── archivo3.txt (3000 bytes)
└── subdir2
    └── archivo4.txt (2000 bytes)

La salida será:

Tamaño del directorio: 7000 bytes  
Tamaño del directorio: 0.01 MB

Explicación del código

os.path.getsize(file_path): Obtiene el tamaño del archivo en bytes.
Manejo de excepciones: Captura el FileNotFoundError en caso de que el archivo sea eliminado o inaccesible durante el recorrido.
Conversión de unidades: Convierte el tamaño de bytes a una forma más comprensible como MB.

Uso avanzado: Calcular el tamaño de archivos con una extensión específica

Para calcular el tamaño total de los archivos con una extensión específica, modifica el código de la siguiente manera:

def calculate_size_by_extension(directory, extension):
    total_size = 0
    for dirpath, dirnames, filenames in os.walk(directory):
        for filename in filenames:
            if filename.endswith(extension):
                file_path = os.path.join(dirpath, filename)
                try:
                    total_size += os.path.getsize(file_path)
                except FileNotFoundError:
                    pass
    return total_size

# Ejemplo: Calcular el tamaño total de los archivos .txt
txt_size = calculate_size_by_extension(target_directory, ".txt")
print(f"Tamaño de los archivos .txt: {txt_size} bytes")

Utilidad

Monitorear el uso de disco en servidores o almacenamiento en la nube.
Conocer el consumo de recursos de carpetas específicas en un proyecto.
Asistir en las tareas de limpieza cuando el espacio en disco esté limitado.

Ejemplo avanzado: Copia de seguridad de todos los archivos

Usando os.walk, puedes recorrer todos los archivos dentro de un directorio de manera recursiva y copiar todo a un directorio de respaldo, creando así una copia de seguridad del directorio completo. Este enfoque es útil para asegurar que los datos sean copiados de manera segura manteniendo la estructura de directorios.

Ejemplo de código

A continuación se muestra un ejemplo de cómo copiar los archivos a un directorio de respaldo:

import os
import shutil

# Especificar el directorio original y el de respaldo
source_directory = "/ruta/a/tu/directorio_origen"
backup_directory = "/ruta/a/tu/directorio_respaldo"

def backup_files(source, backup):
    for dirpath, dirnames, filenames in os.walk(source):
        # Calcular la ruta del respaldo
        relative_path = os.path.relpath(dirpath, source)
        backup_path = os.path.join(backup, relative_path)

        # Crear el directorio de respaldo
        os.makedirs(backup_path, exist_ok=True)

        for filename in filenames:
            source_file = os.path.join(dirpath, filename)
            backup_file = os.path.join(backup_path, filename)

            try:
                # Copiar el archivo
                shutil.copy2(source_file, backup_file)
                print(f"Copiado: {source_file} -> {backup_file}")
            except Exception as e:
                print(f"No se pudo copiar {source_file}: {e}")

# Realizar la copia de seguridad
backup_files(source_directory, backup_directory)

Ejemplo de salida

Si la estructura del directorio es la siguiente:

/ruta/a/tu/directorio_origen
├── archivo1.txt
├── subdir1
│   ├── archivo2.txt
│   └── archivo3.txt
└── subdir2
    └── archivo4.txt

Se creará la siguiente estructura en el directorio de respaldo:

/ruta/a/tu/directorio_respaldo
├── archivo1.txt
├── subdir1
│   ├── archivo2.txt
│   └── archivo3.txt
└── subdir2
    └── archivo4.txt

Explicación del código

os.makedirs(backup_path, exist_ok=True): Crea los directorios de respaldo de manera recursiva. Con exist_ok=True, no se generará un error si el directorio ya existe.
os.path.relpath(dirpath, source): Obtiene la ruta relativa del directorio de origen para crear la estructura de respaldo.
shutil.copy2(source_file, backup_file): Copia el archivo, incluyendo su contenido y metadatos (como las marcas de tiempo).

Consideraciones

Enlaces simbólicos: shutil.copy2 copia los enlaces simbólicos como archivos normales. Si deseas mantener los enlaces, necesitarás un proceso diferente.
Espacio en disco: Asegúrate de que haya suficiente espacio en el directorio de respaldo.
Permisos: Debes tener permisos de acceso para copiar los archivos desde el directorio de origen.

Ejemplos avanzados

Respaldo solo de archivos con una extensión específica: agregar una condición como if filename.endswith(".txt").
Registrar las copias de seguridad en un archivo de log: escribir los archivos copiados en un log.
Copia de seguridad diferencial: comparar las marcas de tiempo o valores de hash de los archivos y copiar solo los archivos modificados.

Conclusión

En este artículo, hemos explicado cómo utilizar os.walk en Python para recorrer directorios de manera recursiva y sus aplicaciones avanzadas. os.walk es una herramienta poderosa para explorar archivos y carpetas de manera eficiente y realizar diversas operaciones sobre ellos.

Desde el uso básico hasta el filtrado por condiciones específicas, la limitación de la profundidad, la exclusión de archivos ocultos, y el cálculo del tamaño de directorios o la creación de copias de seguridad, hemos cubierto muchos ejemplos útiles.

Al aprovechar la flexibilidad de os.walk, puedes automatizar tareas relacionadas con directorios y mejorar significativamente la eficiencia de tu trabajo. ¡Prueba estos ejemplos en tus propios proyectos!