Python
Recuperar archivos en un directorio con Python de manera sencilla

Recuperar archivos en un directorio con Python de manera sencilla

MoeNagy Dev

Obtener todos los archivos en un directorio con Python

El poder de os.listdir()

Comprendiendo la función os.listdir()

La función os.listdir() es una herramienta poderosa en la biblioteca estándar de Python que le permite recuperar una lista de todos los archivos y directorios dentro de un directorio especificado. Esta función es parte del módulo os, que proporciona una forma de interactuar con el sistema operativo.

Aquí hay un ejemplo básico de cómo usar os.listdir():

import os
 
directory_path = '/ruta/al/directorio'
file_list = os.listdir(directory_path)
print(file_list)

Este código mostrará una lista de todos los archivos y directorios dentro del directory_path especificado.

Enumerar todos los archivos en un directorio

Para obtener una lista solo de los archivos (y no directorios) en un directorio, se puede utilizar el siguiente enfoque:

import os
 
directory_path = '/ruta/al/directorio'
file_list = [f for f in os.listdir(directory_path) if os.path.isfile(os.path.join(directory_path, f))]
print(file_list)

En este ejemplo, utilizamos una comprensión de lista para filtrar la lista devuelta por os.listdir() y solo incluir los elementos que son archivos (en lugar de directorios) utilizando la función os.path.isfile().

Manejar subdirectorios y recuperar archivos de forma recursiva

Si desea recuperar archivos no solo del directorio especificado, sino también de sus subdirectorios, puede utilizar un enfoque recursivo. Aquí hay un ejemplo:

import os
 
def get_all_files(directory_path):
    file_list = []
    for root, dirs, files in os.walk(directory_path):
        for file in files:
            file_list.append(os.path.join(root, file))
    return file_list
 
directory_path = '/ruta/al/directorio'
all_files = get_all_files(directory_path)
print(all_files)

En este ejemplo, definimos una función get_all_files() que utiliza la función os.walk() para recorrer el árbol de directorios de forma recursiva. Para cada archivo encontrado, construimos la ruta completa del archivo utilizando os.path.join() y lo agregamos a file_list.

Filtrar archivos por extensión

Especificar extensiones de archivos para incluir

Para recuperar solo los archivos con extensiones de archivo específicas, puede utilizar el siguiente enfoque:

import os
 
directory_path = '/ruta/al/directorio'
allowed_extensions = ['.txt', '.py', '.jpg']
 
file_list = [f for f in os.listdir(directory_path) if any(f.endswith(ext) for ext in allowed_extensions)]
print(file_list)

En este ejemplo, definimos una lista de allowed_extensions y luego utilizamos una comprensión de lista para filtrar la lista de archivos devueltos por os.listdir() para incluir solo los archivos que tienen una de las extensiones especificadas.

Excluir ciertas extensiones de archivo

De manera similar, se pueden excluir ciertas extensiones de archivo modificando la comprensión de lista:

import os
 
directory_path = '/ruta/al/directorio'
excluded_extensions = ['.pyc', '.log']
 
file_list = [f for f in os.listdir(directory_path) if not any(f.endswith(ext) for ext in excluded_extensions)]
print(file_list)

Aquí, definimos una lista de excluded_extensions y luego utilizamos una comprensión de lista para filtrar la lista de archivos, excluyendo cualquier archivo que tenga una de las extensiones especificadas.

Manejo de múltiples extensiones de archivo

También se pueden manejar múltiples extensiones de archivo de una manera más flexible utilizando un conjunto o un diccionario:

import os
 
directory_path = '/ruta/al/directorio'
allowed_extensions = {'.txt', '.py', '.jpg'}
 
file_list = [f for f in os.listdir(directory_path) if any(f.endswith(ext) for ext in allowed_extensions)]
print(file_list)

En este ejemplo, utilizamos un conjunto de allowed_extensions en lugar de una lista. Esto nos permite agregar o eliminar extensiones fácilmente sin modificar la comprensión de lista.

Ordenar y organizar la lista de archivos

Ordenar la lista de archivos alfabéticamente

Para ordenar la lista de archivos alfabéticamente, puede utilizar la función sorted() incorporada:

import os
 
directory_path = '/ruta/al/directorio'
file_list = os.listdir(directory_path)
sorted_file_list = sorted(file_list)
print(sorted_file_list)

Esto ordenará la lista de archivos en orden alfabético ascendente.

Ordenar por tamaño de archivo o fecha de modificación

Para ordenar la lista de archivos por tamaño de archivo o fecha de modificación, puede utilizar las funciones os.path.getsize() y os.path.getmtime(), respectivamente:

import os
 
directory_path = '/ruta/al/directorio'
file_list = os.listdir(directory_path)
 
# Ordenar por tamaño de archivo
sorted_by_size = sorted(file_list, key=lambda x: os.path.getsize(os.path.join(directory_path, x)))
print(sorted_by_size)
 
# Ordenar por fecha de modificación
sorted_by_date = sorted(file_list, key=lambda x: os.path.getmtime(os.path.join(directory_path, x)))
print(sorted_by_date)

En el primer ejemplo, utilizamos la función sorted() con una función de clave personalizada que obtiene el tamaño del archivo utilizando os.path.getsize(). En el segundo ejemplo, utilizamos la fecha de modificación obtenida por os.path.getmtime() como la clave de ordenación.

Agrupar archivos por extensión

Para agrupar los archivos por sus extensiones de archivo, puede utilizar un diccionario para almacenar los archivos agrupados por sus extensiones:

import os
from collections import defaultdict
 
directory_path = '/ruta/al/directorio'
file_list = os.listdir(directory_path)
 
file_groups = defaultdict(list)
for filename in file_list:
    extension = os.path.splitext(filename)[1].lower()
    file_groups[extension].append(filename)
 
for extension, files in file_groups.items():
    print(f"Archivos con extensión '{extension}': {', '.join(files)}")

En este ejemplo, usamos un defaultdict del módulo collections para crear un diccionario que inicializará automáticamente listas vacías para las nuevas extensiones de archivo. Luego recorremos la lista de archivos, extraemos la extensión del archivo usando os.path.splitext() y agregamos el nombre de archivo a la lista correspondiente en el diccionario file_groups.

Trabajando con Pathlib

Presentando el módulo Pathlib

El módulo pathlib en Python proporciona una forma orientada a objetos de trabajar con las rutas de archivo. Ofrece un enfoque más intuitivo y multiplataforma en comparación con el tradicional módulo os.path.

Listar archivos usando Pathlib

Aquí tienes un ejemplo de cómo usar pathlib para listar archivos en un directorio:

from pathlib import Path
 
directory_path = '/ruta/al/directorio'
file_list = [p.name for p in Path(directory_path).glob('*')]
print(file_list)

En este ejemplo, usamos la clase Path del módulo pathlib para representar la ruta del directorio. Luego usamos el método glob() para obtener una lista de todos los archivos y directorios dentro del directorio especificado.

Acceder a los metadatos del archivo con Pathlib

También puedes usar pathlib para acceder fácilmente a los metadatos del archivo, como el tamaño del archivo y la fecha de modificación:

from pathlib import Path
 
file_path = '/ruta/al/archivo.txt'
file_path = Path(file_path)
 
print(f"Nombre de archivo: {file_path.name}")
print(f"Tamaño del archivo: {file_path.stat().st_size} bytes")
print(f"Tiempo de modificación: {file_path.stat().st_mtime}")

Este código demuestra cómo obtener el nombre del archivo, el tamaño del archivo y el tiempo de modificación utilizando el objeto pathlib.Path.

Manejo de archivos y directorios ocultos

Identificando archivos y directorios ocultos

En muchos sistemas de archivos, los archivos y directorios que comienzan con un punto (por ejemplo, .gitignore) se consideran "ocultos" y generalmente no se muestran en las listas de directorios. Para incluir o excluir estos elementos ocultos, puedes usar el siguiente enfoque:

import os
 
directory_path = '/ruta/al/directorio'
all_items = os.listdir(directory_path)
visible_items = [item for item in all_items if not item.startswith('.')]
hidden_items = [item for item in all_items if item.startswith('.')]
 
print("Elementos visibles:", visible_items)
print("Elementos ocultos:", hidden_items)

En este ejemplo, primero obtenemos la lista completa de elementos en el directorio usando os.listdir(). Luego usamos dos comprensiones de lista para separar los elementos visibles y ocultos según si el nombre del elemento comienza con un punto.

Elegir si incluir o excluir los elementos ocultos

Dependiendo de tu caso de uso, es posible que desees incluir o excluir los archivos y directorios ocultos. Aquí tienes un ejemplo de cómo manejar esto:

import os
 
directory_path = '/ruta/al/directorio'
include_hidden = False
 
all_items = os.listdir(directory_path)
if include_hidden:
    lista_archivos = all_items
else:
    lista_archivos = [item for item in all_items if not item.startswith('.')]
 
print(lista_archivos)

En este ejemplo, introducimos una variable booleana include_hidden que controla si se deben incluir los elementos ocultos en la lista final de archivos o no.

Personalizando el comportamiento de búsqueda de archivos

También puedes personalizar aún más el comportamiento de búsqueda de archivos creando una función que te permita especificar reglas personalizadas para incluir o excluir archivos y directorios:

import os
 
def obtener_lista_archivos(directory_path, include_hidden=False, allowed_extensions=None, excluded_extensions=None):
    all_items = os.listdir(directory_path)
    lista_archivos = []
 
    for item in all_items:
        item_path = os.path.join(directory_path, item)
        if os.path.isfile(item_path):
            if allowed_extensions:
                if any(item.endswith(ext) for ext in allowed_extensions):
                    lista_archivos.append(item)
            elif excluded_extensions:
                if not any(item.endswith(ext) for ext in excluded_extensions):
                    lista_archivos.append(item)
            else:
                lista_archivos.append(item)
        elif include_hidden or not item.startswith('.'):
            lista_archivos.append(item)
 
    return lista_archivos
 
# Ejemplo de uso
directory_path = '/ruta/al/directorio'
lista_archivos = obtener_lista_archivos(directory_path, include_hidden=False, allowed_extensions=['.txt', '.py'])
print(lista_archivos)

En este ejemplo, la función obtener_lista_archivos() te permite especificar si deseas incluir archivos y directorios ocultos, así como qué extensiones de archivo incluir o excluir. Esto proporciona una forma flexible y personalizable de obtener la lista de archivos según tus requisitos específicos.

Combinando os.listdir() y os.path.join()

Usando os.path.join() para construir rutas completas de archivos

Cuando trabajas con la lista de archivos obtenida de os.listdir(), a menudo necesitas construir rutas completas de archivos. Puedes usar la función os.path.join() con este propósito:

import os
 
directory_path = '/ruta/al/directorio'
file_list = os.listdir(directory_path)
full_file_paths = [os.path.join(directory_path, filename) for filename in file_list]
print(full_file_paths)

En este ejemplo, usamos una comprensión de lista para iterar a través de la lista de archivos y construir las rutas completas de archivos uniéndo la ruta del directorio y los nombres de archivos individuales usando os.path.join().

Recorriendo el directorio y construyendo la lista de archivos

Puedes combinar os.listdir() y os.path.join() para construir la lista de archivos de una manera más eficiente:

import os
 
def obtener_lista_archivos(directory_path):
    lista_archivos = []
    for filename in os.listdir(directory_path):
        ruta_archivo = os.path.join(directory_path, filename)
        if os.path.isfile(ruta_archivo):
            lista_archivos.append(ruta_archivo)
    return lista_archivos
 
directory_path = '/ruta/al/directorio'
todos_los_archivos = obtener_lista_archivos(directory_path)
print(todos_los_archivos)
 
## Estructuras de datos
 
### Listas
Las listas son una de las estructuras de datos más fundamentales en Python. Son colecciones ordenadas de elementos, que pueden ser de diferentes tipos de datos. Puedes crear una lista usando corchetes `[]` y separar los elementos con comas.
 
```python
fruits = ['manzana', 'plátano', 'cereza']
print(fruits)  # Salida: ['manzana', 'plátano', 'cereza']

Puedes acceder a los elementos individuales de una lista utilizando su índice, que comienza desde 0.

print(fruits[0])  # Salida: 'manzana'
print(fruits[1])  # Salida: 'plátano'

También puedes utilizar índices negativos para acceder a los elementos desde el final de la lista.

print(fruits[-1])  # Salida: 'cereza'
print(fruits[-2])  # Salida: 'plátano'

Las listas admiten una amplia gama de operaciones, como la segmentación, concatenación y modificación.

# Segmentación
print(fruits[1:3])  # Salida: ['plátano', 'cereza']
 
# Concatenación
more_fruits = ['naranja', 'kiwi']
all_fruits = fruits + more_fruits
print(all_fruits)  # Salida: ['manzana', 'plátano', 'cereza', 'naranja', 'kiwi']
 
# Modificación
fruits[0] = 'pera'
print(fruits)  # Salida: ['pera', 'plátano', 'cereza']

Tuplas

Las tuplas son similares a las listas, pero son inmutables, lo que significa que no puedes modificar sus elementos después de la creación. Las tuplas se definen utilizando paréntesis () en lugar de corchetes.

point = (3, 4)
print(point)  # Salida: (3, 4)
print(point[0])  # Salida: 3
print(point[1])  # Salida: 4

Las tuplas pueden ser útiles cuando deseas almacenar un conjunto fijo de valores, como coordenadas o registros de bases de datos.

Diccionarios

Los diccionarios son colecciones desordenadas de pares clave-valor. Se definen utilizando llaves {} y las claves y los valores se separan con dos puntos.

person = {
    'nombre': 'John Doe',
    'edad': 35,
    'ocupación': 'Ingeniero de software'
}
print(person)  # Salida: {'nombre': 'John Doe', 'edad': 35, 'ocupación': 'Ingeniero de software'}

Puedes acceder a los valores en un diccionario utilizando sus claves.

print(person['nombre'])  # Salida: 'John Doe'
print(person['edad'])  # Salida: 35

Los diccionarios son versátiles y se pueden utilizar para almacenar varios tipos de datos, incluyendo listas y otros diccionarios.

person = {
    'nombre': 'John Doe',
    'edad': 35,
    'aficiones': ['leer', 'senderismo', 'fotografía'],
    'dirección': {
        'calle': '123 Main St',
        'ciudad': 'Anytown',
        'estado': 'CA'
    }
}
 
print(person['aficiones'])  # Salida: ['leer', 'senderismo', 'fotografía']
print(person['dirección']['ciudad'])  # Salida: 'Anytown'

Conjuntos

Los conjuntos son colecciones desordenadas de elementos únicos. Se definen utilizando llaves {} y los elementos se separan con comas.

colores = {'rojo', 'verde', 'azul'}
print(colores)  # Salida: {'rojo', 'verde', 'azul'}

Puedes usar conjuntos para realizar varias operaciones, como unión, intersección y diferencia.

colores1 = {'rojo', 'verde', 'azul'}
colores2 = {'verde', 'amarillo', 'naranja'}
 
# Unión
todos_los_colores = colores1 | colores2
print(todos_los_colores)  # Salida: {'rojo', 'verde', 'azul', 'amarillo', 'naranja'}
 
# Intersección
colores_comunes = colores1 & colores2
print(colores_comunes)  # Salida: {'verde'}
 
# Diferencia
colores_únicos1 = colores1 - colores2
print(colores_únicos1)  # Salida: {'rojo', 'azul'}

Estructuras de control

Declaraciones condicionales

En Python, puedes usar declaraciones condicionales para controlar el flujo de tu programa según ciertas condiciones.

La declaración if-elif-else es la forma más común de implementar lógica condicional.

edad = 25
if edad < 18:
    print("Eres menor de edad.")
elif edad < 65:
    print("Eres adulto.")
else:
    print("Eres un adulto mayor.")

También puedes usar el operador ternario, que es una forma abreviada de escribir declaraciones if-else simples.

es_estudiante = True
estado = "Estudiante" if es_estudiante else "No es estudiante"
print(estado)  # Salida: "Estudiante"

Bucles

Los bucles en Python te permiten ejecutar repetidamente un bloque de código. Los dos tipos de bucles más comunes son los bucles for y while.

Un bucle for se utiliza para iterar sobre una secuencia, como una lista o una cadena de texto.

frutas = ['manzana', 'plátano', 'cereza']
for fruta in frutas:
    print(fruta)

Un bucle while se utiliza para ejecutar repetidamente un bloque de código mientras se cumpla una determinada condición.

contador = 0
while contador < 5:
    print(contador)
    contador += 1

También puedes utilizar las instrucciones break y continue para controlar el flujo de tus bucles.

for i in range(10):
    if i == 5:
        break
    print(i)  # Salida: 0 1 2 3 4
 
for j in range(10):
    if j % 2 == 0:
        continue
    print(j)  # Salida: 1 3 5 7 9

Funciones

Las funciones en Python son bloques de código reutilizables que realizan una tarea específica. Se definen utilizando la palabra clave def.

def saludar(nombre):
    print(f"Hola, {nombre}!")
 
saludar("Alice")  # Salida: "Hola, Alice!"

Las funciones también pueden devolver valores utilizando la declaración return.

def sumar_numeros(a, b):
    return a + b
 
resultado = sumar_numeros(3, 4)
print(resultado)  # Salida: 7

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

def imprimir_información(nombre, edad=30, *args):
    print(f"Nombre: {nombre}")
    print(f"Edad: {edad}")
    print("Información adicional:")
    for arg in args:
        print(arg)
 
imprimir_información("John", 35, "Ingeniero de software", "Le encanta hacer senderismo")

Módulos y paquetes

En Python, puedes organizar tu código en módulos y paquetes para que sea más modular y reutilizable.

Un módulo es un único archivo de Python que contiene funciones, clases y variables. Puedes importar módulos utilizando la instrucción import.

import math
print(math.pi)  # Salida: 3.141592653589793

También puedes importar elementos específicos de un módulo utilizando la palabra clave from.

from math import sqrt
print(sqrt(16))  # Salida: 4.0

Los paquetes son colecciones de módulos relacionados. Se organizan en directorios con un archivo __init__.py que define el paquete.

my_package/
__init__.es
module1.es
module2.es

A continuación, puedes importar elementos de un paquete utilizando la notación de puntos.

```python
import my_package.module1
resultado = my_package.module1.my_function()

Manejo de Excepciones

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

Puedes usar la declaración try-except para capturar y manejar excepciones.

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("Error: División por cero")

También puedes manejar múltiples excepciones y proporcionar un bloque except predeterminado.

try:
    num = int(input("Ingresa un número: "))
    print(10 / num)
except ValueError:
    print("Error: Entrada inválida")
except ZeroDivisionError:
    print("Error: División por cero")
except:
    print("Ocurrió un error desconocido")

También puedes crear tus propias excepciones utilizando la declaración raise.

def retirar(saldo, monto):
    if monto > saldo:
        raise ValueError("Fondos insuficientes")
    return saldo - monto
 
try:
    nuevo_saldo = retirar(100, 150)
except ValueError as e:
    print(e)

Conclusión

En este tutorial, has aprendido sobre varias estructuras de datos, declaraciones de flujo de control, funciones, módulos y manejo de excepciones en Python. Estos conceptos son esenciales para construir aplicaciones Python más complejas y robustas. Recuerda practicar y experimentar con los ejemplos proporcionados para afianzar tu comprensión de estos temas.

MoeNagy Dev