DATOS. Acceso a datos

Recuento de archivos

Si en la entrada temáticamente anterior tratamos al directoiro como dato, en esta haremos lo mismo con el archivo: también el recuento de archivos puede ser objeto de análisis, para lo cual, es de gran utilidad saber utilizar bibliotecas-Python como os o pathlib.

De momento, en esta entrada trataremos el tema de un modo similar a cómo lo hicimos en la anterior (ya citada): aprenderemos a identificar específicamente los archivos en dos niveles de profundidad respecto a la estructura de directorios y a diferenciar los archivos en función de su extensión. Esto último constituye el paso previo a acceder a los archivos propiamente dichos en busca de información contenida en ellos; tema que nos lleva a la segunda fase del proceso de acceso a datos.

El script que sigue es la formulación más sencilla de nuestro actual objetivos: identificar los archivos existentes en un directorio dado, mostrarlos por pantalla y cuantificarlos. Los comentario incluídos en el script facilitan la comprensión de su funcionamiento.

import os

#0. Establecemos la ruta (directorio) sobre el que trabajar 
ruta_archivos = "C:/BasesDatosTest"

if not os.path.exists(ruta_archivos): #Comprobamos que la ruta existe
    print("La ruta especificada no existe.")

contador = 0 #Creamos el contador de archivos

# 1. Iteramos sobre cada elemento dentro del directorio buscando los archivos
for elemento in os.listdir(ruta_archivos): # Construimos la ruta completa del elemento
    ruta_completa = os.path.join(ruta_archivos, elemento)
    if os.path.isfile(ruta_completa): # Comprobamos que el elemento es un archivo (no directorio)
        contador += 1 # incrementamos el contador de archivos
        print(elemento) # e imprimimos por pantalla el nombre de cada archivo encontrado

#2. Informamos del resultado (número de archivos encontrados)
print(f"Número total de archivos en el directorio: ", contador)

Lo que hace que este script identifique los archivos (no los directorios) es la función os.path.isfile(), que permite especificar que estamos buscando archivos. Recuerda que la búsqueda de directorios requería la función os.path.isdir().

Dentro de la sencillez y limitación de este script está que únicamente nos da acceso a la raiz del directorio, por lo que el resultado sólo es fiable si el directorio no contiene subdirectorios (directorios secundarios o anidados). En ese caso es de esperar que existan archivos dentro de ellos, con lo que este recuento no sería fiable. Para resolver este problema usaremos un segundo script.

import os

#0. Directorio a estudiar
ruta_raiz = "D:/BasesDatosTest" 

if not os.path.exists(ruta_raiz): #Control simple de error
    print ("Error: La ruta proporcionada no existe.")

total_archivos = 0 #Contador de archivos

# 1. Recuento recursivo de archivos mediante os.walk()).
for ruta_actual, subcarpetas, archivos in os.walk(ruta_raiz): # os.walk() recorre TODOS los (sub)directorios
    print(archivos) #Mostramos la lista de archivos que contiene cada directorio
    cantidad_en_esta_carpeta = len(archivos)
    total_archivos += cantidad_en_esta_carpeta
    print(ruta_actual, "  || ",cantidad_en_esta_carpeta," archivos") #Imprime el recuento de archivos en el (sub)directorio
        
#2. Informe final de resultados
print("*" * 150)
print(f"CONTEO FINALIZADO.")
print("-" * 25)
print(f"Total de archivos (incluyendo subdirectorios): ",  total_archivos )
print("*" * 150)

Este segundo script recorre cada uno de los subdirectorios del principal mediante la función os.walk() obteniendo los archivos existentes en la lista archivos. Hemos creado instrucciones print() que facilitan información del listado de archivos de cada (sub)directorio en print(archivos)) y del recuento de los archivos que contienen en print(ruta_actual, " || ",cantidad_en_esta_carpeta," archivos"), pero esta información no es estrictamente necesaria, pudiendo ser comentadas ambas líneas. Lo realmente importante en cuanto a resultados lo encontramos a partir del comentario #2. Informe final de resultados.

Para finalizar esta entrada vamos a consisderar una tercera cuestión en relación a los archivos como datos: la tipología de archivos, identificada con su extensión. Se trata de un tipo de dato que puede resultar muy relevante según en qué tipo de investigación, ya que se relaciona con cuestiones como la importancia del tipo de herramienta informática (servicio, si se prefiere) que predomina en determinadas actuaciones. En estos contextos, analizar el peso del tipo de archivo es una forma de operativizar esas variables de forma sencilla. También contamos con recursos en Python para obtener este tipo de información.

import os

#Función. INICIO -----------------------------------------------------

def analizar_y_guardar(ruta_raiz, archivo_salida):
    
#A. Control básico de error
    if not os.path.exists(ruta_raiz):
        print("Error: La ruta no existe.")
        return

#B. Para almacenar contenido
    total_general = 0
    conteo_extensiones = {}
    informe_texto = "" # Aquí acumularemos todo lo que irá al TXT

#C. Informe. Encabezado del informe
    linea_div = "-" * 70 + "\n"
    encabezado = f"INFORME DE DIRECTORIO: {ruta_raiz}\n"
    columnas = f"{'DIRECTORIO':<55} | {'ARCHIVOS':<10}\n"
    
    informe_texto += encabezado + linea_div + columnas + linea_div
    print(encabezado + linea_div + columnas + linea_div, end="")

#D. Recorrido del directorio-base en profundidad (os.walk()) para capturar el total de archivos 
    for ruta_actual, _, archivos in os.walk(ruta_raiz):
        cantidad = len(archivos)
        total_general += cantidad
        
#E. Registro (sub)directorio por (sub)directorio
        linea_carpeta = f"{ruta_actual:<55} | {cantidad:<10}\n"
        informe_texto += linea_carpeta
        print(linea_carpeta, end="")

#F. Procesamiento de las extensiones de los archivos (no de su nombre o raiz)
        for nombre in archivos:
            _, ext = os.path.splitext(nombre)
            ext = ext.lower() if ext else "Sin extensión"
            conteo_extensiones[ext] = conteo_extensiones.get(ext, 0) + 1

#G. Resumen Final de extensiones (categorías + frecuencias)
    resumen_global = "\n" + "="*40 + "\n"
    resumen_global += "RESUMEN GLOBAL DE EXTENSIONES\n"
    resumen_global += "="*40 + "\n"
    resumen_global += f"Total de archivos analizados: {total_general}\n"
    resumen_global += "-" * 40 + "\n"
    resumen_global += f"{'EXTENSIÓN':<15} | {'CANTIDAD':<10}\n"
    resumen_global += "-" * 40 + "\n"

    for ext, cant in sorted(conteo_extensiones.items(), key=lambda x: x[1], reverse=True):
        resumen_global += f"{ext:<15} | {cant:<10}\n"
    
    resumen_global += "="*40 + "\n"
    
#H. Informe. Unimos todo el contenido
    informe_texto += resumen_global
    print(resumen_global)

#I. Informe. Guardado del archivo de informe
    try:
        with open(archivo_salida, "w", encoding="utf-8") as f:
            f.write(informe_texto)
        print(f"\n[ÉXITO] Informe guardado en: {archivo_salida}")
    except Exception as e:
        print(f"\n[ERROR] No se pudo guardar el archivo: {e}")

# Función. FINAL--------------------------------------------------------

#Llamada a o ejecución de la función ---------------------------------

mi_ruta = "D:/BasesDatosTest"
nombre_informe = "informe_del_analisis.txt"

analizar_y_guardar(mi_ruta, nombre_informe)

Este script contiene al anterior y añade la funcionalidad de identificar el tipo de archivo por su extensión. Pero es de mayor complejidad que el anterior no sólo por ese motivo: implica el uso de una función y la creación de un informe permanente mediante la creación de un archivo .txt.

Vayamos por partes, y la primera y más importante se refiere al recuento de las extensiones de los archivos, que podemos ver tras el comentario F (Procesamiento de las extensiones...). En este conjunto de instrucciones destaca la siguiente: _, ext = os.path.splitext(nombre), en la que la función os.path.splitext() divide la ruta en dos partes: la raíz y la extensión: como lo que nos interesa es la extensión, la raiz se sustitye por _. Si lo que nos interesara fuera la raiz o nombre del archivo, la instrucción se presentaría de este modo: nombre_raiz, _ = os.path.splitext().

La segunda tiene que ver con el uso de la función analizar_y_guardar() que, como vemos tiene dos parámetros, los mismos que encontramos en la llamada a la función la final del script (analizar_y_guardar(mi_ruta, nombre_informe)). Sobre el uso de funciones en Python tenderemos que volver en otro momento.

Finalmente, a diferencia de los dos script anteriores, en este hemos optado por generar un archivo que guarde tota la información en un formato básico (.txt), lo que nos servirá como elemento de relación con el posterior desarrollo de esta sección del blog; cosa que queda para próximas entradas en las que trabajaremos con el acceso al contenido de losa archivos, emepezando precisamente por los más accesibles: precisamente los archivos de texto plano.

Nota

El código mostrado en esta entrada ha sido desarrollado usando IA Gemini 3.
Cuando consideré necesario fui moldeando la respuesta de la IA hasta obtener el script deseado y finalmente modiqué el contenido del script para adaptarlo a mis objetivos, por ejemplo modificando el código inicial para eliminar una función cuando el uso de funciones no me pareción pertinente.