Como alguien que ha pasado más de una década en el mundo de la programación, he aprendido que automatizar tareas repetitivas puede ahorrar una cantidad significativa de tiempo y esfuerzo.
Python, con su sintaxis simple y potentes bibliotecas, es uno de los mejores lenguajes de programación para crear scripts de automatización. Ya sea que seas un programador o alguien que busca facilitar las tareas diarias, Python tiene herramientas que pueden ayudarte.
En este artículo, compartiré 21 scripts de Python que he utilizado para automatizar diversas tareas. Estos scripts son perfectos para cualquiera que quiera ahorrar tiempo y mejorar la eficiencia en su rutina de trabajo.
1. Renombrar Archivos en Masa
Renombrar archivos uno por uno puede ser una tarea que consume mucho tiempo, pero con Python, puedes automatizar esto fácilmente usando el módulo os.
Aquí tienes un script simple que renombra múltiples archivos en una carpeta basado en un patrón dado:
import os
def bulk_rename(folder_path, old_name_part, new_name_part):
for filename in os.listdir(folder_path):
if old_name_part in filename:
new_filename = filename.replace(old_name_part, new_name_part)
os.rename(os.path.join(folder_path, filename), os.path.join(folder_path, new_filename))
print(f"Renamed {filename} to {new_filename}")
folder = '/path/to/your/folder' bulk_rename(folder, 'old_part', 'new_part')
Este script busca archivos que contengan old_name_part en sus nombres y los reemplaza con new_name_part.
2. Respaldar Archivos Automáticamente
Todos sabemos lo importante que es respaldar archivos regularmente, y esta tarea se puede automatizar fácilmente usando el módulo shutil de Python.
Este script copiará todos los archivos de un directorio a otro con fines de respaldo:
import shutil
import os
def backup_files(src_dir, dest_dir):
if not os.path.exists(dest_dir):
os.makedirs(dest_dir)
for file in os.listdir(src_dir):
full_file_name = os.path.join(src_dir, file)
if os.path.isfile(full_file_name):
shutil.copy(full_file_name, dest_dir)
print(f"Backed up {file} to {dest_dir}")
source = '/path/to/source/directory' destination = '/path/to/destination/directory' backup_files(source, destination)
Puedes programar este script para que se ejecute diariamente utilizando herramientas de programación de tareas como cron (Linux) o Task Scheduler (Windows).
3. Descarga de Archivos de Internet
Si frecuentemente descargas archivos de internet, puedes automatizar esta tarea utilizando la biblioteca aiohttp.
Aquí tienes un script simple para descargar archivos desde URLs:
import aiohttp
import asyncio
import aiofiles
async def download_file(url, filename):
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
async with aiofiles.open(filename, 'wb') as file:
await file.write(await response.read())
print(f"Downloaded {filename}")
urls = {
'https://example.com/file1.zip': 'file1.zip',
'https://example.com/file2.zip': 'file2.zip'
}
async def download_all():
tasks = [download_file(url, filename) for url, filename in urls.items()]
await asyncio.gather(*tasks)
asyncio.run(download_all())
Este script descarga el archivo de la URL especificada y lo guarda en tu carpeta designada.
4. Automatización de Informes por Correo Electrónico
Si necesitas enviar informes por correo electrónico regularmente, puedes automatizarlo utilizando la biblioteca smtplib, que te permite enviar correos desde una cuenta de Gmail fácilmente:
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
def send_email(subject, body, to_email):
sender_email = '[email protected]'
sender_password = 'yourpassword'
receiver_email = to_email
msg = MIMEMultipart()
msg['From'] = sender_email
msg['To'] = receiver_email
msg['Subject'] = subject
msg.attach(MIMEText(body, 'plain'))
try:
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(sender_email, sender_password)
server.sendmail(sender_email, receiver_email, msg.as_string())
server.quit()
print("Email sent successfully!")
except Exception as e:
print(f"Failed to send email: {e}")
subject = 'Monthly Report'
body = 'Here is the monthly report.'
send_email(subject, body, '[email protected]')
Este script enviará un correo simple con un asunto y cuerpo a un destinatario especificado. Asegúrate de habilitar aplicaciones menos seguras en Gmail si utilizas este método.
5. Programador de Tareas (Automatización de Tareas)
La programación de tareas se puede hacer fácilmente utilizando la biblioteca schedule, que te permite automatizar tareas como enviar un correo electrónico o ejecutar un script de respaldo a horas específicas:
import schedule
import time
def job():
print("Running scheduled task!")
# Schedule the task to run every day at 10:00 AM
schedule.every().day.at("10:00").do(job)
while True:
schedule.run_pending()
time.sleep(1)
Este script seguirá ejecutándose y activará tareas a la hora especificada, en este caso, 10:00 AM todos los días.
6. Web Scraping para Recolección de Datos
Usar aiohttp para solicitudes HTTP asíncronas en lugar de la biblioteca síncrona requests puede hacer que el web scraping sea más eficiente.
Este ejemplo recupera varias páginas en paralelo.
import aiohttp
import asyncio
from bs4 import BeautifulSoup
async def fetch(session, url):
async with session.get(url) as response:
return await response.text()
async def scrape(urls):
async with aiohttp.ClientSession() as session:
tasks = [fetch(session, url) for url in urls]
html_pages = await asyncio.gather(*tasks)
for html in html_pages:
soup = BeautifulSoup(html, 'html.parser')
print(soup.title.string)
urls = ['https://example.com/page1', 'https://example.com/page2'] asyncio.run(scrape(urls))
7. Automatización de Publicaciones en Redes Sociales
Si gestionas cuentas en redes sociales, puedes automatizar las publicaciones utilizando bibliotecas como Tweepy (para Twitter) y Instagram-API (para Instagram) que te permiten publicar automáticamente.
A continuación se muestra un ejemplo utilizando la biblioteca Tweepy para publicar un tuit:
import tweepy
def tweet(message):
consumer_key = 'your_consumer_key'
consumer_secret = 'your_consumer_secret'
access_token = 'your_access_token'
access_token_secret = 'your_access_token_secret'
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
api.update_status(message)
print("Tweet sent successfully!")
tweet("Hello, world!")
Este script publica un tuit con el mensaje “¡Hola, mundo!” en tu cuenta de Twitter.
8. Automatización de Generación de Facturas
Si generas facturas regularmente, puedes automatizarlo utilizando bibliotecas como Fpdf, que creará facturas en PDF:
from fpdf import FPDF
def create_invoice(client_name, amount):
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=12)
pdf.cell(200, 10, txt="Invoice", ln=True, align='C')
pdf.cell(200, 10, txt=f"Client: {client_name}", ln=True, align='L')
pdf.cell(200, 10, txt=f"Amount: ${amount}", ln=True, align='L')
pdf.output(f"{client_name}_invoice.pdf")
print(f"Invoice for {client_name} created successfully!")
create_invoice('John Doe', 500)
Este script crea una factura simple y la guarda como PDF.
9. Monitoreo del Tiempo de Actividad del Sitio Web
Python se puede utilizar para automatizar el monitoreo del tiempo de actividad del sitio web utilizando la biblioteca requests, que puede verificar periódicamente si un sitio web está en línea o no:
import requests
import time
def check_website(url):
try:
response = requests.get(url)
if response.status_code == 200:
print(f"Website {url} is up!")
else:
print(f"Website {url} returned a status code {response.status_code}")
except requests.exceptions.RequestException as e:
print(f"Error checking website {url}: {e}")
url = 'https://example.com' while True: check_website(url) time.sleep(3600) # Check every hour
Este script verifica si el sitio web está en línea e imprime el código de estado.
10. Respuesta Automática a Correos Electrónicos
Si a menudo recibes correos electrónicos y deseas configurar una respuesta automática, utiliza las bibliotecas imaplib y smtplib para responder automáticamente a los correos electrónicos:
import imaplib
import smtplib
from email.mime.text import MIMEText
def auto_reply():
# Connect to email server
mail = imaplib.IMAP4_SSL("imap.gmail.com")
mail.login('[email protected]', 'yourpassword')
mail.select('inbox')
# Search for unread emails
status, emails = mail.search(None, 'UNSEEN')
if status == "OK":
for email_id in emails[0].split():
status, email_data = mail.fetch(email_id, '(RFC822)')
email_msg = email_data[0][1].decode('utf-8')
# Send auto-reply
send_email("Auto-reply", "Thank you for your email. I'll get back to you soon.", '[email protected]')
def send_email(subject, body, to_email):
sender_email = '[email protected]'
sender_password = 'yourpassword'
receiver_email = to_email
msg = MIMEText(body)
msg['From'] = sender_email
msg['To'] = receiver_email
msg['Subject'] = subject
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login(sender_email, sender_password)
server.sendmail(sender_email, receiver_email, msg.as_string())
auto_reply()
Este script responde automáticamente a los correos electrónicos no leídos con un mensaje predefinido.
11. Limpieza de Archivos
Python proporciona una forma efectiva de automatizar la limpieza de archivos, especialmente para eliminar o mover archivos antiguos para mantener directorios organizados.
A continuación se muestra un script simple que elimina archivos más antiguos que un número especificado de días utilizando los módulos os y time.
import aiofiles
import os
import asyncio
import time
async def clean_up(folder_path, days_old):
now = time.time()
cutoff_time = now - (days_old * 86400)
for filename in os.listdir(folder_path):
file_path = os.path.join(folder_path, filename)
if os.path.getmtime(file_path) < cutoff_time:
await aiofiles.os.remove(file_path)
print(f"Deleted {filename}")
folder = '/path/to/your/folder'
asyncio.run(clean_up(folder, 30))
12. Generar Contraseñas Automáticamente
Crear contraseñas fuertes y únicas es esencial para la seguridad, y Python puede ayudar a automatizar este proceso utilizando el módulo random.
A continuación se muestra un script simple que genera contraseñas aleatorias de una longitud especificada, incorporando letras, dígitos y caracteres especiales para mejorar la seguridad.
import random
import asyncio
import string
async def generate_password(length=12):
characters = string.ascii_letters + string.digits + string.punctuation
password = ''.join(random.choice(characters) for _ in range(length))
return password
async def generate_multiple_passwords(n, length=12):
tasks = [generate_password(length) for _ in range(n)]
passwords = await asyncio.gather(*tasks)
print(passwords)
asyncio.run(generate_multiple_passwords(5))
13. Seguimiento de Tareas/Recordatorio
Crear un sistema de seguimiento de tareas o recordatorios en Python se puede lograr utilizando los módulos datetime y asyncio.
import asyncio
from datetime import datetime
async def task_reminder(task_name, interval):
while True:
print(f"Reminder: {task_name} - {datetime.now()}")
await asyncio.sleep(interval)
async def main():
await asyncio.gather(
task_reminder("Drink Water", 7200), # Remind every 2 hours
task_reminder("Take a Break", 3600) # Remind every 1 hour
)
asyncio.run(main())
Este script envía un recordatorio sobre la tarea en un horario programado.
14. Auto-Generar Informes Diarios
Automatice los informes diarios utilizando Python para recopilar datos y formatearlos en un informe:
import datetime
import aiofiles
import asyncio
async def generate_report(data):
today = datetime.date.today()
filename = f"daily_report_{today}.txt"
async with aiofiles.open(filename, 'w') as file:
await file.write(f"Report for {today}\n")
await file.write("\n".join(data))
print(f"Report generated: {filename}")
data = ["Task 1: Completed", "Task 2: Pending", "Task 3: Completed"]
asyncio.run(generate_report(data))
15. Monitorear Recursos del Sistema
Si eres un administrador de sistemas, puedes utilizar Python para monitorear los recursos de tu sistema como uso de CPU y memoria, con la ayuda de la biblioteca psutil.
import psutil
def monitor_resources():
cpu_usage = psutil.cpu_percent(interval=1)
memory_usage = psutil.virtual_memory().percent
print(f"CPU Usage: {cpu_usage}%")
print(f"Memory Usage: {memory_usage}%")
monitor_resources()
16. Cambiar el Tamaño de Imágenes por Lote
Si necesitas cambiar el tamaño de imágenes en masa, Python lo hace fácil con la biblioteca Pillow.
from PIL import Image
import os
import asyncio
from concurrent.futures import ProcessPoolExecutor
def resize_image(filename, width, height):
img = Image.open(filename)
img = img.resize((width, height))
img.save(f"resized_{filename}")
return f"Resized {filename}"
async def resize_images(folder_path, width, height):
with ProcessPoolExecutor() as executor:
loop = asyncio.get_event_loop()
tasks = []
for filename in os.listdir(folder_path):
if filename.endswith('.jpg'):
tasks.append(loop.run_in_executor(
executor, resize_image, os.path.join(folder_path, filename), width, height))
results = await asyncio.gather(*tasks)
print(results)
folder = '/path/to/your/images'
asyncio.run(resize_images(folder, 800, 600))
Este script redimensiona todas las imágenes .jpg en una carpeta a las dimensiones especificadas.
17. Automatización de Copias de Seguridad en la Nube
Automatizar copias de seguridad en servicios en la nube como Google Drive es posible con Python usando bibliotecas como pydrive.
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
def backup_to_google_drive(file_path):
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
drive = GoogleDrive(gauth)
file = drive.CreateFile({'title': 'backup_file.txt'})
file.Upload()
print("Backup uploaded successfully!")
file = '/path/to/your/file.txt' backup_to_google_drive(file)
18. Crear Recordatorios Diarios
Configurar recordatorios diarios es fácil con el módulo time, que te recordará beber agua cada 2 horas:
import time
def water_reminder():
while True:
print("Time to drink water!")
time.sleep(7200) # Remind every 2 hours
water_reminder()
19. Automatización de Entrada de Datos en Excel
Si frecuentemente ingresas datos en Excel, Python puede ayudar a automatizar esta tarea con la biblioteca openpyxl:
from openpyxl import Workbook
def create_excel(data):
wb = Workbook()
ws = wb.active
for row in data:
ws.append(row)
wb.save('data.xlsx')
print("Excel file created successfully!")
data = [
["Name", "Age", "City"],
["John", 30, "New York"],
["Anna", 25, "London"],
]
create_excel(data)
20. Automatización de Limpieza de Datos
Si trabajas con grandes conjuntos de datos, Python puede automatizar tareas de limpieza de datos, lo que eliminará filas vacías de un archivo CSV:
import csv
def clean_csv(file_path):
with open(file_path, 'r') as infile:
reader = csv.reader(infile)
rows = [row for row in reader if any(row)]
with open(file_path, 'w', newline='') as outfile:
writer = csv.writer(outfile)
writer.writerows(rows)
print("Empty rows removed from CSV")
file = '/path/to/your/data.csv' clean_csv(file)
21. Extracción de Texto de Imágenes
Python puede ser usado para extraer texto de imágenes usando la biblioteca pytesseract, lo cual puede ser útil cuando necesitas digitalizar contenido impreso o extraer texto de documentos escaneados.
from PIL import Image
import pytesseract
def extract_text_from_image(image_path):
# Open the image file
img = Image.open(image_path)
# Use pytesseract to extract text
text = pytesseract.image_to_string(img)
return text
image_path = 'path_to_your_image.jpg'
extracted_text = extract_text_from_image(image_path)
print("Extracted Text:\n", extracted_text)
Conclusión
Estos son solo algunos ejemplos de lo que Python puede hacer para automatizar tus tareas diarias. Con su sintaxis simple y poderosas bibliotecas, Python puede manejar casi cualquier tarea que le propongas.
Ya sea que estés gestionando archivos, enviando correos electrónicos o generando informes, Python puede ahorrarte tiempo y mejorar tu productividad. ¡Así que comienza con la automatización en Python hoy mismo y deja que se encargue de tus tareas diarias!