20 scripts Python para automatizar tarefas diárias

Como alguém que passou mais de uma década no mundo da programação, aprendi que automatizar tarefas repetitivas pode economizar uma quantidade significativa de tempo e esforço.

Python, com sua sintaxe simples e bibliotecas poderosas, é uma das melhores linguagens de programação para a criação de scripts de automação. Seja você um programador ou alguém que deseja facilitar as tarefas diárias, Python tem ferramentas que podem ajudá-lo.

Neste artigo, compartilharei 20 scripts Python que usei para automatizar várias tarefas. Esses scripts são perfeitos para quem quer economizar tempo e melhorar a eficiência na rotina de trabalho.

1. Renomeando arquivos em massa

Renomear arquivos um por um pode ser uma tarefa demorada, mas com Python você pode automatizar isso facilmente usando o módulo os.

Aqui está um script simples que renomeia vários arquivos em uma pasta com base em um determinado padrão:

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 procura arquivos contendo old_name_part em seus nomes e os substitui por new_name_part.

2. Fazendo backup de arquivos automaticamente

Todos nós sabemos como é importante fazer backup de arquivos regularmente, e essa tarefa pode ser facilmente automatizada usando o módulo shutil do Python.

Este script copiará todos os arquivos de um diretório para outro para fins de 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)

Você pode agendar esse script para ser executado diariamente usando ferramentas de agendamento de tarefas como cron (Linux) ou Agendador de Tarefas (Windows).

3. Baixando arquivos da Internet

Se você baixa arquivos da Internet com frequência, pode automatizar essa tarefa usando a biblioteca requests.

Aqui está um script simples para baixar arquivos de URLs:

import requests

def download_file(url, destination_folder):
    response = requests.get(url)
    if response.status_code == 200:
        with open(destination_folder, 'wb') as file:
            file.write(response.content)
        print(f"Downloaded {url} to {destination_folder}")
    else:
        print(f"Failed to download {url}")

url = 'https://example.com/file.pdf' destination = '/path/to/destination/file.pdf' download_file(url, destination)

Este script baixa o arquivo do URL especificado e o salva na pasta especificada.

4. Automatizando relatórios de e-mail

Se você precisar enviar relatórios por e-mail regularmente, poderá automatizá-lo usando a biblioteca smtplib, que permite enviar e-mails facilmente de uma conta do 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 ' 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 ')

Este script enviará um e-mail simples com assunto e corpo para um destinatário especificado. Certifique-se de ativar aplicativos menos seguros no Gmail se usar este método.

5. Agendador de tarefas (automação de tarefas)

O agendamento de tarefas pode ser feito facilmente usando a biblioteca schedule, que permite automatizar tarefas como enviar um e-mail ou executar um script de backup em horários específicos:

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 continuará em execução e acionará tarefas no horário especificado, neste caso, 10h todos os dias.

6. Web Scraping para coleta de dados

Web scraping é uma técnica poderosa para automatizar a coleta de dados de sites, e as bibliotecas BeautifulSoup e requests do Python tornam esse processo simples.

import requests
from bs4 import BeautifulSoup

def scrape_website(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    data = soup.find_all('h1')  # Example: Get all headings
    for item in data:
        print(item.text)

url = 'https://example.com' scrape_website(url)

Este script busca o conteúdo de uma página da web e imprime todos os títulos (tags h1). Você pode ajustá-lo para extrair outros tipos de dados.

7. Automatizando postagens em mídias sociais

Se você gerencia contas de mídia social, pode automatizar a postagem usando bibliotecas como Tweepy (para Twitter) e Instagram-API (para Instagram) que permitem postar automaticamente.

Abaixo está um exemplo usando a biblioteca Tweepy para postar um 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!")

Este script posta um tweet com a mensagem “Hello, world!” em sua conta do Twitter.

8. Automatizando a geração de faturas

Se você gera faturas regularmente, poderá automatizá-las usando bibliotecas como Fpdf, que criará faturas em 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 cria uma fatura simples e a salva como PDF.

9. Monitorando o tempo de atividade do site

Python pode ser usado para automatizar o monitoramento do tempo de atividade de um site usando a biblioteca requests, que pode verificar periodicamente se um site está online ou não:

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 se o site está online e imprime o código de status.

10. Resposta automática a e-mails

Se você recebe e-mails com frequência e deseja configurar uma resposta automática, use as bibliotecas imaplib e smtplib para responder automaticamente aos e-mails:

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 ', '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 ') def send_email(subject, body, to_email): sender_email = '[email ' 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 automaticamente a e-mails não lidos com uma mensagem predefinida.

11. Limpeza de arquivos

Python fornece uma maneira eficaz de automatizar a limpeza de arquivos, principalmente para excluir ou mover arquivos antigos para manter diretórios organizados.

Abaixo está um script simples que exclui arquivos anteriores a um número especificado de dias usando os módulos os e time.

import os
import time

def clean_up(folder_path, days_old):
    now = time.time()
    cutoff_time = now - (days_old * 86400)  # 86400 seconds in a day
    for filename in os.listdir(folder_path):
        file_path = os.path.join(folder_path, filename)
        if os.path.getmtime(file_path) < cutoff_time:
            os.remove(file_path)
            print(f"Deleted {filename}")

folder = '/path/to/your/folder' clean_up(folder, 30) # Delete files older than 30 days

12. Gere senhas automaticamente

Criar senhas fortes e exclusivas é essencial para a segurança, e Python pode ajudar a automatizar esse processo usando o módulo random.

Abaixo está um script simples que gera senhas aleatórias de comprimento especificado, incorporando letras, dígitos e caracteres especiais para aumentar a segurança.

import random
import string

def generate_password(length=12):
    # Define the character set: letters, digits, and punctuation
    characters = string.ascii_letters + string.digits + string.punctuation
    
    # Generate a random password
    password = ''.join(random.choice(characters) for _ in range(length))
    
    return password

Example usage: generate a password of 16 characters
password_length = 16
random_password = generate_password(password_length)
print(f"Generated Password: {random_password}")

13. Rastreador/Lembrete de Tarefas

A criação de um rastreador de tarefas ou sistema de lembrete em Python pode ser realizada usando os módulos datetime e schedule.

import schedule
import time
from datetime import datetime

def task_reminder(task_name):
    print(f"Reminder: {task_name} - {datetime.now()}")

schedule.every().day.at("09:00").do(task_reminder, task_name="Morning Meeting")

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

Este script envia um lembrete sobre a tarefa em um horário agendado.

14. Gerar relatórios diários automaticamente

Automatize relatórios diários usando Python para coletar dados e formatá-los em um relatório:

import datetime

def generate_report(data):
    today = datetime.date.today()
    filename = f"daily_report_{today}.txt"
    with open(filename, 'w') as file:
        file.write(f"Report for {today}\n")
        file.write("\n".join(data))
    print(f"Report generated: {filename}")

data = ["Task 1: Completed", "Task 2: Pending", "Task 3: Completed"]
generate_report(data)

15. Monitore os recursos do sistema

Se você é um administrador de sistema, pode usar Python para monitorar os recursos do seu sistema, como CPU e uso de memória, com a ajuda da 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. Redimensionamento de imagens em lote

Se você precisar redimensionar imagens em massa, o Python facilita isso com a biblioteca Pillow.

from PIL import Image
import os

def resize_images(folder_path, width, height):
    for filename in os.listdir(folder_path):
        if filename.endswith('.jpg'):
            img = Image.open(os.path.join(folder_path, filename))
            img = img.resize((width, height))
            img.save(os.path.join(folder_path, f"resized_{filename}"))
            print(f"Resized {filename}")

folder = '/path/to/your/images' resize_images(folder, 800, 600)

Este script redimensiona todas as imagens .jpg em uma pasta para as dimensões especificadas.

17. Automatizando backup de dados para nuvem

Automatizar backups para serviços em nuvem como o Google Drive é possível com 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. Criação de lembretes diários

Definir lembretes diários é fácil com o módulo time, que irá lembrá-lo de beber água a 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. Automatizando a entrada de dados no Excel

Se você insere dados frequentemente no Excel, o Python pode ajudar a automatizar essa tarefa com a 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. Automatizando a limpeza de dados

Se você trabalha com grandes conjuntos de dados, o Python pode automatizar tarefas de limpeza de dados, o que removerá linhas vazias de um arquivo 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)

Conclusão

Estes são apenas alguns exemplos do que o Python pode fazer para automatizar suas tarefas diárias. Com sua sintaxe simples e bibliotecas poderosas, Python pode lidar com quase todas as tarefas que você realizar.

Esteja você gerenciando arquivos, enviando e-mails ou gerando relatórios, o Python pode economizar tempo e melhorar sua produtividade. Então, comece hoje mesmo com a automação Python e deixe-a cuidar de suas tarefas diárias!