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 criar scripts de automação. Quer você seja um programador ou alguém querendo facilitar as tarefas diárias, Python tem ferramentas que podem ajudá-lo.
Neste artigo, compartilharei 21 scripts em Python que usei para automatizar várias tarefas. Esses scripts são perfeitos para qualquer pessoa que deseja economizar tempo e melhorar a eficiência em sua rotina de trabalho.
1. Renomear Arquivos em Massa
Renomear arquivos um por um pode ser uma tarefa demorada, mas com Python, você pode facilmente automatizar isso usando o módulo os.
Aqui está um script simples que renomeia vários arquivos em uma pasta com base em um padrão 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 procura por arquivos que contêm old_name_part em seus nomes e os substitui por new_name_part.
2. Fazer Backup de Arquivos Automaticamente
Todos 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 este script para ser executado diariamente usando ferramentas de agendamento de tarefas como o cron (Linux) ou o Agendador de Tarefas (Windows).
3. Download de Arquivos da Internet
Se você frequentemente baixa arquivos da internet, então você pode automatizar essa tarefa usando a biblioteca aiohttp.
Aqui está um script simples para baixar arquivos de 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 baixa o arquivo da URL especificada e o salva na pasta especificada.
4. Automatização de Relatórios por Email
Se você precisa enviar relatórios por email regularmente, você pode automatizá-lo usando a biblioteca smtplib, que permite enviar emails de uma conta do Gmail facilmente:
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á um email simples com um assunto e corpo para um destinatário especificado. Certifique-se de habilitar aplicativos menos seguros no Gmail se você usar este método.
5. Agendador de Tarefas (Automação de Tarefas)
Agendar tarefas pode ser feito facilmente usando a biblioteca schedule, que permite automatizar tarefas como enviar um email 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, 10:00 AM todos os dias.
6. Web Scraping para Coleta de Dados
Usar o aiohttp para requisições HTTP assíncronas em vez da biblioteca síncrona requests pode tornar a raspagem de dados na web mais eficiente.
Este exemplo recupera várias páginas em 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. Automatizando Postagens em Mídias Sociais
Se você gerencia contas de mídias sociais, então pode automatizar postagens usando bibliotecas como Tweepy (para o Twitter) e Instagram-API (para o 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 “Olá, mundo!” na sua conta do Twitter.
8. Automatizando a Geração de Faturas
Se você gera faturas regularmente, então pode automatizar isso usando bibliotecas como Fpdf, que irá 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 um PDF.
9. Monitorando a Disponibilidade de um Site
O Python pode ser usado para automatizar o monitoramento da disponibilidade 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 Emails
Se você frequentemente recebe emails e deseja configurar uma resposta automática, então use as bibliotecas imaplib e smtplib para responder automaticamente aos emails:
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 automaticamente aos emails não lidos com uma mensagem predefinida.
11. Limpeza de Arquivos
O Python oferece uma maneira eficaz de automatizar a limpeza de arquivos, especialmente para excluir ou mover arquivos antigos para manter diretórios organizados.
Abaixo está um script simples que exclui arquivos mais antigos do que um número especificado de dias usando os módulos 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. Gerar Senhas Automaticamente
Criar senhas fortes e únicas é essencial para a segurança, e o Python pode ajudar a automatizar esse processo usando o módulo random.
Abaixo está um script simples que gera senhas aleatórias de um comprimento especificado, incorporando letras, dígitos e caracteres especiais para aumentar a segurança.
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. Rastreador de Tarefas/Lembrete
Criar um sistema de rastreamento de tarefas ou lembretes em Python pode ser feito usando os módulos 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())
Este script envia um lembrete sobre a tarefa em um horário agendado.
14. Auto-Gerar Relatórios Diários
Automatize relatórios diários usando Python para coletar dados e formatá-los em um relatório:
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. Monitorar Recursos do Sistema
Se você é um administrador de sistema, pode usar o Python para monitorar os recursos do seu sistema como uso de CPU e 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 em Lote de Imagens
Se você precisa redimensionar imagens em massa, o Python facilita com a 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 as imagens .jpg em uma pasta para as dimensões especificadas.
17. Automatizando o Backup de Dados para a Nuvem
Automatizar backups para serviços de nuvem como o Google Drive é possível com o 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. Criando Lembretes Diários
Configurar 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ê frequentemente insere dados 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 conjuntos de dados grandes, o Python pode automatizar tarefas de limpeza de dados, que irão 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)
21. Extração de Texto de Imagens
O Python pode ser usado para extrair texto de imagens usando a biblioteca pytesseract, o que pode ser útil quando você precisa digitalizar conteúdo impresso ou extrair texto de documentos digitalizados.
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)
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, o Python pode lidar com quase qualquer tarefa que você lhe apresente.
Seja gerenciando arquivos, enviando e-mails ou gerando relatórios, o Python pode economizar tempo e melhorar sua produtividade. Portanto, comece com a automação em Python hoje e deixe-o lidar com suas tarefas diárias!