Solucionado (ver solução)
Solucionado
(ver solução)
4
respostas

Dúvida sobre uma outra forma diferente do vídeo...

Tentei fazer a máscara de CNPJ antes de assistir ao vídeo como um desafio me baseando na máscara de CPF.

Fiz diferente do vídeo. Ao invés de criar um outro método formata_cnpj() e fazer uma lógica dentro de __str__(), para decidir qual dos dois métodos chamar formata_cnpj() ou formata_cpf(), eu troquei o nome do método que formatava CPF para formata_documento() e nela, ficou a lógica que decide se é CPF ou CNPJ .

E para a minha alegria.... Funcionou!!!

A dúvida é: (nem sei formular direito a pergunta...)

Poderia dar algum problema futuro, pensando que fosse um projeto real em uma empresa grande? Sei lá, algum problema no tempo de execução...? Ou no consumo de memória...?

Segue o meu código para análise da pessoa bondosa, que vai ter paciência de tentar entender a minha pergunta, que eu não sei se consegui formular direito (e juro que tentei melhor que isso...)

from validate_docbr import CPF, CNPJ

class CpfCnpj:
    def __init__(self, documento, tipo_documento):
        self.tipo_documento = tipo_documento
        documento = str(documento)
        if tipo_documento.lower() == "cpf":
            if self.cpf_eh_valido(documento):
                self.cpf = documento
            else:
                raise ValueError("CPF inválido!!!")
        elif self.tipo_documento.lower() == "cnpj":
            if self.cnpj_eh_valido(documento):
                self.cnpj = documento
            else:
                raise ValueError("CNPJ inválido!!!")
        else:
            raise ValueError("Documento inválido!!!")

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

    def cpf_eh_valido(self, documento):
        if len(documento) == 11:
            validador = CPF()
            return validador.validate(documento)
        else:
            raise ValueError("Quantidade de dígitos inválida!!!")

    def formata_documento(self):
        if self.tipo_documento.lower() == "cpf":
            mascara = CPF()
            return mascara.mask(self.cpf)
        elif self.tipo_documento.lower() == "cnpj":
            mascara = CNPJ()
            return mascara.mask(self.cnpj)

    def cnpj_eh_valido(self, cnpj):
        if len(cnpj) == 14:
            validate_cnpj = CNPJ()
            return validate_cnpj.validate(cnpj)
        else:
            raise ValueError("Quantidade de dígitos inválida!!!")
4 respostas
solução!

Olá Vinicius, a princípio seu código não traria grandes problemas. Analisando a complexidade do seu algoritmo acredito que ele seja constante, pois não temos elementos dentro de laços que aumentariam o número de operações conforme o número de entradas.

Agora voltando à produção. Com as regras de negócio atual não sei se seria interessante você usar um algoritmo local para fazer essa validação. Tem vários serviços (APIs) que fazem isso para você, além da capacidade de te trazer diversas outras informações como: nome completo, nome da mãe, aniversário, status (ativo, cancelado, etc).

Muito obrigado!

Falar com quem manja é outra coisa, né? Subiu o nível da conversa lá no alto. Talvez um pouco mais alto do que sou capaz de enxergar agora...

Se não for pedir demais, me dá uma esclarecida em alguns termos que você usou que eles são novos pra mim.

Pelo que você falou, quando você diz "algoritmo constante" significa que ele não tem laços? É isso?

E no caso de uma algoritmo com laços, seria um "algoritmo variável"? Ou tô viajando...?

Quanto a parte do local vs API acho que entendi.

"Algoritmo local" é o que eu fiz aí, ou seja, valida tudo "localmente". Que seria o contrário de usar API's, que faria a validação através de uma interface externa. Entendi certo?

Sobre as API's eu ainda não sei usá-las. Mas vejo que as possibilidades aumentam e muito com o uso delas.

Caraca, Ronald! Com apenas dois parágrafos você chacoalhou a minha mente aqui de uma forma.... Coisa de mestre!

Agradeço muito.

Vinicius, muita calma nessa hora :-)

Para você entender melhor sobre "Algoritmo Constante" dê uma olhada nas questões de Complexidade de Algoritmos. Esse post vai te ajudar mais do que eu escrevendo aqui, e você pode procurar mais material na web:

https://dev.to/danielle8farias/complexidade-de-algoritmos-notacao-big-o-26al

Sobre local e API mais ou menos isso mesmo. Vou apelar para a RedHat te explicar essa:

https://www.redhat.com/pt-br/topics/api/what-are-application-programming-interfaces

Pelo que entendi você está começando nessa vida de TI. Fica tranquilo, você está num bom caminho aqui na Alura e tem um monte de gente muito mais capacitada do que eu para te ajudar. Mas claro, quando eu puder responder farei com o maior prazer e tentando ser o mais didático possível.

Valeu pelas indicações! Ahhh... Agora faz mais sentido.

Sim estou no início dessa jornada e tenho gostado bastante!

Mais uma vez obrigado!