Caso de uso: RegEx
Tags: python, regex, braziliandevs
Published: 2021-12-12 21:10:45

Podemos identificar padrões em uma cadeia de caracteres usando Expressões Regulares (*Regular Expression* ou RegEx).
 
Para validar o formato de um CPF, por exemplo, é necessário que esteja no seguinte padrão:
 
- `xxx.xxx.xxx-xx` (cada `x` corresponde à um dígito decimal)
 
Então através de uma RegEx conseguimos identificar se esse padrão foi seguido ou não.

## Introdução

Usando a linguagem de programação Python, importa-se o módulo `re` que fornece operações de expressões regulares.
 
```python
import re
```
 
Cria-se uma função `validar` a qual recebe uma string `cpf`, ela retorna `válido` ou `inválido`.

```python
def validar(cpf):
    validador = expressao.match(cpf)
    if validador:
        return 'válido'
    return 'inválido'
```

## Primeiro caso

Usando a função `re.match`, compara-se o `cpf` com a expressão regular compilada `expressao`, ela retorna um `Match Object` caso combine, do contrário retorna `None`, o valor é atribuído à variável `validador`.
 
A expressão escrita a seguir contém alguns símbolos com significado especial, são eles:
- `^` sinaliza o início de uma linha ou string
- `$` sinaliza o fim de uma linha ou string
- `\d` corresponde aos dígitos decimais de 0 a 9
 
Um detalhe importante, o uso de `.` também possui um significado especial e para retirar esse significado usa-se a `\` antes do caracter, assim ele se torna o `.` (ponto literal).
 
```python
expressao = re.compile(r'^\d\d\d\.\d\d\d\.\d\d\d-\d\d$')
```
 
Essa expressão é escrita de uma forma simples, repetindo os caracteres no formato esperado.

## Evitando repetição de elementos

Podemos reescrevê-la usando mais recursos implementados no módulo `re`, usando o conceito de repetição de elementos da RegEx representados por chaves `{}`, aplicando-o ao conjunto de dígitos `\d` que é repetido um certo número de vezes, obtem-se:
 
```python
expressao = re.compile(r'^\d{3}\.\d{3}\.\d{3}-\d{2}$')
```

## Evitando repetição de trechos

Outra forma de expressar a RegEx é usando o conceito de grupos. Nesse caso podemos agrupar um trecho do formato que se repete, fazendo um grupo de 3 dígitos e um `.` (ponto literal), que devem ser repetidos duas vezes.
 
```python
expressao = re.compile(r'^(\d{3}\.){2}\d{3}-\d{2}$')
```

## Exemplos de execução

Usaremos quatro exemplos para testar a validação do CPF:
 
```python
a = '111.222.333-44'
b = '1234.123.789-88'
c = '123.12.789-88'
d = 'abs.ert.yui.lk'
 
print(f'''
    O CPF: {a} é {validar(a)}
    O CPF: {b} é {validar(b)}
    O CPF: {c} é {validar(c)}
    O CPF: {d} é {validar(d)}
    ''')
```
 
Analisando a saída obtida, notamos que:
- O exemplo `a` está no formato correto.
- O exemplo `b` contém mais dígitos do que o esperado no primeiro trecho.
- O exemplo `c` contém menos dígitos do que o esperado no segundo trecho.
- O exemplo `d` apresenta caracteres não-dígitos, sendo inválido.
 
```txt
    O CPF: 111.222.333-44 é válido
    O CPF: 1234.123.789-88 é inválido
    O CPF: 1234.12.789-88 é inválido
    O CPF: abs.ert.yui.lk é inválido
```

## Considerações

Vimos que uma RegEx pode ser escrita de várias formas para validar o mesmo padrão e ainda existem diversas outras maneiras, podendo levar em conta a legibilidade ou complexidade da escrita para fazer sua escolha.
 
Aprendendo mais sobre os recursos do [módulo *re* do Python](https://docs.python.org/pt-br/3/library/re.html).

Estudando mais sobre [expressões regulares](https://aurelio.net/regex/).

Se escreve [caracter/caráter/caracteres](https://www.flip.pt/Duvidas-Linguisticas/Duvida-Linguistica/DID/745)?

Enjoy!