Python
Obtener rápidamente una lista de archivos en el directorio: Una guía en Python

Obtener rápidamente una lista de archivos en el directorio: Una guía en Python

MoeNagy Dev

Explorando los módulos os y os.path

Visión general de los módulos os y os.path

Los módulos os y os.path en Python proporcionan una forma independiente de la plataforma para interactuar con el sistema de archivos del sistema operativo. Estos módulos ofrecen una amplia gama de funcionalidades, desde listar archivos en un directorio hasta administrar rutas de archivos y directorios.

Acceder al directorio de trabajo actual

Puede usar la función os.getcwd() para obtener el directorio de trabajo actual:

import os
 
directorio_actual = os.getcwd()
print(directorio_actual)

Esto mostrará la ruta absoluta del directorio de trabajo actual.

Listar archivos en el directorio actual

La función os.listdir() se puede usar para listar todos los archivos y directorios en el directorio de trabajo actual:

import os
 
archivos_y_directorios = os.listdir()
print(archivos_y_directorios)

Esto devolverá una lista de todos los elementos (archivos y directorios) en el directorio actual.

Uso de la función os.listdir()

Conceptos básicos de os.listdir()

La función os.listdir() toma un argumento opcional, que es la ruta al directorio cuyo contenido desea listar. Si no se proporciona ningún argumento, listará el contenido del directorio de trabajo actual.

import os
 
# Listar archivos en el directorio actual
archivos_y_directorios = os.listdir()
print(archivos_y_directorios)
 
# Listar archivos en un directorio específico
directorio_especifico = "/ruta/al/directorio"
archivos_y_directorios = os.listdir(directorio_especifico)
print(archivos_y_directorios)

Listar archivos en un directorio específico

Para listar los archivos en un directorio específico, pase la ruta al directorio como argumento a os.listdir():

import os
 
directorio_especifico = "/ruta/al/directorio"
archivos_y_directorios = os.listdir(directorio_especifico)
print(archivos_y_directorios)

Esto devolverá una lista de todos los elementos (archivos y directorios) en el directorio especificado.

Manejo de rutas relativas y absolutas

Puede usar tanto rutas relativas como rutas absolutas con os.listdir(). Las rutas relativas se interpretan en relación al directorio de trabajo actual, mientras que las rutas absolutas se interpretan como la ruta completa al directorio.

import os
 
# Usando una ruta relativa
ruta_relativa = "documentos"
archivos_y_directorios = os.listdir(ruta_relativa)
print(archivos_y_directorios)
 
# Usando una ruta absoluta
ruta_absoluta = "/home/user/documentos"
archivos_y_directorios = os.listdir(ruta_absoluta)
print(archivos_y_directorios)

Filtrar la lista de archivos

Excluir directorios de la lista

Si solo desea listar los archivos en un directorio y no los propios directorios, puede usar la función os.path.isfile() para filtrar la lista:

import os
 
directorio = "/ruta/al/directorio"
todos_los_elementos = os.listdir(directorio)
archivos = [elemento for elemento in todos_los_elementos if os.path.isfile(os.path.join(directorio, elemento))]
print(archivos)

Esto creará una nueva lista archivos que solo contiene los nombres de archivo, excluyendo cualquier directorio.

Filtrar por extensión de archivo

Para filtrar la lista de archivos por extensión de archivo, puede usar una comprensión de lista:

import os
 
directorio = "/ruta/al/directorio"
todos_los_elementos = os.listdir(directorio)
archivos_txt = [elemento for elemento in todos_los_elementos if elemento.endswith(".txt")]
print(archivos_txt)

Esto creará una nueva lista archivos_txt que solo contiene los nombres de archivo con la extensión .txt.

Uso de comprensión de lista para filtros avanzados

Las comprensiones de lista se pueden usar para aplicar lógica de filtrado más compleja. Por ejemplo, para obtener una lista de archivos que tienen una extensión específica y son más grandes que un cierto tamaño:

import os
 
directorio = "/ruta/al/directorio"
todos_los_elementos = os.listdir(directorio)
archivos_csv_grandes = [
    elemento
    for elemento in todos_los_elementos
    if elemento.endswith(".csv") and os.path.getsize(os.path.join(directorio, elemento)) > 1024 * 1024
]
print(archivos_csv_grandes)

Esto creará una nueva lista archivos_csv_grandes que solo contiene los archivos CSV en el directorio que son más grandes que 1 MB.

Listar archivos en subdirectorios de forma recursiva

Explorar subdirectorios con os.walk()

La función os.walk() se puede usar para recorrer de forma recursiva un árbol de directorios y listar todos los archivos en los subdirectorios. Devuelve un generador que genera una tupla de 3 elementos para cada directorio que visita: la ruta al directorio, una lista de los directorios en ese directorio y una lista de los archivos en ese directorio.

import os
 
directorio = "/ruta/al/directorio"
for raiz, directorios, archivos in os.walk(directorio):
    for archivo in archivos:
        print(os.path.join(raiz, archivo))

Esto imprimirá la ruta completa de cada archivo en el árbol de directorios, comenzando desde el directorio especificado.

Manejo de rutas de archivos de manera recursiva

Cuando se trabaja con os.walk(), es necesario manejar correctamente las rutas de archivos, especialmente al tratar con subdirectorios. La función os.path.join() se puede usar para construir la ruta completa de un archivo combinando la ruta del directorio y el nombre del archivo.

import os
 
directorio = "/ruta/al/directorio"
for raiz, directorios, archivos in os.walk(directorio):
    for archivo in archivos:
        ruta_completa = os.path.join(raiz, archivo)
        print(ruta_completa)

Esto imprimirá la ruta completa de cada archivo, teniendo en cuenta la estructura de directorios.

Personalización del formato de salida

Puede personalizar el formato de salida según sus necesidades. Por ejemplo, puede imprimir el tamaño del archivo y la hora de modificación junto con la ruta del archivo:

import os
from datetime import datetime
 
directorio = "/ruta/al/directorio"
for raiz, directorios, archivos in os.walk(directorio):
    for archivo in archivos:
        ruta_completa = os.path.join(raiz, archivo)
file_size = os.path.getsize(full_path)
mod_time = os.path.getmtime(full_path)
mod_time_str = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M:%S")
print(f"{full_path} - Tamaño: {file_size} bytes - Modificado: {mod_time_str}")
 
Esto imprimirá la ruta del archivo, el tamaño y la hora de modificación para cada archivo en el árbol de directorios.
 
## Trabajando con el módulo os.path
 
### Unir rutas con os.path.join()
 
La función `os.path.join()` se utiliza para construir rutas de archivos uniendo uno o más componentes de ruta de manera inteligente. Maneja los separadores de ruta adecuados (por ejemplo, barras inclinadas en sistemas tipo Unix, barras invertidas en Windows) según el sistema operativo.
 
```python
import os
 
directorio = "/ruta/al/directorio"
nombre_archivo = "ejemplo.txt"
ruta_completa = os.path.join(directorio, nombre_archivo)
print(ruta_completa)

Esto imprimirá la ruta completa del archivo, con los separadores de ruta adecuados para el sistema operativo actual.

Verificar si una ruta es un archivo o un directorio

Las funciones os.path.isfile() y os.path.isdir() se pueden utilizar para verificar si una ruta dada representa un archivo o un directorio, respectivamente.

import os
 
ruta = "/ruta/al/archivo.txt"
if os.path.isfile(ruta):
    print(f"{ruta} es un archivo.")
else:
    print(f"{ruta} no es un archivo.")
 
ruta = "/ruta/al/directorio"
if os.path.isdir(ruta):
    print(f"{ruta} es un directorio.")
else:
    print(f"{ruta} no es un directorio.")

Obtener el tamaño del archivo y la hora de modificación

Las funciones os.path.getsize() y os.path.getmtime() se pueden utilizar para obtener el tamaño de un archivo y la hora de su última modificación, respectivamente.

import os
from datetime import datetime
 
ruta = "/ruta/al/archivo.txt"
tamaño_archivo = os.path.getsize(ruta)
hora_modificacion = os.path.getmtime(ruta)
hora_modificacion_str = datetime.fromtimestamp(hora_modificacion).strftime("%Y-%m-%d %H:%M:%S")
print(f"Tamaño del archivo: {tamaño_archivo} bytes")
print(f"Última modificación: {hora_modificacion_str}")

Esto imprimirá el tamaño del archivo en bytes y la última hora de modificación del archivo.

Manejo de la compatibilidad entre plataformas

Abordar las diferencias entre los sistemas operativos

Los módulos os y os.path están diseñados para proporcionar una interfaz independiente de la plataforma, pero aún existen algunas diferencias en la forma en que se manejan las rutas de archivos en diferentes sistemas operativos (por ejemplo, Windows utiliza barras invertidas, mientras que los sistemas tipo Unix utilizan barras inclinadas).

Asegurar un comportamiento consistente en todas las plataformas

Para asegurar que su código funcione de manera consistente en diferentes plataformas, debe utilizar las funciones y métodos adecuados del módulo os.path, como os.path.join(), os.path.normpath() y os.path.normcase().

Utilizar os.path.normpath() y os.path.normcase()

La función os.path.normpath() se puede utilizar para normalizar una ruta colapsando separadores redundantes y referencias de nivel superior (por ejemplo, ../). La función os.path.normcase() se puede utilizar para normalizar el caso de una ruta, lo cual es importante en sistemas de archivos sensibles a mayúsculas y minúsculas.

import os
 
# Normalizar una ruta
ruta = "/ruta/a/../archivo.txt"
ruta_normalizada = os.path.normpath(ruta)
print(ruta_normalizada)  # Salida: "/ruta/archivo.txt"
 
# Normalizar el caso de una ruta
ruta = "/RUTA/a/ARCHIVO.txt"
ruta_normalizada = os.path.normcase(ruta)
print(ruta_normalizada)  # Salida: "/ruta/a/archivo.txt" (en sistemas tipo Unix)

Utilizando estas funciones, puede asegurarse de que sus rutas de archivos estén formateadas de manera consistente en diferentes sistemas operativos.

Ordenar y organizar la lista de archivos

Ordenar la lista de archivos por nombre, tamaño o hora de modificación

Puede ordenar la lista de archivos en función de diversos atributos, como el nombre del archivo, el tamaño o la hora de modificación. La función sorted() se puede utilizar para este propósito, junto con las funciones clave apropiadas.

import os
 
directorio = "/ruta/al/directorio"
archivos = os.listdir(directorio)
 
# Ordenar por nombre de archivo
archivos_ordenados = sorted(archivos)
print(archivos_ordenados)
 
# Ordenar por tamaño de archivo
tamaños_archivo = [(f, os.path.getsize(os.path.join(directorio, f))) for f in archivos]
archivos_ordenados = sorted(tamaños_archivo, key=lambda x: x[1])
print(archivos_ordenados)
 
# Ordenar por hora de modificación
horas_modificación_archivo = [(f, os.path.getmtime(os.path.join(directorio, f))) for f in archivos]
archivos_ordenados = sorted(horas_modificación_archivo, key=lambda x: x[1])
print(archivos_ordenados)

Esto imprimirá la lista de archivos ordenados por nombre, tamaño y hora de modificación, respectivamente.

Agrupar archivos por extensión u otros atributos

Puede agrupar los archivos por su extensión de archivo u otros atributos utilizando un diccionario o un defaultdict:

import os
from collections import defaultdict
 
directorio = "/ruta/al/directorio"
archivos = os.listdir(directorio)
 
# Agrupar archivos por extensión
grupos_archivo = defaultdict(list)
for archivo in archivos:
    extensión = os.path.splitext(archivo)[1][1:]
    grupos_archivo[extensión].append(archivo)
 
for extensión, archivos in grupos_archivo.items():
    print(f"archivos {extensión}: {', '.join(archivos)}")
 
# Agrupar archivos por tamaño (en MB)
tamaños_archivo = [(f, os.path.getsize(os.path.join(directorio, f))) for f in archivos]
grupos_archivo = defaultdict(list)
for archivo, tamaño in tamaños_archivo:
    tamaño_mb = tamaño / (1024 * 1024)
    grupos_archivo[f"{tamaño_mb:.2f} MB"].append(archivo)
 
for tamaño, archivos in grupos_archivo.items():
    print(f"archivos {tamaño}: {', '.join(archivos)}")

Esto agrupará los archivos por

Estructuras de datos

Listas

Las listas son una de las estructuras de datos más versátiles en Python. Son colecciones ordenadas de elementos, que pueden ser de diferentes tipos de datos. Aquí hay un ejemplo:

mi_lista = [1, 'manzana', 3.14, True]

Puede acceder a elementos individuales en una lista utilizando su índice, que comienza desde 0:

print(mi_lista[0])  # Salida: 1
print(mi_lista[2])  # Salida: 3.14

También puede modificar elementos en una lista:

mi_lista[1] = 'plátano'
print(mi_lista)  # Salida: [1, 'plátano', 3.14, True]

Las listas tienen muchos métodos incorporados, como append(), insert(), remove() y sort().

Tuplas

Las tuplas son similares a las listas, pero son inmutables, lo que significa que no puedes modificar sus elementos después de crearlas. Las tuplas se definen usando paréntesis () en lugar de corchetes [].

mi_tupla = (1, 'manzana', 3.14, True)
print(mi_tupla[0])  # Salida: 1

Las tuplas son útiles cuando deseas asegurarte de que el orden y el contenido de una colección de datos no cambien.

Diccionarios

Los diccionarios son colecciones desordenadas de pares de clave-valor. Se definen utilizando llaves {} y cada par de clave-valor se separa con dos puntos :.

mi_diccionario = {'nombre': 'Juan', 'edad': 30, 'ciudad': 'Nueva York'}
print(mi_diccionario['nombre'])  # Salida: 'Juan'

Puedes agregar, modificar y eliminar pares de clave-valor en un diccionario:

mi_diccionario['email'] = 'juan@example.com'
mi_diccionario['edad'] = 31
del mi_diccionario['ciudad']

Los diccionarios son poderosos para almacenar y recuperar datos basados en claves únicas.

Conjuntos

Los conjuntos son colecciones desordenadas de elementos únicos. Se definen usando llaves {} o la función set().

mi_conjunto = {1, 2, 3, 4, 5}
print(2 in mi_conjunto)  # Salida: True
print(6 in mi_conjunto)  # Salida: False

Los conjuntos son útiles para realizar operaciones como unión, intersección y diferencia entre colecciones de datos.

Control de flujo

Declaraciones condicionales

Las declaraciones condicionales en Python utilizan las palabras clave if, elif y else para ejecutar diferentes bloques de código en base a ciertas condiciones.

x = 10
if x > 0:
    print("x es positivo")
elif x < 0:
    print("x es negativo")
else:
    print("x es cero")

Bucles

Python tiene dos estructuras de bucle principales: for y while. El bucle for se utiliza para iterar sobre secuencias (como listas, tuplas o cadenas), mientras que el bucle while se utiliza para ejecutar un bloque de código siempre y cuando se cumpla una cierta condición.

# Bucle for
frutas = ['manzana', 'banana', 'cereza']
for fruta in frutas:
    print(fruta)
 
# Bucle while
contador = 0
while contador < 5:
    print(contador)
    contador += 1

También puedes utilizar las declaraciones break y continue para controlar el flujo de un bucle.

Comprensiones de listas

Las comprensiones de listas proporcionan una forma concisa de crear nuevas listas basadas en otras existentes. Son particularmente útiles para transformar o filtrar datos.

# Crear una nueva lista con los cuadrados de los números del 1 al 10
cuadrados = [x**2 for x in range(1, 11)]
print(cuadrados)  # Salida: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
# Crear una nueva lista con números pares del 1 al 10
numeros_pares = [x for x in range(1, 11) if x % 2 == 0]
print(numeros_pares)  # Salida: [2, 4, 6, 8, 10]

Funciones

Las funciones en Python se definen utilizando la palabra clave def. Pueden aceptar parámetros y devolver valores.

def saludar(nombre):
    """Saludar a la persona con el nombre dado."""
    print(f"Hola, {nombre}!")
 
saludar("Alice")  # Salida: Hola, Alice!

También puedes definir funciones con valores predeterminados para los parámetros y argumentos de longitud variable.

def calcular_area(longitud, ancho=1):
    """Calcular el área de un rectángulo."""
    return longitud * ancho
 
print(calcular_area(5, 3))  # Salida: 15
print(calcular_area(4))  # Salida: 4 (el ancho predeterminado es 1)
 
def sumar_numeros(*args):
    """Calcular la suma de cualquier cantidad de argumentos."""
    return sum(args)
 
print(sumar_numeros(1, 2, 3))  # Salida: 6
print(sumar_numeros(4, 5, 6, 7, 8))  # Salida: 30

Las funciones también se pueden definir como funciones lambda (funciones anónimas) para operaciones simples de una línea.

cuadrado = lambda x: x**2
print(cuadrado(5))  # Salida: 25

Módulos y paquetes

La biblioteca estándar de Python proporciona una amplia gama de módulos integrados que puedes usar en tus programas. También puedes crear tus propios módulos y paquetes para organizar tu código.

# Usando un módulo integrado
import math
print(math.pi)  # Salida: 3.141592653589793
 
# Creando un módulo personalizado
# my_module.py
def saludar(nombre):
    print(f"Hola, {nombre}!")
 
# Usando el módulo personalizado
import my_module
my_module.saludar("Alice")  # Salida: Hola, Alice!

Los paquetes son colecciones de módulos y te ayudan a estructurar tu código y gestionar las dependencias.

Manejo de excepciones

El mecanismo de manejo de excepciones de Python te permite manejar errores y situaciones inesperadas en tu código.

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("Error: División por cero")
else:
    print(f"Resultado: {resultado}")
finally:
    print("Este bloque siempre se ejecutará.")

También puedes definir tus propias excepciones personalizadas y lanzarlas cuando sea necesario.

class ErrorDeEntradaInvalida(Exception):
    pass
 
def dividir(a, b):
    if b == 0:
        raise ErrorDeEntradaInvalida("Error: División por cero")
    return a / b
 
try:
    print(dividir(10, 0))
except ErrorDeEntradaInvalida as e:
    print(e)

Entrada y salida de archivos

Python proporciona funciones integradas para leer y escribir archivos.

# Escribir en un archivo
with open("output.txt", "w") as archivo:
    archivo.write("¡Hola, Mundo!")
 
# Leer desde un archivo
with open("input.txt", "r") as archivo:
    contenido = archivo.read()
    print(contenido)

La declaración with asegura que el archivo se cierre correctamente después de completar la operación.

Conclusión

En este tutorial de Python, hemos cubierto una amplia gama de temas, que incluyen estructuras de datos, control de flujo, funciones, módulos y paquetes, manejo de excepciones y entrada y salida de archivos. Al comprender estos conceptos, estarás en camino de convertirte en un programador de Python competente. Recuerda practicar regularmente y explorar el vasto ecosistema de bibliotecas y marcos de trabajo de Python para expandir tus habilidades y desarrollar aplicaciones poderosas.

MoeNagy Dev