Processando Arquivos: Leitura e Hash MD5 por Linha

Ao trabalhar com arquivos, é comum precisar processar seu conteúdo linha por linha. Um caso de uso comum é calcular um hash criptográfico para cada linha, como MD5, para verificar a integridade ou para indexação. Python oferece ferramentas robustas para ambas as tarefas.

O módulo hashlib do Python fornece várias algoritmos de hash criptográficos. Para o MD5, o processo envolve criar um objeto hash, atualizar esse objeto com os dados codificados (geralmente UTF-8) e, em seguida, obter o hash em formato hexadecimal.

import hashlib

def gerar_hash_md5(texto):
    """Calcula o hash MD5 de uma string."""
    hasher = hashlib.md5()
    hasher.update(texto.encode('utf-8'))
    return hasher.hexdigest()

# Exemplo de uso: processar um arquivo linha por linha
caminho_arquivo = "dados_exemplo.txt" # Certifique-se de que este arquivo existe
try:
    with open(caminho_arquivo, 'r', encoding='utf-8') as arquivo_entrada:
        print(f"Calculando MD5 para cada linha de '{caminho_arquivo}':")
        for linha in arquivo_entrada:
            linha_limpa = linha.strip() # Remove espaços em branco e quebras de linha
            if linha_limpa: # Processa apenas linhas não vazias
                hash_da_linha = gerar_hash_md5(linha_limpa)
                print(f"'{linha_limpa}' -> {hash_da_linha}")
except FileNotFoundError:
    print(f"Erro: O arquivo '{caminho_arquivo}' não foi encontrado.")
except Exception as e:
    print(f"Ocorreu um erro: {e}")

Métodos para Formatar e Concatenar Strings em Python

A manipulação de strings é uma tarefa fundamental em qualquer linguagem de programação. Python oferece diversas abordagens para concatenar e formatar strings, cada uma com suas vantagens e cenários de uso ideais.

1. Usando o Operador +

A maneira mais direta de concatenar strings é com o operador +. É simples para poucas strings, mas pode ser menos eficiente para muitas operações de concatenação, pois cria um novo objeto string a cada adição.

prefixo = "Olá"
nome = "Mundo"
saudacao = prefixo + ", " + nome + " Python!"
print(saudacao)
# Saída: Olá, Mundo Python!

2. Formatação com o Operador % (Antiga Estilo)

Inspirado na linguagem C, este método usa placeholders como %s para strings, %d para inteiros, e %f para floats. É um método mais antigo, mas ainda presente em muitos códigos legados.

linguagem = "Python"
versao = 3.9
mensagem = "A linguagem %s na versão %.1f é incrível!" % (linguagem, versao)
print(mensagem)
# Saída: A linguagem Python na versão 3.9 é incrível!

3. O Método str.format()

Uma evolução do operador %, o método str.format() oferece maior flexibilidade e legibilidade. Ele usa chaves {} como placeholders, que podem ser preenchidos por posição, nome ou combinação.

# Por posição
frase1 = 'Bem-vindo ao mundo {}! Meu nome é {}.'.format('da programação', 'João')
print(frase1)
# Saída: Bem-vindo ao mundo da programação! Meu nome é João.

# Por nome (argumentos de palavra-chave)
frase2 = 'Conheço {nome_linguagem} e também {nome_framework}.'.format(nome_linguagem='Python', nome_framework='Django')
print(frase2)
# Saída: Conheço Python e também Django.

Cuidado: Evite espaços dentro das chaves, como { nome }, pois isso causará um KeyError se não houver um argumento nomeado correspondente com espaços.

4. F-Strings (Formatted String Literals)

Introduzidas no Python 3.6, as f-strings são a forma mais moderna e recomendada de formatação de strings. Elas permitem incorporar expressões Python diretamente dentro de strings literais, prefixando-as com f ou F.

usuario = "Maria"
idade = 30
frase = f"Olá {usuario}. Você tem {idade} anos."
print(frase)
# Saída: Olá Maria. Você tem 30 anos.

# Expressões podem ser avaliadas dentro das chaves
preco = 25.50
quantidade = 3
total = f"O custo total é R${preco * quantidade:.2f}."
print(total)
# Saída: O custo total é R$76.50.

5. O Método str.join()

O método str.join() é altamente eficiente para conctaenar um grande número de strings de uma lista ou qualquer outro iterável. Ele usa uma string separadora para unir os elementos.

palavras = ['Aprendendo', 'Python', 'agora']
sentenca_espaco = ' '.join(palavras)
print(sentenca_espaco)
# Saída: Aprendendo Python agora

termos = ('banco', 'de', 'dados', 'sql')
sentenca_underline = '_'.join(termos)
print(sentenca_underline)
# Saída: banco_de_dados_sql

6. Template Strings com string.Template

Para cenários onde as strings de template são fornecidas por usuários ou precisam de substituição segura (evitando injeção de código), o módulo string.Template é uma excelente escolha. Ele usa o cifrão $ para indicar placeholders.

from string import Template

template_msg = Template('$assunto, $nome!')
saudacao_personalizada = template_msg.safe_substitute(assunto="Boas-vindas", nome="colega")
print(saudacao_personalizada)
# Saída: Boas-vindas, colega!

# Se um placeholder não for fornecido para substitute(), ele levanta um KeyError.
# safe_substitute() deixa o placeholder intacto se não encontrar uma substituição.
template_seguro = Template('Olá $quem! $mensagem')
print(template_seguro.safe_substitute(quem='Mundo'))
# Saída: Olá Mundo! $mensagem

Comprehensions: Listas, Dicionários e Conjuntos

Comprehensions são uma característica poderosa de Python para criar novas sequências (listas, dicionários, conjuntos) a partir de outras iteráveis de forma concisa e legível.

List Comprehension

Cria uma nova lista aplicando uma expressão a cada item de um iterável, opcionalmente filtrando os itens.

valores_base = [1, 2, 3, 4, 5]
valores_dobrados = [x * 2 for x in valores_base]
print(f"Valores dobrados: {valores_dobrados}")
# Saída: Valores dobrados: [2, 4, 6, 8, 10]

numeros = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
pares_divisiveis_por_4 = [num for num in numeros if num % 2 == 0 and num % 4 == 0]
print(f"Pares divisíveis por 4: {pares_divisiveis_por_4}")
# Saída: Pares divisíveis por 4: [12, 16, 20]

Set Comprehension

Similar ao list comprehension, mas cria um conjunto, garantindo que todos os elementos sejam únicos.

dados_repetidos = [1, 2, 3, 4, 5, 2, 6, 4, 1, 4, 5, 8, 7, 9, 0, 1, 2]
numeros_unicos_impares = {x for x in dados_repetidos if x % 2 != 0}
print(f"Números ímpares únicos: {numeros_unicos_impares}")
# Saída: Números ímpares únicos: {1, 3, 5, 7, 9} (ordem pode variar)

Dict Comprehension

Cria um novo dicionário, onde cada item é um par chave-valor gerado a partir de um iterável.

quadrados = {x: x**2 for x in range(1, 6)}
print(f"Quadrados: {quadrados}")
# Saída: Quadrados: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

cidades = ["São Paulo", "Rio de Janeiro", "Belo Horizonte"]
cidade_id = {cidade: idx for idx, cidade in enumerate(cidades)}
print(f"Cidades com ID: {cidade_id}")
# Saída: Cidades com ID: {'São Paulo': 0, 'Rio de Janeiro': 1, 'Belo Horizonte': 2}

Opeardor Ternário (Expressão Condicional)

O operador ternário permite atribuir um valor a uma variável com base em uma condição, em uma única linha, tornando o código mais compacto e legível para condições simples.

# Sintaxe: valor_se_verdadeiro if condicao else valor_se_falso

temperatura = 28
status = "Quente" if temperatura > 25 else "Frio"
print(f"O tempo está: {status}")
# Saída: O tempo está: Quente

humor = "Feliz" if temperatura > 25 else ("Neutro" if temperatura == 25 else "Triste")
print(f"Meu humor está: {humor}")
# Saída: Meu humor está: Feliz (exemplo de aninhamento)

O operador ternário pode ser usado em várias situações, inclusive na criação de objetos ou em compreensões:

class RelatorioCurto:
    def __init__(self, dado):
        self.dado = dado
        print(f"Relatório Curto: {self.dado}")

class RelatorioCompleto:
    def __init__(self, dado):
        self.dado = dado
        print(f"Relatório Completo: {self.dado} - Gerado com detalhes adicionais.")

modo_debug = False
gerador_relatorio = RelatorioCompleto if modo_debug else RelatorioCurto
relatorio_instancia = gerador_relatorio("Dados de Processamento")
# Saída: Relatório Curto: Dados de Processamento

# Em List Comprehension
valores = [1, 5, 12, 8, 15]
processados = [v * 10 if v > 10 else v + 1 for v in valores]
print(f"Valores processados: {processados}")
# Saída: Valores processados: [2, 6, 120, 9, 150]

Iteração Paralela com zip()

A função zip() é usada para combinar elementos de múltiplos iteráveis em tuplas, agrupando os elementos de mesma posição. É útil para iterar em duas ou mais listas simultaneamente.

nomes = ["Alice", "Bob", "Carlos"]
idades = [25, 30, 22]

print("Nomes e idades:")
for nome, idade in zip(nomes, idades):
    print(f"- {nome}: {idade} anos")
# Saída:
# - Alice: 25 anos
# - Bob: 30 anos
# - Carlos: 22 anos

# Criando um dicionário a partir de duas listas
cargos = ["Desenvolvedor", "Designer", "Gerente"]
salarios = [7000, 6000, 9000]
equipe_salarios = dict(zip(cargos, salarios))
print(f"Salários por cargo: {equipe_salarios}")
# Saída: Salários por cargo: {'Desenvolvedor': 7000, 'Designer': 6000, 'Gerente': 9000}

Iterando com Índices usando enumerate()

Quando você precisa iterar sobre uma sequência (como uma lista ou tupla) e, ao mesmo tempo, ter acesso ao índice de cada item, a função enumerate() é a solução mais pythonica e eficiente.

produtos = ["Teclado", "Mouse", "Monitor", "Webcam"]

print("Produtos com seus índices:")
for indice, produto in enumerate(produtos):
    print(f"Item {indice}: {produto}")
# Saída:
# Item 0: Teclado
# Item 1: Mouse
# Item 2: Monitor
# Item 3: Webcam

Gerando Combinações e Permutações com itertools

O módulo itertools oferece ferramentas para criar iteradores eficientes para loops. combinations e permutations são particularmente úteis para problemass combinatórios.

Combinações com itertools.combinations

Retorna todas as subsequências de comprimento r de um iterável, onde a ordem dos elementos não importa.

from itertools import combinations

cores = ["vermelho", "azul", "verde", "amarelo"]
print("Combinações de 2 cores:")
for comb in combinations(cores, 2):
    print(comb)
# Saída:
# ('vermelho', 'azul')
# ('vermelho', 'verde')
# ('vermelho', 'amarelo')
# ('azul', 'verde')
# ('azul', 'amarelo')
# ('verde', 'amarelo')

Permutações com itertools.permutations

Retorna todas as sequências possíveis de comprimento r de um iterável, onde a ordem dos elementos importa.

from itertools import permutations

numeros_atuais = [1, 2, 3]
print("Permutações de 2 números:")
for perm in permutations(numeros_atuais, 2):
    print(perm)
# Saída:
# (1, 2)
# (1, 3)
# (2, 1)
# (2, 3)
# (3, 1)
# (3, 2)

É crucial notar que combinações focam em grupos únicos de itens (a ordem não altera o grupo), enquanto permutações se preocupam com a ordem dos itens dentro desses grupos.

Contagem de Ocorrências com collections.Counter

O tipo Counter do módulo collections é uma subclasse de dicionário usada para contar objetos hashable. É ideal para determinar a frequência de elementos em um iterável.

from collections import Counter

# Contando letras em uma string
texto_exemplo = "programando em python"
contagem_letras = Counter(texto_exemplo)
print(f"Contagem de letras: {contagem_letras}")
# Saída: Contagem de letras: Counter({'p': 2, 'r': 2, 'o': 2, 'a': 1, 'g': 1, 'm': 2, 'n': 2, 'd': 1, 'e': 1, 'i': 1, 't': 1, 'h': 1, 'y': 1, ' ': 2})

# Encontrando os N elementos mais comuns
elementos_mais_comuns = contagem_letras.most_common(3)
print(f"3 elementos mais comuns: {elementos_mais_comuns}")
# Saída: 3 elementos mais comuns: [('p', 2), ('r', 2), ('o', 2)] (ordem pode variar para empates)

Encontrando o Elemento Mais Frequente em uma Lista

Para identificar o elemento que aparece com mais frequência em uma lista, você pode usar collections.Counter ou uma combinação de max() com key e list.count().

from collections import Counter

lista_numeros = [1, 5, 2, 8, 5, 1, 3, 5, 4, 8, 2, 5, 9, 3]

# Método 1: Usando collections.Counter (geralmente mais eficiente)
contador = Counter(lista_numeros)
elemento_mais_freq_counter = contador.most_common(1)[0][0]
print(f"Elemento mais frequente (Counter): {elemento_mais_freq_counter}")
# Saída: Elemento mais frequente (Counter): 5

# Método 2: Usando max() com key=list.count (mais conciso para listas menores)
# Note: set(lista_numeros) para garantir que cada elemento seja contado apenas uma vez
elemento_mais_freq_max = max(set(lista_numeros), key=lista_numeros.count)
print(f"Elemento mais frequente (max com count): {elemento_mais_freq_max}")
# Saída: Elemento mais frequente (max com count): 5

Operações com Conjuntos (Sets)

Conjuntos em Python são coleções de itens únicos e não ordenados. Eles são excelentes para operações matemáticas de conjuntos como união, interseção, diferença e diferença simétrica.

set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}

print(f"Conjunto A: {set_a}")
print(f"Conjunto B: {set_b}")

# União: Elementos em A OU B
uniao = set_a | set_b
# Alternativa: uniao = set_a.union(set_b)
print(f"União (A | B): {uniao}")
# Saída: União (A | B): {1, 2, 3, 4, 5, 6, 7, 8}

# Interseção: Elementos em A E B
intersecao = set_a & set_b
# Alternativa: intersecao = set_a.intersection(set_b)
print(f"Interseção (A & B): {intersecao}")
# Saída: Interseção (A & B): {4, 5}

# Diferença: Elementos em A MAS NÃO em B
diferenca = set_a - set_b
# Alternativa: diferenca = set_a.difference(set_b)
print(f"Diferença (A - B): {diferenca}")
# Saída: Diferença (A - B): {1, 2, 3}

# Diferença Simétrica: Elementos em A OU B, MAS NÃO em AMBOS
diferenca_simetrica = set_a ^ set_b
# Alternativa: diferenca_simetrica = set_a.symmetric_difference(set_b)
print(f"Diferença Simétrica (A ^ B): {diferenca_simetrica}")
# Saída: Diferença Simétrica (A ^ B): {1, 2, 3, 6, 7, 8}

Removendo Duplicatas de uma Lista

Remover elementos duplicados de uma lista é uma tarefa comum. Python oferece várias maneiras de fazer isso, cada uma com características diferentes em relação à preservação da ordem e eficiência.

minha_lista = [10, 20, 30, 20, 40, 50, 10, 30, 60]
print(f"Lista original: {minha_lista}")

# Método 1: Usando Conjunto (Set) - Mais simples, mas não preserva a ordem original
lista_sem_duplicatas_set = list(set(minha_lista))
print(f"Sem duplicatas (via set, ordem não garantida): {lista_sem_duplicatas_set}")
# Saída: Sem duplicatas (via set, ordem não garantida): [50, 20, 40, 10, 60, 30] (ordem pode variar)

# Método 2: Usando Dicionário (fromkeys) - Preserva a ordem de inserção (Python 3.7+)
lista_sem_duplicatas_dict = list(dict.fromkeys(minha_lista))
print(f"Sem duplicatas (via dict.fromkeys, ordem preservada): {lista_sem_duplicatas_dict}")
# Saída: Sem duplicatas (via dict.fromkeys, ordem preservada): [10, 20, 30, 40, 50, 60]

# Método 3: Usando um loop e verificação (mais explícito, menos Pythônico para grandes listas)
lista_sem_duplicatas_loop = []
for item in minha_lista:
    if item not in lista_sem_duplicatas_loop:
        lista_sem_duplicatas_loop.append(item)
print(f"Sem duplicatas (via loop, ordem preservada): {lista_sem_duplicatas_loop}")
# Saída: Sem duplicatas (via loop, ordem preservada): [10, 20, 30, 40, 50, 60]

# Método 4: Usando set e sort com chave para preservar a ordem (combinação, menos intuitivo)
# Não é um método direto, mas uma forma de "reordenar" após usar set.
# lista_temp = list(set(minha_lista))
# lista_temp.sort(key=minha_lista.index) # Isso não funciona diretamente como esperado para todos os casos
# O método 2 (dict.fromkeys) é preferível para ordem preservada.

Interagindo com Scripts Python na Linha de Comando

Python oferece diferentes maneiras de interagir com seus scripts através da linha de comando, seja passando argumentos diretamente ou solicitando entrada do usuário durante a execução.

Passando Argumentos via sys.argv

O módulo sys contém uma lista de argumentos de linha de comando passados para um script Python em sys.argv. O primeiro elemento (sys.argv[0]) é sempre o nome do script.

Considere o script processar_usuario.py:

# processar_usuario.py
import sys
import json
# Importar requests e time apenas se realmente usados
# import requests
# import time 

print(f"Nome do script: {sys.argv[0]}")

if len(sys.argv) < 4:
    print("Uso: python processar_usuario.py <ID_Usuario> <Nome_Usuario> <ID_Empresa>")
    sys.exit(1)

# Desempacotar os argumentos da linha de comando
nome_script, id_usuario, nome_usuario, id_empresa = sys.argv

print(f"Processando dados para:")
print(f"  ID do Usuário: {id_usuario}")
print(f"  Nome do Usuário: {nome_usuario}")
print(f"  ID da Empresa: {id_empresa}")

# Simular parâmetros de uma requisição
parametros_simulados = {
    "userId": id_usuario,
    "userName": nome_usuario,
    "enterpriseId": id_empresa,
    "status": "ativo"
}

print("\nParâmetros simulados para uma API (apenas para demonstração):")
print(json.dumps(parametros_simulados, indent=4, ensure_ascii=False))

# Exemplo de como você faria uma requisição real (requer a biblioteca 'requests')
# try:
#     import requests
#     # url_api = "http://api.exemplo.com/usuarios/atualizar"
#     # resposta = requests.put(url_api, json=parametros_simulados)
#     # print(f"\nResposta da API: {resposta.status_code}")
#     # print(json.dumps(resposta.json(), indent=4, ensure_ascii=False))
# except ImportError:
#     print("\n'requests' não está instalado. Simulação de API limitada.")

Para executá-lo no terminal:

python processar_usuario.py 12345 "Maria Silva" 9876

Obtendo Entrada Interativa com input()

Para scripts que precisam de dados do usuário durante a execução, a função input() solicita uma string ao usuário no terminal e retorna essa string.

Considere o script configurar_servico.py:

# configurar_servico.py
import json
import time

print("--- Configuração de Serviço ---")

# Solicitar dados ao usuário
nome_servico = input("Digite o nome do serviço: ")
porta_servico = input("Digite a porta do serviço (ex: 8080): ")
ambiente = input("Digite o ambiente (desenvolvimento/produção): ")

print(f"\nIniciando configuração para o serviço '{nome_servico}' no ambiente '{ambiente}'...")
print("Aguarde, por favor...")

tempo_inicio = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
print(f"Hora de início: {tempo_inicio}")

# Simular uma configuração ou chamada de API com os dados fornecidos
configuracao = {
    "nomeServico": nome_servico,
    "porta": int(porta_servico), # Converte para inteiro, assumindo entrada numérica
    "ambiente": ambiente,
    "status": "configurado"
}

print("\nConfiguração aplicada (simulada):")
print(json.dumps(configuracao, indent=4, ensure_ascii=False))

tempo_fim = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
print(f"\nHora de término: {tempo_fim}")

input('\nPressione Enter para sair...')

Para executá-lo no terminal:

python configurar_servico.py

O script irá pausar e solicitar cada entrada do usuário.