Obtener nombres de archivos en una carpeta con Python

1. Introducción

El método para obtener los nombres de archivo dentro de una carpeta con Python es una habilidad muy útil para principiantes y usuarios intermedios de programación. Al obtener los nombres de archivo, se puede optimizar el procesamiento de grandes volúmenes de datos y la manipulación de archivos, lo que ayuda a la automatización de tareas y a la organización de datos.

En este artículo, explicaremos paso a paso cómo obtener los nombres de archivo dentro de una carpeta usando Python. Se explicará de manera clara, incluyendo ejemplos de código, para que incluso los que lo aprenden por primera vez puedan ponerlo en práctica.

2. Método básico para obtener nombres de archivo usando el módulo os

Si se usa el módulo os de la biblioteca estándar de Python, se pueden obtener fácilmente los nombres de archivo dentro de una carpeta. Este método también es adecuado para quienes usan Python por primera vez, y se caracteriza por una estructura de código simple e intuitiva.

Uso básico de la función os.listdir()

os.listdir() devuelve una lista con los nombres de todos los elementos (archivos y carpetas) dentro del directorio especificado.

import os

# Obtener archivos y directorios dentro de la carpeta
folder_path = "sample_folder"
items = os.listdir(folder_path)

print("Elementos dentro de la carpeta:")
print(items)

Al ejecutar el código anterior, se mostrarán los nombres de archivos y directorios dentro de la carpeta especificada en formato de lista.

Método para extraer solo los nombres de archivo

La lista obtenida puede incluir también nombres de directorios. Usando os.path.isfile() es posible extraer solo los archivos.

import os

# Obtener solo los nombres de archivos dentro de la carpeta
folder_path = "sample_folder"
files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]

print("Archivos dentro de la carpeta:")
print(files)

En este código se verifica si cada elemento es un archivo y se almacenan solo los nombres de archivo en la lista.

Ejemplo de uso

Por ejemplo, si se desea crear una lista de archivos de imagen guardados en una carpeta, se puede utilizar de la siguiente manera.

import os

# Obtener archivos de imagen
folder_path = "images"
image_files = [f for f in os.listdir(folder_path) if f.endswith((".png", ".jpg", ".jpeg"))]

print("Lista de archivos de imagen:")
print(image_files)

Ventajas de este método

• Simple y fácil de entender.
• Se puede implementar solo con la biblioteca estándar de Python.
• Ideal para operaciones de archivos en carpetas pequeñas.

Consideraciones

• Puede haber archivos ocultos o nombres de archivo especiales, por lo que es necesario filtrarlos según sea necesario.
• El uso en directorios de gran tamaño puede afectar el rendimiento.

3. Uso del módulo glob con búsqueda de comodines

Si usas el módulo glob de Python, puedes obtener de manera eficiente los nombres de archivo que coinciden con un patrón específico. A diferencia del módulo os, permite utilizar comodines para establecer de forma flexible las condiciones de búsqueda de nombres de archivo.

Uso básico del módulo glob

Al usar glob.glob(), puedes obtener los archivos y carpetas que coinciden con el patrón especificado.

import glob

# Obtener todos los archivos dentro de la carpeta
folder_path = "sample_folder"
files = glob.glob(f"{folder_path}/*")

print("Archivos dentro de la carpeta:")
print(files)

En este código, se obtienen las rutas de todos los elementos (archivos y carpetas) dentro de la carpeta especificada.

Obtener archivos que coincidan con un patrón específico

Por ejemplo, si deseas obtener solo los archivos con una extensión específica, se escribe de la siguiente manera.

import glob

# Obtener archivos con la extensión especificada
folder_path = "sample_folder"
text_files = glob.glob(f"{folder_path}/*.txt")

print("Lista de archivos de texto:")
print(text_files)

En este ejemplo, solo se obtienen los archivos con la extensión .txt. De manera similar, si deseas especificar múltiples extensiones, se escribe como sigue.

import glob

# Obtener archivos especificando múltiples extensiones
folder_path = "sample_folder"
files = glob.glob(f"{folder_path}/*.txt") + glob.glob(f"{folder_path}/*.csv")

print("Lista de archivos de texto y CSV:")
print(files)

Obtener archivos de forma recursiva

Al usar la opción recursive=True del módulo glob, puedes obtener también los archivos dentro de subdirectorios.

import glob

# Obtener todos los archivos recursivamente dentro del subdirectorio
folder_path = "sample_folder"
files = glob.glob(f"{folder_path}/**/*", recursive=True)

print("Todos los archivos dentro del subdirectorio:")
print(files)

Ejemplos de uso de comodines

• *: representa cualquier cadena.
• ?: representa cualquier carácter único.
• [abc]: representa cualquiera de los caracteres dentro de los corchetes.

import glob

# Obtener cualquier archivo cuyo nombre comience con "data"
folder_path = "sample_folder"
files = glob.glob(f"{folder_path}/data*")

print("Listado de archivos que comienzan con 'data':")
print(files)

Ventajas y usos

• Permite especificar patrones flexibles y está especializado en la búsqueda de nombres de archivo.
• En comparación con el módulo os, el código se vuelve más conciso.
• La búsqueda recursiva se puede realizar fácilmente.

Precauciones

• Si no hay coincidencia con el patrón, se devuelve una lista vacía, por lo que es necesario verificar el resultado.
• Dado que la búsqueda recursiva puede obtener una gran cantidad de archivos, se recomienda filtrarlos adecuadamente.

4. Operar el módulo pathlib de forma orientada a objetos

El módulo pathlib de Python es un método moderno e intuitivo que permite manejar la manipulación de rutas de archivos de forma orientada a objetos. Esto mejora la legibilidad del código y simplifica las operaciones.

Uso básico del módulo pathlib

Al usar el objeto Path del módulo pathlib, se pueden obtener fácilmente los elementos dentro de un directorio.

from pathlib import Path

# Obtener elementos dentro de la carpeta
folder_path = Path("sample_folder")
items = list(folder_path.iterdir())

print("Elementos dentro de la carpeta:")
print(items)

En este código, todos los elementos dentro de la carpeta (archivos y carpetas) se devuelven como una lista de objetos Path.

Extraer solo nombres de archivo

Para obtener solo los archivos de los elementos de una carpeta, se utiliza el método is_file().

from pathlib import Path

# Obtener archivos dentro de la carpeta
folder_path = Path("sample_folder")
files = [f for f in folder_path.iterdir() if f.is_file()]

print("Archivos dentro de la carpeta:")
print(files)

En este código, los directorios se excluyen y solo los archivos se almacenan en la lista.

Filtrado por extensión

Para obtener solo los archivos que tienen una extensión específica, se especifica la extensión como condición.

from pathlib import Path

# Obtener archivos con una extensión específica dentro de la carpeta
folder_path = Path("sample_folder")
text_files = [f for f in folder_path.iterdir() if f.is_file() and f.suffix == ".txt"]

print("Archivos de texto:")
print(text_files)

Usando el atributo suffix, se puede obtener fácilmente la extensión de un archivo.

Obtener archivos de forma recursiva

Para obtener también los archivos dentro de subdirectorios, se utiliza el método rglob().

from pathlib import Path

# Obtener todos los archivos dentro del subdirectorio
folder_path = Path("sample_folder")
files = list(folder_path.rglob("*"))

print("Todos los archivos dentro del subdirectorio:")
print(files)

Además, es posible buscar de forma recursiva archivos que coincidan con un patrón específico.

from pathlib import Path

# Obtener archivos con una extensión específica dentro de subdirectorios
folder_path = Path("sample_folder")
text_files = list(folder_path.rglob("*.txt"))

print("Archivos de texto obtenidos recursivamente:")
print(text_files)

Ventajas y casos de uso

• Se puede escribir código intuitivo orientado a objetos.
• Las operaciones y filtrados recursivos se pueden implementar fácilmente.
• Disponible a partir de Python 3.4 y es el módulo recomendado en las versiones más recientes de Python.

Consideraciones

• No se puede usar en versiones de Python no compatibles (anteriores a 3.4).
• Se debe prestar atención al rendimiento en operaciones de directorios a gran escala.

5. Cómo obtener archivos de forma recursiva en subdirectorios

Al obtener archivos dentro de una carpeta, a veces se desea incluir también los archivos que están en subdirectorios de forma recursiva. En esta sección, se explica el método para obtener archivos de forma recursiva usando el módulo os y otros enfoques.

Método usando os.walk()

os.walk() explora de forma recursiva el directorio especificado y sus subdirectorios, y puede obtener nombres de carpetas, subcarpetas y archivos.

import os

# Obtener todos los archivos dentro del subdirectorio
folder_path = "sample_folder"

for root, dirs, files in os.walk(folder_path):
    for file in files:
        print(f"Archivo: {os.path.join(root, file)}")

Explicación del código:

• os.walk() devuelve una tupla (ruta de carpeta, lista de subcarpetas, lista de archivos).
• os.path.join() se usa para crear la ruta completa del archivo.

Obtener la lista completa de archivos

Si se desea almacenar todos los archivos obtenidos en una lista, se puede escribir de la siguiente manera.

import os

# Almacenar todos los archivos dentro de subdirectorios en una lista
folder_path = "sample_folder"
all_files = []

for root, dirs, files in os.walk(folder_path):
    for file in files:
        all_files.append(os.path.join(root, file))

print("Todos los archivos dentro de subdirectorios:")
print(all_files)

Obtener solo archivos con una extensión específica

Por ejemplo, si solo se desean obtener archivos .txt, se agrega la condición como se muestra a continuación.

import os

# Obtener archivos con una extensión específica dentro de subdirectorios
folder_path = "sample_folder"
txt_files = []

for root, dirs, files in os.walk(folder_path):
    for file in files:
        if file.endswith(".txt"):
            txt_files.append(os.path.join(root, file))

print("Text files:")
print(txt_files)

Obtención recursiva usando el módulo glob

Usando ** del módulo glob, es posible realizar búsquedas recursivas fácilmente.

import glob

# Obtener todos los archivos recursivamente
folder_path = "sample_folder"
all_files = glob.glob(f"{folder_path}/**/*", recursive=True)

print("Archivos obtenidos recursivamente:")
print(all_files)

También es sencillo obtener solo archivos con una extensión específica.

import glob

# Obtener archivos con una extensión específica de forma recursiva
folder_path = "sample_folder"
txt_files = glob.glob(f"{folder_path}/**/*.txt", recursive=True)

print("Archivos de texto obtenidos recursivamente:")
print(txt_files)

Obtención recursiva usando el módulo pathlib

El método rglob() del módulo pathlib permite realizar la obtención recursiva de archivos de forma intuitiva.

from pathlib import Path

# Recursively obtain all files
folder_path = Path("sample_folder")
all_files = list(folder_path.rglob("*"))

print("Archivos obtenidos recursivamente:")
print(all_files)

También es sencillo especificar una extensión específica.

from pathlib import Path

# Recursively obtain files with a specific extension
folder_path = Path("sample_folder")
txt_files = list(folder_path.rglob("*.txt"))

print("Archivos de texto obtenidos recursivamente:")
print(txt_files)

Comparación de los métodos

6. Filtrado de nombres de archivo con condiciones específicas y ejemplos de aplicación

Filtrar archivos bajo condiciones específicas ayuda a organizar la lista de nombres de archivo obtenida y a realizar operaciones de datos según el objetivo. En esta sección se explica cómo usar Python para restringir archivos mediante extensiones, nombres de archivo y también expresiones regulares.

Filtrado por extensión

Si se desea obtener solo los archivos con una extensión especificada, se pueden usar comprensiones de listas y estructuras condicionales.Ejemplo: usando el módulo os

import os

# Obtener archivos con la extensión especificada
folder_path = "sample_folder"
txt_files = [f for f in os.listdir(folder_path) if f.endswith(".txt")]

print("Archivos de texto:")
print(txt_files)

Ejemplo: usando el módulo pathlibpathlibAl usar este módulo, el filtrado por extensión se puede escribir de forma aún más concisa.

from pathlib import Path

# Obtener archivos con extensión .txt
folder_path = Path("sample_folder")
txt_files = [f for f in folder_path.iterdir() if f.suffix == ".txt"]

print("Text files:")
print(txt_files)

Cuando el nombre de archivo contiene una cadena específica

Para determinar si una cadena específica está presente en el nombre del archivo, se usa el operador in.

import os

# Obtener archivos que contienen 'report' en el nombre de archivo
folder_path = "sample_folder"
report_files = [f for f in os.listdir(folder_path) if "report" in f]

print("Archivos que contienen 'report':")
print(report_files)

Filtrado avanzado usando expresiones regulares

Con expresiones regulares, se pueden filtrar archivos con condiciones más flexibles. Por ejemplo, es útil para buscar patrones específicos en los nombres de archivo.

import os
import re

# Obtener archivos cuyos nombres están compuestos solo por números
folder_path = "sample_folder"
pattern = re.compile(r"^d+$")

files = [f for f in os.listdir(folder_path) if pattern.match(f)]

print("Nombres de archivos solo con números:")
print(files)

Filtrado por tamaño de archivo

Si se desea filtrar según el tamaño del archivo, se utiliza os.path.getsize().

import os

# Obtener archivos de tamaño 1MB o más
folder_path = "sample_folder"
large_files = [f for f in os.listdir(folder_path) if os.path.getsize(os.path.join(folder_path, f)) > 1 * 1024 * 1024]

print("Archivos de 1MB o más:")
print(large_files)

Ejemplos de aplicación

1. Clasificar por extensiónSi se desea clasificar archivos con múltiples extensiones, se puede escribir de la siguiente manera.

import os

# Clasificar archivos por extensión
folder_path = "sample_folder"
files_by_extension = {}

for f in os.listdir(folder_path):
    ext = os.path.splitext(f)[1]  # Obtener la extensión
    if ext not in files_by_extension:
        files_by_extension[ext] = []
    files_by_extension[ext].append(f)

print("Clasificación por extensión:")
print(files_by_extension)

2. Filtrar por fechaPara filtrar basándose en la fecha de modificación del archivo, se usa os.path.getmtime().

import os
import time

# Obtener archivos actualizados dentro de una semana
folder_path = "sample_folder"
one_week_ago = time.time() - 7 * 24 * 60 * 60

recent_files = [f for f in os.listdir(folder_path) if os.path.getmtime(os.path.join(folder_path, f)) > one_week_ago]

print("Archivos actualizados recientemente:")
print(recent_files)

Usos y conveniencia de cada método

7. Ejemplo práctico: Cómo usar la lista de nombres de archivos obtenidos

Cómo aprovechar la lista de nombres de archivos obtenidos varía ampliamente según el uso y el objetivo. En esta sección se presentan varios escenarios de uso comunes y algunos ejemplos de código específicos.

Procesamiento por lotes del contenido de archivos

Se muestra un ejemplo de cómo usar la lista de archivos obtenidos para leer y procesar el contenido de cada archivo.Ejemplo: Leer el contenido de archivos de texto de forma consolidada

import os

# Obtener archivos de texto dentro de la carpeta
folder_path = "sample_folder"
text_files = [f for f in os.listdir(folder_path) if f.endswith(".txt")]

# Leer el contenido de los archivos de forma consolidada
all_content = ""
for file in text_files:
    with open(os.path.join(folder_path, file), "r", encoding="utf-8") as f:
        all_content += f.read() + "
"

print("Contenido de todos los archivos de texto:")
print(all_content)

Renombrado de archivos

Es posible renombrar archivos en lote utilizando la lista de nombres de archivos obtenidos.Ejemplo: Añadir un prefijo al nombre del archivo

import os

# Obtener archivos dentro de la carpeta
folder_path = "sample_folder"
files = os.listdir(folder_path)

# Agregar prefijo al nombre de archivo
for file in files:
    old_path = os.path.join(folder_path, file)
    new_path = os.path.join(folder_path, f"new_{file}")
    os.rename(old_path, new_path)

print("Se cambió el nombre del archivo.")

Guardado de la lista de archivos

También es útil guardar la lista de nombres de archivos obtenidos en un archivo externo (texto o Excel) para poder consultarla posteriormente.Ejemplo: Guardar la lista de nombres de archivos en un archivo de texto

import os

# Obtener archivos dentro de la carpeta
folder_path = "sample_folder"
files = os.listdir(folder_path)

# Guardar nombres de archivos en un archivo de texto
with open("file_list.txt", "w", encoding="utf-8") as f:
    for file in files:
        f.write(file + "
")

print("Se ha guardado la lista de nombres de archivos.")

Ejemplo: Guardar la lista de nombres de archivos en CSV

import os
import csv

# Obtener archivos dentro de la carpeta
folder_path = "sample_folder"
files = os.listdir(folder_path)

# Guardar nombres de archivo en CSV
with open("file_list.csv", "w", encoding="utf-8", newline="") as csvfile:
    writer = csv.writer(csvfile)
    writer.writerow(["Nombre de archivo"])  # Agregar encabezado
    for file in files:
        writer.writerow([file])

print("Se guardó la lista de nombres de archivo en CSV.")

Creación de copias de seguridad de archivos

Ejemplo de crear copias de seguridad de archivos en una carpeta especificada usando la lista de nombres de archivos.

import os
import shutil

# Obtener archivos dentro de la carpeta
source_folder = "sample_folder"
backup_folder = "backup_folder"
os.makedirs(backup_folder, exist_ok=True)

files = os.listdir(source_folder)

# Copiar archivos a la carpeta de respaldo
for file in files:
    shutil.copy(os.path.join(source_folder, file), os.path.join(backup_folder, file))

print("Se ha creado la copia de seguridad.")

Limitar el procesamiento a archivos específicos

Usando la lista de archivos obtenidos, se ejecuta el procesamiento solo en los archivos que cumplen condiciones específicas.Ejemplo: Eliminar archivos con una extensión específica

import os

# Eliminar archivos con una extensión específica dentro de la carpeta
folder_path = "sample_folder"
files = [f for f in os.listdir(folder_path) if f.endswith(".tmp")]

for file in files:
    os.remove(os.path.join(folder_path, file))

print("Se eliminaron archivos innecesarios.")

Escenarios de aplicación

• Recolección de datos: Obtener una gran cantidad de archivos CSV y consolidar los datos.
• Gestión de logs: Identificar y eliminar archivos de registro antiguos.
• Procesamiento de imágenes: Redimensionar o convertir imágenes dentro de una carpeta específica.

8. Solución de problemas: Consejos para resolver errores

Al realizar operaciones de archivos o obtener nombres de archivos dentro de carpetas, pueden ocurrir varios errores. En esta sección se explican los errores más comunes y sus soluciones.

Error 1: Carpeta no encontrada

SituaciónSi la carpeta especificada no existe, se produce FileNotFoundError.Causa

• La ruta de la carpeta es incorrecta.
• La carpeta ha sido eliminada.

Método de solución

• Verifique si la carpeta existe usando os.path.exists() o pathlib.Path.exists().

Ejemplo: Código para verificar si la carpeta existe

import os

folder_path = "sample_folder"

if not os.path.exists(folder_path):
    print(f"Error: La carpeta no se encontró ({folder_path})")
else:
    print("La carpeta existe.")

Error 2: Error de permisos al operar con archivos

SituaciónAl intentar leer o escribir un archivo, se produce PermissionError.Causa

• No tiene permisos de acceso al archivo o carpeta.
• El archivo está bloqueado por otro proceso.

Método de solución

• Verifique y corrija los permisos de acceso.
• Compruebe que el archivo no esté en uso.

Ejemplo: Manejo de errores de permisos

import os

file_path = "sample_folder/sample_file.txt"

try:
    with open(file_path, "r", encoding="utf-8") as f:
        content = f.read()
        print(content)
except PermissionError:
    print(f"Error: No tienes permiso para acceder al archivo ({file_path})")

Error 3: Ruta de archivo demasiado larga

SituaciónEn entornos Windows, puede producirse un error si la ruta supera los 260 caracteres.Método de solución

• Active la configuración que permite rutas largas en Windows.
• Acorte los nombres de archivos y carpetas.

Ejemplo: Código para acortar la ruta

import os

# Acortar ruta larga
long_path = "a/very/long/path/to/a/folder/with/a/long/file_name.txt"
short_path = os.path.basename(long_path)
print(f"Ruta acortada: {short_path}")

Error 4: Manejo de nombres de archivo con caracteres especiales

SituaciónSi el nombre del archivo contiene caracteres especiales (p. ej., espacios, símbolos especiales, caracteres no ASCII), pueden producirse errores.Método de solución

• Normalice el nombre del archivo.
• Elimine o reemplace los caracteres no ASCII.

Ejemplo: Código para normalizar nombres de archivo

import os

file_path = "sample_folder/ejemplo file!.txt"
normalized_file_path = file_path.replace(" ", "_").replace("!", "")
print(f"Nombre de archivo normalizado: {normalized_file_path}")

Error 5: Error por falta de memoria

SituaciónAl procesar directorios muy grandes, puede producirse un error por falta de memoria.Método de solución

• En lugar de procesar los archivos de una vez, procese pequeñas porciones.
• Use generadores al crear la lista de archivos.

Ejemplo: Procesamiento usando generadores

import os

def get_files(folder_path):
    for root, _, files in os.walk(folder_path):
        for file in files:
            yield os.path.join(root, file)

folder_path = "sample_folder"
for file in get_files(folder_path):
    print(f"Procesando: {file}")

Error 6: Archivo bloqueado

SituaciónPuede que no sea posible eliminar o editar el archivo porque una aplicación lo tiene abierto.Método de solución

• Identifique y finalice el proceso que está usando el archivo.
• Espere hasta que el archivo sea liberado.

Error 7: UnicodeDecodeError

SituaciónOcurre cuando la codificación del archivo es desconocida.Método de solución

• Abra el archivo especificando la codificación.
• Use la biblioteca chardet para detectar la codificación.

Ejemplo: Abrir archivo especificando la codificación

import os

file_path = "sample_folder/sample_file.txt"

try:
    with open(file_path, "r", encoding="utf-8") as f:
        content = f.read()
        print(content)
except UnicodeDecodeError:
    print(f"Error: La codificación del archivo es desconocida ({file_path})")

Resumen

Al aprovechar estas soluciones de problemas, podrá resolver eficientemente los errores que ocurren al manipular archivos y mejorar la fiabilidad de sus scripts.

9. Resumen

En este artículo, explicamos cómo obtener los nombres de archivos dentro de una carpeta usando Python, desde lo básico hasta lo avanzado. Repasamos las características y los casos de uso de cada método y resumimos cuál debería elegirse.

Características y uso de los métodos empleados

Revisión de ejemplos de uso

• Creación de lista de archivos: os módulo y glob módulo para listar todos los archivos en la carpeta.
• Filtrado bajo condiciones específicas: se seleccionan solo los archivos necesarios usando extensiones, nombres o expresiones regulares.
• Procesamiento masivo de archivos: con la lista obtenida, se optimiza la lectura y escritura de contenidos.
• Operaciones avanzadas: renombrado, creación de copias de seguridad, eliminación de archivos innecesarios, etc.

Importancia de la solución de problemas

También se abordaron los errores comunes al manipular archivos. Tener en cuenta lo siguiente mejora la fiabilidad del script.

• Verificar la existencia de archivos y carpetas antes de operar.
• Considerar permisos de acceso y el manejo de caracteres especiales.
• Prestar atención a la falta de memoria y al rendimiento al manejar gran cantidad de archivos.

Ventajas de dominar la obtención de nombres de archivos con Python

Obtener nombres de archivos con Python es útil en muchos escenarios. En particular, ofrece las siguientes ventajas.

1. Eficiencia operativa: automatización de la organización de datos periódica.
2. Flexibilidad: permite operar con archivos bajo diversas condiciones.
3. Escalabilidad: apto para conjuntos de datos desde pequeños hasta muy grandes.

Conclusión

Python ofrece una variedad de módulos y funcionalidades. Al combinar adecuadamente los módulos os, glob, pathlib presentados, se puede maximizar la eficiencia y precisión en la manipulación de archivos.

Esperamos que este artículo ayude a principiantes y usuarios intermedios a mejorar sus habilidades de manipulación de archivos con Python. ¡Apliquen lo aprendido en proyectos y tareas reales y experimenten la comodidad que ofrece Python!