Introduccion: el tiempo que pierdes en tareas repetitivas
Renombrar cientos de archivos a mano. Enviar el mismo correo a 50 personas con datos diferentes. Copiar columnas de un Excel a otro cada semana. Entrar a una pagina web para verificar si cambio un precio. Hacer una copia de seguridad de tus carpetas de trabajo cada viernes antes de salir.
Todas estas tareas tienen algo en comun: son repetitivas, predecibles y consumen un tiempo que podrias dedicar a trabajo mas valioso. La buena noticia es que Python puede encargarse de todas ellas por ti.
Python es uno de los lenguajes mas accesibles para automatizacion gracias a su sintaxis clara, su enorme ecosistema de librerias y su capacidad para interactuar con archivos, correos, paginas web, hojas de calculo y el sistema operativo. En este articulo te mostramos 5 ejemplos practicos con codigo funcional que puedes adaptar a tus necesidades inmediatamente.
Ejemplo 1: Renombrar archivos masivamente
Imagina que tienes una carpeta con 200 fotos de una camara con nombres como IMG_4521.jpg, IMG_4522.jpg, etc. Quieres renombrarlas con un patron mas descriptivo que incluya la fecha actual y un numero secuencial, por ejemplo vacaciones_2026-04-01_001.jpg.
Con Python, esto se resuelve en unas pocas lineas usando los modulos os y datetime de la libreria estandar:
import os
from datetime import datetime
def renombrar_archivos(carpeta, prefijo="archivo", extension=".jpg"):
"""Renombra todos los archivos de una carpeta con un patron
que incluye prefijo, fecha actual y numero secuencial."""
fecha = datetime.now().strftime("%Y-%m-%d")
# Obtener solo los archivos con la extension deseada
archivos = [
f for f in os.listdir(carpeta)
if f.lower().endswith(extension) and os.path.isfile(os.path.join(carpeta, f))
]
# Ordenar para que la numeracion sea consistente
archivos.sort()
print(f"Se encontraron {len(archivos)} archivos con extension {extension}")
for i, nombre_actual in enumerate(archivos, start=1):
nuevo_nombre = f"{prefijo}_{fecha}_{i:03d}{extension}"
ruta_actual = os.path.join(carpeta, nombre_actual)
ruta_nueva = os.path.join(carpeta, nuevo_nombre)
os.rename(ruta_actual, ruta_nueva)
print(f" {nombre_actual} -> {nuevo_nombre}")
print(f"\nListo: {len(archivos)} archivos renombrados.")
# Uso
renombrar_archivos("/home/usuario/fotos", prefijo="vacaciones", extension=".jpg")El script lista todos los archivos con la extension indicada, los ordena alfabeticamente y los renombra con el patron deseado. El formato {i:03d} genera numeros con ceros a la izquierda (001, 002, 003...) para que el orden alfabetico coincida con el orden numerico.
Puedes extender este script facilmente para filtrar por fecha de modificacion, mover archivos a subcarpetas por mes, o procesar multiples extensiones a la vez.
Ejemplo 2: Enviar emails automaticos
Enviar correos electronicos de forma programatica es util para notificaciones, alertas, reportes automaticos o comunicaciones masivas personalizadas. Python incluye el modulo smtplib en su libreria estandar, que permite enviar correos a traves de cualquier servidor SMTP, incluyendo Gmail.
Para usar Gmail, necesitas generar una contrasena de aplicacion desde la configuracion de seguridad de tu cuenta de Google (no uses tu contrasena normal). Aqui tienes un ejemplo completo:
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
def enviar_email(destinatario, asunto, cuerpo_html, remitente, password):
"""Envia un email con contenido HTML usando Gmail SMTP."""
mensaje = MIMEMultipart("alternative")
mensaje["Subject"] = asunto
mensaje["From"] = remitente
mensaje["To"] = destinatario
# Version texto plano (fallback)
texto_plano = cuerpo_html.replace("
", "\n").replace("", "\n")
parte_texto = MIMEText(texto_plano, "plain")
parte_html = MIMEText(cuerpo_html, "html")
mensaje.attach(parte_texto)
mensaje.attach(parte_html)
with smtplib.SMTP_SSL("smtp.gmail.com", 465) as servidor:
servidor.login(remitente, password)
servidor.sendmail(remitente, destinatario, mensaje.as_string())
print(f"Email enviado a {destinatario}")
def enviar_emails_masivos(lista_contactos, asunto, plantilla_html, remitente, password):
"""Envia emails personalizados a una lista de contactos.
Cada contacto es un dict con al menos 'email' y 'nombre'."""
for contacto in lista_contactos:
# Personalizar la plantilla con los datos del contacto
cuerpo = plantilla_html.format(**contacto)
enviar_email(contacto["email"], asunto, cuerpo, remitente, password)
print(f"\nTotal: {len(lista_contactos)} emails enviados.")
# Uso
contactos = [
{"nombre": "Ana Garcia", "email": "ana@ejemplo.com", "empresa": "TechCorp"},
{"nombre": "Carlos Lopez", "email": "carlos@ejemplo.com", "empresa": "DataInc"},
{"nombre": "Maria Torres", "email": "maria@ejemplo.com", "empresa": "CloudSoft"},
]
plantilla = """
<h2>Hola {nombre},</h2>
<p>Te escribimos para informarte sobre las novedades de este mes.</p>
<p>Sabemos que en <strong>{empresa}</strong> valoran la eficiencia,
por eso preparamos este resumen especialmente para ti.</p>
<p>Saludos cordiales.</p>
"""
enviar_emails_masivos(
contactos,
asunto="Novedades de abril 2026",
plantilla_html=plantilla,
remitente="tu_correo@gmail.com",
password="tu_contrasena_de_aplicacion",
)La funcion enviar_emails_masivos recorre la lista de contactos y personaliza cada correo reemplazando las variables {nombre} y {empresa} en la plantilla HTML. Esto te permite enviar correos que se sienten individuales aunque sean generados automaticamente.
Ejemplo 3: Leer y procesar archivos Excel
Procesar archivos Excel es una de las tareas mas comunes en oficinas y departamentos de datos. La libreria pandas hace que leer, filtrar, transformar y guardar datos de Excel sea extremadamente sencillo.
Primero, instala las dependencias necesarias:
pip install pandas openpyxlAhora veamos un ejemplo completo que lee un archivo de ventas, filtra los datos, calcula totales y genera un reporte resumido en un nuevo archivo Excel:
import pandas as pd
from datetime import datetime
def procesar_ventas(archivo_entrada, archivo_salida):
"""Lee un Excel de ventas, filtra datos relevantes,
calcula metricas y genera un reporte resumido."""
# Leer el archivo Excel
df = pd.read_excel(archivo_entrada, sheet_name="Ventas")
print(f"Registros leidos: {len(df)}")
# Asegurarse de que la columna de fecha sea datetime
df["fecha"] = pd.to_datetime(df["fecha"])
# Filtrar solo ventas del ultimo mes
hace_un_mes = datetime.now() - pd.Timedelta(days=30)
df_reciente = df[df["fecha"] >= hace_un_mes].copy()
print(f"Ventas del ultimo mes: {len(df_reciente)}")
# Calcular el monto total por cada venta
df_reciente["total"] = df_reciente["cantidad"] * df_reciente["precio_unitario"]
# Resumen por producto
resumen_producto = (
df_reciente.groupby("producto")
.agg(
unidades_vendidas=("cantidad", "sum"),
ingreso_total=("total", "sum"),
precio_promedio=("precio_unitario", "mean"),
num_ventas=("total", "count"),
)
.sort_values("ingreso_total", ascending=False)
.reset_index()
)
# Resumen por vendedor
resumen_vendedor = (
df_reciente.groupby("vendedor")
.agg(
ventas_realizadas=("total", "count"),
ingreso_total=("total", "sum"),
)
.sort_values("ingreso_total", ascending=False)
.reset_index()
)
# Guardar en un nuevo Excel con multiples hojas
with pd.ExcelWriter(archivo_salida, engine="openpyxl") as writer:
df_reciente.to_excel(writer, sheet_name="Detalle", index=False)
resumen_producto.to_excel(writer, sheet_name="Por Producto", index=False)
resumen_vendedor.to_excel(writer, sheet_name="Por Vendedor", index=False)
total_general = df_reciente["total"].sum()
print(f"Ingreso total del mes: ${total_general:,.2f}")
print(f"Reporte guardado en: {archivo_salida}")
# Uso
procesar_ventas("ventas_2026.xlsx", "reporte_mensual_abril.xlsx")Este script toma un archivo Excel con columnas como fecha, producto, cantidad, precio_unitario y vendedor, y genera un archivo nuevo con tres hojas: el detalle filtrado, un resumen por producto y un resumen por vendedor. Lo que antes tomaba una hora de trabajo manual en Excel ahora toma 2 segundos.
Ejemplo 4: Web scraping basico
El web scraping consiste en extraer datos de paginas web de forma automatica. Es util para monitorear precios, recopilar informacion de productos, extraer noticias o cualquier dato publicado en la web. Las librerias requests y BeautifulSoup son la combinacion clasica para esta tarea.
pip install requests beautifulsoup4Veamos un ejemplo que extrae los titulos y precios de productos de una pagina web de ejemplo:
import requests
from bs4 import BeautifulSoup
import csv
from datetime import datetime
def extraer_productos(url, archivo_salida="productos.csv"):
"""Extrae nombres y precios de productos de una pagina web
y los guarda en un archivo CSV."""
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/120.0.0.0 Safari/537.36"
}
print(f"Descargando pagina: {url}")
respuesta = requests.get(url, headers=headers, timeout=30)
respuesta.raise_for_status()
soup = BeautifulSoup(respuesta.text, "html.parser")
# Buscar elementos de productos (ajustar selectores segun la pagina)
productos = []
for item in soup.select(".product-item"):
nombre = item.select_one(".product-title")
precio = item.select_one(".product-price")
if nombre and precio:
productos.append({
"nombre": nombre.get_text(strip=True),
"precio": precio.get_text(strip=True),
"fecha_extraccion": datetime.now().strftime("%Y-%m-%d %H:%M"),
})
print(f"Productos encontrados: {len(productos)}")
# Guardar en CSV
if productos:
with open(archivo_salida, "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=productos[0].keys())
writer.writeheader()
writer.writerows(productos)
print(f"Datos guardados en: {archivo_salida}")
return productos
def monitorear_precio(url, selector_precio, precio_objetivo):
"""Verifica si el precio de un producto bajo del umbral deseado."""
headers = {"User-Agent": "Mozilla/5.0"}
respuesta = requests.get(url, headers=headers, timeout=30)
soup = BeautifulSoup(respuesta.text, "html.parser")
elemento_precio = soup.select_one(selector_precio)
if not elemento_precio:
print("No se encontro el elemento de precio.")
return False
# Extraer el numero del texto del precio
texto_precio = elemento_precio.get_text(strip=True)
precio_actual = float(
texto_precio.replace("$", "").replace(",", "").replace("S/", "").strip()
)
print(f"Precio actual: ${precio_actual:.2f}")
print(f"Precio objetivo: ${precio_objetivo:.2f}")
if precio_actual <= precio_objetivo:
print("El precio alcanzo el objetivo.")
return True
else:
diferencia = precio_actual - precio_objetivo
print(f"Faltan ${diferencia:.2f} para el objetivo.")
return False
# Uso
productos = extraer_productos("https://ejemplo.com/tienda")
# Monitorear un producto especifico
bajo_precio = monitorear_precio(
url="https://ejemplo.com/producto/laptop-x",
selector_precio=".price-current",
precio_objetivo=899.99,
)El primer ejemplo extrae una lista de productos completa y la guarda en CSV. El segundo monitorea el precio de un producto especifico y te indica si alcanzo tu precio objetivo. Puedes combinar esto con el ejemplo anterior de emails para recibir una notificacion automatica cuando baje el precio.
Nota importante: siempre revisa los terminos de uso del sitio web antes de hacer scraping. Muchos sitios permiten la extraccion de datos publicos, pero algunos lo prohiben en sus terminos de servicio. Respeta tambien el archivo robots.txt del sitio y no envies demasiadas peticiones en poco tiempo.
Ejemplo 5: Hacer backup automatico de carpetas
Perder archivos importantes por no tener una copia de seguridad es uno de los errores mas comunes y evitables. Con Python puedes crear un script que comprima tus carpetas de trabajo en un archivo ZIP con timestamp y lo copie a una ubicacion segura.
import os
import shutil
import zipfile
from datetime import datetime
from pathlib import Path
def crear_backup(carpetas_origen, directorio_destino, nombre_backup="backup"):
"""Crea un archivo ZIP con el contenido de una o varias carpetas.
El nombre del archivo incluye un timestamp para identificarlo."""
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
nombre_archivo = f"{nombre_backup}_{timestamp}.zip"
ruta_zip = os.path.join(directorio_destino, nombre_archivo)
# Crear el directorio de destino si no existe
os.makedirs(directorio_destino, exist_ok=True)
print(f"Creando backup: {nombre_archivo}")
archivos_totales = 0
with zipfile.ZipFile(ruta_zip, "w", zipfile.ZIP_DEFLATED) as zf:
for carpeta in carpetas_origen:
carpeta_path = Path(carpeta)
if not carpeta_path.exists():
print(f" AVISO: La carpeta {carpeta} no existe, se omite.")
continue
print(f" Procesando: {carpeta}")
for archivo in carpeta_path.rglob("*"):
if archivo.is_file():
# Guardar con ruta relativa dentro del ZIP
arcname = os.path.join(
carpeta_path.name, archivo.relative_to(carpeta_path)
)
zf.write(archivo, arcname)
archivos_totales += 1
tamano_mb = os.path.getsize(ruta_zip) / (1024 * 1024)
print(f"\nBackup completado:")
print(f" Archivo: {ruta_zip}")
print(f" Archivos incluidos: {archivos_totales}")
print(f" Tamano: {tamano_mb:.1f} MB")
return ruta_zip
def limpiar_backups_antiguos(directorio_destino, conservar=5):
"""Elimina los backups mas antiguos, conservando solo los N mas recientes."""
archivos_zip = sorted(
Path(directorio_destino).glob("backup_*.zip"),
key=lambda f: f.stat().st_mtime,
reverse=True,
)
if len(archivos_zip) <= conservar:
print(f"Hay {len(archivos_zip)} backups, no es necesario limpiar.")
return
antiguos = archivos_zip[conservar:]
for archivo in antiguos:
archivo.unlink()
print(f" Eliminado backup antiguo: {archivo.name}")
print(f"Se eliminaron {len(antiguos)} backups antiguos.")
# Uso
carpetas_a_respaldar = [
"/home/usuario/documentos",
"/home/usuario/proyectos",
"/home/usuario/scripts",
]
ruta_backup = crear_backup(
carpetas_origen=carpetas_a_respaldar,
directorio_destino="/home/usuario/backups",
nombre_backup="backup",
)
# Mantener solo los 5 backups mas recientes
limpiar_backups_antiguos("/home/usuario/backups", conservar=5)Este script comprime las carpetas indicadas en un archivo ZIP con nombre que incluye fecha y hora. Ademas, la funcion limpiar_backups_antiguos se encarga de eliminar los backups mas viejos para que no se acumule espacio en disco innecesariamente. Puedes configurar cuantos backups conservar con el parametro conservar.
Bonus: Programar tareas con cron o Task Scheduler
Tener scripts de automatizacion es solo la mitad del trabajo. Para que la automatizacion sea realmente completa, necesitas que estos scripts se ejecuten solos, sin que tengas que acordarte de hacerlo manualmente. Aqui es donde entran cron (Linux/macOS) y Task Scheduler (Windows).
En Linux o macOS, puedes usar crontab para programar la ejecucion automatica. Por ejemplo, para ejecutar el script de backup todos los viernes a las 6 de la tarde:
# Abrir el editor de crontab
crontab -e
# Agregar esta linea para ejecutar el backup cada viernes a las 18:00
0 18 * * 5 /usr/bin/python3 /home/usuario/scripts/backup.py >> /home/usuario/logs/backup.log 2>&1
# Otros ejemplos utiles:
# Cada dia a las 8:00 AM - enviar reporte por email
0 8 * * * /usr/bin/python3 /home/usuario/scripts/enviar_reporte.py
# Cada hora - monitorear precios
0 * * * * /usr/bin/python3 /home/usuario/scripts/monitorear_precios.py
# Cada lunes a las 9:00 AM - procesar ventas semanales
0 9 * * 1 /usr/bin/python3 /home/usuario/scripts/procesar_ventas.pyEn Windows, puedes usar el Programador de Tareas (Task Scheduler). Abre una terminal de PowerShell como administrador y ejecuta:
# Crear tarea programada en Windows (PowerShell)
schtasks /create /tn "BackupSemanal" /tr "python C:\scripts\backup.py" /sc weekly /d FRI /st 18:00Tambien puedes usar la libreria schedule de Python si prefieres manejar la programacion desde el propio script, aunque esta opcion requiere que el script este corriendo permanentemente:
import schedule
import time
def tarea_backup():
print("Ejecutando backup...")
# Aqui va la logica del backup
def tarea_reporte():
print("Generando reporte...")
# Aqui va la logica del reporte
# Programar tareas
schedule.every().friday.at("18:00").do(tarea_backup)
schedule.every().day.at("08:00").do(tarea_reporte)
schedule.every(2).hours.do(lambda: print("Verificando precios..."))
print("Scheduler iniciado. Presiona Ctrl+C para detener.")
while True:
schedule.run_pending()
time.sleep(60)Conclusion
Python es una herramienta extraordinaria para eliminar tareas repetitivas de tu rutina diaria. Los cinco ejemplos que vimos en este articulo cubren escenarios que aparecen constantemente en el trabajo de oficina, administracion de sistemas y gestion de datos:
- Renombrar archivos masivamente con patrones personalizados y fechas automaticas
- Enviar emails automaticos personalizados a listas de contactos
- Procesar archivos Excel para generar reportes resumidos sin trabajo manual
- Extraer datos de paginas web para monitorear precios o recopilar informacion
- Crear backups automaticos comprimidos con limpieza de archivos antiguos
La clave esta en identificar las tareas que haces de forma repetitiva, escribir un script que las resuelva y programar su ejecucion automatica con cron o Task Scheduler. Cada script que creas te ahorra minutos u horas cada semana, y ese tiempo se acumula de forma significativa a lo largo del ano.
Empieza por el ejemplo que mas se acerque a tu necesidad actual, adaptalo a tu caso particular y ve construyendo tu propia coleccion de scripts de automatizacion. Con el tiempo, tendras un arsenal de herramientas que trabajan por ti mientras te concentras en lo que realmente importa.