Pular para o conteúdo
🧠Inteligência em Código
📚 Tutoriais•11 min de leitura

Automatize Tarefas com Python e IA: Guia Completo

Aprenda a automatizar tarefas repetitivas combinando Python com modelos de IA: e-mails, relatórios, organização de arquivos, análise de documentos e mais.

#automação#python#ia#produtividade#scripts

Introdução

Automação é uma das aplicações mais práticas e imediatas de Python. Quando combinamos scripts de automação com modelos de Inteligência Artificial, o potencial se multiplica: podemos automatizar tarefas que antes exigiam julgamento humano, como classificar e-mails, resumir documentos, gerar relatórios inteligentes e organizar arquivos por conteúdo.

Neste guia, vamos construir múltiplos scripts de automação que você pode adaptar para o seu dia a dia e ganhar horas de produtividade toda semana.

Pré-requisitos

pip install openai watchdog python-docx openpyxl Pillow pytesseract
pip install schedule python-dotenv jinja2 markdown

1. Organizador Inteligente de Arquivos

Este script monitora uma pasta e organiza os arquivos automaticamente, usando IA para classificar documentos pelo conteúdo:

"""
Organizador Inteligente de Arquivos.
Monitora uma pasta e organiza arquivos por tipo e conteúdo.
"""

import os
import shutil
from pathlib import Path
from datetime import datetime
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import logging
import time

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s"
)
logger = logging.getLogger(__name__)


# Mapeamento de extensões para categorias
CATEGORIAS = {
    "imagens": {".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".bmp"},
    "documentos": {".pdf", ".doc", ".docx", ".txt", ".odt", ".rtf"},
    "planilhas": {".xls", ".xlsx", ".csv", ".ods"},
    "apresentacoes": {".ppt", ".pptx", ".odp"},
    "videos": {".mp4", ".avi", ".mkv", ".mov", ".wmv"},
    "audio": {".mp3", ".wav", ".flac", ".aac", ".ogg"},
    "codigo": {".py", ".js", ".ts", ".html", ".css", ".java", ".cpp", ".rs"},
    "compactados": {".zip", ".rar", ".7z", ".tar", ".gz"},
    "dados": {".json", ".xml", ".yaml", ".yml", ".sql", ".db"},
}


def get_categoria(extensao: str) -> str:
    """Retorna a categoria baseada na extensão do arquivo."""
    ext = extensao.lower()
    for categoria, extensoes in CATEGORIAS.items():
        if ext in extensoes:
            return categoria
    return "outros"


class FileOrganizer(FileSystemEventHandler):
    """Handler que organiza arquivos quando são criados."""
    
    def __init__(self, source_dir: str, target_dir: str):
        self.source_dir = Path(source_dir)
        self.target_dir = Path(target_dir)
        self.target_dir.mkdir(parents=True, exist_ok=True)
    
    def on_created(self, event):
        if event.is_directory:
            return
        
        filepath = Path(event.src_path)
        
        # Ignorar arquivos temporários
        if filepath.name.startswith(".") or filepath.name.startswith("~"):
            return
        
        # Esperar o arquivo terminar de ser copiado
        time.sleep(1)
        
        self._organize_file(filepath)
    
    def _organize_file(self, filepath: Path):
        """Move o arquivo para a pasta da categoria correta."""
        categoria = get_categoria(filepath.suffix)
        
        # Criar subpasta com data
        data_str = datetime.now().strftime("%Y-%m")
        dest_dir = self.target_dir / categoria / data_str
        dest_dir.mkdir(parents=True, exist_ok=True)
        
        # Resolver conflitos de nome
        dest_path = dest_dir / filepath.name
        counter = 1
        while dest_path.exists():
            stem = filepath.stem
            dest_path = dest_dir / f"{stem}_{counter}{filepath.suffix}"
            counter += 1
        
        shutil.move(str(filepath), str(dest_path))
        logger.info(f"📁 {filepath.name} → {categoria}/{data_str}/")


def monitor_folder(source: str, target: str):
    """Inicia o monitoramento de uma pasta."""
    organizer = FileOrganizer(source, target)
    observer = Observer()
    observer.schedule(organizer, source, recursive=False)
    observer.start()
    
    logger.info(f"👀 Monitorando: {source}")
    logger.info(f"📂 Destino: {target}")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()


# Uso: monitor_folder("~/Downloads", "~/Organizado")

2. Classificador de Documentos com IA

Agora vamos além das extensões — usando IA para entender o conteúdo dos documentos:

"""
Classificador de documentos por conteúdo usando IA.
Lê o texto dos arquivos e classifica automaticamente.
"""

from openai import OpenAI
from pathlib import Path
import os
import json
from docx import Document as DocxDocument
import csv


client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))


def extract_text_from_file(filepath: Path) -> str:
    """Extrai texto de diferentes formatos de arquivo."""
    ext = filepath.suffix.lower()
    
    if ext == ".txt":
        return filepath.read_text(encoding="utf-8", errors="ignore")
    
    elif ext == ".docx":
        doc = DocxDocument(str(filepath))
        return "\n".join(para.text for para in doc.paragraphs)
    
    elif ext == ".csv":
        with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
            reader = csv.reader(f)
            rows = list(reader)[:50]  # Primeiras 50 linhas
            return "\n".join(",".join(row) for row in rows)
    
    elif ext in (".py", ".js", ".ts", ".java", ".html", ".css"):
        return filepath.read_text(encoding="utf-8", errors="ignore")
    
    return ""


def classify_document(texto: str) -> dict:
    """
    Usa IA para classificar o conteúdo de um documento.
    
    Returns:
        Dict com categoria, subcategoria e descrição
    """
    prompt = f"""Analise o seguinte trecho de documento e classifique-o.
Retorne um JSON com os campos:
- "categoria": categoria principal (ex: "financeiro", "técnico", "jurídico", "pessoal", "acadêmico")
- "subcategoria": subcategoria específica (ex: "contrato", "relatório", "código-fonte")
- "descricao": descrição breve de uma frase sobre o documento
- "importancia": "alta", "média" ou "baixa"

Trecho do documento:
{texto[:2000]}

Retorne APENAS o JSON válido, sem explicações."""
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "system",
                "content": "Você é um assistente especializado em organização e classificação de documentos."
            },
            {"role": "user", "content": prompt}
        ],
        max_tokens=200,
        temperature=0.1,
        response_format={"type": "json_object"}
    )
    
    return json.loads(response.choices[0].message.content)


def organize_by_content(source_dir: str, target_dir: str):
    """Organiza arquivos de um diretório baseado no conteúdo."""
    source = Path(source_dir)
    target = Path(target_dir)
    
    supported_extensions = {".txt", ".docx", ".csv", ".py", ".js", ".md"}
    
    for filepath in source.iterdir():
        if filepath.is_file() and filepath.suffix.lower() in supported_extensions:
            texto = extract_text_from_file(filepath)
            
            if len(texto) < 50:
                continue
            
            classificacao = classify_document(texto)
            print(f"\n📄 {filepath.name}")
            print(f"   Categoria: {classificacao.get('categoria', 'N/A')}")
            print(f"   Subcategoria: {classificacao.get('subcategoria', 'N/A')}")
            print(f"   Importância: {classificacao.get('importancia', 'N/A')}")
            
            # Mover para pasta da categoria
            cat_dir = target / classificacao.get("categoria", "outros")
            cat_dir.mkdir(parents=True, exist_ok=True)
            
            dest = cat_dir / filepath.name
            shutil.copy2(str(filepath), str(dest))

3. Gerador Automático de Relatórios

Cria relatórios profissionais a partir de dados usando IA para análise e narrativa:

"""
Gerador automático de relatórios com análise por IA.
Lê dados de planilhas/CSVs e cria relatórios em Markdown/HTML.
"""

from openai import OpenAI
from pathlib import Path
from datetime import datetime
import csv
import json
import os
from statistics import mean, median, stdev

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))


def load_csv_data(filepath: str) -> tuple[list[str], list[list[str]]]:
    """Carrega dados de um CSV."""
    with open(filepath, "r", encoding="utf-8") as f:
        reader = csv.reader(f)
        headers = next(reader)
        rows = list(reader)
    return headers, rows


def calculate_statistics(headers: list, rows: list) -> dict:
    """Calcula estatísticas básicas dos dados numéricos."""
    stats = {}
    
    for i, header in enumerate(headers):
        values = []
        for row in rows:
            try:
                values.append(float(row[i].replace(",", ".")))
            except (ValueError, IndexError):
                continue
        
        if values:
            stats[header] = {
                "media": round(mean(values), 2),
                "mediana": round(median(values), 2),
                "desvio_padrao": round(stdev(values), 2) if len(values) > 1 else 0,
                "minimo": round(min(values), 2),
                "maximo": round(max(values), 2),
                "total": round(sum(values), 2),
                "contagem": len(values)
            }
    
    return stats


def generate_analysis(stats: dict, context: str = "") -> str:
    """Usa IA para gerar análise narrativa dos dados."""
    prompt = f"""Com base nas seguintes estatísticas de dados, gere uma análise
em português brasileiro com insights relevantes, tendências identificadas
e recomendações.

Estatísticas:
{json.dumps(stats, ensure_ascii=False, indent=2)}

Contexto adicional: {context or 'Dados gerais da empresa'}

Gere a análise com:
1. Resumo executivo (2-3 frases)
2. Principais insights (3-5 pontos)
3. Tendências identificadas
4. Recomendações
"""
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "system",
                "content": "Você é um analista de dados sênior que gera "
                           "relatórios profissionais e objetivos."
            },
            {"role": "user", "content": prompt}
        ],
        max_tokens=1000,
        temperature=0.3
    )
    
    return response.choices[0].message.content


def create_report(
    csv_path: str,
    output_path: str,
    title: str = "Relatório de Análise de Dados",
    context: str = ""
):
    """Cria relatório completo a partir de dados CSV."""
    headers, rows = load_csv_data(csv_path)
    stats = calculate_statistics(headers, rows)
    analysis = generate_analysis(stats, context)
    
    # Montar relatório em Markdown
    report = f"""# {title}

**Data de geração:** {datetime.now().strftime("%d/%m/%Y às %H:%M")}  
**Fonte de dados:** {Path(csv_path).name}  
**Total de registros:** {len(rows)}

---

## Estatísticas dos Dados

"""
    
    for coluna, valores in stats.items():
        report += f"### {coluna}\n\n"
        report += f"| Métrica | Valor |\n|---------|-------|\n"
        for metrica, valor in valores.items():
            report += f"| {metrica.replace('_', ' ').title()} | {valor} |\n"
        report += "\n"
    
    report += f"""---

## Análise e Insights

{analysis}

---

*Relatório gerado automaticamente por Inteligência em Código.*
"""
    
    Path(output_path).write_text(report, encoding="utf-8")
    print(f"✅ Relatório salvo em: {output_path}")


# Uso:
# create_report("vendas_2026.csv", "relatorio_vendas.md", 
#                title="Relatório de Vendas Q1 2026",
#                context="Dados de vendas do primeiro trimestre")

4. Assistente de E-mail com IA

Script que analisa e-mails e gera respostas automáticas:

"""
Assistente de e-mail com IA.
Analisa e-mails recebidos e sugere/gera respostas.
"""

from openai import OpenAI
from dataclasses import dataclass
from enum import Enum
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))


class Urgencia(str, Enum):
    ALTA = "alta"
    MEDIA = "média"
    BAIXA = "baixa"


class Acao(str, Enum):
    RESPONDER = "responder"
    ENCAMINHAR = "encaminhar"
    ARQUIVAR = "arquivar"
    AGENDAR = "agendar"


@dataclass
class EmailAnalysis:
    """Resultado da análise de um e-mail."""
    assunto: str
    remetente: str
    urgencia: Urgencia
    acao_sugerida: Acao
    resumo: str
    resposta_sugerida: str
    tags: list[str]


def analyze_email(
    assunto: str, corpo: str, remetente: str
) -> EmailAnalysis:
    """
    Analisa um e-mail e retorna classificação + resposta sugerida.
    """
    prompt = f"""Analise o seguinte e-mail e retorne um JSON com:
- "urgencia": "alta", "média" ou "baixa"
- "acao": "responder", "encaminhar", "arquivar" ou "agendar"
- "resumo": resumo de 1-2 frases
- "tags": lista de tags relevantes (max 5)
- "resposta": sugestão de resposta profissional em português

E-mail:
De: {remetente}
Assunto: {assunto}

{corpo[:3000]}"""
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "system",
                "content": "Você é um assistente executivo eficiente. "
                           "Analise e-mails de forma objetiva e gere "
                           "respostas profissionais e cordiais."
            },
            {"role": "user", "content": prompt}
        ],
        max_tokens=500,
        temperature=0.3,
        response_format={"type": "json_object"}
    )
    
    import json
    data = json.loads(response.choices[0].message.content)
    
    return EmailAnalysis(
        assunto=assunto,
        remetente=remetente,
        urgencia=Urgencia(data.get("urgencia", "média")),
        acao_sugerida=Acao(data.get("acao", "responder")),
        resumo=data.get("resumo", ""),
        resposta_sugerida=data.get("resposta", ""),
        tags=data.get("tags", [])
    )


# Exemplo de uso
analise = analyze_email(
    assunto="Proposta de Parceria - Tech Solutions",
    corpo="""Olá,

Somos da Tech Solutions e gostaríamos de propor uma parceria
para desenvolvimento conjunto de soluções de IA para o setor
financeiro. Temos experiência de 5 anos no mercado e atendemos
mais de 200 clientes.

Podemos agendar uma reunião para discutir os detalhes?

Atenciosamente,
Maria Silva
Diretora Comercial""",
    remetente="maria.silva@techsolutions.com.br"
)

print(f"📧 Assunto: {analise.assunto}")
print(f"⚡ Urgência: {analise.urgencia}")
print(f"🎯 Ação: {analise.acao_sugerida}")
print(f"📝 Resumo: {analise.resumo}")
print(f"🏷️ Tags: {', '.join(analise.tags)}")
print(f"\n💬 Resposta sugerida:\n{analise.resposta_sugerida}")

5. Agendador de Tarefas Recorrentes

"""
Agendador de tarefas automatizadas com schedule.
Executa tarefas de automação em horários definidos.
"""

import schedule
import time
from datetime import datetime
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def tarefa_organizar_downloads():
    """Organiza a pasta Downloads a cada 30 minutos."""
    logger.info("🗂️ Organizando Downloads...")
    # Aqui usaria o FileOrganizer definido anteriormente
    # organize_folder("~/Downloads", "~/Organizado")
    logger.info("✅ Downloads organizados!")


def tarefa_gerar_relatorio_diario():
    """Gera relatório diário às 18h."""
    logger.info("📊 Gerando relatório diário...")
    # create_report("dados_hoje.csv", f"relatorio_{datetime.now():%Y%m%d}.md")
    logger.info("✅ Relatório gerado!")


def tarefa_verificar_emails():
    """Verifica e classifica e-mails a cada hora."""
    logger.info("📧 Verificando e-mails...")
    # Integrar com IMAP para buscar novos e-mails
    logger.info("✅ E-mails verificados!")


def tarefa_backup_dados():
    """Faz backup semanal dos dados."""
    logger.info("💾 Iniciando backup semanal...")
    # Copiar dados importantes para backup
    logger.info("✅ Backup concluído!")


# Configurar agendamento
schedule.every(30).minutes.do(tarefa_organizar_downloads)
schedule.every().day.at("18:00").do(tarefa_gerar_relatorio_diario)
schedule.every(1).hours.do(tarefa_verificar_emails)
schedule.every().monday.at("02:00").do(tarefa_backup_dados)


def run_scheduler():
    """Executa o agendador em loop."""
    logger.info("⏰ Agendador iniciado!")
    logger.info("Tarefas configuradas:")
    for job in schedule.get_jobs():
        logger.info(f"  → {job}")
    
    while True:
        schedule.run_pending()
        time.sleep(60)


if __name__ == "__main__":
    run_scheduler()

6. OCR Inteligente: Extraindo Texto de Imagens

"""
OCR com análise inteligente usando Tesseract + IA.
Extrai e interpreta texto de imagens e documentos escaneados.
"""

from PIL import Image
import pytesseract
from openai import OpenAI
from pathlib import Path
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))


def extract_text_from_image(image_path: str, lang: str = "por") -> str:
    """
    Extrai texto de uma imagem usando OCR.
    
    Args:
        image_path: Caminho para a imagem
        lang: Idioma para OCR (por=português, eng=inglês)
        
    Returns:
        Texto extraído da imagem
    """
    image = Image.open(image_path)
    
    # Pré-processamento para melhorar OCR
    image = image.convert("L")  # Escala de cinza
    
    texto = pytesseract.image_to_string(image, lang=lang)
    return texto.strip()


def analyze_document_image(image_path: str) -> dict:
    """
    Extrai texto de imagem e analisa o conteúdo com IA.
    
    Returns:
        Dict com texto extraído, tipo de documento e dados estruturados
    """
    texto = extract_text_from_image(image_path)
    
    if not texto:
        return {"erro": "Nenhum texto encontrado na imagem"}
    
    prompt = f"""Analise o seguinte texto extraído via OCR de um documento.
Identifique o tipo de documento e extraia dados estruturados.

Texto do OCR:
{texto[:3000]}

Retorne JSON com:
- "tipo_documento": tipo identificado (nota fiscal, recibo, contrato, etc)
- "dados_extraidos": dicionário com campos relevantes encontrados
- "texto_corrigido": texto com correções de erros de OCR
- "confianca": "alta", "média" ou "baixa"
"""
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500,
        temperature=0.1,
        response_format={"type": "json_object"}
    )
    
    import json
    result = json.loads(response.choices[0].message.content)
    result["texto_original_ocr"] = texto
    return result


# Exemplo: processar todas as imagens de uma pasta
def process_document_folder(folder: str):
    """Processa todos os documentos escaneados de uma pasta."""
    pasta = Path(folder)
    extensoes = {".png", ".jpg", ".jpeg", ".tiff", ".bmp"}
    
    resultados = []
    for arquivo in pasta.iterdir():
        if arquivo.suffix.lower() in extensoes:
            print(f"\n📸 Processando: {arquivo.name}")
            resultado = analyze_document_image(str(arquivo))
            resultado["arquivo"] = arquivo.name
            resultados.append(resultado)
            
            tipo = resultado.get("tipo_documento", "desconhecido")
            print(f"   Tipo: {tipo}")
            print(f"   Confiança: {resultado.get('confianca', 'N/A')}")
    
    return resultados

Conclusão

A combinação de Python com IA abre possibilidades enormes para automação de tarefas que antes exigiam intervenção humana constante. Neste tutorial, construímos seis ferramentas práticas:

  1. Organizador de arquivos com monitoramento em tempo real
  2. Classificador de documentos que entende o conteúdo via IA
  3. Gerador de relatórios com análise estatística e narrativa inteligente
  4. Assistente de e-mail que classifica e sugere respostas
  5. Agendador de tarefas para execução recorrente
  6. OCR inteligente para digitalizar e interpretar documentos

Cada script pode ser usado independentemente ou combinado em um sistema maior de automação pessoal ou empresarial.

Próximos Passos

  • Integrar com APIs reais de e-mail (Gmail API, IMAP)
  • Adicionar interface web com Streamlit para gerenciar automações
  • Criar notificações via Telegram ou Slack quando tarefas são concluídas
  • Implementar logging centralizado com ElasticSearch
  • Adicionar testes automatizados para cada script
  • Criar CLI com Click ou Typer para facilitar a execução