Capítulo 11 - Dicionários.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Capítulo 11: Dicionários\n",
    "\n",
    "Este capítulo apresenta outro tipo integrado chamado **dicionário**. Dicionários são um dos melhores recursos do Python; eles são os blocos de montar de muitos algoritmos eficientes e elegantes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.1 - Um dicionário é um mapeamento\n",
    "\n",
    "Um dicionário se parece com uma lista, mas é mais geral. Em uma lista, os índices têm que ser números inteiros; em um dicionário, eles podem ser de (quase) qualquer tipo.\n",
    "\n",
    "Um dicionário contém uma coleção de índices, que se chamam **chaves** e uma coleção de valores. Cada chave é associada com um único valor. A associação de uma chave e um valor chama-se **par chave-valor** ou **item**.\n",
    "\n",
    "Em linguagem matemática, um dicionário representa um **mapeamento** de chaves a valores, para que você possa dizer que cada chave “mostra o mapa a” um valor. Como exemplo, vamos construir um dicionário que faz o mapa de palavras do inglês ao espanhol, portanto as chaves e os valores são todos strings.\n",
    "\n",
    "A função `dict` cria um novo dicionário sem itens. Como `dict` é o nome de uma função integrada, você deve evitar usá-lo como nome de variável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> eng2sp = dict()\n",
    ">>> eng2sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As chaves `{}` representam um dicionário vazio. Para acrescentar itens ao dicionário, você pode usar colchetes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> eng2sp['one'] = 'uno'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta linha cria um item que mapeia da chave `'one'` ao valor `'uno'`. Se imprimirmos o dicionário novamente, vemos um par chave-valor com dois pontos entre a chave e o valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'one': 'uno'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> eng2sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este formato de saída também é um formato de entrada. Por exemplo, você pode criar um dicionário com três itens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém, se exibir `eng2sp`, pode se surpreender:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'one': 'uno', 'two': 'dos', 'three': 'tres'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> eng2sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ordem dos pares chave-valor pode não ser a mesma. Se você digitar o mesmo exemplo no seu computador, pode receber um resultado diferente. Em geral, a ordem dos itens em um dicionário é imprevisível.\n",
    "\n",
    "No entanto, isso não é um problema porque os elementos de um dicionário nunca são indexados com índices de números inteiros. Em vez disso, você usa as chaves para procurar os valores correspondentes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dos'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> eng2sp['two']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A chave `'two'` sempre mapeia ao valor `'dos'`, assim a ordem dos itens não importa.\n",
    "\n",
    "Se a chave não estiver no dicionário, você recebe uma exceção:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    ">>> eng2sp['four']\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "KeyError: 'four'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função `len` é compatível com dicionários; ela devolve o número de pares chave-valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> len(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O operador `in` funciona em dicionários também; ele acusa se algo aparece como chave no dicionário (aparecer como valor não é o suficiente)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> 'one' in eng2sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> 'uno' in eng2sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver se algo aparece como um valor em um dicionário, você pode usar o método `values`, que devolve uma coleção de valores, e então usar o operador `in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> vals = eng2sp.values()\n",
    ">>> 'uno' in vals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O operador `in` usa algoritmos diferentes para listas e dicionários. Para listas, ele procura os elementos da lista em ordem, como descrito em “Busca”, Seção 8.6. Conforme a lista torna-se mais longa, o tempo de busca também fica proporcionalmente mais longo.\n",
    "\n",
    "Para dicionários, o Python usa um algoritmo chamado **hashtable** (tabela de dispersão), que tem uma propriedade notável: o operador `in` leva praticamente o mesmo tempo na busca, não importa quantos itens estejam no dicionário. Eu explico como isso é possível em “Hashtables”, no anexo B, mas a explicação pode não fazer sentido até que você tenha lido mais alguns capítulos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.2 - Um dicionário como uma coleção de contadores\n",
    "\n",
    "Suponha que você receba uma string e queira contar quantas vezes cada letra aparece nela. Há vários modos de fazer isso:\n",
    "\n",
    "1. Você pode criar 26 variáveis, uma para cada letra do alfabeto. Então pode atravessar a string e, para cada caractere, incrementar o contador correspondente, provavelmente usando uma condicional encadeada.\n",
    "\n",
    "2. Você pode criar uma lista com 26 elementos. Então pode converter cada caractere em um número (com a função integrada `ord`), usar o número como índice na lista e incrementar o respectivo contador.\n",
    "\n",
    "3. Você pode criar um dicionário com caracteres como chaves e contadores como valores correspondentes. Na primeira vez que visse um caractere, você acrescentaria um item ao dicionário. Depois disso, incrementaria o valor de um item existente.\n",
    "\n",
    "Cada uma dessas opções executa o mesmo cálculo, mas o implementa de forma diferente.\n",
    "\n",
    "Uma **implementação** é um modo de executar um cálculo; algumas implementações são melhores que outras. Por exemplo, uma vantagem da implementação de dicionários é que não precisamos saber de antemão quais letras aparecem na string e só é preciso criar espaço para as letras que realmente venham a aparecer.\n",
    "\n",
    "O código poderia ser assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def histogram(s):\n",
    "    d = dict ()\n",
    "    for c in s:\n",
    "        if c not in d:\n",
    "            d[c] = 1\n",
    "        else:\n",
    "            d[c] += 1\n",
    "    return d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O nome da função é `histogram`, um termo estatístico para uma coleção de contadores (ou frequências).\n",
    "\n",
    "A primeira linha da função cria um dicionário vazio. O _loop_ `for` atravessa a string. Cada vez que passa pelo _loop_, se o caractere `c` não estiver no dicionário, criamos um item com a chave `c` e o valor inicial `1` (pois já vimos esta letra uma vez). Se o `c` já estiver no dicionário, incrementamos `d[c]`.\n",
    "\n",
    "Funciona assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b': 1, 'r': 2, 'o': 2, 'n': 1, 't': 1, 's': 2, 'a': 1, 'u': 2}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> h = histogram('brontosaurus')\n",
    ">>> h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O histograma indica que as letras `'a'` e `'b'` aparecem uma vez; `'o'` aparece duas vezes, e assim por diante.\n",
    "\n",
    "Os dicionários têm um método chamado `get`, que toma uma chave e um valor padrão. Se a chave aparecer no dicionário, `get` retorna o valor correspondente; se não for o caso, ele retorna o valor padrão. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> h = histogram('a')\n",
    ">>> h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> h.get('a', 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> h.get('b', 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como exercício, use o `get` para escrever a função `histogram` de forma mais concisa. Tente eliminar a instrução `if`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.3 - Loop e dicionários\n",
    "\n",
    "Se usar um dicionário em uma instrução `for`, ela percorre as chaves do dicionário. Por exemplo, `print_hist` exibe cada chave e o valor correspondente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_hist(h):\n",
    "    for c in h:\n",
    "        print(c, h[c])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso é o que aparece:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p 1\n",
      "a 1\n",
      "r 2\n",
      "o 1\n",
      "t 1\n"
     ]
    }
   ],
   "source": [
    ">>> h = histogram ('parrot')\n",
    ">>> print_hist (h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente, as chaves não estão em nenhuma ordem determinada. Para atravessar as chaves em ordem ascendente, você pode usar a função integrada `sorted`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1\n",
      "o 1\n",
      "p 1\n",
      "r 2\n",
      "t 1\n"
     ]
    }
   ],
   "source": [
    ">>> for key in sorted(h):\n",
    "        print(key, h[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.4 - Busca reversa\n",
    "\n",
    "Considerando um dicionário `d` e uma chave `k`, é fácil encontrar o valor correspondente `v = d [k]`. Esta operação chama-se **busca**.\n",
    "\n",
    "Mas e se você tiver `v` e quiser encontrar `k`? Você tem dois problemas: em primeiro lugar, pode haver mais de uma chave que esteja mapeada ao valor `v`. Dependendo da aplicação, quem sabe você pode escolher um, ou talvez tenha de fazer uma lista que contenha todos eles. Em segundo lugar, não há sintaxe simples para fazer uma **busca reversa**; é preciso procurar.\n",
    "\n",
    "Aqui está uma função que recebe um valor e retorna a primeira chave mapeada ao valor dado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse_lookup(d, v):\n",
    "    for k in d:\n",
    "        if d[k] == v:\n",
    "            return k\n",
    "    raise LookupError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essa função é mais um exemplo do padrão de busca, mas usa um recurso que ainda não tínhamos visto: `raise`. A **instrução _raise_** causa uma exceção; neste caso, causa um `LookupError`, que é uma exceção integrada, usada para indicar que uma operação de busca falhou.\n",
    "\n",
    "Se chegarmos ao fim do loop significa que `v` não aparece no dicionário como um valor, portanto apresentaremos uma exceção.\n",
    "\n",
    "Aqui está um exemplo de uma busca reversa bem sucedida:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> h = histogram('parrot')\n",
    ">>> k = reverse_lookup(h, 2)\n",
    ">>> k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E uma mal sucedida:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "LookupError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mLookupError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-f236b2966933>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreverse_lookup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-19-624b98b92ec0>\u001b[0m in \u001b[0;36mreverse_lookup\u001b[0;34m(d, v)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mLookupError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mLookupError\u001b[0m: "
     ]
    }
   ],
   "source": [
    ">>> k = reverse_lookup(h, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O efeito causado por você ao apresentar uma exceção é igual ao causado pelo Python quando faz o mesmo: ele exibe um _traceback_ e uma mensagem de erro.\n",
    "\n",
    "A instrução `raise` pode receber uma mensagem de erro detalhada como argumento opcional. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "LookupError",
     "evalue": "value does not appear in the dictionary",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mLookupError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-809967c2546f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mLookupError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'value does not appear in the dictionary'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mLookupError\u001b[0m: value does not appear in the dictionary"
     ]
    }
   ],
   "source": [
    ">>> raise LookupError('value does not appear in the dictionary')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma busca reversa é muito mais lenta que uma busca no sentido normal; se for preciso fazê-lo muitas vezes, ou se o dicionário ficar muito grande, o desempenho do seu programa será prejudicado.\n",
    "\n",
    "## 11.5 - Dicionários e listas\n",
    "\n",
    "As listas podem aparecer como valores em um dicionário. Por exemplo, se você receber um dicionário que mapeie letras e frequências, é uma boa ideia invertê-lo; isto é, crie um dicionário que mapeie de frequências a letras. Como pode haver várias letras com a mesma frequência, cada valor no dicionário invertido deve ser uma lista de letras.\n",
    "\n",
    "Aqui está uma função que inverte um dicionário:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def invert_dict(d):\n",
    "    inverse = dict()\n",
    "    for key in d:\n",
    "        val = d[key]\n",
    "        if val not in inverse:\n",
    "            inverse[val] = [key]\n",
    "        else:\n",
    "            inverse[val].append(key)\n",
    "    return inverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada vez que o programa passar pelo _loop_, a `key` recebe uma chave de `d` e `val` recebe o valor correspondente. Se `val` não estiver em `inverse` significa que não foi vista antes, então criamos um item e o inicializamos com um **item avulso** (em inglês, *singleton*, uma lista que contém um único elemento). Se não for o caso é porque vimos esse valor antes, então acrescentamos a chave correspondente à lista.\n",
    "\n",
    "Aqui está um exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'p': 1, 'a': 1, 'r': 2, 'o': 1, 't': 1}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> hist = histogram('parrot')\n",
    ">>> hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['p', 'a', 'o', 't'], 2: ['r']}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> inverse = invert_dict(hist)\n",
    ">>> inverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Figura 11.1 é um diagrama de estado mostrando `hist` e `inverse`. Um dicionário é representado como uma caixa com o tipo `dict` acima dela e os pares chave-valor no interior. Se os valores forem números inteiros, de ponto flutuante ou strings, desenho-os dentro da caixa, mas normalmente prefiro desenhar listas do lado de fora, para manter o diagrama simples.\n",
    "\n",
    "![Figura 11.1 – Diagrama de estado de um dicionário e seu inverso.](https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1101.png)\n",
    "<br>_Figura 11.1 – Diagrama de estado de um dicionário e seu inverso._\n",
    "\n",
    "As listas podem ser valores em um dicionário, como mostra este exemplo, mas não podem ser chaves. Isso é o que acontece se você tentar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-e3ea20954cd2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'oops'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    ">>> t = [1, 2, 3]\n",
    ">>> d = dict()\n",
    ">>> d[t] = 'oops'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Já mencionei que um dicionário é implementado usando uma hashtable e isso significa que é preciso que as chaves possam ser **hashable** (que seja possível computar seu *hash*, e que este valor de *hash* seja imutável).\n",
    "\n",
    "`hash` é uma função que recebe um valor (de qualquer tipo) e devolve um número inteiro. Dicionários usam esses números inteiros, chamados valores `hash`, para guardar e buscar pares chave-valor.\n",
    "\n",
    "Este sistema funciona perfeitamente se as chaves forem imutáveis. Porém, se as chaves são mutáveis, como listas, coisas ruins acontecem. Por exemplo, quando você cria um par chave-valor, o Python guarda a chave na posição correspondente. Se você modificar a chave e então guardá-la novamente, ela iria para uma posição diferente. Nesse caso, você poderia ter duas entradas para a mesma chave, ou pode não conseguir encontrar uma chave. De qualquer forma, o dicionário não funcionaria corretamente.\n",
    "\n",
    "É por isso que as chaves têm de ser *hashable*, e tipos mutáveis como listas, não são. A forma mais simples de resolver esta limitação é usar tuplas, que serão vistas no próximo capítulo.\n",
    "\n",
    "Como os dicionários são mutáveis, eles não podem ser usados como chaves, mas podem ser usados como valores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.6 - Memos\n",
    "\n",
    "Se usou a função de `fibonacci` em “Mais um exemplo”, na Seção 6.7, pode ter notado que quanto maior o argumento dado mais tempo a função leva para ser executada. Além disso, o tempo de execução aumenta rapidamente.\n",
    "\n",
    "Para entender por que, considere a Figura 11.2, que mostra o **gráfico de chamada** de `fibonacci` com n = 4.\n",
    "\n",
    "![Figura 11.2 – Gráfico de chamada para fibonacci.](https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1102.png)\n",
    "<br>_Figura 11.2 – Gráfico de chamada para_ `fibonacci`.\n",
    "\n",
    "Um gráfico de chamada mostra um conjunto de *frames* de função, com linhas que unem cada *frame* aos *frames* das funções que chama. Na parte de cima do gráfico, `fibonacci` com `n=4` chama `fibonacci` com `n=3` e `n=2`. Por sua vez, `fibonacci` com `n=3` chama `fibonacci` com `n=2` e `n=1`. E assim por diante.\n",
    "\n",
    "Conte quantas vezes `fibonacci(0)` e `fibonacci(1)` são chamadas. Essa é uma solução ineficiente para o problema, e piora conforme o argumento se torna maior.\n",
    "\n",
    "Uma solução é acompanhar os valores que já foram calculados, guardando-os em um dicionário. Um valor calculado anteriormente que é guardado para uso posterior é chamado de **memo (memorização)**. Aqui está uma versão com memos de `fibonacci`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "known = {0:0, 1:1}\n",
    "def fibonacci(n):\n",
    "    if n in known:\n",
    "        return known[n]\n",
    "    res = fibonacci(n-1) + fibonacci(n-2)\n",
    "    known[n] = res\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`known` é um dicionário que monitora os números de Fibonacci que já conhecemos. Começa com dois itens: `0` mapeia a `0` e `1` mapeia a `1`.\n",
    "\n",
    "Sempre que `fibonacci` é chamada, ela verifica `known`. Se o resultado já estiver lá, pode voltar imediatamente. Se não for o caso, é preciso calcular o novo valor, acrescentá-lo ao dicionário e devolvê-lo.\n",
    "\n",
    "Se você executar essa versão de `fibonacci` e a comparar com a original, descobrirá que é muito mais rápida."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.7 - Variáveis globais\n",
    "\n",
    "No exemplo anterior, `known` é criada fora da função, então pertence ao *frame* especial chamado `__main__`. As variáveis em `__main__` às vezes são chamadas de globais, porque podem ser acessadas de qualquer função. Em contraste com as variáveis locais, que desaparecem quando sua função termina, as **variáveis globais** persistem de uma chamada da função à seguinte.\n",
    "\n",
    "É comum usar variáveis globais para `flags`; isto é, variáveis booleanas que indicam (“flag”) se uma condição é verdadeira. Por exemplo, alguns programas usam um **flag** denominado *verbose* para controlar o nível de detalhe da saída:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running example1\n"
     ]
    }
   ],
   "source": [
    "verbose = True\n",
    "\n",
    "def example1():\n",
    "    if verbose:\n",
    "        print('Running example1')\n",
    "example1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se tentar reatribuir uma variável global, você pode se surpreender. O próximo exemplo mostra como acompanhar se a função foi chamada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "been_called = False\n",
    "def example2():\n",
    "    been_called = True # ERRADO\n",
    "example2()\n",
    "been_called"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém, se executá-la, você verá que o valor de `been_called` não se altera. O problema é que `example2` cria uma nova variável local chamada `been_called`. A variável local some quando a função termina e não tem efeito sobre a variável global.\n",
    "\n",
    "Para reatribuir uma variável global dentro de uma função é preciso declarar a variável como global antes de usá-la:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "been_called = False\n",
    "\n",
    "def example2():\n",
    "    global been_called\n",
    "    been_called = True\n",
    "example2()\n",
    "been_called"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **instrução global** diz ao interpretador algo como “Nesta função, quando digo `been_called`, estou falando da variável global; não crie uma local”.\n",
    "\n",
    "Aqui está um exemplo que tenta atualizar uma variável global:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'count' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-0849c5a39cb7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mexample3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mcount\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcount\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m# ERRADO\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mexample3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mcount\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-33-0849c5a39cb7>\u001b[0m in \u001b[0;36mexample3\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mcount\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mexample3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mcount\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcount\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m# ERRADO\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mexample3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mcount\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'count' referenced before assignment"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "def example3():\n",
    "    count = count + 1 # ERRADO\n",
    "example3()\n",
    "count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se executá-la, você recebe:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "UnboundLocalError: local variable 'count' referenced before assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python supõe que `count` seja local, e dentro desta suposição, a variável está sendo lida antes de ser escrita. A solução, mais uma vez, é **declarar** `count` como global:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def example3():\n",
    "    global count\n",
    "    count += 1\n",
    "example3()\n",
    "count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se uma variável global se referir a um valor mutável, você pode alterar o valor sem declarar a variável:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 1}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "known = {0:0, 1:1}\n",
    "\n",
    "def example4():\n",
    "    known[2] = 1\n",
    "example4()\n",
    "known"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então você pode adicionar, retirar e substituir elementos de uma lista global ou dicionário, mas se quiser reatribuir a variável, precisa declará-la:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def example5():\n",
    "    global known\n",
    "    known = dict()\n",
    "example5()\n",
    "known"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As variáveis globais podem ser úteis, mas se você tiver muitas delas e alterá-las com frequência, isso poderá dificultar a depuração do programa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.8 - Depuração"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ao trabalhar com conjuntos de dados maiores, depurar exibindo e verificando a saída à mão pode ser trabalhoso. Aqui estão algumas sugestões para depurar grandes conjuntos de dados:\n",
    "\n",
    "**Reduza a entrada:** <p>\n",
    "> Se for possível, reduza o tamanho do conjunto de dados. Por exemplo, se o programa lê um arquivo de texto, comece com apenas as 10 primeiras linhas, ou com o menor exemplo que puder encontrar. Você pode editar os próprios arquivos ou alterar o programa para que leia só as primeiras n linhas (é melhor).\n",
    "Se houver um erro, você pode reduzir n ao menor valor que manifeste o erro, e então aumentá-lo gradativamente até encontrar e corrigir o erro. <p>\n",
    "\n",
    "**Verifique os resumos e tipos:** <p>\n",
    "> Em vez de imprimir e verificar o conjunto de dados inteiro, pense em exibir resumos dos dados: por exemplo, o número de itens em um dicionário ou o total de uma lista de números.\n",
    "Uma causa comum de erros em tempo de execução são valores de tipo incompatível. Para depurar essa espécie de erro, muitas vezes basta exibir o tipo de um valor. <p>\n",
    "\n",
    "**Crie auto-verificações:** <p>\n",
    "> É possível escrever o código para verificar erros automaticamente. Por exemplo, se estiver calculando a média de uma lista de números, você pode verificar se o resultado não é mais alto que o maior elemento da lista ou mais baixo que o menor. Isso é chamado de “verificação de sanidade” porque descobre resultados “insanos”.\n",
    "Outro tipo de verificação compara os resultados de dois cálculos diferentes para ver se são consistentes. Isso é chamado de “verificação de consistência”. <p>\n",
    "\n",
    "**Formate a saída:**<p>\n",
    "> A formatação da saída para depuração pode facilitar a busca de erros. Vimos um exemplo em “Depuração”, no Capítulo 6. O módulo `pprint` apresenta uma função `pprint` que exibe tipos integrados em um formato mais legível para humanos (`pprint` é a abreviação de *“pretty print”* (bela exibição)).\n",
    "Reforçando, o tempo que você passar construindo o _scaffolding_ (o andaime) pode reduzir o tempo de depuração."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.9 - Glossário"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**mapeamento** <br>\n",
    "&emsp;Relação na qual cada elemento de um conjunto corresponde a um elemento de outro conjunto. \n",
    "\n",
    "**dicionário** <br>\n",
    "&emsp;Mapeamento de chaves aos seus valores correspondentes.\n",
    "\n",
    "**par chave-valor** <br>\n",
    "&emsp;Representação do mapeamento de uma chave a um valor.\n",
    "\n",
    "**item** <br>\n",
    "&emsp;Em um dicionário, outro nome para um par chave-valor.\n",
    "\n",
    "**chave** <br>\n",
    "&emsp;Objeto que aparece em um dicionário como a primeira parte de um par chave-valor.\n",
    "\n",
    "**valor** <br>\n",
    "&emsp;Objeto que aparece em um dicionário como a segunda parte de um par chave-valor. Isso é mais específico que o nosso uso anterior da palavra “valor”.\n",
    "\n",
    "**implementação** <br>\n",
    "&emsp;Uma forma de executar um cálculo.\n",
    "\n",
    "**hashtable** <br>\n",
    "&emsp;Algoritmo usado para implementar dicionários de Python.\n",
    "\n",
    "**função hash** <br>\n",
    "&emsp;Função usada por uma hashtable para calcular a posição de uma chave.\n",
    "\n",
    "**hashable** <br>\n",
    "&emsp;Um tipo que tem uma função `hash`. Tipos imutáveis como números inteiros, de ponto flutuante e strings são *hashable*; tipos mutáveis, como listas e dicionários, não são.\n",
    "\n",
    "**busca** <br>\n",
    "&emsp;Operação de dicionário que recebe uma chave e encontra o valor correspondente.\n",
    "\n",
    "**busca reversa** <br>\n",
    "&emsp;Operação de dicionário que recebe um valor e encontra uma ou várias chaves que o mapeiem.\n",
    "\n",
    "**instrução _raise_** <br>\n",
    "&emsp;Instrução que (deliberadamente) causa uma exceção.\n",
    "\n",
    "**item avulso (*singleton*)** <br>\n",
    "&emsp;Uma lista (ou outra sequência) com um único elemento.\n",
    "\n",
    "**gráfico de chamada** <br>\n",
    "&emsp;Um diagrama que mostra cada frame criado durante a execução de um programa, com uma flecha apontando quem chama a quem é chamado.\n",
    "\n",
    "**memo (memorização)** <br>\n",
    "&emsp;Valor já calculado, guardado para não ter que fazer o mesmo cálculo no futuro.\n",
    "\n",
    "**variável global** <br>\n",
    "&emsp;Variável definida fora de uma função. As variáveis globais podem ser acessadas de qualquer função.\n",
    "\n",
    "**instrução global** <br>\n",
    "&emsp;Instrução que declara um nome de variável global.\n",
    "\n",
    "**flag** <br>\n",
    "&emsp;Variável booleana usada para indicar se uma condição é verdadeira.\n",
    "\n",
    "**declaração** <br>\n",
    "&emsp;Instrução tal como global, que diz ao interpretador algo a respeito de uma variável."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.10 - Exercícios\n",
    "\n",
    "### Exercício 11.1\n",
    "\n",
    "Escreva uma função que leia as palavras em `words.txt` e guarde-as como chaves em um dicionário. Não importa quais são os valores. Então você pode usar o operador `in` como uma forma rápida de verificar se uma string está no dicionário.\n",
    "\n",
    "Se fez o Exercício 10.10, você pode comparar a velocidade desta implementação com o operador `in` de listas e a busca por bisseção.\n",
    "\n",
    "### Exercício 11.2\n",
    "\n",
    "Leia a documentação do método de dicionário `setdefault` e use-o para escrever uma versão mais concisa de `invert_dict`.\n",
    "\n",
    "Solução: http://thinkpython2.com/code/invert_dict.py.\n",
    "\n",
    "### Exercício 11.3\n",
    "\n",
    "Memorize a função de Ackermann do Exercício 6.2 e veja se a memorização permite avaliar a função com argumentos maiores. Dica: não.\n",
    "\n",
    "Solução: http://thinkpython2.com/code/ackermann_memo.py.\n",
    "\n",
    "### Exercício 11.4\n",
    "\n",
    "Se fez o Exercício 10.7, você já tem uma função chamada `has_duplicates`, que recebe uma lista como parâmetro e retorna `True` se houver algum objeto que aparece mais de uma vez na lista.\n",
    "\n",
    "Use um dicionário para escrever uma versão mais rápida e simples de `has_duplicates`.\n",
    "\n",
    "Solução: http://thinkpython2.com/code/has_duplicates.py.\n",
    "\n",
    "### Exercício 11.5\n",
    "\n",
    "Duas palavras são “pares rotacionados” se for possível rotacionar um deles e chegar ao outro (ver `rotate_word` no Exercício 8.5).\n",
    "\n",
    "Escreva um programa que leia uma lista de palavras e encontre todos os pares rotacionados.\n",
    "\n",
    "Solução: http://thinkpython2.com/code/rotate_pairs.py.\n",
    "\n",
    "### Exercício 11.6\n",
    "\n",
    "Aqui está outro quebra-cabeça do programa Car Talk (http://www.cartalk.com/content/puzzlers):\n",
    "\n",
    "> Ele foi enviado por Dan O’Leary. Dan descobriu uma palavra comum, com uma sílaba e cinco letras que tem a seguinte propriedade única. Ao removermos a primeira letra, as letras restantes formam um homófono da palavra original, que é uma palavra que soa exatamente da mesma forma. Substitua a primeira letra, isto é, coloque-a de volta, retire a segunda letra e o resultado é um outro homófono da palavra original. E a pergunta é, qual é a palavra?\n",
    "Agora vou dar um exemplo que não funciona. Vamos usar a palavra de cinco letras, ‘wrack’ (mover, eliminar). W-R-A-C-K, como na expressão ‘wrack with pain’ (se contorcer de dor). Se eu retirar a primeira letra, sobra uma palavra de quatro letras, ‘R-A-C-K’ (galhada). Como na frase, ‘Holy cow, did you see the rack on that buck! It must have been a nine-pointer!’ (‘Minha nossa, você viu a galhada daquele cervo! Deve ter nove pontas!’). É um homófono perfeito. Se puser o ‘w’ de volta e retirar o ‘r’ em vez disso, sobra a palavra ‘wack’, que é uma palavra de verdade, mas não é um homófono das outras duas palavras.\n",
    "\n",
    ">Mas há pelo menos uma palavra que Dan e eu conhecemos, que produz dois homófonos se você retirar qualquer uma das duas primeiras letras, e duas novas palavras de quatro letras são formadas. A pergunta é, qual é a palavra?\n",
    "\n",
    "Você pode usar o dicionário do Exercício 11.1 para verificar se uma string está na lista de palavras.\n",
    "\n",
    "Para verificar se duas palavras são homófonas, você pode usar o Dicionário de pronúncia CMU. Ele pode ser baixado em http://www.speech.cs.cmu.edu/cgi-bin/cmudict ou em http://thinkpython2.com/code/c06d. Você também pode baixar http://thinkpy thon2.com/code/pronounce.py, que tem uma função chamada `read_dictionary`, que lê o dicionário de pronúncia e retorna um dicionário de Python que mapeia cada palavra a uma string que descreve sua pronúncia primária.\n",
    "\n",
    "Escreva um programa que liste todas as palavras que resolvem o quebra-cabeça.\n",
    "\n",
    "Solução: http://thinkpython2.com/code/homophone.py."
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}