21 Script Python Semplici Che Automatizzeranno i Tuoi Compiti Quotidiani

Come qualcuno che ha trascorso oltre un decennio nel mondo della programmazione, ho imparato che automatizzare compiti ripetitivi può far risparmiare una quantità significativa di tempo e sforzi.

Python, con la sua sintassi semplice e le potenti librerie, è uno dei migliori linguaggi di programmazione per creare script di automazione. Sia che tu sia un programmatore o qualcuno che cerca di semplificare le attività quotidiane, Python ha strumenti che possono aiutarti.

In questo articolo, condividerò 21 script Python che ho utilizzato per automatizzare vari compiti. Questi script sono perfetti per chiunque voglia risparmiare tempo e migliorare l’efficienza nella propria routine lavorativa.

1. Rinominare file in blocco

Rinominare i file uno per uno può essere un compito dispendioso in termini di tempo, ma con Python puoi facilmente automatizzare questo utilizzando il modulo os.

Ecco uno script semplice che rinomina più file in una cartella in base a un modello specificato:

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')

Questo script cerca file che contengono old_name_part nei loro nomi e lo sostituisce con new_name_part.

2. Backup automatico dei file

Sappiamo tutti quanto sia importante eseguire regolarmente il backup dei file, e questo compito può essere facilmente automatizzato utilizzando il modulo shutil di Python.

Questo script copierà tutti i file da una directory a un’altra per scopi di backup:

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)

Puoi pianificare questo script per essere eseguito quotidianamente utilizzando strumenti di pianificazione delle attività come cron (Linux) o Task Scheduler (Windows).

3. Scaricare file da Internet

Se scarichi frequentemente file da internet, puoi automatizzare questo compito utilizzando la libreria aiohttp.

Ecco un semplice script per scaricare file da URL:

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())

Questo script scarica il file dall’URL specificato e lo salva nella cartella da te indicata.

4. Automazione dei report via email

Se sei tenuto a inviare report via email regolarmente, puoi automatizzarlo utilizzando la libreria smtplib, che ti consente di inviare email facilmente da un account Gmail:

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]')

Questo script invierà una semplice email con un oggetto e un corpo a un destinatario specificato. Assicurati di abilitare le app meno sicure in Gmail se utilizzi questo metodo.

5. Task Scheduler (Automazione delle attività)

Pianificare attività può essere fatto facilmente utilizzando la libreria schedule, che ti consente di automatizzare compiti come inviare un’email o eseguire uno script di backup in orari specifici:

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)

Questo script continuerà a essere eseguito e attiverà attività all’orario specificato, in questo caso, 10:00 AM ogni giorno.

6. Web Scraping per la raccolta di dati

Utilizzare aiohttp per richieste HTTP asincrone invece della libreria sincrona requests può rendere il web scraping più efficiente.

Questo esempio recupera più pagine in parallelo.

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. Automazione dei Post sui Social Media

Se gestisci account sui social media, puoi automatizzare i post utilizzando librerie come Tweepy (per Twitter) e Instagram-API (per Instagram) che ti permettono di postare automaticamente.

Di seguito è riportato un esempio che utilizza la libreria Tweepy per postare un tweet:

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!")

Questo script pubblica un tweet con il messaggio “Ciao, mondo!” sul tuo account Twitter.

8. Automazione della Generazione di Fatture

Se generi fatture regolarmente, puoi automatizzarlo utilizzando librerie come Fpdf, che creerà fatture in 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)

Questo script crea una semplice fattura e la salva come PDF.

9. Monitoraggio del Tempo di Attività del Sito Web

Python può essere utilizzato per automatizzare il monitoraggio del tempo di attività del sito web utilizzando la libreria requests, che può controllare periodicamente se un sito web è online o meno:

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

Questo script controlla se il sito web è online e stampa il codice di stato.

10. Risposta Automatica alle Email

Se ricevi spesso email e vuoi impostare una risposta automatica, utilizza le librerie imaplib e smtplib per rispondere automaticamente alle email:

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()

Questo script risponde automaticamente alle email non lette con un messaggio predefinito.

11. Pulizia dei File

Python offre un modo efficace per automatizzare la pulizia dei file, in particolare per eliminare o spostare file vecchi per mantenere directory organizzate.

Di seguito è riportato uno script semplice che elimina i file più vecchi di un numero specificato di giorni utilizzando i moduli os e 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. Generazione Automatica di Password

Creare password forti e uniche è essenziale per la sicurezza, e Python può aiutare ad automatizzare questo processo utilizzando il modulo random.

Di seguito è riportato uno script semplice che genera password casuali di una lunghezza specificata, incorporando lettere, numeri e caratteri speciali per migliorare la sicurezza.

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. Tracker/Ricordatore di Attività

Creare un sistema di tracciamento delle attività o di promemoria in Python può essere realizzato utilizzando i moduli datetime e 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())

Questo script invia un promemoria riguardo al compito a un orario programmato.

14. Generazione Automatica di Report Giornalieri

Automatizza i report giornalieri utilizzando Python per raccogliere dati e formattarli in un report:

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. Monitoraggio delle Risorse di Sistema

Se sei un amministratore di sistema, puoi utilizzare Python per monitorare le risorse del tuo sistema come l’utilizzo della CPU e della memoria, con l’aiuto della libreria 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. Ridimensionamento Batch delle Immagini

Se hai bisogno di ridimensionare immagini in blocco, Python lo rende facile con la libreria 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))

Questo script ridimensiona tutte le immagini .jpg in una cartella alle dimensioni specificate.

17. Automazione del Backup Dati nel Cloud

L’automazione dei backup su servizi cloud come Google Drive è possibile con Python utilizzando librerie come 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. Creazione di Promemoria Giornalieri

Impostare promemoria giornalieri è facile con il modulo time, che ti ricorderà di bere acqua ogni 2 ore:

import time

def water_reminder():
    while True:
        print("Time to drink water!")
        time.sleep(7200)  # Remind every 2 hours

water_reminder()

19. Automazione dell’Inserimento Dati in Excel

Se inserisci frequentemente dati in Excel, Python può aiutarti ad automatizzare questo compito con la libreria 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. Automazione della Pulizia dei Dati

Se lavori con grandi set di dati, Python può automatizzare i compiti di pulizia dei dati, che rimuoveranno righe vuote da un file 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. Estrazione di Testo da Immagini

Python può essere utilizzato per estrarre testo da immagini utilizzando la libreria pytesseract, che può essere utile quando hai bisogno di digitalizzare contenuti stampati o estrarre testo da documenti scansionati.

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)

Conclusione

Questi sono solo alcuni esempi di ciò che Python può fare per automatizzare le tue attività quotidiane. Con la sua sintassi semplice e le sue potenti librerie, Python può gestire quasi qualsiasi compito tu gli affidi.

Che tu stia gestendo file, inviando email o generando report, Python può risparmiarti tempo e migliorare la tua produttività. Quindi, inizia oggi con l’automazione in Python e lascia che si occupi dei tuoi compiti quotidiani!