Como validar um CNPJ com Python

Antes de aprender a validar um CNPJ, vamos entender um pouco como ele funciona

O CNPJ é composto por 14 dígitos, onde os últimos 2 dígitos são chamados de dígitos verificadores. Vamos pegar esse CNPJ 13.347.016/0001-XX de exemplo para entender como funciona o cálculo do CNPJ:

Você vai pegar os 12 primeiros dígitos e multiplicar cada dígito. Nesse CNPJ de exemplo, ficaria assim:

1 3 3 4 7 0 1 6 0 0 0 1

5 4 3 2 9 8 7 6 5 4 3 2

Multiplicando cada coluna, ou seja, 1x5, 3x4, 3x3 e por aí vai..., após multiplicar tudo e somar todos os valores, encontramos o valor: 142. Esse número deve ser dividido por 11 e você deve guardar o resto da divisão, que será 10. Agora você pega 11-10, que será igual a 1. Se 1 for maior ou igual a 10, o nosso primeiro dígito verificador será 0, caso contrário segue como 1. Para esse exemplo, encontramos nosso primeiro dígito, o valor 1.

Agora vamos calcular o segundo dígito verificador. Você deve pegar todos os 12 primeiros dígitos e o primeiro dígito verificador encontrado. Ficando assim:

1 3 3 4 7 0 1 6 0 0 0 1 1

6 5 4 3 2 9 8 7 6 5 4 3 2

Multiplicando cada coluna, ou seja, 1x6, 3x5, 3x4, ..., após multiplicar tudo, o total deve ser igual a 114. Agora vamos usar a mesma lógica do primeiro dígito verificador. Pegaremos o resto da divisão de 114 por 11, que será 4. Agora você deve pegar o número 11 e subtrair de 4, sendo o número que encontramos. O valor será igual a 7, com esse valor, você deve comparar se ele é maior ou igual a 10, se for, nosso segundo dígito verificador será igual a 0. Em nosso exemplo o valor é 7, é um valor menor ou igual a 10, logo nosso segundo dígito verificador será igual 7 mesmo.

Então é isso, encontramos nossos dois dígitos verificadores 1 e 7.

Como testar e validar se meu CNPJ está correto?

Aqui no Geratudo, temos uma ferramenta para gerar e validar CNPJ. Se você deseja colocar em prática e validar se está tudo certo com o seu CNPJ, utilize nossa ferramenta de validação de CNPJ, basta clicar aqui. Caso deseje criar CNPJs, você pode usar nosso gerador de CNPJ. Convido a conhecer também nosso gerador de CPF.

Validando CNPJ em Python: Um Passo a Passo Detalhado

O algoritmo que você está utilizando é uma implementação para validar o Cadastro Nacional de Pessoa Jurídica (CNPJ) em Python. A validação do CNPJ é essencial em muitos sistemas para garantir a integridade dos dados e evitar erros causados por informações incorretas.

Passo 1: Limpeza e Preparação dos Dados

A primeira etapa do algoritmo consiste em limpar o CNPJ de qualquer caractere não numérico. Isso pode ser feito utilizando expressão regular, que remove todos os caracteres que não são dígitos.

import re
cleaned_cnpj = re.sub(r'[^0-9]', '', cnpj)

Passo 2: Verificação do Tamanho

Após a limpeza, o algoritmo verifica se o CNPJ tem exatamente 14 dígitos. Um CNPJ válido deve ter essa quantidade específica de números.

if not cleaned_cnpj or len(cleaned_cnpj) != 14:
    return False

Passo 3: Conversão para Array de Números

O CNPJ limpo é então convertido para um array de números para facilitar a manipulação dos dígitos individuais.

cnpj_elements = list(map(int, list(cleaned_cnpj)))

Passo 4: Cálculo do Dígito Verificador 1 (D1)

Agora, o algoritmo realiza o cálculo do primeiro dígito verificador (D1). Os primeiros 12 dígitos do CNPJ são multiplicados por pesos específicos, e o resultado é somado. O módulo 11 é aplicado, e o D1 é calculado como a diferença de 11 e o resultado, com tratamento especial caso o resultado seja maior ou igual a 10.

cnpj_elements = [int(char) for char in cleaned_cnpj]

n1, n2, n3, n4, n5, n6, n7, n8 = cnpj_elements

n9 = 0
n10 = 0
n11 = 0
n12 = 1

d1 = (
    n12 * 2 +
    n11 * 3 +
    n10 * 4 +
    n9 * 5 +
    n8 * 6 +
    n7 * 7 +
    n6 * 8 +
    n5 * 9 +
    n4 * 2 +
    n3 * 3 +
    n2 * 4 +
    n1 * 5
)

d1 = 11 - (d1 % 11)
if d1 >= 10:
    d1 = 0

Passo 5: Verificação do Primeiro Dígito Verificador

O algoritmo verifica se o primeiro dígito verificador calculado (D1) é igual ao penúltimo dígito do CNPJ.

if d1 != cnpj_elements[-2]:
    return False

Passo 6: Cálculo do Dígito Verificador 2 (D2)

Com a validação do primeiro dígito, o algoritmo prossegue para o cálculo do segundo dígito verificador (D2). D1 é multiplicado por 2, e os primeiros 12 dígitos do CNPJ (agora incluindo D1) são novamente multiplicados por pesos específicos. O módulo 11 é aplicado, e D2 é calculado da mesma forma que D1.

d2 = (
    d1 * 2 +
    n12 * 3 +
    n11 * 4 +
    n10 * 5 +
    n9 * 6 +
    n8 * 7 +
    n7 * 8 +
    n6 * 9 +
    n5 * 2 +
    n4 * 3 +
    n3 * 4 +
    n2 * 5 +
    n1 * 6
)

d2 = 11 - (d2 % 11)
if d2 >= 10:
    d2 = 0

Passo 7: Verificação do Segundo Dígito Verificador

Finalmente, o algoritmo verifica se o segundo dígito verificador calculado (D2) é igual ao último dígito do CNPJ.

if d2 != cnpj_elements[-1]:
    return False

Passo 8: CNPJ Válido

Se o algoritmo passar por todas essas etapas sem retornar false, o CNPJ é considerado válido, e a função retorna true.

return True

Espero que tenham gostado da explicação! Para mais detalhes, acessem o nosso site, para conseguir gerar e validar CNPJ válidos.