01-python-intro/aula-04/Aula 04.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Py-Intro] Aula 04\n",
    "# Tipos básicos e estruturas de controles\n",
    "\n",
    "## O que você vai aprender nesta aula?\n",
    "\n",
    "Após o término da aula você terá aprendido:\n",
    "\n",
    "- Formatação de strings\n",
    "- Conjuntos: set\n",
    "- Mapeamentos: dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatação de strings\n",
    "\n",
    "Complementando a aula passada será explicado melhor como funciona a função `format()` e `str.format()` começando pela última.\n",
    "\n",
    "A função `str.format()` converte os campos envolvos por chaves pelos argumentos passados a ela. Caso não seja especificado o nome ou posição dos argumentos a troca de chaves por dados é feita na ordem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10 + 10 = 20'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{} + {} = {}'.format(10, 10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém podemos especificar explicitamente as posições que queremos substituir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10 + 10 = 20'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0} + {1} = {2}'.format(10, 10, 20)  # esse é o padrão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos repetir um único argumento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10 + 10 = 20'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0} + {0} = {1}'.format(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Informar uma ordem arbritária:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'20 + 30 = 10'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{1} + {0} = {2}'.format(30, 20, 10)  # evite fazer isso para não causar confusão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível dar nomes a esses campos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bruxelas é muito bonito(a) durante o(a) Inverno'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string = '{cidade} é muito bonito(a) durante o(a) {estação}'\n",
    "string.format(cidade='Bruxelas', estação='Inverno')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos formatar números:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'O total é R$59.8912313'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'O total é R${0}'.format(59.8912313)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'O total é R$59.89'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'O total é R${0:.2f}'.format(59.8912313)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A porcentagem é de 89.12%'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A porcentagem é de {0:.2%}'.format(0.8912313)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`format()` também permite alinhar elementos dentro de um espaço de 10 caracteres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Qtd.       | Cor        | Valor     '"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:<10} | {1:<10} | {2:<10}'.format('Qtd.', 'Cor', 'Valor')  # alinhado à esquerda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'      Qtd. |        Cor |      Valor'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:>10} | {1:>10} | {2:>10}'.format('Qtd.', 'Cor', 'Valor')  # alinhado à direita"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O tamanho do espaço pode ser diferente nos elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' Qtd.  |    Cor    |   Valor   '"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:^6} | {1:^9} | {2:^10}'.format('Qtd.', 'Cor', 'Valor')  # centralizado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é  possível mudar o caracter de preenchimento do espaço dado de caracter em branco para algum outro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+Qtd.+ | ===Cor=== | --Valor---'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:+^6} | {1:=^9} | {2:-^10}'.format('Qtd.', 'Cor', 'Valor')  # centralizado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+Qtd.+ | ===Cor=== | --Valor---'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:+^6} | {1:=^9} | {2:-^10}'.format('Qtd.', 'Cor', 'Valor')  # centralizado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos armazenar format e reaplicá-los para valores diferentes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{0:^6} | {1:^9} | {2:^10}'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "formato_tabela = '{0:^6} | {1:^9} | {2:^10}'\n",
    "formato_tabela"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 'Amarelo', 18.5), (5, 'Verde', 48.5), (2, 'Azul', 78.5)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "produtos = [\n",
    "    (2, 'Amarelo', 18.50),\n",
    "    (5, 'Verde', 48.50),\n",
    "    (2, 'Azul', 78.50),\n",
    "]\n",
    "produtos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Qtd.  |    Cor    |  Valor R$ \n",
      "  2    |  Amarelo  |    18.5   \n",
      "  5    |   Verde   |    48.5   \n",
      "  2    |   Azul    |    78.5   \n"
     ]
    }
   ],
   "source": [
    "print(formato_tabela.format('Qtd.', 'Cor', 'Valor R$'))\n",
    "for qtd, cor, valor in produtos:\n",
    "    print(formato_tabela.format(qtd, cor, valor))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível especificar o tipo dos dados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.100000e-06 0.000003 0.000310%'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:e} {0:f} {0:%}'.format(.0000031)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os formatos possíveis são:\n",
    "\n",
    "![Formatação da função `format()`](img/format_tipos.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível formatar valores usando a função embutida `format()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' 3.142'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "format(math.pi, '6.3f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python......'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format('Python', '.<12')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'......Python'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format('Python', '.>12')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'...Python...'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format('Python', '.^12')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferentemente da função `str.format()` a função embutida `format()` não permite substituição de caracteres usando chaves.\n",
    "\n",
    "Para saber mais sobre o assunto consulte a [documentação](https://docs.python.org/3/library/string.html#format-string-syntax) e este [documento](cartao-format.pdf) feito pelo Luciano Ramalho que explica detalhadamente como usar essa função."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos básicos - conjuntos e mapeamentos\n",
    "\n",
    "Na aula passada vimos outros tipos básicos: números e sequência.\n",
    "\n",
    "Agora vamos falar sobre conjuntos.\n",
    "\n",
    "### Set (conjunto)\n",
    "\n",
    "Conjunto, ou set, é uma ferramenta subutilizada do Python, tanto que muitos cursos introdutórios não passam abordam esse assunto.\n",
    "\n",
    "Set vem da teoria de conjuntos da matemática. Um conjunto não permite a existência de elementos iguais dentro de si, por conta disso é muito utilizado para remover repetições:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'spam', 'eggs', 'spam']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['spam', 'spam', 'eggs', 'spam']\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eggs', 'spam'}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos ver a sintaxe de set - {1}, {1, 2}, etc. - se parece exatamente com a notação matemática, com exceção que não existe uma notação para set vazio. Caso você precise criar um conjunto vazio use: `set()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-bf2aaa473a28>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mA\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "A = set()\n",
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vale lembrar que conjuntos também se comportam como sequências, por conta disso é possível usar neles as funções que aprendemos anteriormente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5, 10}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {5, 4, 3, 3, 2, 10}\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um ponto importante a se observar é que conjunto não mantém a ordem dos elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 5, 7}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {4, 5, 1, 3, 4, 5, 7}\n",
    "A  # ordem diferente da declarada!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por isso não é possível acessar os elementos pela posição:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-31-3f7632ffc2df>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mA\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'set' object does not support indexing"
     ]
    }
   ],
   "source": [
    "A[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível acessar seus elementos iterando o set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "4\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for num in A:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou convertendo-o para tupla ou lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3, 4, 5, 7)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(A)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 5, 7]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(A)[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como listas os conjuntos também possuem um mecanismo simplificado para construir conjuntos o `set comprehension`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'd', 'k', 'l', 'm', 'r', 'z'}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{letra for letra in 'abrakadabraalakazam'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26, 28, 29}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{numero for numero in range(30) if numero % 3 != 0}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra característica importante de conjuntos é que eles realizam verificações de pertencimento de forma muito mais eficiente.\n",
    "\n",
    "Para verificar se um elemento está presente em um conjunto usamos o mesmo operador `in` que vimos para lista, tuplas e string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{-10, 0, 10, 20, 30, 40}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {-10, 0, 10, 20, 30, 40}\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-10 in A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para demonstrar que conjuntos verificam se um elemento pertence em uma coleção de maneira mais rápida isso vamos usar o módulo [timeit](https://docs.python.org/3/library/timeit.html) que oferece uma maneira simples de contar o tempo de execução de código Python.\n",
    "\n",
    "O módulo `timeit` possui uma função `timeit(stmt='pass', setup='pass', number=1000000, ...)` que executa um `setup` e um `código` (stmt) uma dada quantidade de vezes e contabiliza o tempo levado para executar o código (o tempo de rodar o setup não é incluído). O código e o setup devem ser passados como strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.4771713519985497"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import timeit\n",
    "\n",
    "tempo = timeit.timeit('[math.exp(x) for x in range(10)]', setup='import math')\n",
    "tempo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O código acima executa primeiro o setup `import math` depois o código `[math.exp(x) for x in range(10)]`, que cria uma lista com os exponencianciais de 0 a 9, 1000000 vezes.\n",
    "\n",
    "Para sabermos qual a média do tempo de execução desse código fazemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.4771713519985495e-06"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tempo / 1000000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sabendo disso agora podemos calcular o tempo de verificação de um elemento em lista e set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tamanho  | tempo da lista | tempo do set | list vs set\n",
      "1000     | 2.573e-05      | 3e-08        | set é 888x + rápido\n",
      "10000    | 0.00017057     | 4e-08        | set é 3997x + rápido\n",
      "100000   | 0.00165465     | 4e-08        | set é 37923x + rápido\n",
      "1000000  | 0.01546964     | 3e-08        | set é 494918x + rápido\n",
      "10000000 | 0.14962824     | 6e-08        | set é 2717154x + rápido\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "import random\n",
    "\n",
    "# PS: esse código demora para ser executado\n",
    "vezes = 1000\n",
    "print('tamanho  | tempo da lista | tempo do set | list vs set')\n",
    "tamanhos = (10 ** i for i in range(3, 8))\n",
    "for tamanho in tamanhos:  # cria um gerador com os valores 10^3, 10^4, ..., 10^7\n",
    "    setup_lista = 'l = list(range({}))'.format(tamanho)\n",
    "    tempo = timeit.timeit('9999999 in l', setup=setup_lista, number=vezes)\n",
    "    media_lista = tempo / vezes\n",
    "    \n",
    "    setup_set = 's = set(range({}))'.format(tamanho)\n",
    "    tempo = timeit.timeit('9999999 in s', setup=setup_set, number=vezes)\n",
    "    media_set = tempo / vezes\n",
    "    \n",
    "    msg = '{:<9}| {:<15}| {:<13}| set é {:<}x + rápido'\n",
    "    msg = msg.format(tamanho, round(media_lista, 8), round(media_set, 8),\n",
    "                     round(media_lista / media_set))\n",
    "    print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse código usa alguns recursos mais avançados de formatação de string. Para entender melhor o que é feito verifique a [documentação oficial do assunto](https://docs.python.org/3/library/string.html#format-string-syntax)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Conjuntos também oferecem algumas operações interessantes:\n",
    "\n",
    "<center>União $${(A \\cup B)}$$</center>\n",
    "![União (A U B)](img/uniao.svg)\n",
    "\n",
    "A união pode ser feita a partir da função A.union(B) ou através da utilização do operador bitwise ou `|` : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5, 7}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {2, 3, 4}\n",
    "B = {3, 5, 7}\n",
    "A | B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5, 7}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.union(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<center>Intersecção $${A \\cap B}$$</center>\n",
    "![](img/interseccao.svg)\n",
    "\n",
    "A intersecção pode ser feita a partir da função A.intersection(B) ou com o operador bitwise e `&` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {2, 3, 4}\n",
    "B = {3, 5, 7}\n",
    "A & B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.intersection(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>Diferença $${A - B}$$</center>\n",
    "![](img/diferenca.svg)\n",
    "\n",
    "A diferença pode ser feita a partir da função A.difference(B) ou com o operador `-` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 4}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {2, 3, 4}\n",
    "B = {3, 5, 7}\n",
    "A - B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 4}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {2, 3, 4}\n",
    "B = {3, 5, 7}\n",
    "A.difference(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>Diferença simétrica $${A \\bigtriangleup B}$$</center>\n",
    "![](img/diferenca-simetrica.svg)\n",
    "\n",
    "A diferença pode ser feita a partir da função A.difference(B) ou com o operador `^` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 4, 5, 7}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {2, 3, 4}\n",
    "B = {3, 5, 7}\n",
    "A ^ B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 4, 5, 7}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.symmetric_difference(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, essas funções são legais, mas eu já vi isso no ensino médio e nunca usei na minha vida, como isso vai ser útil para mim? (pelo menos foi isso que eu pensei ao ver isso)\n",
    "\n",
    "Para testar isso vamos gerar um conjunto de nomes. Vamos usar a biblioteca externa [faker](http://fake-factory.readthedocs.io/en/latest/index.html) que gera dados falsos.\n",
    "\n",
    "Para usá-la é necessário instalar:\n",
    "    \n",
    "    $ pip install fake-factory\n",
    "\n",
    "Depois de instalá-la em nosso virtualenv podemos usá-la:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nina Correia',\n",
       " 'Eduardo Rocha',\n",
       " 'Joaquim Martins',\n",
       " 'Sra. Bruna Ferreira',\n",
       " 'Lívia Barbosa',\n",
       " 'Srta. Ana Ferreira',\n",
       " 'Pedro Henrique Ribeiro',\n",
       " 'Letícia Martins',\n",
       " 'Dra. Ana Sophia Araújo',\n",
       " 'Thomas Melo',\n",
       " 'Nicolas Dias',\n",
       " 'Srta. Maria Cecília Pereira',\n",
       " 'João Guilherme Cardoso',\n",
       " 'Bryan Azevedo',\n",
       " 'Lavínia Martins',\n",
       " 'Valentina Barbosa',\n",
       " 'Sr. Isaac Castro',\n",
       " 'Sr. Renan Cunha',\n",
       " 'Pedro Lucas Lima',\n",
       " 'Olivia Pereira',\n",
       " 'Laura Rocha',\n",
       " 'Bernardo Santos',\n",
       " 'Ana Lívia Azevedo',\n",
       " 'Mariane Rodrigues',\n",
       " 'Clarice Almeida',\n",
       " 'Sofia Gomes',\n",
       " 'Theo Ribeiro',\n",
       " 'Dra. Maria Fernanda Castro',\n",
       " 'Heloísa Carvalho',\n",
       " 'Diogo Castro',\n",
       " 'Fernando Ferreira',\n",
       " 'Sra. Camila Costela',\n",
       " 'Letícia Carvalho',\n",
       " 'Juliana Silva',\n",
       " 'Miguel Pereira',\n",
       " 'Ryan Dias',\n",
       " 'Isabel Pereira',\n",
       " 'Emanuel Correia',\n",
       " 'Dr. Diogo Ferreira',\n",
       " 'Dr. Marcos Vinicius Alves',\n",
       " 'Murilo Correia',\n",
       " 'Sr. Marcelo Pereira',\n",
       " 'Benjamin Fernandes',\n",
       " 'Luiz Felipe Fernandes',\n",
       " 'Esther Costela',\n",
       " 'Isabelly Souza',\n",
       " 'Sra. Heloísa Costela',\n",
       " 'Arthur Melo',\n",
       " 'Sr. João Lucas Santos',\n",
       " 'Luiz Miguel Araújo',\n",
       " 'Nina Alves',\n",
       " 'Stephany Alves',\n",
       " 'Lucas Ribeiro',\n",
       " 'Enzo Gabriel Castro',\n",
       " 'Catarina Ferreira',\n",
       " 'Sr. Raul Barros',\n",
       " 'Daniel Melo',\n",
       " 'Lucas Gabriel Barros',\n",
       " 'Melissa Costela',\n",
       " 'Dr. Thiago Lima',\n",
       " 'Maria Julia Barbosa',\n",
       " 'Sr. Nicolas Carvalho',\n",
       " 'Olivia Alves',\n",
       " 'Maria Sophia Ribeiro',\n",
       " 'Emanuella Pereira',\n",
       " 'Luiz Fernando Rocha',\n",
       " 'Heloísa Silva',\n",
       " 'Lavínia Araújo',\n",
       " 'Dr. Luiz Felipe Costela',\n",
       " 'Ana Beatriz Fernandes',\n",
       " 'Dra. Bruna Dias',\n",
       " 'Pedro Miguel Ferreira',\n",
       " 'Dr. Vitor Costela',\n",
       " 'Emilly Alves',\n",
       " 'Paulo Santos',\n",
       " 'Dra. Daniela Cardoso',\n",
       " 'Luiz Otávio Gomes',\n",
       " 'Murilo Souza',\n",
       " 'Mirella Barros',\n",
       " 'Dr. Anthony Alves',\n",
       " 'Dr. Guilherme Dias',\n",
       " 'Esther Barros',\n",
       " 'Leandro Correia',\n",
       " 'André Rodrigues',\n",
       " 'Igor Souza',\n",
       " 'Camila Alves',\n",
       " 'Dr. Emanuel Santos',\n",
       " 'Lara Carvalho',\n",
       " 'Maria Alice Araújo',\n",
       " 'Maria Cecília Cardoso',\n",
       " 'Kevin Ribeiro',\n",
       " 'Sabrina Cunha',\n",
       " 'Srta. Alícia Cunha',\n",
       " 'Calebe Pereira',\n",
       " 'João Guilherme Oliveira',\n",
       " 'Vitória Silva',\n",
       " 'Srta. Emanuelly Rodrigues',\n",
       " 'Sra. Olivia Cardoso',\n",
       " 'Emanuella Azevedo',\n",
       " 'Marina Barbosa',\n",
       " 'Maria Sophia Gomes',\n",
       " 'Dra. Alice Araújo',\n",
       " 'Luana Barbosa',\n",
       " 'Dr. Bryan Rodrigues',\n",
       " 'Srta. Gabriela Lima',\n",
       " 'Mariana Carvalho',\n",
       " 'Melissa Barros',\n",
       " 'Sr. Nathan Rodrigues',\n",
       " 'Thomas Barros',\n",
       " 'Bryan Almeida',\n",
       " 'Sra. Letícia Pereira',\n",
       " 'Benjamin Costela',\n",
       " 'Sra. Ana Carolina Pinto',\n",
       " 'Vinicius Melo',\n",
       " 'Davi Lucca Silva',\n",
       " 'Thiago Santos',\n",
       " 'Isaac Almeida',\n",
       " 'Marcela Lima',\n",
       " 'Marcela Ribeiro',\n",
       " 'Enrico Almeida',\n",
       " 'Daniel Costela',\n",
       " 'Isabella Barros',\n",
       " 'Sr. Nicolas Ribeiro',\n",
       " 'Bruno Alves',\n",
       " 'Sr. Benjamin Ferreira',\n",
       " 'Sr. Marcelo Fernandes',\n",
       " 'Davi Martins',\n",
       " 'André Azevedo',\n",
       " 'Rafael Pinto',\n",
       " 'Henrique Oliveira',\n",
       " 'Catarina Cardoso',\n",
       " 'Nathan Alves',\n",
       " 'Nicole Dias',\n",
       " 'Pedro Miguel Castro',\n",
       " 'Erick Cunha',\n",
       " 'Davi Lucca Santos',\n",
       " 'Manuela Barbosa',\n",
       " 'Maria Sophia Souza',\n",
       " 'Mariane Ferreira',\n",
       " 'Fernanda Pereira',\n",
       " 'Bruno Castro',\n",
       " 'Calebe Dias',\n",
       " 'Pedro Henrique Santos',\n",
       " 'Laura Martins',\n",
       " 'Marina Alves',\n",
       " 'Letícia Cardoso',\n",
       " 'Maria Clara Pereira',\n",
       " 'Bryan Ribeiro',\n",
       " 'Srta. Milena Pinto',\n",
       " 'Milena Souza',\n",
       " 'Vicente Carvalho',\n",
       " 'Stella Gomes',\n",
       " 'Raquel Cunha',\n",
       " 'Isabelly Oliveira',\n",
       " 'Henrique Almeida',\n",
       " 'Stella Carvalho',\n",
       " 'Sr. Theo Rodrigues',\n",
       " 'Gustavo Azevedo',\n",
       " 'Ana Sophia Pereira',\n",
       " 'Sra. Maria Alice Pereira',\n",
       " 'Sra. Mariana Martins',\n",
       " 'Sr. Otávio Almeida',\n",
       " 'Dr. Benício Araújo',\n",
       " 'Laura Castro',\n",
       " 'Ana Dias',\n",
       " 'Davi Lucca Castro',\n",
       " 'Rafaela Carvalho',\n",
       " 'Lorena Castro',\n",
       " 'Valentina Souza',\n",
       " 'Srta. Emilly Fernandes',\n",
       " 'Bryan Oliveira',\n",
       " 'Dra. Eduarda Araújo',\n",
       " 'Bernardo Ribeiro',\n",
       " 'Maria Sophia Cardoso',\n",
       " 'Sr. Arthur Ribeiro',\n",
       " 'Daniel Rocha',\n",
       " 'Stephany Almeida',\n",
       " 'Mariana Dias',\n",
       " 'Luana Correia',\n",
       " 'Sr. João Gomes',\n",
       " 'Stella Dias',\n",
       " 'Luiz Henrique Rodrigues',\n",
       " 'Pedro Correia',\n",
       " 'Davi Lucca Rocha',\n",
       " 'Alícia Barbosa',\n",
       " 'Thomas Oliveira',\n",
       " 'Agatha Cunha',\n",
       " 'Sr. João Guilherme Gomes',\n",
       " 'Vitor Gabriel Araújo',\n",
       " 'Dr. Joaquim Ferreira',\n",
       " 'Stella Pereira',\n",
       " 'Felipe Santos',\n",
       " 'Antonio Pinto',\n",
       " 'Maria Vitória Rodrigues',\n",
       " 'Sr. Luiz Otávio Fernandes',\n",
       " 'André Correia',\n",
       " 'Isabella Barbosa',\n",
       " 'Cecília Costela',\n",
       " 'Maria Cecília Rodrigues',\n",
       " 'Sr. Caio Melo',\n",
       " 'Carlos Eduardo Souza',\n",
       " 'Theo Cunha',\n",
       " 'Lavínia Alves',\n",
       " 'Sra. Isadora Almeida',\n",
       " 'Arthur Barros',\n",
       " 'Lívia Santos',\n",
       " 'Daniela Cunha',\n",
       " 'Breno Almeida',\n",
       " 'Carolina Barros',\n",
       " 'Isadora Melo',\n",
       " 'Srta. Rebeca Rocha',\n",
       " 'Gabrielly Santos',\n",
       " 'Ana Clara Ferreira',\n",
       " 'Sabrina Barbosa',\n",
       " 'Emilly Ferreira',\n",
       " 'Maria Eduarda Rodrigues',\n",
       " 'Maria Julia Silva',\n",
       " 'Dr. Pedro Miguel Santos',\n",
       " 'Dr. Thales Fernandes',\n",
       " 'Dra. Laís Costela',\n",
       " 'Agatha Cardoso',\n",
       " 'Sra. Beatriz Ribeiro',\n",
       " 'Giovanna Santos',\n",
       " 'Sra. Ana Carolina Correia',\n",
       " 'Maria Luiza Araújo',\n",
       " 'Thiago Alves',\n",
       " 'Luiza Martins',\n",
       " 'Nicole Fernandes',\n",
       " 'Luana Alves',\n",
       " 'Sra. Fernanda Santos',\n",
       " 'Sophie Souza',\n",
       " 'Lucas Gabriel Correia',\n",
       " 'Isadora Ribeiro',\n",
       " 'Leonardo Cunha',\n",
       " 'Julia Castro',\n",
       " 'Valentina Martins',\n",
       " 'Luigi Costela',\n",
       " 'Matheus Martins',\n",
       " 'Carolina Gomes',\n",
       " 'Sr. Lorenzo Cunha',\n",
       " 'Dr. Theo Cardoso',\n",
       " 'Dr. Theo Ferreira',\n",
       " 'Esther Ferreira',\n",
       " 'Dr. Calebe Barbosa',\n",
       " 'Srta. Giovanna Ribeiro',\n",
       " 'Sra. Isabelly Araújo',\n",
       " 'Sra. Vitória Melo',\n",
       " 'Isabel Costela',\n",
       " 'Dr. Renan Correia',\n",
       " 'Cecília Lima',\n",
       " 'Dra. Emanuelly Correia',\n",
       " 'Maria Julia Fernandes',\n",
       " 'Mirella Silva',\n",
       " 'Dr. João Costela',\n",
       " 'Isabelly Azevedo',\n",
       " 'Luana Ferreira',\n",
       " 'Valentina Santos',\n",
       " 'Srta. Manuela Castro',\n",
       " 'Melissa Souza',\n",
       " 'Caroline Cardoso',\n",
       " 'Maria Martins',\n",
       " 'Sr. Theo Lima',\n",
       " 'Dra. Ana Laura Barbosa',\n",
       " 'Dr. Marcos Vinicius Silva',\n",
       " 'Valentina Araújo',\n",
       " 'Eloah Barros',\n",
       " 'Dra. Ana Lívia Alves',\n",
       " 'Ryan Santos',\n",
       " 'Eduarda Lima',\n",
       " 'Sofia Pereira',\n",
       " 'Sra. Bianca Carvalho',\n",
       " 'Giovanna Gomes',\n",
       " 'Dra. Ana Sophia Azevedo',\n",
       " 'Sr. Luiz Gustavo Souza',\n",
       " 'Thiago Araújo',\n",
       " 'Ian Santos',\n",
       " 'Sra. Yasmin Cunha',\n",
       " 'Otávio Gomes',\n",
       " 'Vitor Dias',\n",
       " 'Maria Luiza Azevedo',\n",
       " 'Dra. Heloísa Azevedo',\n",
       " 'Erick Castro',\n",
       " 'Dr. Leandro Santos',\n",
       " 'Yago Pinto',\n",
       " 'Alexia Correia',\n",
       " 'Diogo Barros',\n",
       " 'Brenda Correia',\n",
       " 'Sr. João Lucas Fernandes',\n",
       " 'Julia Melo',\n",
       " 'Bárbara Ribeiro',\n",
       " 'Sra. Maria Alice Dias',\n",
       " 'Sr. Davi Lucca Barros',\n",
       " 'André Silva',\n",
       " 'Dr. João Guilherme Martins',\n",
       " 'Sr. Pedro Miguel Araújo',\n",
       " 'Dra. Julia Rodrigues',\n",
       " 'Emanuella Barbosa',\n",
       " 'Dra. Laura Oliveira',\n",
       " 'Nicole Cardoso',\n",
       " 'Benício Ribeiro',\n",
       " 'Eduardo Ribeiro',\n",
       " 'Ana Vitória Carvalho',\n",
       " 'Sr. Gustavo Henrique Martins',\n",
       " 'João Pedro Barros',\n",
       " 'Gabriela Ribeiro',\n",
       " 'Ana Julia Correia',\n",
       " 'Dr. Davi Lucca Pereira',\n",
       " 'Arthur Rocha',\n",
       " 'Sra. Alexia Correia',\n",
       " 'Maysa Pinto',\n",
       " 'Dr. Juan Almeida',\n",
       " 'Emanuelly Rocha',\n",
       " 'Dr. Cauê Cunha',\n",
       " 'Marcela Carvalho',\n",
       " 'Ana Lívia Araújo',\n",
       " 'Srta. Maitê Costela',\n",
       " 'João Pedro Souza',\n",
       " 'Dra. Manuela Carvalho',\n",
       " 'Sr. Eduardo Almeida',\n",
       " 'Rafaela Almeida',\n",
       " 'Heitor Pinto',\n",
       " 'Samuel Carvalho',\n",
       " 'Amanda Souza',\n",
       " 'Nicole Martins',\n",
       " 'Davi Cardoso',\n",
       " 'Sr. Matheus Fernandes',\n",
       " 'Davi Gomes',\n",
       " 'Dr. Bernardo Carvalho',\n",
       " 'Leonardo Oliveira',\n",
       " 'Murilo Oliveira',\n",
       " 'Maitê Melo',\n",
       " 'Luiz Gustavo Ferreira',\n",
       " 'Sarah Cardoso',\n",
       " 'Sra. Sophie Rodrigues',\n",
       " 'Isabel Fernandes',\n",
       " 'Guilherme Alves',\n",
       " 'Dra. Emilly Costela',\n",
       " 'Carolina Pereira',\n",
       " 'Carolina Lima',\n",
       " 'Dr. Francisco Gomes',\n",
       " 'Noah Fernandes',\n",
       " 'Noah Souza',\n",
       " 'Sra. Ana Carolina Ribeiro',\n",
       " 'Agatha Correia',\n",
       " 'Dr. Luigi Cunha',\n",
       " 'Sophie Martins',\n",
       " 'Ana Vitória Ferreira',\n",
       " 'Sarah Araújo',\n",
       " 'Sra. Natália Barbosa',\n",
       " 'Maria Eduarda Castro',\n",
       " 'Srta. Maysa Castro',\n",
       " 'Dra. Stephany Barros',\n",
       " 'Yago Souza',\n",
       " 'Emanuella Castro',\n",
       " 'Dr. João Vitor Almeida',\n",
       " 'Kevin Santos',\n",
       " 'Emanuella Costela',\n",
       " 'Caroline Souza',\n",
       " 'Beatriz Melo',\n",
       " 'Alana Castro',\n",
       " 'Dr. Diogo Pereira',\n",
       " 'Kaique Rocha',\n",
       " 'Thales Pinto',\n",
       " 'Fernando Azevedo',\n",
       " 'Pedro Henrique Alves',\n",
       " 'Alana Carvalho',\n",
       " 'Breno Ferreira',\n",
       " 'Luiz Felipe Dias',\n",
       " 'Valentina Castro',\n",
       " 'Luiz Felipe Cardoso',\n",
       " 'Daniela Correia',\n",
       " 'Lorenzo Carvalho',\n",
       " 'Ana Clara Azevedo',\n",
       " 'Marcelo Rodrigues',\n",
       " 'Luiz Miguel Melo',\n",
       " 'Carlos Eduardo Correia',\n",
       " 'Miguel Alves',\n",
       " 'Ana Oliveira',\n",
       " 'Sra. Natália Santos',\n",
       " 'Augusto Ribeiro',\n",
       " 'Stella Silva',\n",
       " 'Cauê Cunha',\n",
       " 'Sra. Amanda Lima',\n",
       " 'Sra. Carolina Costela',\n",
       " 'Dr. Noah Souza',\n",
       " 'Bernardo Alves',\n",
       " 'Nathan Rocha',\n",
       " 'Lorenzo Melo',\n",
       " 'Carlos Eduardo Barros',\n",
       " 'Lucca Carvalho',\n",
       " 'Yuri Cardoso',\n",
       " 'Bernardo Costela',\n",
       " 'Elisa Lima',\n",
       " 'Dra. Luana Azevedo',\n",
       " 'Joaquim Dias',\n",
       " 'Sra. Maria Alice Fernandes',\n",
       " 'Otávio Castro',\n",
       " 'Esther Araújo',\n",
       " 'Anthony Costela',\n",
       " 'Maria Luiza Silva',\n",
       " 'Dr. Heitor Melo',\n",
       " 'Dr. Cauê Alves',\n",
       " 'Nina Oliveira',\n",
       " 'Srta. Marcela Ferreira',\n",
       " 'Sophie Oliveira',\n",
       " 'Vitória Carvalho',\n",
       " 'Srta. Caroline Carvalho',\n",
       " 'João Miguel Carvalho',\n",
       " 'Dr. Ryan Barbosa',\n",
       " 'Ian Barbosa',\n",
       " 'Amanda Barbosa',\n",
       " 'Kaique Araújo',\n",
       " 'Raul Gomes',\n",
       " 'Theo Ferreira',\n",
       " 'Luiz Gustavo Almeida',\n",
       " 'Catarina Dias',\n",
       " 'Manuela Almeida',\n",
       " 'Bárbara Fernandes',\n",
       " 'Sr. Murilo Cunha',\n",
       " 'Ana Sophia Almeida',\n",
       " 'Dr. João Vitor Silva',\n",
       " 'Laura Pinto',\n",
       " 'Maria Julia Araújo',\n",
       " 'Maria Sophia Cunha',\n",
       " 'Maria Cecília Fernandes',\n",
       " 'Bruno Lima',\n",
       " 'Srta. Lívia Barbosa',\n",
       " 'Lucca Rodrigues',\n",
       " 'Sra. Alícia Rodrigues',\n",
       " 'Sr. João Vitor Cardoso',\n",
       " 'Davi Barbosa',\n",
       " 'Arthur Silva',\n",
       " 'Luna Araújo',\n",
       " 'Agatha Martins',\n",
       " 'Sra. Mirella Ribeiro',\n",
       " 'João Santos',\n",
       " 'Dr. Anthony Dias',\n",
       " 'Sr. João Felipe Barros',\n",
       " 'Olivia Barros',\n",
       " 'Arthur Ferreira',\n",
       " 'Sra. Larissa Castro',\n",
       " 'Sra. Brenda Barbosa',\n",
       " 'Maria Eduarda Martins',\n",
       " 'Sr. Luiz Otávio Carvalho',\n",
       " 'Noah Barbosa',\n",
       " 'Pedro Henrique Martins',\n",
       " 'Srta. Maysa Melo',\n",
       " 'Henrique Silva',\n",
       " 'Rebeca Barbosa',\n",
       " 'Renan Rodrigues',\n",
       " 'Pedro Araújo',\n",
       " 'Isabelly Santos',\n",
       " 'Dr. Pedro Miguel Rocha',\n",
       " 'Gustavo Castro',\n",
       " 'Marcos Vinicius Martins',\n",
       " 'Catarina Carvalho',\n",
       " 'Sr. Kevin Costela',\n",
       " 'Enrico Oliveira',\n",
       " 'Luna Ribeiro',\n",
       " 'Bruna Ribeiro',\n",
       " 'Dr. Henrique Castro',\n",
       " 'André Lima',\n",
       " 'Benício Cunha',\n",
       " 'Luna Cardoso',\n",
       " 'Emanuel Rocha',\n",
       " 'Gustavo Ferreira',\n",
       " 'Ana Araújo',\n",
       " 'Stella Fernandes',\n",
       " 'Enzo Gabriel Alves',\n",
       " 'Paulo Fernandes',\n",
       " 'Lucca Melo',\n",
       " 'Camila Gomes',\n",
       " 'Ana Julia Cunha',\n",
       " 'Maysa Dias',\n",
       " 'Yago Cunha',\n",
       " 'Ryan Fernandes',\n",
       " 'Esther Oliveira',\n",
       " 'Isadora Pinto',\n",
       " 'Sra. Mariana Pinto',\n",
       " 'Ana Clara Dias',\n",
       " 'Dr. Alexandre Costela',\n",
       " 'Emanuel Almeida',\n",
       " 'Vitor Correia',\n",
       " 'Dr. Pedro Henrique Ribeiro',\n",
       " 'Alice Cardoso',\n",
       " 'Igor Pereira',\n",
       " 'Giovanna Carvalho',\n",
       " 'Joana Ferreira',\n",
       " 'Dra. Brenda Azevedo',\n",
       " 'Laura Araújo',\n",
       " 'Mirella Costela',\n",
       " 'Sarah Costela',\n",
       " 'Benício Silva',\n",
       " 'Clara Gomes',\n",
       " 'Rafael Cardoso',\n",
       " 'Olivia Gomes',\n",
       " 'Isadora Almeida',\n",
       " 'Maysa Rodrigues',\n",
       " 'Natália Pereira',\n",
       " 'Sr. Pedro Costela',\n",
       " 'Davi Lucas Pereira',\n",
       " 'Danilo Santos',\n",
       " 'Vitor Carvalho',\n",
       " 'Sr. Miguel Santos',\n",
       " 'Gustavo Henrique Alves',\n",
       " 'Dra. Valentina Rocha',\n",
       " 'Bruna Pinto',\n",
       " 'Raul Souza',\n",
       " 'Gabriel Pinto',\n",
       " 'Bernardo Melo',\n",
       " 'Marcos Vinicius Rodrigues',\n",
       " 'Nicolas Almeida',\n",
       " 'Ana Lívia Pinto',\n",
       " 'Ana Clara Santos',\n",
       " 'Amanda Rodrigues',\n",
       " 'Alana Rodrigues',\n",
       " 'Sra. Maria Sophia Oliveira',\n",
       " 'Erick Dias',\n",
       " 'Ana Carolina Gomes',\n",
       " 'Srta. Pietra Barros',\n",
       " 'Nicole Araújo',\n",
       " 'Dra. Gabrielly Correia',\n",
       " 'Kamilly Azevedo',\n",
       " 'Luiz Henrique Barbosa',\n",
       " 'Vitor Hugo Lima',\n",
       " 'Isadora Cardoso',\n",
       " 'Marcela Rodrigues',\n",
       " 'Nicolas Lima',\n",
       " 'Ana Clara Rodrigues',\n",
       " 'Lavínia Souza',\n",
       " 'Dr. Benício Cardoso',\n",
       " 'Yuri Dias',\n",
       " 'Dr. João Pedro Barbosa',\n",
       " 'Vicente Alves',\n",
       " 'Nicole Santos',\n",
       " 'Luiz Henrique Alves',\n",
       " 'Ana Sophia Correia',\n",
       " 'João Guilherme Silva',\n",
       " 'Sr. Joaquim Barbosa',\n",
       " 'Dr. Arthur Gomes',\n",
       " 'Nathan Azevedo',\n",
       " 'Antonio Silva',\n",
       " 'Sra. Melissa Araújo',\n",
       " 'Cauã Cunha',\n",
       " 'Luiza Silva',\n",
       " 'Laura Barbosa',\n",
       " 'Gabriel Azevedo',\n",
       " 'Dra. Mirella Correia',\n",
       " 'Amanda Pinto',\n",
       " 'Murilo Barbosa',\n",
       " 'Laís Santos',\n",
       " 'Stephany Pereira',\n",
       " 'Isabel Correia',\n",
       " 'Cauã Martins',\n",
       " 'Enzo Gabriel Cunha',\n",
       " 'Srta. Daniela Martins',\n",
       " 'Dr. Vicente Rodrigues',\n",
       " 'Maria Julia Rodrigues',\n",
       " 'Luiz Otávio Cardoso',\n",
       " 'Vitor Hugo Castro',\n",
       " 'Dra. Heloísa Pereira',\n",
       " 'Camila Pereira',\n",
       " 'Ian Cardoso',\n",
       " 'Julia Santos',\n",
       " 'Eloah Fernandes',\n",
       " 'Nicole Melo',\n",
       " 'Enrico Santos',\n",
       " 'Rafael Dias',\n",
       " 'Catarina Gomes',\n",
       " 'Emilly Rodrigues',\n",
       " 'Sophie Silva',\n",
       " 'Dr. Ryan Ribeiro',\n",
       " 'Esther Lima',\n",
       " 'Maysa Souza',\n",
       " 'Rebeca Silva',\n",
       " 'Sr. Luiz Henrique Azevedo',\n",
       " 'Gabrielly Almeida',\n",
       " 'Levi Rocha',\n",
       " 'Elisa Cardoso',\n",
       " 'Isaac Pinto',\n",
       " 'Srta. Stella Santos',\n",
       " 'Ana Lívia Pereira',\n",
       " 'Sra. Cecília Araújo',\n",
       " 'Ana Vitória Alves',\n",
       " 'Srta. Rebeca Rodrigues',\n",
       " 'Evelyn Costela',\n",
       " 'Vitor Gabriel Carvalho',\n",
       " 'Lívia Costela',\n",
       " 'Raul Dias',\n",
       " 'Maria Julia Alves',\n",
       " 'Sabrina Martins',\n",
       " 'Marcelo Alves',\n",
       " 'Eduardo Oliveira',\n",
       " 'Sra. Ana Araújo',\n",
       " 'João Lucas Pinto',\n",
       " 'Brenda Rodrigues',\n",
       " 'Sra. Sophie Melo',\n",
       " 'Elisa Rodrigues',\n",
       " 'Joana Rocha',\n",
       " 'Pietro Barbosa',\n",
       " 'Lucas Martins',\n",
       " 'Nina Gomes',\n",
       " 'Luiza Carvalho',\n",
       " 'Sr. Paulo Pinto',\n",
       " 'Maria Vitória Dias',\n",
       " 'Dra. Clara Castro',\n",
       " 'Sra. Maria Clara Carvalho',\n",
       " 'Sra. Camila Alves',\n",
       " 'Dr. Lucca Alves',\n",
       " 'Srta. Ana Beatriz Almeida',\n",
       " 'Sra. Sophie Costela',\n",
       " 'Amanda Carvalho',\n",
       " 'Dr. Henrique Rocha',\n",
       " 'Bianca Rocha',\n",
       " 'Marcelo Barros',\n",
       " 'Sophie Correia',\n",
       " 'Helena Gomes',\n",
       " 'Manuela Santos',\n",
       " 'Vitor Gabriel Fernandes',\n",
       " 'Valentina Alves',\n",
       " 'Luna Lima',\n",
       " 'Eduardo Barros',\n",
       " 'Ana Martins',\n",
       " 'Benjamin Ribeiro',\n",
       " 'André Rocha',\n",
       " 'João Barbosa',\n",
       " 'Pedro Miguel Pereira',\n",
       " 'Alana Gomes',\n",
       " 'Srta. Caroline Cardoso',\n",
       " 'Clarice Melo',\n",
       " 'Erick Lima',\n",
       " 'Dr. Vicente Azevedo',\n",
       " 'Srta. Emilly Barbosa',\n",
       " 'Antonio Fernandes',\n",
       " 'Bernardo Pinto',\n",
       " 'Thiago Castro',\n",
       " 'Bruno Ribeiro',\n",
       " 'Dr. Pedro Lucas Cardoso',\n",
       " 'Dra. Sabrina Costela',\n",
       " 'Felipe Pinto',\n",
       " 'João Miguel Lima',\n",
       " 'João Gabriel Fernandes',\n",
       " 'Dr. Alexandre Melo',\n",
       " 'Dr. Noah Pereira',\n",
       " 'Sra. Juliana Oliveira',\n",
       " 'Gabriela Cardoso',\n",
       " 'Srta. Lorena Fernandes',\n",
       " 'Maria Costela',\n",
       " 'Mirella Souza',\n",
       " 'Maria Eduarda Rocha',\n",
       " 'Mariane Lima',\n",
       " 'Alexandre Cunha',\n",
       " 'Ian Araújo',\n",
       " 'Paulo Oliveira',\n",
       " 'Ana Lívia Lima',\n",
       " 'Cauã Castro',\n",
       " 'Luiz Otávio Martins',\n",
       " 'Nina Castro',\n",
       " 'Gabriel Correia',\n",
       " 'Maria Clara Rocha',\n",
       " 'Luiz Otávio Lima',\n",
       " 'Isabella Costela',\n",
       " 'Henrique Araújo',\n",
       " 'Sr. Cauê Silva',\n",
       " 'Srta. Clara Dias',\n",
       " 'Ana Beatriz Castro',\n",
       " 'Theo Correia',\n",
       " 'Sr. Thales Araújo',\n",
       " 'Isabelly Pereira',\n",
       " 'Maria Eduarda Cardoso',\n",
       " 'Sr. Samuel Castro',\n",
       " 'Sr. Benício Martins',\n",
       " 'Srta. Vitória Alves',\n",
       " 'Srta. Lorena Barros',\n",
       " 'Rodrigo Gomes',\n",
       " 'Luana Silva',\n",
       " 'Srta. Ana Carolina Azevedo',\n",
       " 'Dr. Kevin Santos',\n",
       " 'Yasmin Lima',\n",
       " 'Natália Oliveira',\n",
       " 'Dr. Pedro Miguel Almeida',\n",
       " 'Diogo Almeida',\n",
       " 'Juliana Correia',\n",
       " 'Sr. Gustavo Oliveira',\n",
       " 'Larissa Carvalho',\n",
       " 'Diego Silva',\n",
       " 'Cauã Carvalho',\n",
       " 'Emanuella Lima',\n",
       " 'Gabrielly Pereira',\n",
       " 'Cauê Costela',\n",
       " 'Luiz Gustavo Castro',\n",
       " 'Kaique Silva',\n",
       " 'Benjamin Dias',\n",
       " 'Kaique Gomes',\n",
       " 'Helena Fernandes',\n",
       " 'Srta. Ana Silva',\n",
       " 'Pietra Gomes',\n",
       " 'Dr. Davi Castro',\n",
       " 'Isaac Gomes',\n",
       " 'João Lucas Fernandes',\n",
       " 'Leandro Martins',\n",
       " 'Luiz Otávio Cunha',\n",
       " 'Natália Dias',\n",
       " 'Dra. Alexia Fernandes',\n",
       " 'Calebe Barbosa',\n",
       " 'Cauã Santos',\n",
       " 'Nathan Silva',\n",
       " 'Dr. Nathan Santos',\n",
       " 'Sofia Ferreira',\n",
       " 'Caroline Rocha',\n",
       " 'Emanuella Dias',\n",
       " 'Sofia Oliveira',\n",
       " 'Yago Barbosa',\n",
       " 'Dr. Vinicius Alves',\n",
       " 'Ana Lívia Correia',\n",
       " 'Raul Azevedo',\n",
       " 'Bruno Santos',\n",
       " 'Sra. Marcela Alves',\n",
       " 'Lucas Almeida',\n",
       " 'Heloísa Santos',\n",
       " 'Samuel Gomes',\n",
       " 'Sr. Joaquim Santos',\n",
       " 'Maria Cecília Pereira',\n",
       " 'Emanuelly Carvalho',\n",
       " 'Sr. Davi Lucca Melo',\n",
       " 'Luiz Fernando Rodrigues',\n",
       " 'Srta. Valentina Ferreira',\n",
       " 'Srta. Bruna Almeida',\n",
       " 'Brenda Almeida',\n",
       " 'Dr. Felipe Araújo',\n",
       " 'Srta. Isadora Alves',\n",
       " 'Dr. Pedro Miguel Ferreira',\n",
       " 'Maria Cecília Cunha',\n",
       " 'Carolina Fernandes',\n",
       " 'Dr. Levi Barros',\n",
       " 'Enzo Cunha',\n",
       " 'Srta. Lorena Rocha',\n",
       " 'Davi Lucas Gomes',\n",
       " 'Marcelo Azevedo',\n",
       " 'Srta. Joana Pereira',\n",
       " 'Giovanna Castro',\n",
       " 'Isabella Correia',\n",
       " 'Emilly Azevedo',\n",
       " 'Maria Eduarda Melo',\n",
       " 'Letícia Araújo',\n",
       " 'Lucca Cunha',\n",
       " 'Isadora Lima',\n",
       " 'Augusto Pereira',\n",
       " 'Pedro Miguel Alves',\n",
       " 'João Felipe Castro',\n",
       " 'Augusto Oliveira',\n",
       " 'Brenda Cunha',\n",
       " 'Henrique Fernandes',\n",
       " 'Maria Fernanda Araújo',\n",
       " 'Lucas Gabriel Lima',\n",
       " 'Vicente Silva',\n",
       " 'Sofia Martins',\n",
       " 'Dra. Lívia Cardoso',\n",
       " 'Dr. Antonio Santos',\n",
       " 'Ian Almeida',\n",
       " 'Sr. Kaique Carvalho',\n",
       " 'Ian Castro',\n",
       " 'Sr. Rafael Alves',\n",
       " 'Vitor Oliveira',\n",
       " 'Dr. Murilo Gomes',\n",
       " 'Maria Fernanda Barros',\n",
       " 'Carolina Carvalho',\n",
       " 'Bárbara Correia',\n",
       " 'Mariane Rocha',\n",
       " 'Henrique Dias',\n",
       " 'Cauê Martins',\n",
       " 'Luigi Ribeiro',\n",
       " 'Igor Rodrigues',\n",
       " 'Nathan Ribeiro',\n",
       " 'Srta. Ana Laura Castro',\n",
       " 'Dra. Ana Sophia Santos',\n",
       " 'Dra. Bianca Castro',\n",
       " 'Maitê Castro',\n",
       " 'Alana Araújo',\n",
       " 'Leonardo Ribeiro',\n",
       " 'Dr. Gustavo Henrique Barbosa',\n",
       " 'Srta. Alana Fernandes',\n",
       " 'Sra. Luana Rocha',\n",
       " 'Augusto Azevedo',\n",
       " 'Mariana Rocha',\n",
       " 'Sr. Pedro Miguel Cunha',\n",
       " 'Lorenzo Rocha',\n",
       " 'Lucas Barros',\n",
       " 'Anthony Carvalho',\n",
       " 'Sr. Noah Gomes',\n",
       " 'Helena Dias',\n",
       " 'Stella Rocha',\n",
       " 'Amanda Correia',\n",
       " 'Levi Santos',\n",
       " 'Evelyn Santos',\n",
       " 'Sr. Erick Fernandes',\n",
       " 'Ryan Rodrigues',\n",
       " 'Evelyn Ribeiro',\n",
       " 'Breno Santos',\n",
       " 'Maria Clara Souza',\n",
       " 'Sr. Enzo Gabriel Souza',\n",
       " 'Eduardo Cunha',\n",
       " 'Gabrielly Carvalho',\n",
       " 'Ana Carolina Melo',\n",
       " 'Julia Alves',\n",
       " 'Ana Vitória Cardoso',\n",
       " 'Danilo Pinto',\n",
       " 'Emanuella Rocha',\n",
       " 'Nina Almeida',\n",
       " 'Luiz Miguel Castro',\n",
       " 'Sabrina Alves',\n",
       " 'Yuri Castro',\n",
       " 'Sr. Yuri Costela',\n",
       " 'Sr. Nathan Rocha',\n",
       " 'Lucas Gabriel Cunha',\n",
       " 'Isabella Carvalho',\n",
       " 'Kamilly Pinto',\n",
       " 'Eloah Ferreira',\n",
       " 'João Lucas Correia',\n",
       " 'Erick Pinto',\n",
       " 'Amanda Oliveira',\n",
       " 'Pedro Lucas Oliveira',\n",
       " 'Isadora Rodrigues',\n",
       " 'Camila Rodrigues',\n",
       " 'Pedro Henrique Melo',\n",
       " 'Bianca Correia',\n",
       " 'Paulo Barbosa',\n",
       " 'Diego Ribeiro',\n",
       " 'Luiz Henrique Fernandes',\n",
       " 'Sra. Esther Gomes',\n",
       " 'Lorena Melo',\n",
       " 'Bárbara Melo',\n",
       " 'Sr. Antonio Costela',\n",
       " 'Ana Sophia Melo',\n",
       " 'Maria Vitória Lima',\n",
       " 'Dr. Antonio Ribeiro',\n",
       " 'Kevin Lima',\n",
       " 'Isabelly Dias',\n",
       " 'Paulo Cardoso',\n",
       " 'Juan Alves',\n",
       " 'Sr. Nathan Pereira',\n",
       " 'Nathan Araújo',\n",
       " 'Pedro Henrique Dias',\n",
       " 'Erick Fernandes',\n",
       " 'Dr. Luiz Gustavo Pereira',\n",
       " 'Dr. Noah Araújo',\n",
       " 'Fernando Costela',\n",
       " 'Srta. Esther Alves',\n",
       " 'Sr. Vinicius Gomes',\n",
       " 'Pedro Miguel Pinto',\n",
       " 'Samuel Pereira',\n",
       " 'Francisco Fernandes',\n",
       " 'Maria Almeida',\n",
       " 'Natália Almeida',\n",
       " 'Sra. Ana Lima',\n",
       " 'Catarina Ribeiro',\n",
       " 'Marina Cardoso',\n",
       " 'Juan Silva',\n",
       " 'Paulo Barros',\n",
       " 'Natália Ribeiro',\n",
       " 'Dra. Helena Ferreira',\n",
       " 'Pedro Henrique Cardoso',\n",
       " 'Alana Silva',\n",
       " 'Camila Costela',\n",
       " 'Nicole Azevedo',\n",
       " 'Ana Vitória Gomes',\n",
       " 'Srta. Heloísa Costela',\n",
       " 'Raquel Alves',\n",
       " 'Dr. Vitor Hugo Dias',\n",
       " 'Marcelo Carvalho',\n",
       " 'Samuel Fernandes',\n",
       " 'Miguel Souza',\n",
       " 'Thales Araújo',\n",
       " 'Rafaela Martins',\n",
       " 'Srta. Agatha Silva',\n",
       " 'João Felipe Barbosa',\n",
       " 'Marcela Dias',\n",
       " 'Olivia Azevedo',\n",
       " 'Sr. Murilo Azevedo',\n",
       " 'Ryan Oliveira',\n",
       " 'André Dias',\n",
       " 'Valentina Cardoso',\n",
       " 'Emanuelly Gomes',\n",
       " 'Dra. Luana Pereira',\n",
       " 'Valentina Carvalho',\n",
       " 'Dra. Marina Souza',\n",
       " 'Lucca Gomes',\n",
       " 'Bryan Santos',\n",
       " 'Srta. Valentina Fernandes',\n",
       " 'Sr. Benício Lima',\n",
       " 'Cauê Barbosa',\n",
       " 'Valentina Silva',\n",
       " 'Ana Julia Carvalho',\n",
       " 'Emanuel Pereira',\n",
       " 'Vinicius Santos',\n",
       " 'Joana Martins',\n",
       " 'Nathan Barbosa',\n",
       " 'Cecília Cardoso',\n",
       " 'Dr. Davi Pereira',\n",
       " 'Augusto Costela',\n",
       " 'Dra. Camila Barbosa',\n",
       " 'Larissa Lima',\n",
       " 'Thomas Rocha',\n",
       " 'Sr. Vitor Rocha',\n",
       " 'Helena Pereira',\n",
       " 'André Cardoso',\n",
       " 'Maria Cecília Alves',\n",
       " 'Maria Cecília Melo',\n",
       " 'Srta. Sarah Gomes',\n",
       " 'Maria Fernanda Cunha',\n",
       " 'Laura Melo',\n",
       " 'Enzo Fernandes',\n",
       " 'Bruno Cardoso',\n",
       " 'Yuri Lima',\n",
       " 'Benjamin Oliveira',\n",
       " 'Ana Julia Araújo',\n",
       " 'Rodrigo Pereira',\n",
       " 'Mariane Carvalho',\n",
       " 'Benício Barros',\n",
       " 'Dr. Juan Carvalho',\n",
       " 'Dra. Lorena Oliveira',\n",
       " 'Srta. Maria Clara Cunha',\n",
       " 'Marina Melo',\n",
       " 'Dra. Isabella Silva',\n",
       " 'Luana Costela',\n",
       " 'Amanda Ribeiro',\n",
       " 'Igor Ribeiro',\n",
       " 'Samuel Souza',\n",
       " 'Alice Pinto',\n",
       " 'Luiz Gustavo Pinto',\n",
       " 'Carlos Eduardo Dias',\n",
       " 'Clarice Lima',\n",
       " 'Nicolas Cunha',\n",
       " 'Dr. Danilo Cardoso',\n",
       " 'Maria Julia Barros',\n",
       " 'Srta. Ana Ribeiro',\n",
       " 'Sra. Marina Castro',\n",
       " 'Theo Pinto',\n",
       " 'Sr. Henrique Castro',\n",
       " 'Miguel Castro',\n",
       " 'Sra. Emanuelly Pinto',\n",
       " 'Cauê Souza',\n",
       " 'Paulo Rocha',\n",
       " 'Esther Almeida',\n",
       " 'Calebe Rocha',\n",
       " 'Arthur Barbosa',\n",
       " 'Dra. Eloah Cardoso',\n",
       " 'Fernando Silva',\n",
       " 'Sra. Isabella Martins',\n",
       " 'Samuel Correia',\n",
       " 'Yasmin Ribeiro',\n",
       " 'Luiz Henrique Gomes',\n",
       " 'Theo Santos',\n",
       " 'Rodrigo Cardoso',\n",
       " 'Danilo Cunha',\n",
       " 'João Lucas Carvalho',\n",
       " 'Danilo Fernandes',\n",
       " 'João Miguel Correia',\n",
       " 'Joana Melo',\n",
       " 'Isabel Lima',\n",
       " 'Marina Almeida',\n",
       " 'Srta. Luna Rodrigues',\n",
       " 'Maria Clara Ribeiro',\n",
       " 'Srta. Maria Luiza Martins',\n",
       " 'Sr. Paulo Gomes',\n",
       " 'Dr. Theo Ribeiro',\n",
       " 'Nicole Correia',\n",
       " 'Cauã Ferreira',\n",
       " 'Francisco Costela',\n",
       " 'Maria Sophia Oliveira',\n",
       " 'Helena Cardoso',\n",
       " 'Leonardo Ferreira',\n",
       " 'Sr. Vitor Ferreira',\n",
       " 'Caio Cunha',\n",
       " 'Antonio Carvalho',\n",
       " 'Gustavo Henrique Martins',\n",
       " 'Vitor Hugo Almeida',\n",
       " 'Sra. Lívia Azevedo',\n",
       " 'Luiz Felipe Souza',\n",
       " 'Pietra Pereira',\n",
       " 'Dr. Felipe Barbosa',\n",
       " 'Yago Gomes',\n",
       " 'Anthony Barbosa',\n",
       " 'Eloah Rocha',\n",
       " 'Sr. Henrique Gomes',\n",
       " 'Sarah Martins',\n",
       " 'Dra. Daniela Lima',\n",
       " 'Antonio Melo',\n",
       " 'Sr. Yuri Lima',\n",
       " 'Kevin Rocha',\n",
       " 'Milena Costela',\n",
       " 'Lucca Alves',\n",
       " 'Gustavo Martins',\n",
       " 'Thiago Carvalho',\n",
       " 'Francisco Melo',\n",
       " 'Sr. Fernando Melo',\n",
       " 'Sr. Luiz Henrique Pinto',\n",
       " 'Sra. Maria Sophia Alves',\n",
       " 'Erick Alves',\n",
       " 'Lara Gomes',\n",
       " ...}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from faker import Factory\n",
    "\n",
    "factory = Factory.create('pt_BR')  # criando fábrica de dados falsos português brasileiro\n",
    "nomes = {factory.name() for _ in range(10000)}\n",
    "nomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Agora vamos supor que temos uma lista de nomes e queremos conferir se eles estão no conjunto de nomes. Normalmente faríamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana Ferreira', 'Eduardo Santos']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buscas = {'João Silva', 'Ana Ferreira', 'Eduardo Santos', 'Pedro Alves', 'Enzo Correira'}\n",
    "\n",
    "presentes = [busca for busca in buscas if busca in nomes]\n",
    "presentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['João Silva', 'Enzo Correira', 'Pedro Alves']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ausentes = [busca for busca in buscas if busca not in nomes]\n",
    "ausentes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém se usarmos operações de conjunto podemos fazer isso de forma mais simples e eficiente.\n",
    "\n",
    "Para saber quais nomes buscados estão no conjunto de nomes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana Ferreira', 'Eduardo Santos'}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buscas & nomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os nomes que não estão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Enzo Correira', 'João Silva', 'Pedro Alves'}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buscas - nomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparando o tempo de execução das buscas usando `for` contra buscas usando intersecção obtemos o seguinte resultado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# tamanho  | tempo set + for | tempo set + & | for vs &\n",
    "# 100      | 3.945e-05       | 1.86e-06      | & é 21.25x + rápido\n",
    "# 1000     | 5.844e-05       | 1.751e-05     | & é 3.34x + rápido\n",
    "# 10000    | 0.00014848      | 5.991e-05     | & é 2.48x + rápido\n",
    "# 100000   | 0.00015138      | 8.862e-05     | & é 1.71x + rápido\n",
    "# 1000000  | 0.00014647      | 8.113e-05     | & é 1.81x + rápido"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dict\n",
    "\n",
    "Dict, dictnionary ou dicionário é a estrutura padrão de mapeamento e é indexado por chaves compostas por tipos imutáveis (números, strings, tuplas etc.).\n",
    "\n",
    "Já falamos sobre dicionários anteriormente, nesta aula faremos uma rápida revisão e aprofundremos mais sobre o assunto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votos = {'joão': 10, 'maria': 25, 'ana': 40, 'pedro': 75}\n",
    "votos['joão']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': 40, 'joão': 11, 'maria': 25, 'pedro': 75}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votos['joão'] = 11\n",
    "votos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podem ver aqui os dicionários não mantém a ordem de seus elementos. Criamos o dict com os elementos {'joão': 10, 'maria': 25, 'ana': 40, 'pedro': 75}, porém sua ordem atual é {'ana': 40, 'joão': 11, 'maria': 25, 'pedro': 75} e, futuramente, essa ordem pode ser outra conforme alteramos esse dicionário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(votos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': 40, 'maria': 25, 'pedro': 75}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del votos['joão']\n",
    "votos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vale notar que ao tentar acessar um elemento não existente é levantada uma exceção:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'joão'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-60-5818ac2b3445>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mvotos\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'joão'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'joão'"
     ]
    }
   ],
   "source": [
    "votos['joão']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As vezes pode ser necessário evitar esse tipo de comportamento. Isso pode ser feito usando a função:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(votos.get('joão'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "também é possível estabelecer um valor para ser retornado caso a chave não seja encontrada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votos.get('joão', 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por exemplo se você quiser contabilizar os votos de uma eleição em que nem todos os candidatos receberam votos e, portanto, não aparecem no dicionário votos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['maria', 'ana', 'pedro', 'joão', 'muriel', 'marcola']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "candidatos = list(votos.keys()) + ['joão', 'muriel', 'marcola']\n",
    "candidatos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maria recebeu 25 votos.\n",
      "ana recebeu 40 votos.\n",
      "pedro recebeu 75 votos.\n",
      "joão recebeu 0 votos.\n",
      "muriel recebeu 0 votos.\n",
      "marcola recebeu 0 votos.\n"
     ]
    }
   ],
   "source": [
    "for candidato in candidatos:\n",
    "    print('{} recebeu {} votos.'.format(candidato, votos.get(candidato, 0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos verificar se alguma chave existe no dicionário com o `in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': 40, 'maria': 25, 'pedro': 75}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ana' in votos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'penélope' in votos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(votos)  # número de items no dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': 40, 'maria': 25, 'milena': 100, 'mário': 1, 'pedro': 75}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "outros_votos = {'milena': 100, 'mário': 1}\n",
    "votos.update(outros_votos)  # atualiza o dicionário votos com os items de outros_votos\n",
    "votos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar somente as chaves de um dicionário fazemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['ana', 'maria', 'milena', 'mário', 'pedro'])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votos.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Percebe-se que o retorno não é uma lista de chaves, mas sim um `dict_keys`. Não vou entrar em detalhes, mas esse `dict_keys` - junto com `dict_values` e `dict_items` que serão mostrados mais a frente - se comportam como conjunto, por tanto verificações de pertencimento são muito eficientes, além de suportar algumas operações de conjuntos:\n",
    "\n",
    "*Para mais informações verifique a [documentação oficial](https://docs.python.org/3/library/stdtypes.html#dict-views) e o [PEP 3106](https://www.python.org/dev/peps/pep-3106/) em que essa mudança foi proposta*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'maria'}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['maria', 'adelaide'] & votos.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'adelaide'}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['maria', 'adelaide'] - votos.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar somente os valores do dicionários:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([40, 25, 100, 1, 75])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votos.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como os valores não são únicos o `dict_values` não pode se comportar como conjunto, por esse motivo ele não possui as operações de conjuntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('ana', 40), ('maria', 25), ('milena', 100), ('mário', 1), ('pedro', 75)])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "votos.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém o `dict.items()` implementa as operações de conjuntos, pois a dupla `chave` e `valor` são únicas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('maria', 25)}"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[('jean', 50), ('maria', 25)] & votos.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('jean', 50)}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[('jean', 50), ('maria', 25)] - votos.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Revendo iteração de dicionários:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ana\n",
      "maria\n",
      "milena\n",
      "mário\n",
      "pedro\n"
     ]
    }
   ],
   "source": [
    "for nome in votos.keys():\n",
    "    print(nome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "25\n",
      "100\n",
      "1\n",
      "75\n"
     ]
    }
   ],
   "source": [
    "for qtd_votos in votos.values():\n",
    "    print(qtd_votos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana recebeu 40 votos.\n",
      "Maria recebeu 25 votos.\n",
      "Milena recebeu 100 votos.\n",
      "Mário recebeu 1 votos.\n",
      "Pedro recebeu 75 votos.\n"
     ]
    }
   ],
   "source": [
    "for nome, qtd_votos in votos.items():  # atribuição múltipla, lembra?\n",
    "    print('{} recebeu {} votos.'.format(nome.capitalize(), qtd_votos))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício\n",
    "\n",
    "- Calcule a média de votos por candidatos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# não mude esse código, ele que gera os votos para você testar seu programa\n",
    "\n",
    "from faker import Factory\n",
    "import random\n",
    "\n",
    "factory = Factory.create('pt_BR')\n",
    "\n",
    "# usa distribuição de gauss para gerar quantidade de votos\n",
    "votos = {factory.name(): abs(round(random.gauss(0, .2) * 10000)) for _ in range(333)}\n",
    "# deixa nomes completos com somente dois nomes\n",
    "votos = {nome: votos for nome, votos in votos.items() if len(nome.split()) == 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def media(votos):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como listas e sets, dicionários também possuem uma maneira de criar dicts com facilidade: `dict comprehension`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Amanda Barros': '092.546.137-71',\n",
       " 'Dr. João Azevedo': '453.168.209-24',\n",
       " 'Emanuella Ferreira': '210.796.483-13',\n",
       " 'João Felipe Melo': '103.647.825-44',\n",
       " 'João Felipe Oliveira': '965.731.428-37',\n",
       " 'Maysa Dias': '912.638.507-41',\n",
       " 'Nicole Souza': '532.496.078-19',\n",
       " 'Srta. Brenda Costela': '264.519.038-33',\n",
       " 'Stephany Rocha': '843.076.159-48',\n",
       " 'Vitória Souza': '315.698.240-71'}"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from faker import Factory\n",
    "\n",
    "factory = Factory.create('pt_BR')\n",
    "cpfs = {factory.name(): factory.cpf() for _ in range(10)}\n",
    "cpfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{numero: numero ** 2 for numero in range(10)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acontece que dict comprehension nos dá uma maneira muito bonilinda de inverter as chaves e valores de dicionários:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': '9103', 'joão': '9941', 'maria': '9301', 'pedro': '9203'}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "telefones = {'joão': '9941', 'ana': '9103', 'maria': '9301', 'pedro': '9203'}\n",
    "telefones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normalmente faríamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'9103': 'ana', '9203': 'pedro', '9301': 'maria', '9941': 'joão'}"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes = {}\n",
    "for nome, telefone in telefones.items():\n",
    "    nomes[telefone] = nome\n",
    "    \n",
    "nomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas com dict comprehension é muito mais fácil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'9103': 'ana', '9203': 'pedro', '9301': 'maria', '9941': 'joão'}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{telefone: nome for nome, telefone in telefones.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ordenando um dict pelas chaves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ana', '9103'), ('joão', '9941'), ('maria', '9301'), ('pedro', '9203')]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(telefones.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Não faz snetido obter dict pq dict nào mantém a ordem.\n",
    "\n",
    "Para ter um objeto do tipo dict é necessário converter o código acima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': '9103', 'joão': '9941', 'maria': '9301', 'pedro': '9203'}"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(sorted(telefones.items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ordernar pelos valores precisamos \"avisar\" a função `sorted()` para usar o valor como a chave. Isso é feito passando um argumento `key` que recebe uma função que é usada para pegar o valor que será usado na ordenação. Nesse caso precisamos criar uma função que retorna o segundo elemento de nossa lista de tuplas chave e valor, referente a esse último."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ana', '9103'), ('pedro', '9203'), ('maria', '9301'), ('joão', '9941')]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def pega_segundo_elemento(tupla):\n",
    "    return tupla[1]\n",
    "\n",
    "sorted(telefones.items(), key=pega_segundo_elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Adendo: no Python funções são objetos de primeira classe. Isso signfica que funções, assim como inteiros, strings e listas, podemos passá-las como parâmetros, atribuí-las a variáveis e outras operações. Esse assunto será abordando com maior profundidade na aula sobre funções.*\n",
    "\n",
    "Um outro jeito comum de realizar essa ordenação é usar funções anônimas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ana', '9103'), ('pedro', '9203'), ('maria', '9301'), ('joão', '9941')]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pega_segundo_elemento = lambda x: x[1]\n",
    "\n",
    "sorted(telefones.items(), key=pega_segundo_elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Geralmente o uso de funções anônimas é feito assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ana', '9103'), ('pedro', '9203'), ('maria', '9301'), ('joão', '9941')]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(telefones.items(), key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém, o jeito mais eficiente de realizar esse tipo de operação é utilizando a biblioteca `operator` que implementa os operadores do python de forma eficiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ana', '9103'), ('pedro', '9203'), ('maria', '9301'), ('joão', '9941')]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from operator import itemgetter\n",
    "\n",
    "sorted(telefones.items(), key=itemgetter(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função `itemgetter()` da biblioteca `operator` faz o mesmo que a função `pega_segundo_elemento()` mas de forma muito mais rápida. Para saber mais sobre `operator` veja sua [documentação](https://docs.python.org/3/library/operator.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dicionários podem ser utilizados para armazenar matrizes esparsas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Exercícios\n",
    "\n",
    "- Dado uma frase calcule as ocorrências de cada palavra naquela. Armazene cada palavra como chave em um dict e as quantidade seu valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from collections  import defaultdict\n",
    "\n",
    "def conta_palavras(frase):\n",
    "    contagem = {}\n",
    "    ...\n",
    "    return contagem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# rode o código abaixo para testar a corretude de seu programa\n",
    "\n",
    "assert conta_palavras(\"quod dolore dolore dolore modi sapiente quod ullam nostrum ullam\") == {'ullam': 2, 'sapiente': 1, 'quod': 2, 'nostrum': 1, 'dolore': 3, 'modi': 1}\n",
    "assert conta_palavras(\"soluta Soluta sapiente sapiente nostrum Sapiente dolore nostrum modi ullam\") == {'ullam': 1, 'sapiente': 3, 'nostrum': 2, 'dolore': 1, 'soluta': 2, 'modi': 1}\n",
    "assert conta_palavras(\"quod dolore dolore soluta sapiente sapiente dolore quod sapiente modi\") == {'dolore': 3, 'quod': 2, 'soluta': 1, 'modi': 1, 'sapiente': 3}\n",
    "assert conta_palavras(\"dolore Dolore quis quod dolore nostrum quod Nostrum sapiente soluta\") == {'sapiente': 1, 'quod': 2, 'nostrum': 2, 'soluta': 1, 'dolore': 3, 'quis': 1}\n",
    "assert conta_palavras(\"sapiente sapiente quod soluta quis ullam nostrum soluta ullam ullam\") == {'ullam': 3, 'sapiente': 2, 'quod': 1, 'nostrum': 1, 'soluta': 2, 'quis': 1}\n",
    "assert conta_palavras(\"modi Sapiente dolore Soluta sapiente quis soluta modi dolore ullam\") == {'ullam': 1, 'sapiente': 2, 'quis': 1, 'dolore': 2, 'soluta': 2, 'modi': 2}\n",
    "assert conta_palavras(\"quis quis nostrum nostrum sapiente quis nostrum quod quis dolore\") == {'sapiente': 1, 'quod': 1, 'quis': 4, 'nostrum': 3, 'dolore': 1}\n",
    "assert conta_palavras(\"nostrum sapiente quis ullam ullam quod ullam nostrum ullam soluta\") == {'ullam': 4, 'sapiente': 1, 'quod': 1, 'nostrum': 2, 'soluta': 1, 'quis': 1}\n",
    "assert conta_palavras(\"sapiente ullam quod quis dolore modi Quis quod dolore nostrum\") == {'ullam': 1, 'sapiente': 1, 'quod': 2, 'quis': 2, 'nostrum': 1, 'dolore': 2, 'modi': 1}\n",
    "assert conta_palavras(\"modi nostrum ullam Quis Soluta modi quis ullam modi ullam\") == {'ullam': 3, 'soluta': 1, 'modi': 3, 'nostrum': 1, 'quis': 2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "- Escreva uma função `comprime_chaves_dict()` que receba um dict e remova as vogais das chaves de um dicionário. Por exempo o dict {'foo': 10, 'bar': 100} deve ser comprimido para {'f': 10, 'br': 100}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def comprime_chaves_dict(dicionario):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "assert comprime_chaves_dict({'molestias': 3950, 'tempore': 'possimus', 'rerum': 1200}) == {'tmpr': 'possimus', 'mlsts': 3950, 'rrm': 1200}\n",
    "assert comprime_chaves_dict({'nam': 5300, 'minus': 3700, 'fugit': 8600}) == {'mns': 3700, 'nm': 5300, 'fgt': 8600}\n",
    "assert comprime_chaves_dict({'magnam': 2850, 'quam': 2300, 'asperiores': 7750}) == {'qm': 2300, 'sprrs': 7750, 'mgnm': 2850}\n",
    "assert comprime_chaves_dict({'quos': 'dignissimos', 'qui': 1700, 'repellendus': 'aut'}) == {'rpllnds': 'aut', 'q': 1700, 'qs': 'dignissimos'}\n",
    "assert comprime_chaves_dict({'quaerat': 9850, 'magni': 8600, 'blanditiis': 'optio'}) == {'mgn': 8600, 'qrt': 9850, 'blndts': 'optio'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fim da aula 04"
   ]
  }
 ],
 "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.5.1+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}