Cómo automatizar tareas cotidianas con Python

Aprender a automatizar tareas con Python puede ahorrar muchas horas de trabajo repetitivo. Un script puede organizar descargas, renombrar cientos de archivos, combinar informes, generar copias de seguridad, revisar carpetas y ejecutar controles con resultados consistentes.

Una automatización útil no necesita ser una aplicación enorme. Muchos scripts prácticos tienen menos de cien líneas. La clave es elegir una tarea predecible, definir reglas claras y probar el proceso con copias antes de modificar datos reales.

Qué tareas conviene automatizar

Una buena candidata suele repetirse con frecuencia, seguir reglas estables y trabajar con información digital. Algunos ejemplos son:

• mover archivos según su extensión;
• renombrar imágenes o documentos;
• combinar archivos CSV;
• extraer valores de texto;
• generar informes periódicos;
• comprobar si llegaron archivos esperados;
• crear copias de seguridad.

Las tareas que implican decisiones delicadas, datos sensibles o acciones irreversibles necesitan más controles y revisión humana.

Planificar antes de escribir código

Describe el proceso manual con preguntas concretas:

1. ¿De dónde llega la información?
2. ¿Qué regla determina cada acción?
3. ¿Qué resultado debe producirse?
4. ¿Qué errores son posibles?
5. ¿Cómo se valida el resultado?
6. ¿Cómo se revierten los cambios?

Esta planificación separa la lógica del negocio de la sintaxis. La guía de lógica de programación con Python explica cómo convertir un proceso en pasos precisos.

Trabajar con pathlib

El módulo estándar pathlib proporciona rutas orientadas a objetos:

from pathlib import Path

folder = Path.home() / "Downloads"

for path in folder.iterdir():
    print(path.name)

Funciona en Windows, macOS y Linux sin concatenar separadores. La guía de pathlib en Python presenta navegación, filtros, creación y metadatos.

La documentación oficial de pathlib describe todas las operaciones disponibles.

Proyecto 1: organizar una carpeta

from pathlib import Path
import shutil

SOURCE = Path.home() / "Downloads"

CATEGORIES = {
    ".pdf": "Documents",
    ".docx": "Documents",
    ".xlsx": "Spreadsheets",
    ".csv": "Spreadsheets",
    ".jpg": "Images",
    ".jpeg": "Images",
    ".png": "Images",
    ".zip": "Archives",
}


def unique_destination(folder, filename):
    destination = folder / filename
    counter = 1

    while destination.exists():
        destination = folder / (
            f"{destination.stem}_{counter}"
            f"{destination.suffix}"
        )
        counter += 1

    return destination


for path in SOURCE.iterdir():
    if not path.is_file():
        continue

    category = CATEGORIES.get(
        path.suffix.casefold(),
        "Other",
    )

    target_folder = SOURCE / category
    target_folder.mkdir(exist_ok=True)

    destination = unique_destination(
        target_folder,
        path.name,
    )

    shutil.move(str(path), destination)
    print(f"Movido: {path.name} -> {destination.name}")

La función de destino evita sobrescribir silenciosamente un archivo que ya existe. La documentación oficial de shutil explica copia, movimiento, archivado y operaciones con directorios.

Añadir un modo de simulación

Un dry run muestra lo que ocurriría sin aplicar cambios:

DRY_RUN = True

if DRY_RUN:
    print(f"Movería {path} a {destination}")
else:
    shutil.move(str(path), destination)

Este interruptor es una de las medidas de seguridad más valiosas para automatizaciones de archivos.

Proyecto 2: renombrar archivos por lotes

from pathlib import Path

folder = Path("photos")
files = sorted(folder.glob("*.jpg"))

for index, path in enumerate(files, start=1):
    new_name = (
        f"vacation_{index:03d}"
        f"{path.suffix.lower()}"
    )
    destination = path.with_name(new_name)

    if destination.exists():
        raise FileExistsError(
            f"Ya existe: {destination}"
        )

    path.rename(destination)
    print(f"{path.name} -> {destination.name}")

El formato {index:03d} produce 001, 002 y 003. Antes de renombrar, guarda una tabla con el nombre antiguo y el nuevo para poder crear una reversión.

Proyecto 3: resumir un CSV

import csv
from collections import defaultdict
from pathlib import Path

source = Path("sales.csv")
totals = defaultdict(float)

with source.open(
    encoding="utf-8",
    newline="",
) as file:
    reader = csv.DictReader(file)

    for row in reader:
        category = row["category"].strip()
        amount = float(row["amount"])
        totals[category] += amount

with Path("summary.csv").open(
    "w",
    encoding="utf-8",
    newline="",
) as file:
    writer = csv.writer(file)
    writer.writerow(["category", "total"])

    for category, total in sorted(totals.items()):
        writer.writerow([category, f"{total:.2f}"])

La guía de archivos CSV en Python explica delimitadores, DictReader, validación y streaming.

Proyecto 4: crear una copia de seguridad

from datetime import datetime
from pathlib import Path
import shutil

source = Path.home() / "Documents" / "project"
backup_root = Path.home() / "Backups"
backup_root.mkdir(exist_ok=True)

timestamp = datetime.now().strftime(
    "%Y%m%d_%H%M%S"
)
archive_base = backup_root / f"project_{timestamp}"

archive_path = shutil.make_archive(
    str(archive_base),
    "zip",
    root_dir=source,
)

print(f"Copia creada: {archive_path}")

Una copia no está validada solamente porque el ZIP exista. Prueba restaurar un archivo y comprueba el contenido esperado.

Separar configuración y código

Las rutas y reglas que cambian no deberían quedar repartidas por el script. Guarda configuraciones no secretas en JSON:

{
  "source_folder": "incoming",
  "archive_folder": "processed",
  "extensions": [".csv", ".xlsx"]
}

import json
from pathlib import Path

with open("config.json", encoding="utf-8") as file:
    config = json.load(file)

source = Path(config["source_folder"])

Las contraseñas y tokens deben almacenarse como variables de entorno, nunca en el repositorio.

Añadir logging

Los mensajes de terminal desaparecen cuando una tarea programada se ejecuta sin supervisión:

import logging

logging.basicConfig(
    filename="automation.log",
    level=logging.INFO,
    format=(
        "%(asctime)s %(levelname)s "
        "%(message)s"
    ),
)

logging.info("Automatización iniciada")

Registra el inicio, el final, la cantidad procesada, los archivos omitidos y los errores. No incluyas credenciales ni datos privados.

Manejar errores por elemento

for path in files:
    try:
        process_file(path)
    except PermissionError:
        logging.exception(
            "Permiso denegado: %s",
            path,
        )
    except ValueError:
        logging.exception(
            "Datos inválidos: %s",
            path,
        )

Un archivo incorrecto no siempre debería detener todo el lote. Decide si corresponde omitir, reintentar, mover a cuarentena o finalizar. La guía de try y except en Python ayuda a capturar excepciones específicas.

Crear procesos idempotentes

Una automatización idempotente puede ejecutarse otra vez sin duplicar o corromper información. Algunas estrategias son:

• mover archivos completados a otra carpeta;
• comprobar si la salida ya existe;
• utilizar identificadores únicos;
• escribir en un archivo temporal y reemplazar al final;
• guardar el estado de los elementos procesados.

Programar la ejecución

En Windows puedes utilizar Task Scheduler. En Linux y macOS, cron es una alternativa habitual. Usa la ruta completa del intérprete del entorno virtual y del script:

/ruta/proyecto/.venv/bin/python /ruta/proyecto/main.py

Los trabajos programados pueden comenzar en otra carpeta, por lo que conviene construir rutas desde __file__:

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent
CONFIG_FILE = BASE_DIR / "config.json"

La guía de entornos virtuales explica cómo identificar el ejecutable correcto.

Probar con seguridad

1. Utiliza copias de los datos.
2. Comienza con pocos elementos.
3. Activa la simulación.
4. Registra cada operación.
5. Prueba nombres duplicados.
6. Interrumpe el script y revisa la recuperación.
7. Valida la salida antes de eliminar entradas.

Las funciones pequeñas son más fáciles de probar. La guía de Pytest para principiantes muestra cómo validar operaciones sin modificar carpetas reales.

Organizar el proyecto

automation_project/
├── config.json
├── main.py
├── operations.py
├── validation.py
├── logs/
├── tests/
└── README.md

Separa operaciones, validación y configuración. La guía de módulos y paquetes en Python explica cómo distribuir responsabilidades.

Errores frecuentes

• Probar directamente con archivos importantes.
• Sobrescribir nombres duplicados.
• Depender del directorio actual.
• Eliminar entradas antes de validar la salida.
• Guardar secretos en el código.
• Ignorar codificación y delimitadores.
• Programar una tarea sin logs.
• Automatizar un proceso que todavía no se comprende.

Conclusión

La automatización con Python funciona mejor cuando las reglas son explícitas y los fallos pueden detectarse. Empieza con un script que solo lea y muestre lo que haría. Añade simulación, logs, protección contra duplicados, manejo específico de errores y un plan de recuperación antes de habilitar cambios reales.