Python para Desenvolvedores: Desvendando o Poder da Produtividade Crítica

import os
import shutil
 
def organizar_arquivos_por_extensao(diretorio_origem: str, diretorio_destino: str):
    """
    Organiza arquivos de um diretório de origem para subdiretórios no diretório de destino,
    baseado na extensão do arquivo.
 
    Args:
        diretorio_origem (str): Caminho para o diretório de onde os arquivos serão lidos.
        diretorio_destino (str): Caminho para o diretório onde os arquivos serão organizados.
    """
    if not os.path.exists(diretorio_destino):
        os.makedirs(diretorio_destino)
        print(f"Diretório de destino '{diretorio_destino}' criado.")
 
    print(f"Organizando arquivos de '{diretorio_origem}' para '{diretorio_destino}'...")
 
    for nome_arquivo in os.listdir(diretorio_origem):
        caminho_completo_origem = os.path.join(diretorio_origem, nome_arquivo)
 
        # Ignora diretórios e links simbólicos
        if os.path.isfile(caminho_completo_origem):
            # Obtém a extensão do arquivo (ex: '.txt', '.jpg')
            _, extensao = os.path.splitext(nome_arquivo)
            extensao = extensao.lstrip('.').lower() # Remove o ponto e converte para minúsculas
 
            if not extensao: # Arquivos sem extensão
                extensao = "sem_extensao"
 
            diretorio_extensao = os.path.join(diretorio_destino, extensao)
 
            if not os.path.exists(diretorio_extensao):
                os.makedirs(diretorio_extensao)
                print(f"  Diretório para extensão '.{extensao}' criado.")
 
            caminho_completo_destino = os.path.join(diretorio_extensao, nome_arquivo)
 
            try:
                # Move o arquivo
                shutil.move(caminho_completo_origem, caminho_completo_destino)
                print(f"  Movido: '{nome_arquivo}' para '{extensao}/'")
            except shutil.Error as e:
                print(f"  Erro ao mover '{nome_arquivo}': {e}")
            except Exception as e:
                print(f"  Erro inesperado com '{nome_arquivo}': {e}")
 
    print("Organização de arquivos concluída.")
 
# Exemplo de uso:
# Crie alguns arquivos de teste para simular
# os.makedirs('temp_origem', exist_ok=True)
# with open('temp_origem/doc1.txt', 'w') as f: f.write('teste')
# with open('temp_origem/image1.jpg', 'w') as f: f.write('teste')
# with open('temp_origem/report.pdf', 'w') as f: f.write('teste')
# with open('temp_origem/script.py', 'w') as f: f.write('teste')
# with open('temp_origem/README', 'w') as f: f.write('teste')
 
# organizar_arquivos_por_extensao('temp_origem', 'temp_destino_organizado')

import requests
from bs4 import BeautifulSoup
import json
 
def extrair_titulos_e_links(url: str):
    """
    Realiza web scraping em uma URL para extrair títulos de links.
 
    Args:
        url (str): A URL da página web a ser raspada.
 
    Returns:
        list: Uma lista de dicionários, onde cada dicionário contém 'titulo' e 'url'.
    """
    try:
        response = requests.get(url)
        response.raise_for_status()  # Levanta um erro para status HTTP ruins (4xx ou 5xx)
    except requests.exceptions.RequestException as e:
        print(f"Erro ao acessar a URL {url}: {e}")
        return []
 
    soup = BeautifulSoup(response.text, 'html.parser')
    links_encontrados = []
 
    # Exemplo: Encontrar todos os links dentro de tags <a> com um atributo href
    for a_tag in soup.find_all('a', href=True):
        titulo = a_tag.get_text(strip=True)
        link = a_tag['href']
        if titulo and link: # Garante que há título e link
            links_encontrados.append({'titulo': titulo, 'url': link})
 
    return links_encontrados
 
def consumir_api_json(url_api: str, params: dict = None):
    """
    Consome uma API RESTful que retorna JSON.
 
    Args:
        url_api (str): A URL da API.
        params (dict, optional): Parâmetros da query para a requisição. Defaults to None.
 
    Returns:
        dict or None: O objeto JSON retornado pela API, ou None em caso de erro.
    """
    try:
        response = requests.get(url_api, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Erro ao consumir API {url_api}: {e}")
        return None
    except json.JSONDecodeError:
        print(f"Erro ao decodificar JSON da API {url_api}. Resposta: {response.text[:200]}...")
        return None
 
# Exemplo de uso:
# links = extrair_titulos_e_links("https://www.forjade.dev")
# if links:
#     print(f"Links encontrados em ForjaDev ({len(links)}):")
#     for link in links[:5]: # Mostra os primeiros 5
#         print(f"  - Título: {link['titulo']}, URL: {link['url']}")
 
# print("\n---")
 
# # Exemplo de consumo de API (usando uma API pública de exemplo)
# api_url = "https://jsonplaceholder.typicode.com/posts/1"
# post_data = consumir_api_json(api_url)
# if post_data:
#     print(f"Dados do Post ID 1:\n{json.dumps(post_data, indent=2)}")
 
# api_url_params = "https://jsonplaceholder.typicode.com/comments"
# comments = consumir_api_json(api_url_params, params={'postId': 1})
# if comments:
#     print(f"\nComentários do Post ID 1 ({len(comments)}):\n{json.dumps(comments[0], indent=2)}") # Apenas o primeiro

import pandas as pd
import openpyxl
 
def processar_dados_vendas(caminho_csv: str, caminho_excel_saida: str):
    """
    Lê um CSV de vendas, calcula o total de vendas por produto e salva em um Excel.
 
    Args:
        caminho_csv (str): Caminho para o arquivo CSV de entrada.
        caminho_excel_saida (str): Caminho para o arquivo Excel de saída.
    """
    try:
        # Carrega o CSV para um DataFrame pandas
        df = pd.read_csv(caminho_csv)
        print(f"DataFrame carregado. Primeiras 5 linhas:\n{df.head()}\n")
 
        # Garante que as colunas existem (exemplo de validação)
        if 'Produto' not in df.columns or 'PrecoUnitario' not in df.columns or 'Quantidade' not in df.columns:
            raise ValueError("CSV deve conter as colunas 'Produto', 'PrecoUnitario' e 'Quantidade'.")
 
        # Calcula o total de vendas por item
        df['TotalVenda'] = df['PrecoUnitario'] * df['Quantidade']
 
        # Agrupa por produto e soma os totais
        vendas_por_produto = df.groupby('Produto')['TotalVenda'].sum().reset_index()
        vendas_por_produto = vendas_por_produto.sort_values(by='TotalVenda', ascending=False)
 
        print(f"Vendas totais por produto:\n{vendas_por_produto}\n")
 
        # Salva o resultado em um arquivo Excel
        # Usando openpyxl como motor de escrita para garantir compatibilidade
        vendas_por_produto.to_excel(caminho_excel_saida, index=False, engine='openpyxl')
        print(f"Relatório de vendas salvo em '{caminho_excel_saida}'")
 
    except FileNotFoundError:
        print(f"Erro: Arquivo '{caminho_csv}' não encontrado.")
    except ValueError as ve:
        print(f"Erro de dados: {ve}")
    except Exception as e:
        print(f"Ocorreu um erro inesperado: {e}")
 
# Exemplo de uso:
# # Crie um CSV de exemplo para testar
# with open('vendas.csv', 'w') as f:
#     f.write("Produto,PrecoUnitario,Quantidade\n")
#     f.write("Mouse,50,10\n")
#     f.write("Teclado,120,5\n")
#     f.write("Monitor,800,2\n")
#     f.write("Mouse,55,8\n")
#     f.write("Teclado,125,3\n")
 
# processar_dados_vendas('vendas.csv', 'relatorio_vendas.xlsx')

import subprocess
import os
 
def converter_video_para_mp4(caminho_entrada: str, caminho_saida: str, codec_video: str = 'libx264', crf: int = 23):
    """
    Converte um arquivo de vídeo para o formato MP4 usando FFmpeg.
 
    Args:
        caminho_entrada (str): Caminho para o arquivo de vídeo de entrada.
        caminho_saida (str): Caminho para o arquivo MP4 de saída.
        codec_video (str): Codec de vídeo a ser usado (ex: 'libx264' para H.264).
        crf (int): Constant Rate Factor (0-51, onde 0 é lossless, 23 é padrão).
    """
    if not os.path.exists(caminho_entrada):
        print(f"Erro: Arquivo de entrada '{caminho_entrada}' não encontrado.")
        return
 
    # Comando FFmpeg:
    # -i: arquivo de entrada
    # -c:v: codec de vídeo
    # -crf: Constant Rate Factor (qualidade)
    # -preset: velocidade de codificação (ultrafast, superfast, fast, medium, slow, slower, slowest)
    # -c:a: codec de áudio (copy para copiar o áudio sem re-codificar)
    comando_ffmpeg = [
        'ffmpeg',
        '-i', caminho_entrada,
        '-c:v', codec_video,
        '-crf', str(crf),
        '-preset', 'medium', # Pode ajustar para 'fast' ou 'slow' dependendo da necessidade de velocidade/tamanho
        '-c:a', 'aac',        # Codec de áudio comum para MP4
        '-b:a', '128k',       # Bitrate de áudio
        '-y',                 # Sobrescrever arquivo de saída se existir
        caminho_saida
    ]
 
    print(f"Executando comando FFmpeg: {' '.join(comando_ffmpeg)}")
 
    try:
        # Executa o comando FFmpeg
        processo = subprocess.run(comando_ffmpeg, check=True, capture_output=True, text=True)
        print("Conversão de vídeo concluída com sucesso.")
        print(f"Saída do FFmpeg:\n{processo.stdout}")
        if processo.stderr:
            print(f"Erros/Warnings do FFmpeg:\n{processo.stderr}")
 
    except FileNotFoundError:
        print("Erro: FFmpeg não encontrado. Certifique-se de que está instalado e no seu PATH.")
    except subprocess.CalledProcessError as e:
        print(f"Erro durante a execução do FFmpeg: {e}")
        print(f"Saída Padrão: {e.stdout}")
        print(f"Saída de Erro: {e.stderr}")
    except Exception as e:
        print(f"Ocorreu um erro inesperado: {e}")
 
# Exemplo de uso:
# # Crie um arquivo dummy de vídeo para teste (requer que FFmpeg esteja instalado)
# # Este comando cria um vídeo de 5 segundos com tela preta e áudio mudo
# # subprocess.run(['ffmpeg', '-f', 'lavfi', '-i', 'color=c=black:s=1280x720:d=5', '-f', 'lavfi', '-i', 'anullsrc', '-c:v', 'libx264', '-crf', '23', '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-b:a', '128k', 'input_video.mp4', '-y'])
 
# # converter_video_para_mp4('input_video.mp4', 'output_video.mp4')

from PIL import Image, ImageFilter
import os
 
def processar_imagem(caminho_entrada: str, caminho_saida_redimensionada: str, caminho_saida_grayscale: str, tamanho_novo: tuple = (300, 200)):
    """
    Abre uma imagem, redimensiona e salva em um novo arquivo,
    e também converte para escala de cinza e salva.
 
    Args:
        caminho_entrada (str): Caminho para o arquivo de imagem de entrada.
        caminho_saida_redimensionada (str): Caminho para o arquivo de imagem redimensionada de saída.
        caminho_saida_grayscale (str): Caminho para o arquivo de imagem em escala de cinza de saída.
        tamanho_novo (tuple): Tupla (largura, altura) para o redimensionamento.
    """
    if not os.path.exists(caminho_entrada):
        print(f"Erro: Arquivo de imagem '{caminho_entrada}' não encontrado.")
        return
 
    try:
        with Image.open(caminho_entrada) as img:
            print(f"Imagem '{caminho_entrada}' aberta. Formato: {img.format}, Modo: {img.mode}, Tamanho: {img.size}")
 
            # 1. Redimensionar a imagem
            img_redimensionada = img.resize(tamanho_novo)
            img_redimensionada.save(caminho_saida_redimensionada)
            print(f"Imagem redimensionada para {tamanho_novo} e salva em '{caminho_saida_redimensionada}'")
 
            # 2. Converter para escala de cinza
            img_grayscale = img.convert('L') # 'L' para modo luminância (escala de cinza)
            img_grayscale.save(caminho_saida_grayscale)
            print(f"Imagem convertida para escala de cinza e salva em '{caminho_saida_grayscale}'")
 
            # Exemplo adicional: Aplicar um filtro de nitidez
            img_nitidez = img.filter(ImageFilter.SHARPEN)
            # img_nitidez.save("imagem_nitidez.jpg")
            # print(f"Imagem com nitidez aplicada salva em 'imagem_nitidez.jpg'")
 
    except FileNotFoundError:
        print(f"Erro: Arquivo '{caminho_entrada}' não encontrado.")
    except Exception as e:
        print(f"Ocorreu um erro ao processar a imagem: {e}")
 
# Exemplo de uso:
# # Para testar, você precisará de uma imagem de entrada, por exemplo, 'exemplo.jpg'
# # imagem_entrada_teste = 'exemplo.jpg' # Substitua pelo caminho da sua imagem
# # if not os.path.exists(imagem_entrada_teste):
# #     print(f"Por favor, crie ou coloque uma imagem '{imagem_entrada_teste}' no diretório para testar.")
# # else:
# #     processar_imagem(imagem_entrada_teste, 'exemplo_redimensionada.jpg', 'exemplo_grayscale.jpg')

# Exemplo simplificado de uma API RESTful com Flask
# Salve como app.py e execute `flask run`
from flask import Flask, jsonify, request
 
app = Flask(__name__)
 
# Dados de exemplo
tasks = [
    {'id': 1, 'title': 'Aprender Flask', 'done': False},
    {'id': 2, 'title': 'Escrever artigo ForjaDev', 'done': True}
]
next_task_id = 3
 
@app.route('/tasks', methods=['GET'])
def get_tasks():
    """Retorna todas as tarefas."""
    return jsonify({'tasks': tasks})
 
@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    """Retorna uma tarefa específica pelo ID."""
    task = next((t for t in tasks if t['id'] == task_id), None)
    if task:
        return jsonify({'task': task})
    return jsonify({'message': 'Tarefa não encontrada'}), 404
 
@app.route('/tasks', methods=['POST'])
def create_task():
    """Cria uma nova tarefa."""
    global next_task_id
    if not request.json or not 'title' in request.json:
        return jsonify({'message': 'Título da tarefa é obrigatório'}), 400
    new_task = {
        'id': next_task_id,
        'title': request.json['title'],
        'done': request.json.get('done', False) # Padrão para False se não fornecido
    }
    tasks.append(new_task)
    next_task_id += 1
    return jsonify({'task': new_task}), 201
 
@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    """Atualiza uma tarefa existente."""
    task = next((t for t in tasks if t['id'] == task_id), None)
    if not task:
        return jsonify({'message': 'Tarefa não encontrada'}), 404
    if not request.json:
        return jsonify({'message': 'Dados de atualização ausentes'}), 400
 
    task['title'] = request.json.get('title', task['title'])
    task['done'] = request.json.get('done', task['done'])
    return jsonify({'task': task})
 
@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    """Deleta uma tarefa."""
    global tasks
    initial_len = len(tasks)
    tasks = [t for t in tasks if t['id'] != task_id]
    if len(tasks) < initial_len:
        return jsonify({'message': 'Tarefa deletada com sucesso'}), 200
    return jsonify({'message': 'Tarefa não encontrada'}), 404
 
# Para executar:
# 1. Instale Flask: pip install Flask
# 2. Salve o código acima como `app.py`
# 3. No terminal, defina a variável de ambiente:
#    No Linux/macOS: `export FLASK_APP=app.py`
#    No Windows (CMD): `set FLASK_APP=app.py`
#    No Windows (PowerShell): `$env:FLASK_APP="app.py"`
# 4. Execute: `flask run`
# 5. Acesse http://127.0.0.1:5000/tasks no navegador ou com um cliente HTTP (Postman, curl)

import re
 
def demonstrar_regex():
    """
    Demonstra as principais funcionalidades do módulo `re` em Python.
    """
    texto = "O número de telefone é (11) 98765-4321, email: contato@forjade.dev. Outro telefone: 21-3333-4444."
 
    print(f"Texto original: '{texto}'\n")
 
    # 1. re.search(): Encontra a primeira ocorrência de um padrão.
    # Padrão para número de telefone (formato (XX) XXXXX-XXXX ou XX-XXXX-XXXX)
    padrao_telefone = r'\(\d{2}\) \d{5}-\d{4}|\d{2}-\d{4}-\d{4}'
    match_telefone = re.search(padrao_telefone, texto)
    if match_telefone:
        print(f"re.search (telefone): Encontrado '{match_telefone.group()}' na posição {match_telefone.span()}")
    else:
        print("re.search (telefone): Nenhum telefone encontrado.")
 
    # 2. re.findall(): Encontra todas as ocorrências de um padrão.
    # Padrão para e-mail
    padrao_email = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
    emails_encontrados = re.findall(padrao_email, texto)
    print(f"re.findall (e-mail): {emails_encontrados}")
 
    # 3. re.sub(): Substitui ocorrências de um padrão.
    # Substituir números de telefone por "[TELEFONE_OCULTO]"
    texto_anonimizado = re.sub(padrao_telefone, '[TELEFONE_OCULTO]', texto)
    print(f"re.sub (anonimização): '{texto_anonimizado}'")
 
    # 4. re.match(): Verifica se o padrão corresponde AO INÍCIO da string.
    # (diferente de search, que busca em qualquer lugar)
    texto_com_email_inicio = "meu.email@dominio.com.br é o meu contato."
    match_inicio_email = re.match(padrao_email, texto_com_email_inicio)
    if match_inicio_email:
        print(f"re.match (início da string): Email '{match_inicio_email.group()}' encontrado no início.")
    else:
        print("re.match (início da string): Email não encontrado no início.")
 
    # 5. re.split(): Divide uma string usando um padrão como delimitador.
    log_line = "INFO: 2023-10-27 10:30:00 - Usuário logado com sucesso. ID: 123"
    partes_log = re.split(r': | - ', log_line, maxsplit=3) # Divide por ': ' ou ' - '
    print(f"re.split (log): {partes_log}")
 
    # 6. re.compile(): Compila um padrão Regex para uso repetido, otimizando performance.
    # Útil quando se usa o mesmo padrão várias vezes.
    padrao_compilado = re.compile(r'\b\w{4}\b') # Palavras com exatamente 4 letras
    quatro_letras = padrao_compilado.findall("Este é um teste de palavras curtas.")
    print(f"re.compile (quatro letras): {quatro_letras}")
 
# Executar a demonstração
demonstrar_regex()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
"""
Meu Script Produtivo: Uma descrição concisa do que o script faz.
Exemplo: Processa dados de log e gera um relatório.
"""
 
import os
import sys
import argparse
import logging
 
# Configuração básica de logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
def configurar_argumentos():
    """Configura e parseia os argumentos da linha de comando."""
    parser = argparse.ArgumentParser(description="Processa logs para gerar um relatório.")
    parser.add_argument('caminho_log', type=str, help='Caminho para o arquivo de log de entrada.')
    parser.add_argument('--saida', '-o', type=str, default='relatorio.txt',
                        help='Nome do arquivo de saída do relatório.')
    parser.add_argument('--verbose', '-v', action='store_true',
                        help='Habilita saída de log detalhada.')
    return parser.parse_args()
 
def processar_log(caminho_log: str) -> dict:
    """
    Função principal para processar o arquivo de log.
    Retorna um dicionário com estatísticas ou dados processados.
    """
    if not os.path.exists(caminho_log):
        logging.error(f"Arquivo de log não encontrado: {caminho_log}")
        sys.exit(1)
 
    estatisticas = {'total_linhas': 0, 'erros': 0, 'avisos': 0}
    try:
        with open(caminho_log, 'r', encoding='utf-8') as f:
            for linha_num, linha in enumerate(f, 1):
                estatisticas['total_linhas'] += 1
                if "ERROR" in linha.upper():
                    estatisticas['erros'] += 1
                    logging.debug(f"Erro na linha {linha_num}: {linha.strip()}")
                elif "WARNING" in linha.upper():
                    estatisticas['avisos'] += 1
                    logging.debug(f"Aviso na linha {linha_num}: {linha.strip()}")
        logging.info(f"Processamento de log concluído para '{caminho_log}'.")
    except Exception as e:
        logging.error(f"Erro ao ler o arquivo de log '{caminho_log}': {e}")
        sys.exit(1)
    return estatisticas
 
def gerar_relatorio(dados: dict, caminho_saida: str):
    """
    Gera um relatório formatado a partir dos dados processados.
    """
    try:
        with open(caminho_saida, 'w', encoding='utf-8') as f:
            f.write("--- Relatório de Análise de Log ---\n")
            f.write(f"Total de Linhas Processadas: {dados.get('total_linhas', 0)}\n")
            f.write(f"Erros Encontrados: {dados.get('erros', 0)}\n")
            f.write(f"Avisos Encontrados: {dados.get('avisos', 0)}\n")
            f.write("------------------------------------\n")
        logging.info(f"Relatório gerado em '{caminho_saida}'.")
    except Exception as e:
        logging.error(f"Erro ao gerar relatório em '{caminho_saida}': {e}")
        sys.exit(1)
 
def main():
    """Função principal do script."""
    args = configurar_argumentos()
 
    if args.verbose:
        logging.getLogger().setLevel(logging.DEBUG)
        logging.debug("Modo verbose ativado.")
 
    logging.info(f"Iniciando processamento do log: {args.caminho_log}")
    dados_processados = processar_log(args.caminho_log)
    gerar_relatorio(dados_processados, args.saida)
    logging.info("Script concluído.")
 
if __name__ == "__main__":
    main()
 

# No ambiente virtual ativado, após instalar suas dependências
pip freeze > requirements.txt
 
# Para instalar dependências em um novo ambiente
pip install -r requirements.txt

def calcular_media(numeros: list[float]) -> float:
    """
    Calcula a média aritmética de uma lista de números.
 
    Args:
        numeros (list[float]): Uma lista de números de ponto flutuante.
 
    Returns:
        float: A média dos números na lista. Retorna 0.0 se a lista estiver vazia.
 
    Raises:
        TypeError: Se a entrada não for uma lista ou contiver não-números.
    """
    if not isinstance(numeros, list):
        raise TypeError("A entrada deve ser uma lista de números.")
    if not all(isinstance(n, (int, float)) for n in numeros):
        raise TypeError("Todos os elementos da lista devem ser números.")
 
    if not numeros:
        return 0.0
    return sum(numeros) / len(numeros)