Microcurso práctico para automatizar tus flujos de trabajo
La automatización de tareas es el proceso de crear sistemas que ejecuten trabajos repetitivos sin intervención humana. Python es ideal para automatización debido a su sintaxis clara y gran ecosistema de librerías.
# Ejemplos de tareas automatizables:
1. Procesamiento y transformación de datos
2. Extracción de información de sitios web (web scraping)
3. Manipulación de archivos y carpetas
4. Envío automatizado de emails
5. Ejecución programada de tareas
6. Interacción con APIs
7. Generación de reportes
8. Monitoreo de sistemas
Nota: Antes de automatizar, evalúa si el tiempo invertido en crear el script se justifica por el tiempo que ahorrará a futuro.
Piensa en 3 tareas repetitivas que realizas en tu trabajo o estudios que podrían automatizarse. Anótalas para considerarlas más adelante en el curso.
Para comenzar a automatizar con Python, necesitamos configurar correctamente nuestro entorno de desarrollo.
Descarga la última versión de Python desde python.org. Durante la instalación:
# En Windows abre CMD, en Mac/Linux abre Terminal
python --version
# Deberías ver algo como: Python 3.9.7
Es buena práctica usar entornos virtuales para aislar las dependencias de cada proyecto:
# Crear un entorno virtual
python -m venv mi_entorno
# Activar el entorno (Windows)
mi_entorno\Scripts\activate
# Activar el entorno (Mac/Linux)
source mi_entorno/bin/activate
Importante: Siempre activa tu entorno virtual antes de instalar paquetes o ejecutar tus scripts de automatización.
VS Code es una excelente opción con gran soporte para Python:
Una de las automatizaciones más útiles es la manipulación de archivos y directorios.
import os # Para operaciones del sistema operativo
import shutil # Para operaciones de archivos avanzadas
import glob # Para búsqueda de archivos con patrones
Listar archivos en un directorio:
archivos = os.listdir('mi_directorio')
for archivo in archivos:
print(archivo)
Crear un directorio si no existe:
if not os.path.exists('nuevo_directorio'):
os.makedirs('nuevo_directorio')
Mover todos los archivos de un tipo a otra carpeta:
for archivo in glob.glob('*.txt'):
shutil.move(archivo, 'directorio_destino')
Crea un script que:
Tip: Usa os.path.join() para crear rutas compatibles con cualquier
sistema operativo.
Pandas es la librería más popular para manipulación y análisis de datos en Python.
pip install pandas
Leer un archivo CSV:
import pandas as pd
df = pd.read_csv('datos.csv')
print(df.head())
Procesamiento básico:
# Filtrar datos
ventas_altas = df[df['ventas'] > 1000]
# Agrupar datos
ventas_por_region = df.groupby('region')['ventas'].sum()
# Aplicar transformaciones
df['ventas_con_iva'] = df['ventas'] * 1.16
Generar reporte automatizado:
# Crear un resumen estadístico
resumen = df.describe()
# Guardar en Excel
with pd.ExcelWriter('reporte.xlsx') as writer:
df.to_excel(writer, sheet_name='Datos Completos')
resumen.to_excel(writer, sheet_name='Resumen')
Excelente uso: Puedes programar este script para que se ejecute diariamente y siempre tengas reportes actualizados.
Enviar emails automáticamente puede ahorrarte mucho tiempo en comunicaciones rutinarias.
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
def enviar_email(destinatario, asunto, cuerpo):
# Configuración
remitente = 'tu_email@gmail.com'
password = 'tu_contraseña' # Considera usar variables de entorno
# Crear mensaje
mensaje = MIMEMultipart()
mensaje['From'] = remitente
mensaje['To'] = destinatario
mensaje['Subject'] = asunto
mensaje.attach(MIMEText(cuerpo, 'plain'))
# Enviar email
with smtplib.SMTP('smtp.gmail.com', 587) as server:
server.starttls()
server.login(remitente, password)
server.send_message(mensaje)
print(f"Email enviado a {destinatario}")
# Uso
enviar_email('cliente@example.com', 'Recordatorio de pago', 'Estimado cliente...')
Seguridad: Nunca dejes contraseñas hardcodeadas en tus scripts. Usa variables de entorno o un gestor de secretos.
# Leer datos de destinatarios
import pandas as pd
datos = pd.read_csv('clientes.csv')
# Enviar email a cada cliente
for _, fila in datos.iterrows():
cuerpo = f"""Estimado {fila['nombre']},
Su factura por ${fila['monto']} vence el {fila['fecha_vencimiento']}.
Por favor realice el pago a tiempo.
Saludos."""
enviar_email(fila['email'], 'Recordatorio de pago', cuerpo)
Extraer información de sitios web automáticamente puede ser muy útil para monitoreo o recolección de datos.
pip install requests beautifulsoup4
import requests
from bs4 import BeautifulSoup
url = 'https://ejemplo.com/noticias'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
# Extraer todos los títulos de noticias
titulares = soup.find_all('h2', class_='titular-noticia')
for titular in titulares:
print(titular.text.strip())
Ética del web scraping: Siempre revisa el archivo robots.txt del sitio (ej. https://ejemplo.com/robots.txt) y respeta las reglas de scraping del sitio.
import csv
with open('noticias.csv', 'w', newline='', encoding='utf-8') as file:
writer = csv.writer(file)
writer.writerow(['Título', 'Enlace'])
for titular in titulares:
enlace = titular.find('a')['href']
writer.writerow([titular.text.strip(), enlace])
Crea un script que:
Podemos programar la ejecución automática de nuestros scripts en horarios específicos.
Edita tu crontab:
crontab -e
Agrega una línea como esta (ejecuta diario a las 9am):
0 9 * * * /ruta/a/python /ruta/a/tu/script.py
pip install schedule
import schedule
import time
def tarea_diaria():
print("Ejecutando tarea programada...")
# Aquí va tu código de automatización
# Programar la tarea
schedule.every().day.at("09:00").do(tarea_diaria)
# Bucle para mantener el script corriendo
while True:
schedule.run_pending()
time.sleep(60)
Nota: Para scripts de larga duración con schedule, considera usar un proceso en segundo plano o un servidor.
Las APIs permiten interactuar con servicios web de manera programática.
import requests
url = "https://api.ejemplo.com/data"
params = {
"api_key": "tu_api_key",
"fecha": "2023-01-01"
}
response = requests.get(url, params=params)
datos = response.json()
print(datos)
def obtener_clima(ciudad):
api_key = "tu_api_key" # Usa variables de entorno
url = f"http://api.openweathermap.org/data/2.5/weather?q={ciudad}&appid={api_key}&units=metric"
response = requests.get(url)
if response.status_code == 200:
datos = response.json()
temp = datos['main']['temp']
return f"La temperatura en {ciudad} es {temp}°C"
else:
return "No se pudo obtener el clima"
# Uso
print(obtener_clima("Madrid"))
# Ejemplo: Monitoreo de precios de criptomonedas
import time
def monitorear_cripto(cripto, limite):
while True:
url = f"https://api.coingecko.com/api/v3/simple/price?ids={cripto}&vs_currencies=usd"
response = requests.get(url)
precio = response.json()[cripto]['usd']
if precio < limite:
enviar_email("tu_email@example.com",
f"Alerta de precio: {cripto}",
f"El precio de {cripto} ha bajado a ${precio}")
time.sleep(3600) # Esperar 1 hora
Combinando múltiples técnicas para flujos de trabajo complejos.
import pandas as pd
import smtplib
from datetime import datetime
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.application import MIMEApplication
def generar_reporte():
# 1. Leer datos
ventas = pd.read_csv('ventas_diarias.csv')
# 2. Procesar datos
resumen = ventas.groupby('region').agg({
'ventas': 'sum',
'clientes': 'nunique'
})
resumen['venta_por_cliente'] = resumen['ventas'] / resumen['clientes']
# 3. Generar Excel
fecha = datetime.now().strftime('%Y-%m-%d')
nombre_archivo = f"reporte_ventas_{fecha}.xlsx"
resumen.to_excel(nombre_archivo)
return nombre_archivo
def enviar_reporte(destinatarios, archivo):
msg = MIMEMultipart()
msg['From'] = 'reportes@empresa.com'
msg['To'] = ", ".join(destinatarios)
msg['Subject'] = f"Reporte de ventas {datetime.now().strftime('%d/%m/%Y')}"
cuerpo = "Adjunto encontrarás el reporte diario de ventas."
msg.attach(MIMEText(cuerpo, 'plain'))
with open(archivo, 'rb') as f:
attach = MIMEApplication(f.read(), _subtype="xlsx")
attach.add_header('Content-Disposition', 'attachment', filename=archivo)
msg.attach(attach)
with smtplib.SMTP('smtp.empresa.com', 587) as server:
server.send_message(msg)
# Ejecutar
archivo_reporte = generar_reporte()
enviar_reporte(['gerente@empresa.com', 'ventas@empresa.com'], archivo_reporte)
Para tareas que requieren interacción con aplicaciones de escritorio, podemos usar PyAutoGUI:
pip install pyautogui
import pyautogui
import time
# Ejemplo: Automatizar entrada de datos en una aplicación
def llenar_formulario(datos):
# Dar tiempo para cambiar a la aplicación
time.sleep(5)
for campo, valor in datos.items():
pyautogui.write(str(valor))
pyautogui.press('tab')
pyautogui.press('enter')
# Uso
datos_formulario = {
'nombre': 'Juan Pérez',
'email': 'juan@example.com',
'telefono': '5551234567'
}
llenar_formulario(datos_formulario)
Para mantener tus scripts de automatización efectivos y mantenibles.
import logging
# Configurar logging
logging.basicConfig(
filename='automation.log',
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
def tarea_automatizada():
try:
logging.info("Iniciando tarea automatizada")
# Código de la tarea
logging.info("Tarea completada exitosamente")
except Exception as e:
logging.error(f"Error en tarea automatizada: {str(e)}")