Validar CPFs repetidamente pode ser um processo lento e ineficiente, especialmente ao lidar com grandes volumes de dados. Implementar um sistema de cache para armazenar os resultados de validação evita reprocessamentos desnecessários, economizando tempo e recursos computacionais.
Crie uma função que valide o CPF usando o algoritmo padrão de verificação dos dígitos verificadores.
def validar_cpf(cpf: str) -> bool:
cpf = ''.join(filter(str.isdigit, cpf))
if len(cpf) != 11 or cpf == cpf[0] * 11:
return False
def calculo_digito(digitos: str) -> int:
soma = sum(int(d) * (len(digitos) + 1 - i) for i, d in enumerate(digitos))
resto = soma % 11
return 0 if resto < 2 else 11 - resto
d1 = calculo_digito(cpf[:9])
d2 = calculo_digito(cpf[:9] + str(d1))
return str(d1) == cpf[9] and str(d2) == cpf[10]Utilize um dicionário Python para armazenar os resultados das validações, evitando reprocessamentos.
cache_validacao = {}
def validar_cpf_cache(cpf: str) -> bool:
cpf_limpo = ''.join(filter(str.isdigit, cpf))
if cpf_limpo in cache_validacao:
return cache_validacao[cpf_limpo]
resultado = validar_cpf(cpf)
cache_validacao[cpf_limpo] = resultado
return resultadoAplique a validação com cache em um arquivo CSV contendo CPFs, gerando um novo arquivo com os resultados.
import csv
def processar_csv(input_file: str, output_file: str):
with open(input_file, 'r') as infile, open(output_file, 'w', newline='') as outfile:
reader = csv.DictReader(infile)
fieldnames = reader.fieldnames + ['valido']
writer = csv.DictWriter(outfile, fieldnames=fieldnames)
writer.writeheader()
for row in reader:
cpf = row['cpf']
row['valido'] = 'Sim' if validar_cpf_cache(cpf) else 'Não'
writer.writerow(row)| CPF (Entrada) | Válido (Cache) | Válido (Sem Cache) |
|---|---|---|
| 123.456.789-09 | Não | Não |
| 529.982.247-25 | Sim | Sim |
| 111.111.111-11 | Não | Não |
| 529.982.247-25 (repetido) | Sim (retornado do cache) | Sim |
Com este método, você reduz significativamente o tempo de processamento ao evitar validações redundantes, tornando o sistema mais eficiente e escalável para grandes conjuntos de dados.