Cuente la cantidad de archivos en un directorio en Python

Para contar las entradas de archivos de un directorio específico, recorre sus elementos y comprueba cada uno con Path.is_file(). Estas comprobaciones siguen los enlaces simbólicos, por lo que se cuenta una entrada si su destino es un archivo, incluso si es un enlace simbólico a un archivo. Los ejemplos siguientes distinguen entre contar las entradas inmediatas de un directorio, recorrerlo de forma recursiva y buscar por patrones. Las rutas relativas se resuelven desde el directorio de trabajo actual de Python; cuando la ubicación sea importante, usa una ruta absoluta o establece ese directorio de forma explícita.

Contar archivos de un directorio con pathlib

Path.iterdir() devuelve las entradas que están directamente dentro de un directorio. Combínalo con Path.is_file() para contar las entradas cuyo destino sea un archivo, incluidos los enlaces simbólicos a archivos, y excluir los subdirectorios. El ejemplo crea un árbol de directorios pequeño: en el nivel superior hay dos archivos y un subdirectorio.

Ejecuta este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as temp_dir:
    directory = Path(temp_dir)
    (directory / "alpha.txt").write_text("A", encoding="utf-8")
    (directory / "beta.csv").write_text("B", encoding="utf-8")
    child = directory / "nested"
    child.mkdir()
    (child / "gamma.txt").write_text("C", encoding="utf-8")

    count = sum(1 for entry in directory.iterdir() if entry.is_file())
    print(f"Number of files: {count}")

Number of files: 2

El resultado es dos porque iterdir() examina solo las entradas inmediatas e is_file() excluye el directorio nested. Cambia directory por la ruta que quieras inspeccionar. Es una buena opción predeterminada cuando necesitas contar los archivos de un único directorio y te conviene trabajar con rutas de forma legible.

Contar archivos de un directorio con os.listdir()

os.listdir(directory_path) devuelve los nombres de todas las entradas inmediatas del directorio especificado, incluidos los nombres de los directorios. Devuelve nombres de entradas tanto si directory_path es una cadena como si es otro objeto compatible con rutas. Une cada nombre con el directorio para formar una ruta antes de comprobar con os.path.isfile() si el destino de esa entrada es un archivo; esto también cuenta los enlaces simbólicos a archivos:

sum(1 for name in os.listdir(directory_path) if os.path.isfile(os.path.join(directory_path, name)))

Este recuento no es recursivo. Si omites directory_path, os.listdir() devuelve el contenido del directorio de trabajo actual. Pasa una ruta explícita si el programa no debe depender del lugar desde el que se ejecutó. Este método resulta útil cuando también necesitas los nombres para procesarlos de otra manera.

Contar archivos eficientemente con os.scandir()

os.scandir(directory_path) devuelve un iterador de objetos os.DirEntry. Cada entrada permite comprobar su tipo con is_file(), que sigue los enlaces simbólicos de forma predeterminada; así se cuentan las entradas cuyo destino sea un archivo, incluidos los enlaces simbólicos a archivos. El recuento se puede escribir así:

sum(1 for entry in os.scandir(directory_path) if entry.is_file())

El iterador abarca las entradas inmediatas, no los directorios descendientes. Si recorres las entradas explícitamente, usa with os.scandir(directory_path) as entries: para cerrar el iterador del directorio cuanto antes. scandir() puede ser una opción útil para directorios grandes o cuando necesitas varios atributos de cada entrada. El rendimiento real depende del sistema de archivos y de la carga de trabajo, así que mide tu propio caso antes de dar por sentada una diferencia de velocidad.

Contar archivos de forma recursiva con os.walk()

Usa os.walk(directory_path) si el recuento debe incluir los archivos del directorio y de sus subdirectorios. Para cada directorio que visita, devuelve la ruta actual, los nombres de los subdirectorios y los nombres de los archivos. La lista files puede incluir nombres de enlaces simbólicos cuyo destino sea un archivo, por lo que sumar su longitud también cuenta esas entradas. Suma la longitud de cada lista files:

sum(len(files) for _, _, files in os.walk(directory_path))

A diferencia de los métodos anteriores, este recuento abarca todo el árbol de directorios. os.walk() incluye nombres en su lista de archivos y normalmente excluye los subdirectorios. Si los enlaces o los cambios simultáneos en los directorios afectan a tu caso, decide cómo debe tratarlos la aplicación. De forma predeterminada, si el directorio inicial no existe, no se generan filas y la suma es cero.

Contar archivos que coinciden con glob.glob()

glob.glob() selecciona rutas según un patrón. Por ejemplo, glob.glob(os.path.join(directory_path, "*.txt")) busca nombres que terminen en .txt directamente dentro del directorio especificado. El patrón no busca en subdirectorios; si quieres incluir coincidencias anidadas, usa un patrón recursivo como **/*.txt junto con recursive=True.

El patrón también puede coincidir con un directorio cuyo nombre se ajuste a él. Filtra las rutas devueltas con os.path.isfile() para contar las entradas cuyo destino sea un archivo, incluidos los enlaces simbólicos a archivos:

sum(1 for path in glob.glob(os.path.join(directory_path, "*.txt")) if os.path.isfile(path))

Elige pathlib para un recuento sencillo de las entradas inmediatas, listdir() si necesitas los nombres de las entradas, scandir() si quieres objetos de entrada, os.walk() para recorrer todo el árbol o glob.glob() cuando un patrón de nombres determine qué contar.