11.Expressões Regulares.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\" style=\"margin-top: 1em;\"><ul class=\"toc-item\"><li><span><a href=\"#Expressões-Regulares\" data-toc-modified-id=\"Expressões-Regulares-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Expressões Regulares</a></span><ul class=\"toc-item\"><li><span><a href=\"#Método-search\" data-toc-modified-id=\"Método-search-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Método <code>search</code></a></span></li><li><span><a href=\"#Objetos-do-tipo-match\" data-toc-modified-id=\"Objetos-do-tipo-match-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Objetos do tipo <code>match</code></a></span></li><li><span><a href=\"#Outras-Funções-da-biblioteca-RE\" data-toc-modified-id=\"Outras-Funções-da-biblioteca-RE-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Outras Funções da biblioteca RE</a></span></li></ul></li><li><span><a href=\"#Compilando-REs\" data-toc-modified-id=\"Compilando-REs-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Compilando REs</a></span></li><li><span><a href=\"#Regras-básicas-para-escrita-de-uma-RE\" data-toc-modified-id=\"Regras-básicas-para-escrita-de-uma-RE-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Regras básicas para escrita de uma RE</a></span><ul class=\"toc-item\"><li><span><a href=\"#Backslash\" data-toc-modified-id=\"Backslash-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Backslash</a></span></li><li><span><a href=\"#Repetições\" data-toc-modified-id=\"Repetições-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Repetições</a></span></li><li><span><a href=\"#Classe-de-caracteres\" data-toc-modified-id=\"Classe-de-caracteres-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Classe de caracteres</a></span></li><li><span><a href=\"#Opcional\" data-toc-modified-id=\"Opcional-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>Opcional</a></span></li><li><span><a href=\"#Outros-Meta-Caracteres\" data-toc-modified-id=\"Outros-Meta-Caracteres-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>Outros Meta-Caracteres</a></span></li></ul></li><li><span><a href=\"#Exemplo---Buscando-um-email\" data-toc-modified-id=\"Exemplo---Buscando-um-email-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Exemplo - Buscando um email</a></span></li><li><span><a href=\"#Exercícios\" data-toc-modified-id=\"Exercícios-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Exercícios</a></span></li><li><span><a href=\"#Referência\" data-toc-modified-id=\"Referência-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Referência</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Expressões Regulares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Expressões regulares são formas concisas de descrever um conjunto de strings que satisfazem um determinado padrão. Por exemplo, podemos criar uma expressão regular para descrever todas as strings na forma dd/dd/dddd, um padrão que representa datas, onde d é um dígito qualquer.\n",
    "\n",
    "Dada uma expressão regular podemos resolver por exemplo este problema:\n",
    "\n",
    "- Existe uma sequência de caracteres numa string de entrada que pode ser interpretada como um número de telefone? E qual é ele?\n",
    "\n",
    "Note que números de telefones podem vir em vários “formatos”. Exemplos:\n",
    "  - 19-91234-5678\n",
    "  - (019) 91234 5678\n",
    "  - (19)912345678\n",
    "  - 91234-5678"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Expressões regulares são uma mini-linguagem que permite especificar as regras de construção de um conjunto de strings.\n",
    "Essa mini-linguagem de especificação é muito parecida entre as diferentes linguagens de programação que contém o conceito de expressões regulares (também chamado de RE ou REGEX).\n",
    "Assim, aprender a escrever expressões regulares em Python será útil também para descrever REs em outras linguagens de programação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Um exemplo de expressão regular é:\n",
    "```\n",
    "’\\d+’\n",
    "```\n",
    "Essa RE representa uma sequência de 1 ou mais dígitos.\n",
    "Vamos ver algumas regras de como escrever essas REs mais tarde na aula $--$ no momento vamos ver como usar uma RE.\n",
    "\n",
    "É conveniente escrever a string da RE com um $r$ na frente para especificar uma `raw string`, isto é, uma string onde sequência de caracteres como ’\\n’ são tratados como 2 caracteres e não uma quebra de linha.\n",
    "\n",
    "Assim a RE é:\n",
    "```\n",
    "r’\\d+’\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Método `search`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Expressões regulares e operações sobre eles são definidas na biblioteca [re](https://docs.python.org/3/library/re.html) de Python. A principal função da biblioteca é a função `search`. Dada uma RE e uma string, a função busca a primeira ocorrência de uma substring especificada pela RE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "a = re.search(r'\\d+', 'Ouviram do Ipir723anga margens 45')\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O resultado de `search` é do tipo match que permite extrair informação sobre qual é a substring que foi encontrada (o `match`) e onde na string ele foi encontrado (o `span`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b = re.search(r'\\d+', 'Ouviram do Ipiranga margens')\n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Neste último exemplo, nenhum `match` é encontrado. Neste caso, b retorna o valor `None` (classe NoneType). Como vimos, o valor `None` se comporta como False em expressões condicionais. Assim, depois de usar o método `search` deve-se verificar se algo foi encontrado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b = re.search(r'\\d+', 'Ouviram do Ipiranga margens')\n",
    "if b:\n",
    "    pass\n",
    "else:\n",
    "    print(\"Não encontrado\")\n",
    "a = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objetos do tipo `match`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O método `span` de um objeto match retorna a posição inicial e final+1 de onde a substring foi encontrada, enquanto o método `group` retorna a substring encontrada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = re.search(r'\\d+', 'Ouviram do Ipir723anga margens 45')\n",
    "print(a)\n",
    "a.span()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note que o método `search` acha apenas a primeira instância da RE na string (o número 45 também satisfaz a RE)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Outras Funções da biblioteca RE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- A função `findall` retorna uma lista de todas as ocorrências da RE:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.findall(r'\\d+', 'Ouviram do Ipir723anga margens 45')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.findall(r'\\d+', 'Ouviram do Ipiranga margens')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- A função `sub` substitui na string todas as substrings que conformam com a expressão regular fornecida por uma outra substring:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.sub(r'\\d+', '#', 'Ouviram do Ipir723anga margens 45')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- A função `split` funciona como a função `split` para strings, mas permite usar uma expressão regular como separador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.split(r'\\d+','ab 1 cd34efg h 56789 z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Compilando REs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Procurar uma RE numa string pode ser um processamento custoso e\n",
    "demorado. É possível “compilar” uma RE de forma que a procura seja executada de forma mais rápida:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "rec = re.compile(r'\\d+')\n",
    "xpto = rec.search('Ouviram do Ipir723anga margens 45')\n",
    "print(xpto.group())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "As funções vistas anteriormente funcionam também como métodos de REs compilados, e normalmente permitem mais alternativas. Por exemplo, o método `search` de uma RE compilada permite dizer a partir de que ponto da string deve-se começar a procurar a RE:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "rec = re.compile(r'\\d+')\n",
    "index = 0\n",
    "found = True\n",
    "while found:\n",
    "    xpto = rec.search('Ouviram do Ipir723anga margens 45', index)\n",
    "    if xpto:\n",
    "        print(xpto.group(), 'at position ', xpto.span()[0])\n",
    "        index = xpto.span()[1]\n",
    "    else:\n",
    "        found = False\n",
    "print('Finish')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Regras básicas para escrita de uma RE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "As letras e números numa RE representam a si próprios. Assim, a RE:\n",
    "```\n",
    "r'wb45p'\n",
    "``` \n",
    "representa apenas a substring 'wb45p'.\n",
    "\n",
    "Os caracteres especiais (chamados de meta-caracteres) são:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    ". ^ $ ∗ + ? { } [ ] \\ | ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Backslash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "As expressões regulares usam o caractere de barra invertida ('\\') para indicar formas especiais ou para permitir a utilização de caracteres especiais sem invocar o seu significado especial. Para combinar um literal barra invertida, é preciso escrever '\\\\\\\\\\\\\\\\' como uma seqüência RE, porque a expressão regular deve ser '\\\\\\\\', e cada barra invertida deve ser expressa como '\\\\\\\\' dentro de um string literal do Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Repetições"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- O meta-caractere $.$ (ponto) representa qualquer caractere. Por exemplo, a RE `r'.ao'` representa todas as strings de 3 caracteres cujos 2 últimos são \"ao\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r = re.compile(r'.ão')\n",
    "r.findall(\"Adotar um cão é uma ótima opção, pois eles são grandes companheiros!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- O meta-caractere $+$ representa $1$ (uma) ou mais repetições do caractere ou grupo de caracteres imediatamente anterior.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r1 = re.compile(r'abc(de)+')\n",
    "r1.search(\"abcde2de\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# não acha pois tem que ter pelo menos uma cadeia \"de\"\n",
    "a = r1.search(\"Este é o nosso abcedário\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- O meta-caractere $*$ representa $0$ ou mais repetições do caractere ou grupo de caracteres imediatamente anterior. Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r2 = re.compile(r'abc(de)*')\n",
    "r2.search(\"abc1de\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r2.search(\"Este é o nosso abcedário\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classe de caracteres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- A notação $[\\ ]$ representa uma classe de caracteres, de forma que deve-se ter um match com algum dos caracteres da classe. Por exemplo, r’m[ei]nta’ significa todas as strings de 5 caracteres que começam com $m$ seguido de um $e$, ou $i$ e terminam com $nta$. No exemplo abaixo, a palavra manta não faz parte da expressão regular:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r = re.compile(r'm[ei]nta')\n",
    "r.findall(\"Não minta para mim. Vc sujou a manta de menta ou não? Vc é uma pimenta!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- O caractere $-$ dentro do $[\\ ]$ representa um intervalo. Assim, $[1-7]$ representa um dos dígitos de $1$ a $7$. De forma parecida, $[a-z]$ e $[0-9]$ representam as letras minúsculas e os dígitos, respectivamente.\n",
    "\n",
    "\n",
    "- O caractere $^$ no início de $[\\ ]$ representa a negação da classe. Assim, \n",
    "```\n",
    "r'ab[^h-z]'\n",
    "```\n",
    "representa qualquer string começando com $ab$ e terminando com qualquer caractere exceto os de $h$ até $z$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r = re.compile(r'ab[^h-z]')\n",
    "r.search(\"Oi abm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# não acha pois ab é seguido de h\n",
    "r.search(\"Oi abh\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python fornece algumas classes pré-definidas que são bastante úteis:\n",
    "\n",
    "- \\d - Qualquer dígito decimal, isto é, $[0-9]$\n",
    "- \\D - É o complemento de \\d, equivalente a $[$^$0-9]$, i.e, faz o match com um caractere que não seja dígito.\n",
    "- \\s - Faz match com caracteres \\textit{whitespace}, i.e, equivalente a $[\\t\\n\\r\\f\\v]$.\n",
    "- \\S - O complemento de \\s.\n",
    "- \\w - Faz o match com um caractere alfanumérico, i.e, equivalente a $[a-zA-Z0-9]$.\n",
    "- \\W - O complemento de \\w."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Opcional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O meta-caractere $?$ significa que o caractere que o precede pode ou não aparecer. Nos dois exemplos abaixo há um match de $r'ab?c'$ tanto com $abc$ quanto com $ac$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r = re.compile(r'ab?c')\n",
    "r.search(\"ac\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r.search(\"ac\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Pode-se criar um grupo incluindo-se uma string entre parênteses. Por exemplo, se quisermos detectar ocorrências de \"Maio/18\", \"Maio/2018\" ou \"Maio de 2018\", etc, podemos usar a RE `r'Maio(/)? ?(de)? ?(20)?18'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r = re.compile(r'Maio(/)? ?(de)? ?(20)?18')\n",
    "r.search(\"Maio/de18\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r.search(\"Maio/2018\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "r.search(\"Maio/18\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Outros Meta-Caracteres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- $|$ representa um OU de diferentes REs.\n",
    "\n",
    "\n",
    "- \\b indica o separador de palavras (pontuação, branco, fim da string).\n",
    "\n",
    "  - r’\\bcasa\\b’  ́e a forma correta de procurar a palavra “casa” numa string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(r'\\bcasa\\b','a casa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(r'\\bcasa\\b',' casa ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(r'\\bcasa\\b','o casamento')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exemplo - Buscando um email"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Vamos construir uma RE para buscar um email:\n",
    "\n",
    "- O userid é uma sequência de caracteres alfanuméricos \\w+ separado por @.\n",
    "- O host é uma sequência de caracteres alfanuméricos \\w+."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(r'\\w+@\\w+', 'bla bla bla abc@gmail.com bla')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O host não foi casado corretamente. O ponto não é um caractere alfanumérico.\n",
    "Vamos tentar r'\\w+@\\w+\\.\\w+' (note que \\. serve para considerar o caractere \\. e não o meta-caractere)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(r'\\w+@\\w+\\.\\w+', 'bla bla bla abc@gmail.com bla')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(r'\\w+@\\w+\\.\\w+', 'bla bla bla abc@gmail.com.br bla')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note que neste último exemplo não foi casado corretamente o \".br\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Podemos tentar r'\\w+@\\w+\\.\\w+(\\.\\w+)?'. Criamos um grupo no final (\\.\\w+)? que é um ponto seguido de caracteres alfanuméricos, porém opcional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(r'\\w+@\\w+.\\w+(.\\w+)?', 'bla bla bla abc@gmail.com.br bla')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Agora a RE casa com os dois tipos de endereços de email!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "a. Escreva uma RE para encontrar numeros de telefone do tipo:\n",
    "\n",
    " - (019)91234 5678\n",
    " - 19 91234 5678\n",
    " - 19-91234-5678\n",
    " - (19) 91234-5678\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "p = re.compile(r'(\\(0?[0-9]{2}\\)|[0-9]{2})( |-)?[0-9]{5}[ -][0-9]{4}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = p.search(\"(019)91234 5678\")\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "b. Faca uma função que recebe um string e retorna o string com os números de telefones transformados para um único formato: (19) 91234 5678"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Referência\n",
    "\n",
    "Consulte a página web (https://docs.python.org/3/howto/regex.html) para uma visão mais completa sobre expressões regulares em Python."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "livereveal": {
   "theme": "solarized",
   "transition": "slide"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}