Como Fazer um Validador de CPF com Python de forma simples e refatorada!
Tags: python, validadorcpf
Published: 2024-04-19 13:03:06

CPF ou Cadastro de Pessoa Fisica é um documento com numeração única que pertence a uma pessoa para sempre. Ele é composto de nove dígitos iniciais, mais dois dígitos verificadores, totalizando onze dígitos.

A validação do CPF baseia-se na análise dos nove primeiros dígitos em comparação com os dois últimos dígitos verificadores, sendo assim esta verificação é feita em duas partes, cada um com suas devidas particularidades.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/i3jgy8alw5inqoj1n41u.png)

**- Primeira Validação:**
Multiplicamos os nove primeiros dígitos do CPF pelos valores de 10 a 2.
Se a soma desses produtos dividida por 11 resultar em um resto menor ou igual a 1, o penúltimo dígito do CPF deve ser zero.
Se o resto for maior que 2, o penúltimo dígito do CPF deve ser 11 menos o resto.

**- Segunda Validação:**
Repetimos o processo, começando a multiplicação pelo número 11.
Adicionamos o primeiro dígito verificador na soma.
Verificamos novamente as regras para o último dígito do CPF.


Abaixo, um código que foi elaborado de forma explicativa e simples, sem a utilização de bibliotecas, para facilitar a compreensão, mesmo para aqueles que não conhecem a linguagem Python.

```
# Criado abaixo uma função para validar um CPF digitado.
NOVO_CPF = list(input("Digite um CPF para ser validado >>>"))
NOVO_CPF_STRING = " ".join(NOVO_CPF)

def validacao_cpf():
    if len(NOVO_CPF) == 11:
        primeiro1 = int(NOVO_CPF[0]) * 10
        primeiro2 = int(NOVO_CPF[1]) * 9
        primeiro3 = int(NOVO_CPF[2]) * 8
        primeiro4 = int(NOVO_CPF[3]) * 7
        primeiro5 = int(NOVO_CPF[4]) * 6
        primeiro6 = int(NOVO_CPF[5]) * 5
        primeiro7 = int(NOVO_CPF[6]) * 4
        primeiro8 = int(NOVO_CPF[7]) * 3
        primeiro9 = int(NOVO_CPF[8]) * 2

        seg_primeiro1 = int(NOVO_CPF[0]) * 11
        seg_primeiro2 = int(NOVO_CPF[1]) * 10
        seg_primeiro3 = int(NOVO_CPF[2]) * 9
        seg_primeiro4 = int(NOVO_CPF[3]) * 8
        seg_primeiro5 = int(NOVO_CPF[4]) * 7
        seg_primeiro6 = int(NOVO_CPF[5]) * 6
        seg_primeiro7 = int(NOVO_CPF[6]) * 5
        seg_primeiro8 = int(NOVO_CPF[7]) * 4
        seg_primeiro9 = int(NOVO_CPF[8]) * 3
        seg_primeiro10 = int(NOVO_CPF[9]) * 2

        soma_validacao = (primeiro1 + primeiro2 + primeiro3 + primeiro4 + primeiro5 + primeiro6 + primeiro7 + primeiro8 + primeiro9)
        divisao_soma = (soma_validacao // 11)
        resto = (soma_validacao - (11 * divisao_soma))

        soma_validacao_2 = (seg_primeiro1 + seg_primeiro2 + seg_primeiro3 + seg_primeiro4 + seg_primeiro5 + seg_primeiro6 + seg_primeiro7 + seg_primeiro8 + seg_primeiro9 + seg_primeiro10)
        divisao_soma_2 = (soma_validacao_2 // 11)
        resto_2 = (soma_validacao_2 - (11 * divisao_soma_2))
        
        antepenultimo_digito_cpf = int(NOVO_CPF[8])
        penultimo_digito_cpf = int(NOVO_CPF[9])
        ultimo_digito_cpf = int(NOVO_CPF[10])

        val_1 = False
        val_2 = False
        val_3 = False
        val_4 = False

        if(resto <=1) and (penultimo_digito_cpf == 0):
            val_1 = True
        if( resto >=2 and resto < 10) and (11 - resto == penultimo_digito_cpf):
            val_2 = True
        if( resto_2 <=1 ) and (ultimo_digito_cpf == 0):
            val_3 = True
        if ( resto_2 >=2 and resto_2 < 10 ) and (11 - resto_2 == ultimo_digito_cpf):
            val_4 = True
        else: ()

        if (val_1 == True or val_2 == True) and (val_3 == True or val_4 == True):
            print(f"O CPF número: {NOVO_CPF_STRING} é válido !")
        else:
            print(f"O CPF número: {NOVO_CPF_STRING} é inválido, tente novamente.")

        #Abaixo Validação dos estado de origem do CPF
        if antepenultimo_digito_cpf == 1:
            print("Seu CPF é originário do estado do Distrito Federal, Goiás, Mato Grosso do Sul ou Tocantins")
        elif antepenultimo_digito_cpf == 2:
            print("Seu CPF é originário do estado do Pará, Amazonas, Acre, Amapá, Rondônia ou Roraima")
        elif antepenultimo_digito_cpf == 3:
            print("Seu CPF é originário do estado do Ceará, Maranhão ou Piauí")
        elif antepenultimo_digito_cpf == 4:
            print("Seu CPF é originário do estado de Pernambuco, Rio Grande do Norte, Paraíba ou Alagoas")
        elif antepenultimo_digito_cpf == 5:
            print("Seu CPF é originário do estado da Bahia; e Sergipe")
        elif antepenultimo_digito_cpf == 6:
            print("Seu CPF é originário de Minas Gerais")
        elif antepenultimo_digito_cpf == 7:
            print("Seu CPF é originário do estado do Rio de Janeiro ou Espírito Santo")
        elif antepenultimo_digito_cpf == 8:
            print("Seu CPF é originário do estado de São Paulo")
        elif antepenultimo_digito_cpf == 9:
            print("Seu CPF é originário do estado do Paraná ou Santa Catarina")
        else:
            print("Seu CPF é de origem do estado do Rio Grande do Sul")

    else: 
        print(f"O CPF número: {NOVO_CPF_STRING} é inválido, tente novamente.")

validacao_cpf()
```
Abaixo, eu reescrevi o código, refatorando-o para torna-lo mais legível e fácil de entender, utilizando alguns artifícios da biblioteca re, possibilitando maior facilidade para manutenções futuras, deixando o código menor e mais enxuto.

```
import re

def validador():
    cpf = input("Digite um CPF para ser validado ao lado. >>>")

    # Retira apenas os dígitos do CPF, ignorando os caracteres especiais
    numeros = [int(digito) for digito in cpf if digito.isdigit()]
    
    formatacao = False
    quant_digitos = False
    validacao1 = False
    validacao2 = False

    # Verifica a estrutura do CPF (111.222.333-44) ou (11122233344)
    if re.match(r'\d{3}\.\d{3}\.\d{3}-\d{2}', cpf) or re.match(r'\d{11}', cpf):
        formatacao = True

    if len(numeros) == 11:
        quant_digitos = True
    
        soma_produtos = sum(a * b for a, b in zip(numeros[0:9], range(10, 1, -1)))
        digito_esperado = (soma_produtos * 10 % 11) % 10
        if numeros[9] == digito_esperado:
            validacao1 = True

        soma_produtos1 = sum(a * b for a, b in zip(numeros[0:10], range(11, 1, -1)))
        digito_esperado1 = (soma_produtos1 * 10 % 11) % 10
        if numeros[10] == digito_esperado1:
            validacao2 = True

        if quant_digitos and formatacao and validacao1 and validacao2:
            print(f"O CPF {cpf} é válido.")
        else:
            print(f"O CPF {cpf} não é válido... Tente outro CPF...")

        # Verificação dos estados de origem do CPF
        estado_origem = numeros[8]
        estados = {
            1: "Distrito Federal, Goiás, Mato Grosso do Sul ou Tocantins",
            2: "Pará, Amazonas, Acre, Amapá, Rondônia ou Roraima",
            3: "Ceará, Maranhão ou Piauí",
            4: "Pernambuco, Rio Grande do Norte, Paraíba ou Alagoas",
            5: "Bahia ou Sergipe",
            6: "Minas Gerais",
            7: "Rio de Janeiro ou Espírito Santo",
            8: "São Paulo",
            9: "Paraná ou Santa Catarina"
        }
        if estado_origem in estados:
            print(f"Seu CPF é originário do estado de {estados[estado_origem]}.")
        else:
            print("Seu CPF é de origem do estado do Rio Grande do Sul")

    else:
        print(f"O CPF {cpf} não é válido... Tente outro CPF...")

validador()
```
Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!

﻿

**Segue o Link do meu GitHub** com o código Simples: [Meu GitHUb](https://github.com/Carlos-CGS/ProjetosPython/tree/main/Validador%20de%20CPF%20Python%20-%20C%C3%B3digo%20Simples)

**Segue o Link do meu GitHub** com o código Refatorado: [Códigos](https://github.com/Carlos-CGS/ProjetosPython/blob/main/Validador%20CPF%20Python%20-%20vers%C3%A3o%20Melhorada/Validador_de_CPF_01.py)

**Segue o Link do meu LinkedIn**: [Meu LinkedIn](https://www.linkedin.com/in/carlos-cgs/)