Automação com Python é uma forma prática de eliminar tarefas repetitivas: organizar arquivos, gerar relatórios, consultar APIs, tratar planilhas e acompanhar páginas da web. Neste guia, você encontrará 20 scripts prontos, organizados do mais simples ao mais completo e acompanhados das adaptações necessárias para usar no seu computador.
Os exemplos priorizam segurança: operações potencialmente destrutivas começam em modo de simulação, requisições usam tempo limite e senhas não ficam escritas no código. Antes de começar, confirme que o Python está disponível seguindo o guia de como instalar Python.
Preparando o ambiente para as automações
Crie uma pasta para o projeto, abra o terminal nela e use um ambiente virtual. No Windows:
python -m venv .venv
.venv\Scripts\activate
python -m pip install --upgrade pipNo macOS ou Linux:
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pipA maioria dos scripts usa apenas a biblioteca padrão. Para os exemplos de web, Excel e extração de HTML, instale:
python -m pip install requests beautifulsoup4 openpyxlAutomação de arquivos e pastas
1. Organizar arquivos por extensão
O script cria subpastas e separa os arquivos por categoria. Ele começa com SIMULAR = True; altere para False somente depois de conferir a lista exibida.
from pathlib import Path
import shutil
PASTA = Path.home() / "Downloads"
SIMULAR = True
GRUPOS = {
"imagens": {".jpg", ".jpeg", ".png", ".webp"},
"documentos": {".pdf", ".docx", ".txt", ".xlsx"},
"compactados": {".zip", ".rar", ".7z"},
}
for arquivo in PASTA.iterdir():
if not arquivo.is_file():
continue
destino_nome = next((nome for nome, exts in GRUPOS.items()
if arquivo.suffix.lower() in exts), "outros")
destino = PASTA / destino_nome / arquivo.name
print(f"{arquivo.name} -> {destino}")
if not SIMULAR:
destino.parent.mkdir(exist_ok=True)
shutil.move(str(arquivo), str(destino))2. Renomear arquivos em lote
from pathlib import Path
PASTA = Path("fotos")
SIMULAR = True
for numero, arquivo in enumerate(sorted(PASTA.glob("*.*")), start=1):
novo = arquivo.with_name(f"viagem_{numero:03d}{arquivo.suffix.lower()}")
print(f"{arquivo.name} -> {novo.name}")
if not SIMULAR and not novo.exists():
arquivo.rename(novo)Evite executar diretamente em uma pasta importante. Faça uma cópia de teste e verifique se nenhum nome de destino já existe.
3. Criar backup ZIP com data e hora
from datetime import datetime
from pathlib import Path
import shutil
origem = Path("projeto")
destino = Path("backups")
destino.mkdir(exist_ok=True)
carimbo = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
base = destino / f"projeto_{carimbo}"
arquivo_zip = shutil.make_archive(str(base), "zip", root_dir=origem)
print(f"Backup criado: {arquivo_zip}")4. Localizar arquivos duplicados sem apagar nada
from collections import defaultdict
from hashlib import sha256
from pathlib import Path
PASTA = Path("documentos")
por_hash = defaultdict(list)
for arquivo in PASTA.rglob("*"):
if not arquivo.is_file():
continue
digest = sha256()
with arquivo.open("rb") as entrada:
for bloco in iter(lambda: entrada.read(1024 * 1024), b""):
digest.update(bloco)
por_hash[digest.hexdigest()].append(arquivo)
for caminhos in por_hash.values():
if len(caminhos) > 1:
print("Possíveis duplicados:")
for caminho in caminhos:
print(" -", caminho)O código apenas lista arquivos de conteúdo idêntico. A exclusão deve ser feita manualmente, depois de verificar cada grupo.
5. Copiar arquivos alterados recentemente
from datetime import datetime, timedelta
from pathlib import Path
import shutil
origem = Path("projeto")
destino = Path("arquivos_recentes")
limite = datetime.now() - timedelta(days=7)
for arquivo in origem.rglob("*"):
if arquivo.is_file() and datetime.fromtimestamp(arquivo.stat().st_mtime) >= limite:
relativo = arquivo.relative_to(origem)
copia = destino / relativo
copia.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(arquivo, copia)
print("Copiado:", relativo)6. Encontrar arquivos grandes
from pathlib import Path
PASTA = Path.home()
LIMITE_MB = 500
arquivos = []
for caminho in PASTA.rglob("*"):
try:
if caminho.is_file():
tamanho = caminho.stat().st_size / (1024 ** 2)
if tamanho >= LIMITE_MB:
arquivos.append((tamanho, caminho))
except (PermissionError, OSError):
continue
for tamanho, caminho in sorted(arquivos, reverse=True):
print(f"{tamanho:,.1f} MB | {caminho}")Automação de CSV, JSON e Excel
7. Filtrar linhas de um CSV
import csv
with open("vendas.csv", encoding="utf-8", newline="") as entrada, \
open("vendas_altas.csv", "w", encoding="utf-8", newline="") as saida:
leitor = csv.DictReader(entrada)
escritor = csv.DictWriter(saida, fieldnames=leitor.fieldnames)
escritor.writeheader()
for linha in leitor:
if float(linha["valor"].replace(",", ".")) >= 1000:
escritor.writerow(linha)8. Somar valores por categoria
import csv
from collections import defaultdict
soma = defaultdict(float)
with open("despesas.csv", encoding="utf-8", newline="") as arquivo:
for linha in csv.DictReader(arquivo):
soma[linha["categoria"]] += float(linha["valor"].replace(",", "."))
for categoria, total in sorted(soma.items()):
print(f"{categoria}: R$ {total:.2f}")9. Converter JSON em CSV
import csv
import json
with open("clientes.json", encoding="utf-8") as arquivo:
clientes = json.load(arquivo)
if not clientes:
raise SystemExit("O JSON não contém registros.")
campos = sorted({chave for item in clientes for chave in item})
with open("clientes.csv", "w", encoding="utf-8", newline="") as arquivo:
escritor = csv.DictWriter(arquivo, fieldnames=campos)
escritor.writeheader()
escritor.writerows(clientes)10. Criar uma planilha Excel
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = "Resumo"
ws.append(["Produto", "Quantidade", "Preço"])
ws.append(["Teclado", 2, 150.00])
ws.append(["Mouse", 3, 80.00])
ws["E1"] = "Total"
ws["E2"] = "=SUMPRODUCT(B2:B3,C2:C3)"
wb.save("resumo.xlsx")
print("Planilha criada.")O método save() sobrescreve um arquivo existente com o mesmo nome. Use um nome novo ou faça uma cópia antes de editar uma planilha importante.
11. Gerar relatório de uma pasta em CSV
import csv
from datetime import datetime
from pathlib import Path
PASTA = Path("documentos")
with open("relatorio_arquivos.csv", "w", encoding="utf-8", newline="") as saida:
escritor = csv.writer(saida)
escritor.writerow(["arquivo", "extensao", "tamanho_bytes", "modificado_em"])
for arquivo in PASTA.rglob("*"):
if arquivo.is_file():
dados = arquivo.stat()
escritor.writerow([
str(arquivo.relative_to(PASTA)),
arquivo.suffix.lower(),
dados.st_size,
datetime.fromtimestamp(dados.st_mtime).isoformat(timespec="seconds"),
])Automação de web e APIs
Antes de coletar conteúdo, confira os termos de uso, o arquivo robots.txt e os limites do serviço. Não contorne autenticação, CAPTCHA ou bloqueios. Para um estudo aprofundado, consulte o guia de web scraping com BeautifulSoup e Requests.
12. Consultar uma API JSON
import requests
url = "https://api.github.com/repos/python/cpython"
try:
resposta = requests.get(url, timeout=(5, 20))
resposta.raise_for_status()
dados = resposta.json()
print("Repositório:", dados["full_name"])
print("Estrelas:", dados["stargazers_count"])
except requests.RequestException as erro:
print("Falha na consulta:", erro)13. Baixar um arquivo em blocos
from pathlib import Path
import requests
url = "https://www.python.org/static/community_logos/python-logo.png"
destino = Path("python-logo.png")
with requests.get(url, stream=True, timeout=(5, 30)) as resposta:
resposta.raise_for_status()
with destino.open("wb") as arquivo:
for bloco in resposta.iter_content(chunk_size=64 * 1024):
if bloco:
arquivo.write(bloco)
print("Salvo em:", destino.resolve())14. Extrair o título de uma página
import requests
from bs4 import BeautifulSoup
url = "https://www.python.org/"
resposta = requests.get(
url,
headers={"User-Agent": "EstudoPython/1.0"},
timeout=(5, 20),
)
resposta.raise_for_status()
soup = BeautifulSoup(resposta.text, "html.parser")
print(soup.title.get_text(strip=True) if soup.title else "Sem título")15. Monitorar o status de uma página
from datetime import datetime
import time
import requests
URL = "https://example.com/"
INTERVALO = 300 # cinco minutos
while True:
try:
resposta = requests.get(URL, timeout=(5, 20))
status = resposta.status_code
except requests.RequestException as erro:
status = f"erro: {erro}"
print(datetime.now().isoformat(timespec="seconds"), status)
time.sleep(INTERVALO)Use intervalos razoáveis. Para monitoramento permanente, prefira um agendador do sistema e registros em arquivo em vez de manter o terminal aberto indefinidamente.
Automação de produtividade e sistema
16. Executar outro programa com segurança
import subprocess
import sys
resultado = subprocess.run(
[sys.executable, "gerar_relatorio.py", "--mes", "2026-07"],
capture_output=True,
text=True,
timeout=120,
check=False,
)
print(resultado.stdout)
if resultado.returncode != 0:
print(resultado.stderr)Passar os argumentos como lista evita depender de shell=True. Não execute comandos recebidos diretamente de formulários ou usuários sem validação.
17. Enviar e-mail usando variáveis de ambiente
import os
import smtplib
from email.message import EmailMessage
usuario = os.environ["SMTP_USUARIO"]
senha = os.environ["SMTP_SENHA"]
mensagem = EmailMessage()
mensagem["From"] = usuario
mensagem["To"] = "[email protected]"
mensagem["Subject"] = "Relatório concluído"
mensagem.set_content("O relatório foi gerado com sucesso.")
with smtplib.SMTP_SSL("smtp.example.com", 465, timeout=30) as servidor:
servidor.login(usuario, senha)
servidor.send_message(mensagem)Troque o servidor e o destinatário pelos dados do seu provedor. Use senha de aplicativo quando o serviço exigir e envie mensagens somente para destinatários autorizados.
18. Registrar atividades em arquivo de log
import logging
logging.basicConfig(
filename="automacao.log",
level=logging.INFO,
format="%(asctime)s | %(levelname)s | %(message)s",
encoding="utf-8",
)
logging.info("Automação iniciada")
try:
resultado = 10 / 2
logging.info("Resultado calculado: %s", resultado)
except Exception:
logging.exception("A automação falhou")19. Transformar o script em comando de terminal
import argparse
from pathlib import Path
parser = argparse.ArgumentParser(description="Conta arquivos por extensão.")
parser.add_argument("pasta", type=Path)
parser.add_argument("--extensao", default=".py")
args = parser.parse_args()
extensao = args.extensao if args.extensao.startswith(".") else f".{args.extensao}"
total = sum(1 for item in args.pasta.rglob(f"*{extensao}") if item.is_file())
print(f"Encontrados: {total}")Salve como contar.py e execute, por exemplo: python contar.py projeto --extensao .py.
20. Gerar um relatório final de tarefas
from datetime import datetime
from pathlib import Path
resultados = [
("Backup", True, "backup criado"),
("API", True, "dados recebidos"),
("E-mail", False, "credencial ausente"),
]
linhas = [
"# Relatório da automação",
"",
f"Gerado em: {datetime.now().isoformat(timespec='seconds')}",
"",
]
for tarefa, sucesso, detalhe in resultados:
simbolo = "OK" if sucesso else "FALHA"
linhas.append(f"- [{simbolo}] {tarefa}: {detalhe}")
Path("relatorio.md").write_text("\n".join(linhas), encoding="utf-8")Como agendar uma automação
Depois de testar o script manualmente, use o Agendador de Tarefas do Windows, o cron no Linux ou o launchd no macOS. Informe o caminho completo do interpretador do ambiente virtual e o caminho completo do arquivo. Assim, a execução não depende da pasta aberta no terminal.
Boas práticas antes de colocar em produção
- Teste com cópias de arquivos e poucos registros.
- Registre o que foi alterado e mantenha backups.
- Use caminhos configuráveis com
pathlib. - Não salve senhas, tokens ou chaves de API no código.
- Defina timeout, trate exceções e valide as respostas de serviços externos.
- Respeite permissões, termos de uso e limites de requisições.
- Fixe as dependências do projeto quando a automação se tornar importante.
Qual script escolher primeiro?
Para começar, escolha uma tarefa pequena e reversível, como gerar um relatório de arquivos ou filtrar um CSV. Depois, transforme valores fixos em argumentos, adicione logs e agende a execução. Essa evolução é mais segura do que tentar automatizar um processo inteiro de uma só vez.
Quem ainda está consolidando a base da linguagem pode seguir o roadmap de Python e praticar os exemplos no compilador Python online. Scripts que acessam arquivos, rede ou pacotes externos devem ser executados localmente.
Perguntas frequentes
Python é bom para automatizar tarefas?
Sim. A linguagem possui módulos prontos para arquivos, processos, dados, rede, e-mail e linha de comando, além de bibliotecas externas para planilhas, navegadores e APIs.
Preciso saber Python avançado?
Não. Variáveis, condições, laços, funções e tratamento de erros já permitem criar automações úteis. O mais importante é testar com dados controlados e entender cada operação antes de executá-la.
Posso copiar os scripts e usar diretamente?
Os exemplos são modelos. Você precisa ajustar caminhos, nomes de colunas, endereços de serviços e regras do seu processo. Leia o código e teste em uma pasta separada.
Como evitar que uma automação apague dados?
Comece em modo de simulação, não exclua arquivos automaticamente, valide os destinos, crie backup e registre todas as ações. Para operações críticas, exija confirmação humana.
