10.Conjuntos e Dicionários.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\" style=\"margin-top: 1em;\"><ul class=\"toc-item\"><li><span><a href=\"#Conjuntos-e-Dicionários\" data-toc-modified-id=\"Conjuntos-e-Dicionários-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Conjuntos e Dicionários</a></span><ul class=\"toc-item\"><li><span><a href=\"#Conjuntos\" data-toc-modified-id=\"Conjuntos-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Conjuntos</a></span></li><li><span><a href=\"#Dicionários\" data-toc-modified-id=\"Dicionários-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Dicionários</a></span><ul class=\"toc-item\"><li><span><a href=\"#Motivação\" data-toc-modified-id=\"Motivação-1.2.1\"><span class=\"toc-item-num\">1.2.1&nbsp;&nbsp;</span>Motivação</a></span></li><li><span><a href=\"#Mais-um-exemplo\" data-toc-modified-id=\"Mais-um-exemplo-1.2.2\"><span class=\"toc-item-num\">1.2.2&nbsp;&nbsp;</span>Mais um exemplo</a></span></li><li><span><a href=\"#Método-get\" data-toc-modified-id=\"Método-get-1.2.3\"><span class=\"toc-item-num\">1.2.3&nbsp;&nbsp;</span>Método <code>get</code></a></span></li><li><span><a href=\"#A-Função-dict\" data-toc-modified-id=\"A-Função-dict-1.2.4\"><span class=\"toc-item-num\">1.2.4&nbsp;&nbsp;</span>A Função <code>dict</code></a></span></li></ul></li><li><span><a href=\"#Chaves-e-Conteúdos-(valores)-de-Dicionários\" data-toc-modified-id=\"Chaves-e-Conteúdos-(valores)-de-Dicionários-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Chaves e Conteúdos (valores) de Dicionários</a></span><ul class=\"toc-item\"><li><span><a href=\"#Métodos-items,-keys-e-values\" data-toc-modified-id=\"Métodos-items,-keys-e-values-1.3.1\"><span class=\"toc-item-num\">1.3.1&nbsp;&nbsp;</span>Métodos <code>items</code>, <code>keys</code> e <code>values</code></a></span></li><li><span><a href=\"#Método-copy\" data-toc-modified-id=\"Método-copy-1.3.2\"><span class=\"toc-item-num\">1.3.2&nbsp;&nbsp;</span>Método <code>copy</code></a></span></li><li><span><a href=\"#Método-clear\" data-toc-modified-id=\"Método-clear-1.3.3\"><span class=\"toc-item-num\">1.3.3&nbsp;&nbsp;</span>Método <code>clear</code></a></span></li></ul></li><li><span><a href=\"#Compreensão-de-dicionários\" data-toc-modified-id=\"Compreensão-de-dicionários-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Compreensão de dicionários</a></span></li><li><span><a href=\"#Iterando-em-dicionários\" data-toc-modified-id=\"Iterando-em-dicionários-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Iterando em dicionários</a></span></li><li><span><a href=\"#Exercício:-Contando-letras-em-um-String\" data-toc-modified-id=\"Exercício:-Contando-letras-em-um-String-1.6\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>Exercício: Contando letras em um String</a></span></li><li><span><a href=\"#Ordenando-dicionários-por-chave-e-valor\" data-toc-modified-id=\"Ordenando-dicionários-por-chave-e-valor-1.7\"><span class=\"toc-item-num\">1.7&nbsp;&nbsp;</span>Ordenando dicionários por chave e valor</a></span></li><li><span><a href=\"#Ordenação-Customizada\" data-toc-modified-id=\"Ordenação-Customizada-1.8\"><span class=\"toc-item-num\">1.8&nbsp;&nbsp;</span>Ordenação Customizada</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercício:-Escreva-uma-função-que-retorna-a-palavra-mais-comum-de-uma-string:\" data-toc-modified-id=\"Exercício:-Escreva-uma-função-que-retorna-a-palavra-mais-comum-de-uma-string:-1.8.1\"><span class=\"toc-item-num\">1.8.1&nbsp;&nbsp;</span>Exercício: Escreva uma função que retorna a palavra mais comum de uma string:</a></span></li><li><span><a href=\"#Exercício:-Decodificador-de-data.\" data-toc-modified-id=\"Exercício:-Decodificador-de-data.-1.8.2\"><span class=\"toc-item-num\">1.8.2&nbsp;&nbsp;</span>Exercício: Decodificador de data.</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Conjuntos e Dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Em tipos abstratos de dados, nós cobrimos até agora as seqüências que são coleções ordenadas de valores (e.g., strings, tuplas e listas). Em uma coleção ordenada, tanto o valor quanto a posição de cada item são significativos e cada item é acessado por sua posição. Nesta aula, vamos estudar as coleções não ordenadas. Do ponto de vista do usuário, apenas os valores dos itens são importantes; para o usuário, a posição de um item não é um problema. Assim, nenhuma das operações em uma coleção não ordenada é baseada em posição. Uma vez adicionado, um item é acessado pelo seu valor. Os usuários podem inserir, recuperar ou remover itens de coleções não ordenadas, mas eles não podem acessar o i-ésimo item, o próximo item ou o item anterior. Alguns exemplos de coleções não ordenadas são conjuntos e dicionários."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Como vocês aprenderam com o estudo de matemática, um conjunto é uma coleção de itens sem nenhuma ordem particular. Do ponto de vista do usuário, os itens em um conjunto são únicos. Ou seja, não há itens duplicados em um conjunto. Em matemática, realizamos muitas operações em conjuntos. Algumas das operações mais típicas são as seguintes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Retorne o número de itens no conjunto.\n",
    "- Teste o conjunto vazio (um conjunto que não contém itens).\n",
    "- Adicione um item ao conjunto.\n",
    "- Remova um item do conjunto.\n",
    "- Teste a associação do conjunto (se um determinado item está ou não no conjunto).\n",
    "- Obtenha a união de dois conjuntos. A união de dois conjuntos A e B é um conjunto que contém todos os itens em A e todos os itens em B.\n",
    "- Obtenha a interseção de dois conjuntos. A interseção de dois conjuntos A e B é o conjunto de itens em A que também são itens em B.\n",
    "- Obtenha a diferença de dois conjuntos. A diferença de dois conjuntos A e B é o conjunto de itens em A que não são também itens em B.\n",
    "- Teste um conjunto para determinar se outro conjunto é ou não seu subconjunto. O conjunto B é um subconjunto do conjunto A se e somente se B for um conjunto vazio ou todos os itens em B também estão em A."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "Observe que as operações de diferença e subconjunto não são simétricas. Por exemplo, a diferença dos conjuntos A e B nem sempre é a mesma diferença entre os conjuntos B e A.\n",
    "\n",
    "Para descrever o conteúdo de um conjunto, usamos a notação {<item-1> ... <item-n>}, mas assumimos que os itens não estão em ordem particular. Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = {1, 3, 5, 7}\n",
    "print(s, type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "No próximo exemplo, criamos dois conjuntos denominados A e B e realizamos algumas operações neles. Quando o construtor de conjunto recebe uma lista como um argumento, os elementos da lista são copiados para o conjunto, omitindo itens duplicados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "S = [0, 1, 1, 2]\n",
    "A = set(S)\n",
    "print(A)\n",
    "B = set()\n",
    "print(1 in A)\n",
    "print(B)\n",
    "C = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "C = A.intersection(B)\n",
    "print(C)\n",
    "B.add(1)\n",
    "B.add(1)\n",
    "B.add(5)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "A.intersection(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "A.union(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "A.difference(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "B.remove(1)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "B.issubset(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ao contrário de uma lista, um conjunto não permite nenhum acesso baseado em índice. Vocês podem estar se perguntando como um programador pode visitar todos os itens em um conjunto depois de terem sido adicionados. Observe que a classe `set` inclui um iterador, que permite ao programador usar um laço for em um conjunto para visitar seus itens em uma ordem não especificada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for item in A:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Dicionários** são estruturas de dados que implementam mapeamentos. Um mapeamento é uma coleção de associações entre pares de valores.\n",
    "O primeiro elemento do par é chamado de chave (`key`) e o outro de conteúdo (`value`).\n",
    "De certa forma, um mapeamento é uma generalização da idéia de acessar dados por índices, exceto que num mapeamento os índices (ou chaves) podem ser de \n",
    "qualquer tipo imutável."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Motivação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "As listas organizam seus elementos por posição. Este modo de organização é útil quando você deseja localizar o primeiro elemento, o último elemento ou visitar cada elemento em uma seqüência. Suponha, por exemplo, que precisamos armazenar as temperaturas de três cidades: Campinas, Londres e Paris. Para este propósito, podemos usar uma lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "temps = [23, 15.4, 17.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Mas, então, precisamos lembrar a sequência de cidades, por exemplo, o índice 0 corresponde à cidade de Campinas, o índice 1 a Londres e o índice 2 a Paris. Ou seja, a temperatura de Londres é obtida como temps [1]. Um **dicionário** com o nome da cidade como índice é mais conveniente, porque isso nos permite escrever temps [\"Londres\"] para procurar a temperatura em Londres. Esse dicionário é criado por uma das duas instruções a seguir. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "temps = {'Campinas': 23, 'Londres': 15.4, 'Paris': 17.5}\n",
    "# ou\n",
    "temps = dict(Campinas=23, Londres=15.4, Paris=17.5)\n",
    "\n",
    "print(temps[\"Campinas\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Pares adicionais de valor de texto podem ser adicionados quando desejado. Nós podemos, por exemplo, escrever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "temps['Madri'] = 26.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "O dicionário de temperaturas tem agora quatro pares de valores de texto e sua impressão resulta em:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(temps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Mais um exemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Em outras situações, a posição de um dado em uma estrutura é irrelevante; Estamos interessados em sua associação com algum outro elemento na estrutura. Por exemplo, suponha que queiramos recuperar o curso e o respectivo coeficiente de rendimento dos alunos da Unicamp. Vocês podem usar uma lista separada para cada item. Note que cada lista deve ter o mesmo comprimento. As informações são armazenadas em listas no mesmo índice, onde cada índice refere-se a informações para uma pessoa diferente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "names   = ['Ana', 'Paulo', 'Denise', 'Katia']\n",
    "average = ['7.5', '8.2', '6.9', '8.5']\n",
    "course  = ['computação', 'mecânica', 'civil', 'elétrica']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Podemos então definir uma função para recuperar as informações do curso e do coeficiente de rendimento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def get_course_and_cr(student, name_list, cr_list, course_list):\n",
    "    i = name_list.index(student)\n",
    "    cr = cr_list[i]\n",
    "    course = course_list[i]\n",
    "    return (course, cr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "curso, cr = get_course_and_cr('Denise', names, average, course)\n",
    "print(\"Denise estuda {} e tem coeficiente de rendimento {}\".format(curso, cr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Esta solução tem problemas se tivermos muitas informações diferentes para gerenciar. Devemos manter muitas listas e passá-las como argumentos.\n",
    "Temos sempre que indexar as listas por números inteiros e, além disso, devemos nos lembrar de atualizar informações em várias listas.\n",
    "Seria bom indexar o item de interesse diretamente (nem sempre um inteiro) e seria bom usar uma estrutura de dados, sem listas separadas. Novamente, \\textbf{dicionários} é a solução:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Considere que queiramos representar as informações de um estudante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "student = {'name': 'Paulo', 'age': 21, 'courses': ['MC102', 'MA111']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Uma variável do tipo dicionário pode ser “indexada”:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(student['name'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O conteúdo associado a uma chave pode ser alterado \n",
    "atribuindo-se um novo valor àquela posição do dicionário:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "student['age'] = 22\n",
    "student"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Método `get`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Obtém o conteúdo de chave. Sintaxe:\n",
    "```python\n",
    "get (chave, valor)\n",
    "```\n",
    "Não causa erro caso chave não exista: retorna `valor`\n",
    "Se `valor` não for especificado chaves inexistentes retornam `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(student['phone'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(student.get('phone', \"Not found\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Novos valores podem ser acrescentados a um dicionário \n",
    "fazendo atribuição a uma chave ainda não definida:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "student['phone'] = '9-9191-1919'\n",
    "student"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### A Função `dict`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A função `dict` é usada para construir dicionários e requer \n",
    "como parâmetros:\n",
    "- Uma lista de tuplas, cada uma com um par chave/conteúdo, ou\n",
    "- Uma seqüência de itens no formato chave=valor. Nesse caso, as chaves têm que ser strings, mas são escritas sem aspas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d = dict([(1, 2), ('chave', 'conteudo'), ('cursos', ['MC102', 'MC300'])])\n",
    "print(d[1])\n",
    "print(d['chave'])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d = dict(x = 1, y = 2)\n",
    "print(d['x'])\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Chaves e Conteúdos (valores) de Dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\\textbf{valores}\n",
    "- podem ser de qualquer tipo (imutável e mutável)\n",
    "- podem ser duplicados\n",
    "- os valores do dicionário podem ser listas, ou mesmo outros dicionários!\n",
    "\n",
    "\\textbf{chaves}\n",
    "- deve ser único\n",
    "- tipo imutável (int, float, string, tuple, bool)\n",
    "\n",
    "  - cuidado com o a escolha do tipo de float como uma chave\n",
    "  -  as tuplas podem ser usados como chaves se elas contêm apenas listas, números ou tuplas; se uma tupla contiver qualquer objeto mutável, direta ou indiretamente, não pode ser usada como uma chave."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Métodos `items`, `keys` e `values`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `items()` retorna um objeto iterável para os pares chave/conteúdo do dicionário\n",
    "- `keys()` retorna um objeto iterável para as chaves do dicionário\n",
    "- `values()` retorna um objeto iterável para os valores do dicionário\n",
    "\n",
    "Para visualizar os pares, chaves e valores, vocês podem usar o construtor `list`. `list` retorna uma lista de todas as chaves usadas no dicionário, em ordem arbitrária. Se desejar que ele seja ordenado, basta usar `sorted`.\n",
    "\n",
    "Para verificar se uma única chave está no dicionário, use o operador `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dic = { \"Nick\": \"pet\", \"Maria\": \"girl\", \"Joao\": \"boy\" }\n",
    "list(dic.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "list(dic.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "sorted(dic.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'Maria' in dic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Método `copy`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "O método `copy` retorna um outro dicionário com os mesmos pares \n",
    "chave/conteúdo. Observe que os conteúdos não são cópias, mas apenas \n",
    "referências para os mesmos valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = dic.copy()\n",
    "y = dic\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%load_ext tutormagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%tutor --lang python3 --link --heapPrimitives\n",
    "dic1 = {1:'a', 2:'b'}\n",
    "dic2 = dic1.copy()\n",
    "dic2[1] = 'c'\n",
    "x = dic1\n",
    "x[1] = 'd'\n",
    "print(dic1, dic2, x, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Método `clear`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "O método `clear` remove todos os elementos do dicionário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dic.clear()\n",
    "print(dic, x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Compreensão de dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "As compreensões de dicionários podem ser usadas para criar dicionários a partir de expressões de chaves e valores arbitrárias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "{x: x**2 for x in (2, 4, 6)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterando em dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ao fazer uma iteração sobre dicionários, a chave e o conteúdo (ou valor) correspondente podem ser recuperados ao mesmo tempo usando o método `items ()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "cavaleiros = { 'Galahad' : 'O Valente',\n",
    "               'Gareth'  : 'O Franco',\n",
    "               'Lancelot': 'O Cavaleiro Branco',\n",
    "               'Ivain'   : 'O Cavaleiro do Leão',\n",
    "               'Gauvain' : 'O Falcão' }\n",
    "for k, v in cavaleiros.items():\n",
    "    print(k, v, sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício: Contando letras em um String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Faça uma função que dada um string, retorna a letra mais comum nesse string (em caso de empate retorne qualquer uma das mais frequentes).\n",
    "- Idéia: usar um dicionário para contar cada letra.\n",
    "- A letra é a chave do dicionário, e o valor será quantas vezes a letra foi encontrada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def contaletra(s):\n",
    "    s = s.lower()\n",
    "    conta = {}          # dicionário vazio\n",
    "    for car in s:\n",
    "        if car in conta:\n",
    "            conta[car] += 1\n",
    "        else:\n",
    "            conta[car] = 1\n",
    "    x, y = '', 0\n",
    "    for k, v in conta.items():\n",
    "        if not x:   # nenhuma mais comum ainda\n",
    "            x, y = k, v\n",
    "        elif v > y:\n",
    "            x, y = k, v\n",
    "    return x, y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "c, n = contaletra(\"Era uma vez na America\")\n",
    "print(c, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**b.** Modifique a função **contaletra** para que ela não conte brancos e pontuação como letras.\n",
    "Conte as letras maiúsculas e minúsculas como as mesmas letras. Dica: use a função `lower` para transformar maiúsculas em minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ordenando dicionários por chave e valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "numbers = {'first': 1, 'second': 2, 'third': 3, 'Fourth': 4}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Embora os pares de chave-valores estejam em uma certa ordem na instrução de instanciação, chamando o método de lista (que criará uma lista de suas chaves), podemos ver que eles não necessariamente são armazenados ordenados (no exemplo, em ordem alfabética):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(list(numbers))\n",
    "print(sorted(numbers))   # Equivalente a chamar sorted(numbers.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "da mesma forma que fizemos com as chaves, podemos usar a função sorted para ordenar o dicionário do Python pelos seus valores (neste caso, temos que chamar numbers.value()):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sorted(numbers.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ordenação Customizada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se simplesmente fornecermos à função **sorted** as chaves e valores do dicionário como argumentos, ele irá executar uma ordenação simples, mas utilizando seus outros argumentos (isto é, key e reverse), podemos fazer com que ele execute tipos mais complexos.\n",
    "\n",
    "O argumento **key** (não confundir com as chaves do dicionário) para classificado nos permite definir funções específicas para usar ao ordenar os itens, como um iterador (em nosso objeto dicionário). Nos dois exemplos acima, as chaves e os valores eram os itens a serem classificados e os itens usados para comparação, mas se quiséssemos classificar nossas chaves do dicionário usando nossos valores, então diríamos à função sorted para fazer isso através de seu argumento key. Como segue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sorted(numbers, key=lambda x: (numbers[x], x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercício: Escreva uma função que retorna a palavra mais comum de uma string:\n",
    "- Use o método `split()` para quebrar a string em uma lista de palavras.\n",
    "- Use as palavras como chaves do dicionário.\n",
    "- Converta cada palavra para minúsculo com a função `lower`.\n",
    "- Remova os caracteres de pontuação das palavras (mais difícil)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def most_common(s):\n",
    "    counts = dict()\n",
    "    words = s.split()\n",
    "    words = [w.lower() for w in words]\n",
    "    print('Words:', words)\n",
    "    for word in words:\n",
    "        counts[word] = counts.get(word, 0) + 1\n",
    "    print('Counts', counts)\n",
    "    common = sorted(counts, key=lambda x: (-counts[x], x))\n",
    "    return common[0]\n",
    "\n",
    "text=\"The clown ran after the car and the Car ran into the Tent and the tent fell down on the clown and the car\"\n",
    "print(most_common(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercício: Decodificador de data.\n",
    "Uma data no formato \"8-Mar-15\" inclui o nome do mês, que deve ser traduzido para um número. Crie um dicionário adequado para decodificar nomes de mês para números. Crie uma função que use operações de string para dividir a data em 3 itens usando o caractere \"-\". Traduzir o mês, corrigir o ano para incluir todos os dígitos.\n",
    "A função deverá aceitar uma data no formato \"dd-MMM-yy\" e responderá com uma tupla de (y, m, d). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "livereveal": {
   "theme": "solarized",
   "transition": "slide"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}