DATOS. Acceso a datos.

El directorio como dato

Podemos trabajar con directorios como para de la gestión documental, pero también podemos considerar el directorio como un tipo más de dato, sujeto, en consecuencia, a procesos de análisis. En ambos casos es necesario disponer de recursos para el manejo de directorios. Bibliotecas como os y pathlib de Python nos los proporcionan.

En esta entrada nos plantearemos el tratamiento de los directorios como datos, por lo que enfocaremos los procedimientos de uso de las funciones que ofrecen esas librerías al logro de este objetivo, con independencia de otros tratamientos posibles que se abordan en otras publicaciones de este blog. No se puede descartar que parte de lo que se diga aquí no haya sido tratado en ellas; y aunque el enfoque sea diferente (pensado más en la creación y manipulación de archivos), las instrucciones y los procedimientos de trabajo no tienen por qué serlo en lo fundamental.

Centrándonos ahora en lo que aquí nos interesa, nos situaremos ante circunstancias en las que, por diferentes razones (suponemos ahora que en el marco de un proyecto de análisis de datos) necesitamos conocer la estructura de (sub)directorios de un conjunto documental (en su lugar y momento trabajaremos sobre un proyecto real que materializa esta hipótesis). En este momento, ese conocimiento (referido a los directorios) se convierte en nuestro objetivo. Herramientas como las contenidas en el módulo os nos sirven para identificar las rutas (relativas o absolutas) y de generar el listado (base de la cuantificación) de los (sub)directorios implicados.

A modo de ejemplo, veamos una concreción de lo anterior como script:

import os

# Define la ruta del directorio
directorio = "D:/BasesDatosTest"

# Obtiene una lista con los nombres de los archivos y carpetas
contenido = os.listdir(directorio)

#Lee el listado de componentes del directorio (serviría como ruta relativa)

print(f'Colección de elementos del directorio \n {contenido} \n')

#Recorre el directorio y muestra las rutas absolutas

print('Rutas absolutas de archivo \n')

for elemento in contenido:
    print(directorio + '/' + elemento + '\n')

#Recorre el directorio, cuenta los elementos y muestra los componentes y cuántos son

n_elem = 0

print('Listado de documentos y subdirectorios componentes \n')
 
for elemento in contenido:
    n_elem = n_elem +1
    print (f'Elemento número {str(n_elem)} -> {elemento}')

print(f'\n TOTAL elementos del directorio {str(n_elem)}')

Analizo acontinuación el contexto, el código y el resultado que obtenemos con él.

Empezando por el contexto, se presupone que nuestro objetivo es identificar la estructura de elementos de un determinado directorio ubicado en la unidad D: (directorio = "D:/BasesDatosTest"), a fin de conocer su composición (en principio a nivel cuantitativo).

Con una instrucción (contenido = os.listdir(directorio), este script nos permite obtener el contenido del directorio solicitado, incluyendo los (sub)directorios y los archivos, lo que excede lo que necesitamos en este momento, pero que nos sirve como referencia para afinar el logro de nuestro objetivo. Lo que sigue no es otra cosa que diferentes formas de visualizar ese contenido.

No me detengo en explicar esas formas, ya que lo que realmente nos interesa es identificar de forma diferenciada los (sub)directorios existentes, sin atender (en estos momentos) a los archivos que también contiene el directorio principal.

Además también debemos tener en cuenta que este script sólo nos muestra el contenido inmediato de ese directorio principal, no el contendio de los subdirectorios, dato que también nos puede interesar en nuestro actual análisis de los directorios como contenido.

Vayamos por partes. Primero nos centraremos en aislar los subdirectorios para no mezclarlos con los archivos:

import os

# 0. Identificamos la ruta del directorio a estudiar
directorio = "D:/BasesDatosTest"

# 1. Guardamos el elemento sólo si es un directorio
directorios = [] #Creamos la lista para contener los directorios

for elemento in os.listdir(directorio): #Recorremos el iterable resultante de la función listdir()
    ruta_completa = os.path.join(directorio, elemento)  # Unimos la ruta base con el nombre del elemento
    if os.path.isdir(ruta_completa): # Añadimos cada subdirectorio encontrado (isdir()) a la lista de directorios append())
        directorios.append(elemento)

# 2. Identificamos el número de elementos de la lista directorios con la función len()
total_directorios = len(directorios)

# 3. Mostramos los resultados
print(f' Los subdirectorios encontrados son los siguientes: {directorios} \n') #Nombres de los (sub)directorios

print(f'El número total de directorios en "{directorio}" es: {total_directorios}') #Número de (sub)directorios (principales)

La función principal, la que nos resuelve el problema de identificar sólo los directorios (excluyendo los archivos) es isdir(), cuya función es evidente: identificar en el contenido del directorio obtenido por la función listdir() aquellos elementos que son directorios, excluyendo los elementos que no lo son. Otra función (len()), aplicada sobre la lista directorios (len(directorios)) nos permite contar el número de elementos (directorios).

El script anterior nos ha permitido identificar los directorios existente en la raiz de nuestro directorio de referencia, pero no sabemos si esos (sub)directorios cuentan, a su vez con subdivisiones (subdirectorios de segundo nivel), lo cual en determinados estudios puede ser un dato de interés. Si queremos profundizar en detalle, deberemos aplicar otro procedimiento, como el propuesto en este último script.

import os

# 0. Identificamos la ruta del directorio a estudiar
ruta_base = "D:/BasesDatosTest"

# Establecemos los contadores para el conteo de elementos
carpetas_principales = []
conteo_por_principal = {} # Diccionario para guardar {NombrePrincipal: TotalSubdirs}
total_subdirectorios_global = 0

print(f"--- DESGLOSE DE DIRECTORIOS EN: {ruta_base} ---\n")

# 1. Obtenemos los directorios de primer nivel
elementos_raiz = [f for f in os.listdir(ruta_base) if os.path.isdir(os.path.join(ruta_base, f))] #Obsérvese el uso de las funciones listdir() e isdir()

for principal in elementos_raiz:    #Este ciclo permite dar contenido a la lista mediante append()
    ruta_principal = os.path.join(ruta_base, principal)
    carpetas_principales.append(principal)
    
# 2. Para cada principal, recorremos recursivamente sus subdirectorios
    conteo_subdirs_rama = 0
    subdirectorios_lista = []
    
    for root, dirs, files in os.walk(ruta_principal):
        for d in dirs:
            conteo_subdirs_rama += 1
            ruta_relativa = os.path.relpath(os.path.join(root, d), ruta_base) # Guardamos la ruta relativa para que el listado sea legible
            subdirectorios_lista.append(ruta_relativa)
    
    conteo_por_principal[principal] = conteo_subdirs_rama # Guardamos el conteo y mostramos el listado de esta rama
    total_subdirectorios_global += conteo_subdirs_rama
    
    print(f"Directorio Principal: [{principal}]")
    if subdirectorios_lista:
        for s in subdirectorios_lista:
            print(f"  └── {s}")
    else:
        print("  └── (Sin subdirectorios)")
    print(f"  > Total subdirectorios en esta rama: {conteo_subdirs_rama}\n")

# 3. Resumen final del recuento de contenidos 
print("="*50)
print("RESUMEN DEL RECUENTO")
print("="*50)
print(f"Total de Directorios Principales: {len(carpetas_principales)}")
print(f"Total Global de Subdirectorios:   {total_subdirectorios_global}")
print(f"Total de carpetas (Suma total):    {len(carpetas_principales) + total_subdirectorios_global}")

Lo que este script añade al anterior es el acceso a los (sub)directorios y la visualización de su contenido (sólo de los subdirectorios de segundo, tercer... nivel (ver punto 2 del script). Para esto es fundamental el uso de la función os.walk() en (os.walk(ruta_principal)).

A fin de facilitar la obtención de datos, hemos incorporado al script un sistema de recuento que resumen la información obtenidas (punto 3 del script)

Nota

El código mostrado en esta entrada ha sido desarrollado usando Gemini-IA a modo de auxiliar de programación.
La respuesta de la IA fue moldeada mediante prompt sucesivos hasta obtener el funcionamiento deseado.
Finalmente, el contenido del script (instrucciones y comentarios) y su funcionamiento en local fue objeto de revisión, comprobación y modificación por parte del autor de esta entrada.