04 - Listas, Dicionários, Tuplas e tudo mais.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listas, Dicionários, Tuplas e etc\n",
    "\n",
    "Python oferece um monte de estruturas de dados prontas para serem usadas! Vamos explorá-las agora :D\n",
    "\n",
    "## Listas\n",
    "\n",
    "Forma mais básica de armazenar um conjunto de dados. A sintaxe é bastante simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = []  # Inicia uma lista vazia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "ímpares = [1, 3, 7, 9]  # Inicia uma lista com dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também iniciar uma lista fazendo um _casting_ através da palavra `list`. Se passarmos uma string como parâmetro, teremos uma lista de seus caracteres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['U', 'S', 'P']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "faculdade = \"USP\"\n",
    "list(faculdade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings também implementam o método `split` que permitem a geração de uma lista de termos quebrados ao redor de um certo caractere:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "parágrafo = \"USP e UNICAMP ficam no estado de São Paulo. UFV e UFMG ficam em Minas. UFRJ e UFF ficam no RJ\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['USP e UNICAMP ficam no estado de São Paulo',\n",
       " ' UFV e UFMG ficam em Minas',\n",
       " ' UFRJ e UFF ficam no RJ']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parágrafo.split('.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['USP ',\n",
       " ' UNICAMP ficam no ',\n",
       " 'stado d',\n",
       " ' São Paulo. UFV ',\n",
       " ' UFMG ficam ',\n",
       " 'm Minas. UFRJ ',\n",
       " ' UFF ficam no RJ']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parágrafo.split('e')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterações e Continência\n",
    "\n",
    "O operador `in` é bastante útil nos dois casos! Checar continência em listas é fácil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'batata' in [\"maria\", 2, 3.14, True, \"João\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos fazer iterações de forma bastante simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "for item in [1, 3, 5, 7, 9, 11]:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se seu programa precisar checar continências muitas vezes, talvez um set ou uma tupla sejam mais eficiente pro seu caso! Veja mais sobre isso a seguir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inserção"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['olá!', 'oi', 'olá!']\n"
     ]
    }
   ],
   "source": [
    "lista.append(\"olá!\")  # Podemos adicionar valores com append\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['olá!', 'oi']\n"
     ]
    }
   ],
   "source": [
    "lista += [\"oi\"]  # Também podemos usar uma soma embutida para adicionar elementos\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível inserirmos valores em pontos arbitrários:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 7, 9]\n",
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "print(ímpares)\n",
    "ímpares.insert(2, 5)  # Insere 5 na posíção 2\n",
    "print(ímpares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['olá!', 'oi', 'olá!', 1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista + ímpares  # Na verdade, podemos somar listas como faríamos com strings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 'olá!', 'oi', 'olá!']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ímpares + lista  # A ordem importa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ímpares)  # Inspecionamos o tamanho de uma lista com len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ímpares[0]  # E acessamos itens específicos usando colchetes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ímpares[0:3]  # Slicing também existe!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Curiosidade: [Porque contagem deveria começar do 0 - E. Dijkstra](https://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pesquisa e contagem\n",
    "\n",
    "Podemos determinar se um elemento está ou não numa lista simplesmente usando a expressão `in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 in [1, 4, 7, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 in [1, 8, 4, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para localizar o índice de um elemento em si, usamos `index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes = [\"João\", \"Alice\", \"Matheus\", \"Aline\", \"Flávia\", \"Matheus\", \"Alice\", \"Matheus\"]\n",
    "nomes.index(\"Matheus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E podemos contar as ocorrência com `count`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes = [\"João\", \"Alice\", \"Matheus\", \"Aline\", \"Flávia\", \"Matheus\", \"Alice\", \"Matheus\"]\n",
    "nomes.count(\"Matheus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando mais de um resultado existe, o método `index` irá retornar o primeiro da esquerda para a direita. No entanto, ele aceita um parâmetro opcional que é de onde ele vai começar a busca.\n",
    "\n",
    "A primeira ocorrência de \"Matheus\" vem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes.index(\"Matheus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos utilizar o resultado da primeira busca para localizar a segunda ocorrência. No caso, precisamos colocar para iniciar a busca após o resultado atual:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes.index(\"Matheus\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes.index(\"Matheus\", 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: Na variável `bases` guarde uma lista com as letras separadas da variável `p53`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "p53 = \"\"\"GATGGGATTGGGGTTTTCCCCTCCCATGTGCTCAAGACTGGCGCTAAAAGTTTTGAGCTTCTCAAAAGTC\n",
    "TAGAGCCACCGTCCAGGGAGCAGGTAGCTGCTGGGCTCCGGGGACACTTTGCGTTCGGGCTGGGAGCGTG\n",
    "CTTTCCACGACGGTGACACGCTTCCCTGGATTGGGTAAGCTCCTGACTGAACTTGATGAGTCCTCTCTGA\n",
    "GTCACGGGCTCTCGGCTCCGTGTATTTTCAGCTCGGGAAAATCGCTGGGGCTGGGGGTGGGGCAGTGGGG\n",
    "ACTTAGCGAGTTTGGGGGTGAGTGGGATGGAAGCTTGGCTAGAGGGATCATCATAGGAGTTGCATTGTTG\n",
    "GGAGACCTGGGTGTAGATGATGGGGATGTTAGGACCATCCGAACTCAAAGTTGAACGCCTAGGCAGAGGA\n",
    "GTGGAGCTTTGGGGAACCTTGAGCCGGCCTAAAGCGTACTTCTTTGCACATCCACCCGGTGCTGGGCGTA\"\"\"\n",
    "\n",
    "bases = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: Conte quantas vezes a letra `A` aparece em `bases`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A ocorrência de A é None\n"
     ]
    }
   ],
   "source": [
    "contagem_a = None\n",
    "\n",
    "print(f\"A ocorrência de A é {contagem_a}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: O operador `len` permite calcular o tamanho de uma lista. Calcule o tamanho de `bases`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bases possui None elementos\n"
     ]
    }
   ],
   "source": [
    "tamanho = None\n",
    "\n",
    "print(f\"Bases possui {tamanho} elementos\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: A lista `atcg` contém uma lista com todas as bases nitrogenadas. Use um loop para contar a ocorrência de cada base em `bases`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "atcg = [\"A\", \"T\", \"C\", \"G\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Exercício bônus: use f-strings para imprimir as ocorrências calculadas no exercício anterior num formato como \"a ocorrência da base T é 10\"_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "u\n",
      "n\n",
      "i\n",
      "c\n",
      "a\n",
      "m\n",
      "p\n"
     ]
    }
   ],
   "source": [
    "for letra in \"unicamp\":\n",
    "    print(letra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou seja, embora seja possível converter explicitamente uma palavra para uma lista de letras, isso não é _obrigatório_. Como uma `string` já e implementada como sendo uma lista, é possível fazer um loop através dela de forma implícita."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ordenação\n",
    "\n",
    "[Referência](https://docs.python.org/3/howto/sorting.html#sortinghowto)\n",
    "\n",
    "Listas possuem o método `sort` que torna fácil fazer uma ordenação simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "letras = [\"A\", \"G\", \"E\", \"O\", \"E\", \"R\", \"W\", \"S\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "letras.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'E', 'E', 'G', 'O', 'R', 'S', 'W']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python também oferece a função `sorted` capaz de realizar ordenações mais poderosas. No funcionamento básico, ela se comporta igual ao `sort` normal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Felipe', 'Isabella', 'José', 'Osvaldo', 'Roberto', 'Vitor']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes = [\"Ana\", \"Osvaldo\", \"José\", \"Roberto\", \"Felipe\", \"Isabella\", \"Vitor\"]\n",
    "sorted(nomes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas, observe que sorted não alterou a lista em memória!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Osvaldo', 'José', 'Roberto', 'Felipe', 'Isabella', 'Vitor']"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sorted` permite uma ordenação decrescente direto da chamada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Vitor', 'Roberto', 'Osvaldo', 'José', 'Isabella', 'Felipe', 'Ana']"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(nomes, reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E uma das características mais poderosas, podemos modificar qual vai ser o parâmetro de ordenação que vai ser utilizando criando uma função!\n",
    "\n",
    "Suponha que você queira ordenas os nomes pela _segunda_ letra deles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Felipe', 'Vitor', 'Ana', 'José', 'Roberto', 'Osvaldo', 'Isabella']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def segunda_letra(palavra):\n",
    "    return palavra[1]\n",
    "\n",
    "sorted(nomes, key=segunda_letra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inversão\n",
    "\n",
    "Assim como strings, podemos inverter usando as opções de slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['W', 'S', 'R', 'O', 'G', 'E', 'E', 'A']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letras[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'E', 'E', 'G', 'O', 'R', 'S', 'W']"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como você pode ver, o _slicing_ apenas retorna uma representação da lista invertida. Se você quiser inverter a lista em memória pode usar o método `reverse`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['W', 'S', 'R', 'O', 'G', 'E', 'E', 'A']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letras.reverse()\n",
    "letras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dicionários\n",
    "\n",
    "Dicionários são ótimos para armazenar valores no formato `chave: valor`. Se você nunca viu essa estrutura na vida, pense num dicionário normal onde palavras são ligadas a um significado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "letras = {\n",
    "    'a': 'Essa é a primeira letra do alfabeto!',\n",
    "    'z': 'Essa é a última'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Essa é a primeira letra do alfabeto!'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letras['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Essa é a última'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letras['z']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterar em dicionários é fácil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A chave a tem valor Essa é a primeira letra do alfabeto!\n",
      "A chave z tem valor Essa é a última\n"
     ]
    }
   ],
   "source": [
    "for chave in letras:\n",
    "    print(f\"A chave {chave} tem valor {letras[chave]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma forma mais elaborada de fazer um loop em dicionários é com o atributo `items` e fazendo um loop **duplo**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A chave é 'a' e tem valor 'Essa é a primeira letra do alfabeto!'\n",
      "A chave é 'z' e tem valor 'Essa é a última'\n"
     ]
    }
   ],
   "source": [
    "for chave, valor in letras.items():\n",
    "    print(f\"A chave é '{chave}' e tem valor '{valor}'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Determinar continência em dicionários também é fácil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in letras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'w' in letras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dicionários aceitam valores arbitrários, inclusive outros dicionários!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "pessoas = {\n",
    "    \"João\": {\n",
    "        \"ra\": '1234',\n",
    "        \"idade\": 20,\n",
    "        \"veterano\": False\n",
    "    },\n",
    "    \n",
    "    \"Maria\": {\n",
    "        \"ra\": '12',\n",
    "        \"idade\": 30,\n",
    "        \"veterano\": True\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O valor de ra para João é 1234\n",
      "O valor de idade para João é 20\n",
      "O valor de veterano para João é False\n",
      "O valor de ra para Maria é 12\n",
      "O valor de idade para Maria é 30\n",
      "O valor de veterano para Maria é True\n"
     ]
    }
   ],
   "source": [
    "for nome in pessoas:\n",
    "    for atributo in pessoas[nome]:\n",
    "        print(\"O valor de {} para {} é {}\".format(atributo, nome, pessoas[nome][atributo]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas\n",
    "\n",
    "[Referência](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)\n",
    "\n",
    "Tuplas se comportam de forma muito parecida com listas mas são imutáveis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "tupla = (\"oi\", \"olá\", \"boa tarde\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oi'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-97681632f1c5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtupla\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Tchau\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tupla[0] = \"Tchau\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas ainda é fácil checar continência e iterar em tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"oi\" in tupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oi\n",
      "olá\n",
      "boa tarde\n"
     ]
    }
   ],
   "source": [
    "for valor in tupla:\n",
    "    print(valor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em geral, tuplas são mais eficientes que listas na checagem de continência! Se o seu problema não vai alterar os valores inicializado e vai checar por continência diversas vezes, usar uma tupla é uma ótima ideia!\n",
    "\n",
    "### Tuplas de Listas\n",
    "\n",
    "É possível criar tuplas partindo de listas de maneira fácil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 7, 3, 6, 8, 4, 7)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1, 5, 7, 3, 6, 8, 4, 7]\n",
    "t = tuple(l)\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível iniciar a lista dentro da tupla de forma implícita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('usp', 'unesp', 'unicamp')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = tuple(['usp', 'unesp', 'unicamp'])\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas de Tuplas\n",
    "\n",
    "É possível executar a operação inversa e criar listas com base em tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['usp', 'unesp', 'unicamp']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = list(t)\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "[Referência](https://docs.python.org/3/library/stdtypes.html#set)\n",
    "\n",
    "Sets implementam um conjunto em Python da forma com você esperaria da matemática.\n",
    "\n",
    "Elementos duplicados são ignorados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = {1, 2, 2, 3, 4}\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível calcular a intesercção:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 8}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib = {1, 1, 2, 3, 5, 8, 13}\n",
    "pares = {0, 2, 4, 6, 8}\n",
    "pares & fib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As diferenças:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 4, 6}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pares - fib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 5, 13}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib - pares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A diferença simétrica:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 3, 4, 5, 6, 13}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib ^ pares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 3, 4, 5, 6, 13}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pares ^ fib "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível calcular de forma rápida se dois conjuntos são disjuntos (não possuem elementos em comum):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pares = {0, 2, 4, 6, 8}\n",
    "ímpares = {1, 3, 5, 7, 9}\n",
    "\n",
    "pares.isdisjoint(ímpares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível determinar se conjuntos são contidos ou contém outros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = {0, 1, 2, 3, 4, 5, 6, 8, 9, 10}\n",
    "pares.issubset(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n.issuperset(pares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets são uma estrutura altamente otimizada. Se o problema que você está tentando resolver pode ser feito em sets ao invés de em listas, utilize-os!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em geral, tuplas são mais eficientes que listas na checagem de continência! Se o seu problema não vai alterar os valores inicializado e vai checar por continência diversas vezes, usar uma tupla é uma ótima ideia!\n",
    "\n",
    "### Sets de Listas\n",
    "\n",
    "É possível criar sets partindo de listas de maneira fácil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 5, 7, 8, 9}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [9, 5, 7, 3, 9, 8]\n",
    "s = set(l)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível iniciar a lista dentro do set de forma implícita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'campinas', 'são carlos', 'são paulo'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = set(['campinas', 'são carlos', 'são paulo'])\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas de Sets\n",
    "\n",
    "É possível executar a operação inversa e criar listas com base em sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['campinas', 'são paulo', 'são carlos']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = list(s)\n",
    "l"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}