Python Brasil: validação de dados no padrão nacional

Validando CPF e acessando o PYPI - Introdução

Boas vindas!

Sou o instrutor Rodrigo Siqueira e este é o curso de Python Brasilidades: Validação de Dados no Padrão Nacional.

Em nossas aulas, atenderemos as solicitações de construção da biblioteca de classes para o banco fictício ByteBank.

Utilizando o PyCharm, criaremos diversas classes com funções diferentes; primeiro, geraremos a Documento que será uma factory, ou seja, um padrão de projeto responsável por decidir se instanciará a DocCpf ou DocCnpj, de acordo com o documento que passaremos para a classe.

Depois faremos validação e formatação de número de telefone utilizando expressões regulares.

Em seguida, usaremos a biblioteca datetime e timedelta do Python para fazermos com que as informações de cadastro de usuário sejam salvas e exibidas da forma com que estamos acostumados a ver aqui no Brasil.

Também usaremos uma formatação específica da timedelta chamada strftime e alguns métodos para conseguirmos mostrar o dia da semana e meses do ano dentro dos padrões nacionais.

Outra função dessa classe será mostrar o tempo de cadastro de usuário, e para isso usaremos o timedelta também.

Por fim, criaremos a classe BuscaEndereco responsável por formatar e validar CEP, além de acessar uma API ou WebService online em tempo real que enviará o CEP e receberá uma informação serializada do endereço de usuário, contendo informações de ruas, bairros, estados e etc. que possibilitará o envio de boletos aos clientes.

Vamos lá!

Validando CPF e acessando o PYPI - Validando um CPF

Nesta parte, mostraremos as funcionalidades que serão implementadas na biblioteca de classes de acordo com as demandas do Bytebank.

Dividiremos cada solicitação em uma classe com algumas exceções, de forma a sempre termos uma validação e uma máscara. Ao final, haverão alguns detalhes que discutiremos melhor futuramente.

Primeiro, começaremos verificando se o CPF possui onze caracteres ou não, para depois apurarmos mais precisamente utilizando bibliotecas do PyPI.

Em seguida, faremos uma máscara tanto para o CPF quanto para o CNPJ, o qual também será validado com quatorze caracteres através dos mesmos recursos.

Quando trabalharmos com telefone fixo e celular, validaremos a quantidade de caracteres novamente com uma abordagem um pouco diferente dos elementos anteriores.

Depois trabalharemos com data e hora para podermos printar esses dados corretamente, da maneira que estamos acostumados a visualizar aqui no Brasil.

Por fim, validaremos e faremos a máscara do CEP. Acessando um WebService, enviaremos um CEP e receberemos informações do endereço, como rua, número, bairro, cidade e etc.

Partiremos para a parte prática no PyCharm.

Criaremos um novo projeto chamado python-brasilidades que receberá um novo arquivo main.py, onde testaremos toda nossa lógica antes de importarmos e testarmos a classe dentro deste file.

Para começarmos, a primeira solicitação é a verificação dos onze dígitos obrigatórios do CPF. Gerarmos um cpf qualquer de número 15616987913 e verificarmos a quantidade de caracteres com o método len() por meio da variável tamanho_cpf.

Imprimiremos o tamanho_cpf e clicaremos com o botão direito sobre a tela para selecionar "Run 'main'" e executar o código.

cpf = 15616987913
tamanho_cpf = len(cpf)
print(tamanho_cpf)

Como retorno, receberemos um erro indicando que o objeto do tipo int não possui len(). Lembramos que é muito importante no dia-a-dia lermos e analisarmos todos os erros apresentados. Isso significa que precisaremos para extrair a quantidade de caracteres através do tipo str, já que o tipo inteiro não suporta o método len().

Métodos especiais podem ser vistos no Curso Python: Manipulação de Strings e em outros conteúdos escritos sobre o tema aqui da plataforma Alura, o que é altamente recomendado.

cpf = "15616987913"
tamanho_cpf = len(cpf)
print(tamanho_cpf)

Executando o código, o sistema indicará a presença de 11 caracteres.

Porém, não obrigaremos que as usuárias e usuários fiquem inserindo seu CPF sempre entre aspas. Para isso, retiraremos as " do número de cpf e o passaremos como uma str() dentro de len().

cpf = 15616987913
tamanho_cpf = len(str(cpf))
print(tamanho_cpf)

Se rodarmos novamente, o resultado continuará indicando os onze caracteres que esperamos.

Poderemos sobrescrever a variável cpf como str(cpf) apenas, retirando o str() de len() para executarmos de novo.

cpf = 15616987913
cpf = str(cpf)
tamanho_cpf = len(cpf)
print(tamanho_cpf)

Agora começaremos a construir a classe com esta aplicação que fizemos.

Criando um novo Python file chamado cpf.py, geraremos uma classe de nome Cpf. O primeiro passo é criar o método cpf_eh_Valido() que validará o CPF, recebendo self e um documento.

Com um laço if, verificaremos se o tamanho do documento é igual a 11 para retornarmos True, e caso contrário o retorno será False.

class Cpf:
    def cpf_eh_Valido(self, documento):
        if len(documento) == 11:
            return True
        else:
            return False

Faremos essa validação no momento em que estamos instanciando a classe, colocando-a dentro de __init__() recebendo self e documento também. Passaremos o documento como str para não nos preocuparmos com as aspas, e adicionaremos self.cpf_eh_Valido() do documento.

Se este for igual ao documento, lançaremos uma exceção ValueError() com a mensagem "CPF invalido!".

class Cpf:
    def __init__(self, documento):
        documento = str(documento)
        if self.cpf_eh_Valido(documento):
            self.cpf = documento
        else:
            raise ValueError("CPF inválido!")

    def cpf_eh_Valido(self, documento):
        if len(documento) == 11:
            return True
        else:
            return False

Testaremos os códigos em main.py e a lógica antes de passarmos para a classe, e depois passaremos para a classe Cpf propriamente dita.

Importaremos Cpf de Cpf para podermos testá-la. Usaremos a variável cpf já pronta para podermos apagar as últimas três linhas e adicionarmos objeto_cpf igual a Cpf(cpf) em seu lugar, desta forma:

from Cpf import Cpf

cpf = 15616987913

objeto_cpf = Cpf(cpf)

Executando este código, não receberemos acusação de erros; então a compilação foi realizada com sucesso.

Se retirarmos um caractere do número de CPF fictício, o sistema acusará a exceção ValueError() com a mensagem que escrevemos, pois não possui mais o tamanho requisitado em len().

Agora criaremos o método que também servirá para formatar o CPF através do fatiamento de str. Em main.py, comentaremos a linha com a variável objeto_cpf.

Em seguida, começaremos a dividir a str em pedaços que nos possibilitarão montar em pontos e depois do hífen no caso do CPF, da forma como queremos.

Criaremos a variável fatia_um que será igual a cpf[] com fatiamento de zero a três. Depois faremos a fatia_dois igual ao cpf fatiando de três até seis, e a fatia_tres dividirá cpf[] de três a nove. Por fim, a fatia_quatro fatiará de nove em diante.

Se imprimirmos cada pedaço, poderemos ver o cpf desmembrado. Não poderemos esquecer de colocar o número do CPF entre aspas novamente, indicando a str.

from Cpf import Cpf

cpf = "15616987913"
#objeto_cpf = Cpf(cpf)

fatia_um = cpf[:3]
fatia_dois = cpf[3:6]
fatia_tres = cpf[6:9]
fatia_quatro = cpf[9:]
print(fatia_um)
print(fatia_dois)
print(fatia_tres)
print(fatia_quatro)

Executando o código, poderemos ver os grupos de caracteres separados de acordo com o que estabelecemos nas variáveis.

O próximo passo é pegar cada pedaço e encaixá-los na máscara, sendo os três primeiros conjuntos com três números separados entre pontos e o último com apenas dois após o hífen, conforme o padrão nacional.

Para isso, criaremos uma nova variável cpf_formatado igual ao modelo "{}.{}.{}-{}" seguido de format().

Dentro, adicionaremos as variáveis das quatro fatias em ordem crescente e imprimiremos o CPF formatado com print().

from Cpf import Cpf

cpf = "15616987913"
#objeto_cpf = Cpf(cpf)

fatia_um = cpf[:3]
fatia_dois = cpf[3:6]
fatia_tres = cpf[6:9]
fatia_quatro = cpf[9:]

cpf_formatado = "{}.{}.{}-{}".format(
    fatia_um,
    fatia_dois,
    fatia_tres,
    fatia_quatro
)

print(cpf_formatado)

Como resultado, veremos o número de CPF devidamente formatado.

Testaremos o código com um valor diferente para cpf, como "15398745687". Após executarmos, o retorno também aparecerá conforme o esperado.

Nosso próximo passo é passarmos do main.py para colocarmos na classe Cpf.

Em Cpf.py, criaremos um novo método format_cpf() que precisará do self para pegar o atributo que já foi feito no momento em que a classe foi instanciada.

Em seguida, copiaremos o bloco das quatro variáveis com as fatias de main() e o colaremos dentro de format_cpf() em Cpf.py. Adicionaremos self antes de cpf[] também.

Ao invés de fazermos uma variável, retornaremos todo o conteúdo de format() que define a máscara presente no arquivo main.py, e o lugar certo de chamá-la é dentro da representação str da classe.

Portanto, adicionaremos def __str__() recebendo self após else, para então retornarmos self.format_cpf().

class Cpf:
    def __init__(self, documento):
        documento = str(documento)
        if self.cpf_eh_Valido(documento):
            self.cpf = documento
        else:
            raise ValueError("CPF inválido!")

    def __str__(self):
        return self.format_cpf()

    def cpf_eh_Valido(self, documento):
        if len(documento) == 11:
            return True
        else:
            return False

    def format_cpf(self):
        fatia_um = self.cpf[:3]
        fatia_dois = self.cpf[3:6]
        fatia_tres = self.cpf[6:9]
        fatia_quatro = self.cpf[9:]
        return(
            "{}.{}.{}-{}".format(
                fatia_um,
                fatia_dois,
                fatia_tres,
                fatia_quatro
            )
        )

Para testarmos, retornaremos ao arquivo main.py para podermos apagar as linhas das fatias e da máscara. Descomentaremos o objeto_cpf, o imprimiremos e rodaremos o código.

from Cpf import Cpf

cpf= "15398745687"
objeto_cpf = Cpf(cpf)

print(objeto_cpf)

Ao executarmos, veremos a validação dentro da classe e a formatação do CPF.

Se retirarmos o último dígito do número de cpf no arquivo main(), o programa nos retornará um erro com a mensagem sobre o CPF inválido.

Com tudo funcionando corretamente ao reescrever o último caractere, precisaremos saber se um cpf_novo de valor 11111111112 realmente é válido dentro dos padrões nacionais.

A seguir, veremos uma forma de formatar e validar minuciosamente o CPF.

Validando CPF e acessando o PYPI - Pacotes Python

Anteriormente, nossa validação apenas verificando a quantidade de dígitos no CPF não é suficiente para um resultado correto, e precisamos de algumas variáveis e lógicas para sabermos se o número é realmente válido dentro do sistema nacional.

Para isso, acessaremos um algoritmo para validar CPF neste link. Mais importante do que entender o algoritmo em si, é aprendermos como utilizar pacotes já prontos para aplicarmos em um projeto, como buscar ou como plugar para reutilizarmos os métodos de um pacote de classes.

Estes estão dentro do Python Package Index ou PyPI e podem ser acessados através deste endereço. Na barra de busca, escreveremos "valida cpf" e clicaremos na versão mais recente de validate-docbr para abri-lo em uma nova guia.

Nesta página com maiores detalhes sobre a biblioteca, teremos o comando pip install validate-docbr que escreveremos no terminal para instalar o pacote que lida com CPF, CNPJ e CNS, além de plugá-lo em nosso código.

Outra página importante do PyPI é a Homepage de Project links que pode ser encontrada nesta mesma parte de detalhes da biblioteca validate-docbr, onde todos os códigos-fontes estarão presentes no GitHub do repositório deste pacote.

Clicando na pasta de "validate_docbr" da lista, veremos o arquivo CPF.py com o código disponível para adaptarmos.

Primeiro, instalaremos a biblioteca validate-docbr no terminal do PyCharm.

Feito isso, apagaremos todo o conteúdo de main.py deixando somente a importação de Cpf. Na página principal do pacote PyPI, há uma pequena documentação que poderemos utilizar; começaremos importando e instanciando o objeto da classe importada para termos acesso ao método validate().

Em seguida, imprimiremos cpf.validate() passando "012.345.678-90" que sabemos ser verdadeira por estar no exemplo do código presente na página do pacote. Como esta biblioteca é bem robusta, já possui a máscara correta com os pontos e hífen.

from validate_docbr import CPF
from cpf import Cpf

cpf = CPF()

print(cpf.validate("012.345.678-90"))

Pegando o mesmo exemplo do passo anterior, tentaremos passar 11111111112 ao validate() com a certeza de que o resultado será falso. O mesmo acontecerá se tiver um dígito a mais ou a menos.

Já sabemos o funcionamento básico desta biblioteca, e começaremos a passar sua lógica para dentro da nossa classe a seguir, afinal validate() precisará receber uma str e não um valor inteiro.

Sobre o curso Python Brasil: validação de dados no padrão nacional

O curso Python Brasil: validação de dados no padrão nacional possui 145 minutos de vídeos, em um total de 37 atividades. Gostou? Conheça nossos outros cursos de Python em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Validando CPF e acessando o PYPI
• Validando CNPJ e construindo uma Factory
• Validando telefones com expressões regulares
• Manipulando e formatando datas
• Trabalhando com CEP e acessando uma API