'''

REGULAR EXPRESSIONS - modulo re

util para extrair informações especificas de arquivos de texto

Principais conceitos: 2) class caracter; 3) repeated matches; 1) special

characters;

Resumo símbolos:
. -> substitui qualquer caractere
* -> completa os caracteres
+ -> caracteres na sequencia
? -> caractere opcional
^ -> linhas que começam com caractere
$ -> linhas que terminam com caractere
[] -> listar possíveis caracteres
[^] -> caractere não contido
() -> group
{} -> limitar numero de caracteres
\ -> caractere de escape
\w -> combina (matches) qualquer caractere alfabético, numérico e
underlines
\d -> combina com caracteres numéricos
\s -> combina só para espaços em branco
\b -> delimita limite de palavras, ou seja, pega somente palavras
inteiras. (Word Boundary)

OBS.. sempre que tivermos uma dessas letras em maiúsculo (ex: \B)
significa o 'oposto', com o b por exemplo
seria Non-Word Boundary, que combina qualquer palavra entre dois
caracteres, já o \b combina entre um caractere
e um não-caractere

-----------------------------------------------------------------------------------
--------------------------------------
1) CARACTERES ESPECIAIS:

wildcards -> substitui um caractere

. --> o ponto é um coringa, pode substituir qualquer caractere

ancoras
^ --> somente LINHAS que começam com o arg passado, deve ser colocado no
começo do arg
$ --> somente LINHAS que terminam com o arg passado, deve ser colocado no
final do arg

| -> listar mais de uma opção para combinar (dar match)

exemplo: print(re.search(r'[cachorro|gato]','O cachorro comeu o
gato'))

(**SEMPRE UTILIZAR**)
r --> raw string --> indica que o interpretador python não deve interpretar
nenhum caractere
especial dentro da string passada como arg,
como por exemplo, um \n.
Porem, funciona com os caracteres especiais da
própria biblioteca.
-----------------------------------------------------------------------------------
--------------------------------------
DIRETAMENTE NO TERMINAL:
grep --> um dos métodos do 're' é o 'grep', que pode ser usado diretamente no
terminal e retorna
todas as palavrar que contem a string que passamos.

Exemplos:

grep s.ring <path> --> string; spring (retorno caso o arquivo tenhas as
palavras)
grep ^bic <path> --> somente linhas que começam com 'bic'
grep bic$ <path> --> somente linhas que terminam com 'bic'

OBS. 'grep' só funciona no terminal

-----------------------------------------------------------------------------------
--------------------------------------
ALGUMAS FUNÇÕES DO MODULO:
re.search(arg, string) -> escaneia a string procurando pela primeira posição
que aparece arg e
retorna um match object dizendo a posição

re.findall(arg, string) -> mesma coisa da search, porém para todos os itens
na string, e
retorna uma lista

re.split(arg, string) -> mesma coisa do split para strings, porém podemos
passar mais de um parâmetro
para a quebra
exemplo: print(re.split('[.?!]','um cu! dois cu? tres
cu. meu cu' )) ---> somente as frases
print(re.split('([.?!])','um cu! dois cu?
tres cu. meu cu' )) -> frases e pontos

re.sub(arg, subs ,string) -> parecido com o replace, substitui uma parte
da string

exemplo: print(re.sub(r"[\w.%+-]+@[\w.-]+","[ANONIMO]","e-
mail recebido do lucas_69@gmail.com"))
nesse caso, nenhum dos caracteres dentro do
primeiro [] tem função especial.

re.IGNORECASE --> ignora maiúsculo e minúsculo e é usado dentro de outras

funções
ex: re.search(r'p.ng', 'SPONGE', re.IGNORECASE)

OBS. O re.search e o grep são ambas funções para dar 'match' e encontrar uma
palavra específica
no texto

-----------------------------------------------------------------------------------
--------------------------------------
2) CLASSE DE CARACTERE (é um wildcard, ou um 'coringa')
[<caracteres>] --> escrito dessa forma, sem os <>, e nos deixa listar os
possíveis caracteres que
queremos que de match (seja igual) com o resto da string.

Exemplos:

print(re.seach(r'[Pp]','Python')) 'p' ou 'P'

print(re.seach(r'[a-z]indo','meu cu caindo no chão'))'a' até 'z'

podemos ainda combinar os ranges e ter mais de um '[]':

print(re.search(r'cloud[a-zA-Z0-9][a-z]', 'cloud3z'))
exemplo da aula: import re
def check_punctuation (text):
result = re.search(r"[.,?!]", text)
return result != None

print(check_punctuation("This is a sentence
that ends with a period.")) # True
print(check_punctuation("This is a sentence
fragment without a period")) # False
print(check_punctuation("Aren't regular
expressions awesome?")) # True
print(check_punctuation("Wow! We're really
picking up some steam now!")) # True
print(check_punctuation("End of the line")) #
False

Símbolos:
^ -> é como se fosse uma negação. Serve para listar caracteres que não
estão contidos nos []
exemplo: print(re.search(r'[^a-z]', 'Essa frase contem espaços',
re.IGNORECASE))
nesse caso, o retorno será o primeiro espaço, já que
este não é letra
print(re.search(r'[^a-z ]'), 'Essa frase contem
espaços', re.IGNORECASE))
já nesse caso, o retorno será '.', pois o espaço foi
adicionado na classe de
caractere

-----------------------------------------------------------------------------------
--------------------------------------

3) REPETITION QUALIFIERS

* --> indica que queremos todos os caracteres subjacentes ou até o caractere

limite passado após o *
+ --> caractere+ -> combina com 'n' ocorrências do caractere anterior
? --> caractere anterior se torna opcional -> k? -> 'k' é opcional
{} --> repete um numero especifico de vezes -> {5,10} -> combina de 5 à 10
itens, se n tiver o segundo numero, n
tem limite superior, se n tiver o primeiro, n tem limite inferior

Exemplos:
* print(re.search(r'Py.*','Pyubveiuibihba')) --> retorna toda a string
* print(re.search(r'Py[a-z]*','Python Programming')) --> 'Python'
* print(re.search(r'Py.*n','Python Programming')) --> 'Python Programmin'
+ print(re.search(r'o+l+','hoolly')) --> ooll
+ print(re.search(r'o+l+','oil')) --> none
? print(re.search(r'b?oil','oil')) --> oil
? print(re.search(r'b?oil','boil')) --> boil
{} print(re.search(r'[a-zA-Z]{5}','um carro quebrado')) --> letras com 5
caracteres somente
{} print(re.findall(r'\b[a-zA-Z]{5}\b','um carro quebrado')) --> letras com 5
caracteres e que seja uma palavra completa
{} print(re.findall(r'\w{6,}\??','você comprou pão na padaria?')) -->
['comprou','padaria?']
-----------------------------------------------------------------------------------
--------------------------------------

CARACTERES DE ESCAPE

Caracteres para utilizar quando queremos dar match em um caractere especial

do modulo, como '*' ou '.'

\ --> qualquer caractere especial seguido do barra invertida será considerado

caractere normal

-----------------------------------------------------------------------------------
--------------------------------------
-----------------------------------------------------------------------------------
--------------------------------------
CAPTURANDO GRUPOS --> usando o valor retornado pela regex para futuras
operações
<referencia de mais exemplos: https://regular-
expressions.mobi/refcapture.html?wlr=1>

(regex) --> para capturarmos um grupo, utilizamos o arg dentro de parênteses

podemos acessar os conteúdos dentro d um grupo através de índices, porém o
[0] será sempre a string completa, e os
demais seguem a ordem padrão.

exemplo:
1) função que pega o nome de uma pessoa na ordem: sobrenome, nome. E
organiza: nome sobrenome

import re
def ordenando_nome(nome):
# result = re.search(r'^(\w*), (\w* ?.*?)$', nome)
result = re.search(r'^([\w \.-]*), ([\w \.-]*)$', nome)
if result is None:
return nome
return f'{result[2]} {result[1]}'

print(ordenando_nome('beludo, cuca'))
print(ordenando_nome('Bezerra, Mateus V.'))

reformulando com o re.sub:

def ordenando_nome(nome):
r = re.sub(r"^([\w .-]*), ([\w .-]*)$", r"\2 \1","nome")
return r

'''

import re

import re
def convert_phone_number(phone):
result = re.sub(r"(\d{3})-(\d{3})-(\d{4})", r"(\1) \2-\3", phone)
return result

print(convert_phone_number("My number is 212-345-9999.")) # My number is (212) 345-

9999.
print(convert_phone_number("Please call 888-555-1234")) # Please call (888) 555-
1234
print(convert_phone_number("123-123-12345")) # 123-123-12345