Python pentru automatizarea task-urilor zilnice

Introducere

Python este unul dintre cele mai populare limbaje pentru automatizare datorită sintaxei simple și ecosistemului bogat de librării. În acest articol, vom explora cum să folosești Python pentru a automatiza diverse task-uri zilnice.

De ce Python pentru automatizare?

Avantaje cheie:

1. Sintaxă simplă și intuitivă - Ușor de învățat și citit
2. Ecosistem bogat - Mii de librării pentru orice task
3. Cross-platform - Funcționează pe Windows, Mac și Linux
4. Comunitate activă - Suport excelent și documentație

Librării esențiale pentru automatizare

1. Gestionarea fișierelor - os, pathlib, shutil

import os
from pathlib import Path
import shutil

# Organizarea automată a fișierelor
def organize_downloads():
    downloads_path = Path.home() / "Downloads"
    
    file_types = {
        'images': ['.jpg', '.jpeg', '.png', '.gif'],
        'documents': ['.pdf', '.docx', '.txt'],
        'videos': ['.mp4', '.avi', '.mkv']
    }
    
    for file in downloads_path.iterdir():
        if file.is_file():
            extension = file.suffix.lower()
            
            for folder, extensions in file_types.items():
                if extension in extensions:
                    target_folder = downloads_path / folder
                    target_folder.mkdir(exist_ok=True)
                    shutil.move(str(file), target_folder / file.name)
                    break

2. Web scraping - requests, BeautifulSoup

import requests
from bs4 import BeautifulSoup
import pandas as pd

def monitor_product_prices(urls):
    products = []
    
    for url in urls:
        response = requests.get(url)
        soup = BeautifulSoup(response.content, 'html.parser')
        
        title = soup.find('h1', class_='product-title').text.strip()
        price = soup.find('span', class_='price').text.strip()
        
        products.append({
            'title': title,
            'price': price,
            'url': url,
            'timestamp': pd.Timestamp.now()
        })
    
    return pd.DataFrame(products)

3. Email automation - smtplib, email

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders

class EmailAutomation:
    def __init__(self, smtp_server, port, username, password):
        self.smtp_server = smtp_server
        self.port = port
        self.username = username
        self.password = password
    
    def send_report(self, to_emails, subject, body, attachment_path=None):
        msg = MIMEMultipart()
        msg['From'] = self.username
        msg['To'] = ', '.join(to_emails)
        msg['Subject'] = subject
        
        msg.attach(MIMEText(body, 'html'))
        
        if attachment_path:
            with open(attachment_path, 'rb') as attachment:
                part = MIMEBase('application', 'octet-stream')
                part.set_payload(attachment.read())
                encoders.encode_base64(part)
                part.add_header(
                    'Content-Disposition',
                    f'attachment; filename= {attachment_path.name}'
                )
                msg.attach(part)
        
        with smtplib.SMTP(self.smtp_server, self.port) as server:
            server.starttls()
            server.login(self.username, self.password)
            server.send_message(msg)

Exemple practice de automatizare

1. Backup automat al fișierelor

import schedule
import time
import zipfile
from datetime import datetime

def create_backup():
    backup_folders = [
        Path.home() / "Documents",
        Path.home() / "Pictures",
        Path.home() / "Desktop"
    ]
    
    backup_name = f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
    backup_path = Path.home() / "Backups" / backup_name
    backup_path.parent.mkdir(exist_ok=True)
    
    with zipfile.ZipFile(backup_path, 'w', zipfile.ZIP_DEFLATED) as backup_zip:
        for folder in backup_folders:
            for file in folder.rglob('*'):
                if file.is_file():
                    backup_zip.write(file, file.relative_to(Path.home()))
    
    print(f"Backup creat: {backup_path}")

# Programare backup zilnic la 20:00
schedule.every().day.at("20:00").do(create_backup)

while True:
    schedule.run_pending()
    time.sleep(60)

2. Monitorizarea sistemului

import psutil
import time
import pandas as pd

def system_monitor():
    while True:
        # Colectarea datelor sistem
        cpu_percent = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory()
        disk = psutil.disk_usage('/')
        
        # Verificarea pragurilor
        if cpu_percent > 80:
            send_alert(f"CPU usage high: {cpu_percent}%")
        
        if memory.percent > 85:
            send_alert(f"Memory usage high: {memory.percent}%")
        
        if disk.percent > 90:
            send_alert(f"Disk usage high: {disk.percent}%")
        
        # Logging
        log_data = {
            'timestamp': pd.Timestamp.now(),
            'cpu_percent': cpu_percent,
            'memory_percent': memory.percent,
            'disk_percent': disk.percent
        }
        
        # Salvare în CSV
        df = pd.DataFrame([log_data])
        df.to_csv('system_monitor.csv', mode='a', header=False, index=False)
        
        time.sleep(300)  # Check every 5 minutes

3. Procesarea automată Excel

import pandas as pd
import openpyxl
from pathlib import Path

def process_sales_data():
    input_folder = Path("input_data")
    output_folder = Path("processed_data")
    output_folder.mkdir(exist_ok=True)
    
    all_data = []
    
    # Procesarea fiecărui fișier Excel
    for file in input_folder.glob("*.xlsx"):
        df = pd.read_excel(file)
        
        # Curățarea datelor
        df = df.dropna()
        df['date'] = pd.to_datetime(df['date'])
        df['total'] = df['quantity'] * df['price']
        
        # Adăugarea sursei
        df['source_file'] = file.name
        all_data.append(df)
    
    # Combinarea datelor
    combined_df = pd.concat(all_data, ignore_index=True)
    
    # Generarea raportului
    summary = combined_df.groupby(['date', 'product']).agg({
        'quantity': 'sum',
        'total': 'sum'
    }).reset_index()
    
    # Salvarea rezultatelor
    with pd.ExcelWriter(output_folder / 'sales_report.xlsx') as writer:
        combined_df.to_excel(writer, sheet_name='Raw_Data', index=False)
        summary.to_excel(writer, sheet_name='Summary', index=False)

Task scheduler și cron jobs

Windows Task Scheduler cu Python

# script pentru Windows Task Scheduler
import sys
import logging
from datetime import datetime

# Setup logging
logging.basicConfig(
    filename=f'automation_log_{datetime.now().strftime("%Y%m")}.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def main():
    try:
        # Aici vine logica principală
        logging.info("Starting automated task")
        
        # Execută task-ul
        result = execute_main_task()
        
        logging.info(f"Task completed successfully: {result}")
        
    except Exception as e:
        logging.error(f"Task failed: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()

Best Practices pentru automatizare

1. Gestionarea erorilor

• Folosește try-except blocks pentru operațiuni critice
• Implementează retry logic pentru operațiuni nesigure
• Creează logging detaliat pentru debugging

2. Configurare externă

• Folosește fișiere de configurare (JSON, YAML)
• Separă credențialele de cod
• Folosește environment variables

3. Testing și monitoring

• Testează script-urile în medii de development
• Implementează health checks
• Monitorizează performanța și erorile

Concluzie

Python oferă instrumente puternice pentru automatizarea task-urilor zilnice. Cu librăriile potrivite și best practices, poți economisi ore de muncă manuală și reduci erorile.

Resurse utile

• Python.org
• Automate the Boring Stuff with Python
• Real Python Tutorials